public void HexToBitsTest()
{
BitArray[] hexBits = new BitArray[16];
hexBits[0] = new BitArray(new bool[] { false, false, false, false });
hexBits[1] = new BitArray(new bool[] { false, false, false, true });
hexBits[2] = new BitArray(new bool[] { false, false, true, false });
hexBits[3] = new BitArray(new bool[] { false, false, true, true });
hexBits[4] = new BitArray(new bool[] { false, true, false, false });
hexBits[5] = new BitArray(new bool[] { false, true, false, true });
hexBits[6] = new BitArray(new bool[] { false, true, true, false });
hexBits[7] = new BitArray(new bool[] { false, true, true, true });
hexBits[8] = new BitArray(new bool[] { true, false, false, false });
hexBits[9] = new BitArray(new bool[] { true, false, false, true });
hexBits[10] = new BitArray(new bool[] { true, false, true, false });
hexBits[11] = new BitArray(new bool[] { true, false, true, true });
hexBits[12] = new BitArray(new bool[] { true, true, false, false });
hexBits[13] = new BitArray(new bool[] { true, true, false, true });
hexBits[14] = new BitArray(new bool[] { true, true, true, false });
hexBits[15] = new BitArray(new bool[] { true, true, true, true });
for (int i = 0; i < 16; i++)
{
string hexChar = StringConverters.hexMap[i].ToString();
BitArray testBits = StringConverters.HexToBits(hexChar);
for (int j = 0; j < 4; j++)
{
Assert.IsTrue(testBits[j] == hexBits[i][j]);
}
}
}
public void ValidateHexTest()
{
Assert.IsTrue(StringConverters.ValidateHex("ab345"));
Assert.IsTrue(StringConverters.ValidateHex("abcee23597862651456178965916efadccdafab1346"));
Assert.IsFalse(StringConverters.ValidateHex("ab345y"));
Assert.IsFalse(StringConverters.ValidateHex("5913489750ygigiguanbahbjkllnjkan"));
}
internal void FromBool(StringConverters sut)
{
// arrange
// act
var actual = sut.Convert(true, CultureInfo.InvariantCulture);
// assert
Assert.Equal("True", actual);
}
internal void FromString(StringConverters sut, string expected)
{
// arrange
// act
var actual = sut.Convert(expected, CultureInfo.InvariantCulture);
// assert
Assert.Equal(expected, actual);
}
public void UpdateColumn(string Input)
{
int Temp = 0;
if (StringConverters.StrToInt32(Input, ref Temp))
{
this.Col = Temp;
}
}
public void UpdateRow(string Input)
{
int Temp = 0;
if (StringConverters.StrToInt32(Input, ref Temp))
{
this.Row = Temp;
}
}
internal void FromStringArray(StringConverters sut, ImmutableArray <string> values)
{
// act
var actual = sut.Convert(values, CultureInfo.InvariantCulture);
// assert
var expected = string.Join(", ", values);
Assert.Equal(expected, actual);
}
/// <summary>
/// Removes the Sensor
/// </summary>
/// <param name="args"></param>
/// <returns></returns>
private IEnumerable <char> RemoveSensor(params string[] args)
{
if (args.Length < 3 && args.Length != 2)
{
throw new CommandInputException("Invalid command usage, should be : sensor remove <model> [side] [sensor] [sensor]");
}
;
CarModel model;
Direction side;
CreateSensor sensorFactory;
try
{
model = CarModel.GetModel(args[1]);
}
catch (Exception e)
{
throw new CommandInputException("Invalid command: Model doesn't exist.");
}
listPotentialRemoved = model.Sensors;
var countSensorsModel = model.Sensors.Count;
if (args.Length == 2)
{
printListPotentialRemoved();
App.Console.SendCommand += removeSensors;
return(null);
}
else
{
try
{
side = StringConverters.StringToDirection(args[2]);
}
catch (Exception e)
{
throw new CommandInputException("Invalid command: Side is wrong used.");
}
try
{
sensorFactory = StringConverters.GetSensor(args[3]);
}
catch (Exception e)
{
throw new CommandInputException("Invalid command: Could not create sensor.");
}
var count = model.Sensors
.FindAll(sensor => sensor.Create.Equals(sensorFactory) && side == sensor.Direction)
.Count;
model.Sensors.RemoveAll(sensor => sensor.Create.Equals(sensorFactory) && side == sensor.Direction);
return($"Removed {count} {args[3]} sensors.");
}
}
/// <summary>
/// prints all types of sensors
/// </summary>
/// <param name="args"></param>
/// <returns></returns>
private string printTypes(string[] args)
{
var items = StringConverters.GetSensorNames();
foreach (var item in items)
{
App.Console.Print(item);
}
return(null);
}
private void ReportUpdateProgress(DownloadProgress progress)
{
if (progress.Percentage == 1)
{
progressBox.finished = true;
}
progressBox.progressBar.Value = progress.Percentage * 100;
progressBox.taskBarItem.ProgressValue = progress.Percentage;
progressBox.progressTitle.Text = $"Downloading {progress.FileName}...";
progressBox.progressText.Text = $"{Math.Round(progress.Percentage * 100, 2)}% " +
$"({StringConverters.FormatSize(progress.DownloadedBytes)} of {StringConverters.FormatSize(progress.TotalBytes)})";
}
public static UserSettingsVM MToVM(UserSettings model)
{
try
{
return(new UserSettingsVM()
{
ID = model.ID.ToString(),
UserID = model.UserID.ToString(),
AccessLevelID = model.AccessLevelID.ToString(),
JoinedOn = StringConverters.DateTimeToString(model.JoinedOn)
});
} catch { return(null); }
}
public static UsersReviewVM MToVM(UsersReview model)
{
try {
return(new UsersReviewVM()
{
ID = model.ID.ToString(),
Comment = model.comment,
UserID = model.UserID.ToString(),
SenderID = model.SenderID.ToString(),
UpdatedAt = StringConverters.DateTimeToString(model.UpdatedAt),
Stars = model.Stars
});
} catch { return(null); }
}
public async Task <JsonResult> Insert()
{
try {
var id = Guid.NewGuid();
var api = Guid.Parse(Request.Form["api"]);
var code = StringConverters.GuidToCode(Guid.NewGuid(), 4);
var ownerID = Request.Form["oid"];
if (SecurityCodeGeneratorService.Insert(id, api, code, ownerID))
{
return(Success(id.ToString()));
}
return(Failed(MessageUtility.ServerError()));
} catch { return(Failed(MessageUtility.ServerError())); }
}
public void UpdateGridUIDataHandler(object sender, RoutedEventWithDataArgs routedEventWithDataArgs)
{
List <string> MessageContents = EnveloperOpener.OpenStringEnvelope(routedEventWithDataArgs.Content);
int ConvertedValue = 0;
StringConverters.StrToInt32(MessageContents[0], ref ConvertedValue);
if (MessageContents[0] == "Row")
{
this.RowDelta = this.GetDelta(this.Rows, ConvertedValue);
this.Rows = ConvertedValue;
}
else if (MessageContents[0] == "Column")
{
this.ColumnDelta = this.GetDelta(this.Columns, ConvertedValue);
this.Columns = ConvertedValue;
}
routedEventWithDataArgs.Handled = true;
}
public static ItemsViewModel MToVM(Items model)
{
try {
return(new ItemsViewModel()
{
ID = model.ID.ToString(),
Title = model.Title,
Description = model.Description,
Price = model.Price,
OwnerID = model.OwnerID.ToString(),
longitude = model.longitude,
latitude = model.latitude,
PostType = model.PostType,
UpdatedAt = StringConverters.DateTimeToString(model.UpdatedAt),
TimesViewed = model.TimesViewed,
isArchived = model.isArchived
});
} catch { return(null); }
}
public EntityMemberInfo(EntityInfo entity, MemberKind kind, string name, Type dataType)
{
Entity = entity;
Kind = kind;
MemberName = ColumnName = DisplayName = name;
DataType = dataType;
if (DataType.IsNullableValueType())
{
Flags |= EntityMemberFlags.Nullable;
}
//Set to nullable if it is Nullable generic
if (DataType == typeof(decimal) || DataType == typeof(decimal?))
{
this.Precision = 18; //defaults
this.Scale = 4;
}
this.AreValuesEqual = MemberValueGettersSetters.AreObjectsEqual;
//Assign default get/set handlers and to-from string converters, and comparer method
MemberValueGettersSetters.AssignDefaultGetSetHandlers(this);
StringConverters.AssignStringConverters(this);
Entity.AddMember(this);
}
public void StringToInt_C()
{
input = "C";
StringConverters.StringToInt(input).Should().Be(3);
}
public void StringToInt_D()
{
input = "D";
StringConverters.StringToInt(input).Should().Be(4);
}
public Task <T> GetListAsync <T>(string relativeUri, string from, int?limit, IDictionary <string, string> otherParameters = null)
{
string url = relativeUri + StringConverters.BuildListQueryString(from, limit, otherParameters);
return(SendHttpRequestAsync <T>(HttpMethod.Get, url));
}
public static string Stringify(ulong item) => StringConverters.ToString(item);
/// <summary>Register all the default converters</summary>
private static void RegisterDefaultConverters()
{
//TODO: there is too much generic type combinations! need to refactor this ...
RegisterUnsafe <bool, Slice>((value) => Slice.FromByte(value ? (byte)1 : default(byte)));
RegisterUnsafe <bool, byte[]>((value) => Slice.FromByte(value ? (byte)1 : default(byte)).GetBytes());
RegisterUnsafe <bool, string>((value) => value ? "true" : "false");
RegisterUnsafe <bool, sbyte>((value) => value ? (sbyte)1 : default(sbyte));
RegisterUnsafe <bool, byte>((value) => value ? (byte)1 : default(byte));
RegisterUnsafe <bool, short>((value) => value ? (short)1 : default(short));
RegisterUnsafe <bool, ushort>((value) => value ? (ushort)1 : default(ushort));
RegisterUnsafe <bool, int>((value) => value ? 1 : default(int));
RegisterUnsafe <bool, uint>((value) => value ? 1U : default(uint));
RegisterUnsafe <bool, long>((value) => value ? 1L : default(long));
RegisterUnsafe <bool, ulong>((value) => value ? 1UL : default(ulong));
RegisterUnsafe <bool, double>((value) => value ? 1.0d : default(double));
RegisterUnsafe <bool, float>((value) => value ? 1.0f : default(float));
RegisterUnsafe <bool, decimal>((value) => value ? 1m : default(decimal));
RegisterUnsafe <int, Slice>(Slice.FromInt32);
RegisterUnsafe <int, byte[]>((value) => Slice.FromInt32(value).GetBytes());
RegisterUnsafe <int, string>(StringConverters.ToString);
RegisterUnsafe <int, bool>((value) => value != 0);
RegisterUnsafe <int, sbyte>((value) => checked ((sbyte)value));
RegisterUnsafe <int, byte>((value) => checked ((byte)value));
RegisterUnsafe <int, short>((value) => checked ((short)value));
RegisterUnsafe <int, ushort>((value) => checked ((ushort)value));
RegisterUnsafe <int, uint>((value) => (uint)value);
RegisterUnsafe <int, long>((value) => value);
RegisterUnsafe <int, ulong>((value) => (ulong)value);
RegisterUnsafe <int, double>((value) => value);
RegisterUnsafe <int, float>((value) => value); // possible loss of precision
RegisterUnsafe <int, decimal>((value) => value);
RegisterUnsafe <uint, Slice>(Slice.FromUInt32);
RegisterUnsafe <uint, byte[]>((value) => Slice.FromUInt32(value).GetBytes());
RegisterUnsafe <uint, string>(StringConverters.ToString);
RegisterUnsafe <uint, bool>((value) => value != 0);
RegisterUnsafe <uint, sbyte>((value) => checked ((sbyte)value));
RegisterUnsafe <uint, byte>((value) => checked ((byte)value));
RegisterUnsafe <uint, short>((value) => checked ((short)value));
RegisterUnsafe <uint, ushort>((value) => checked ((ushort)value));
RegisterUnsafe <uint, int>((value) => (int)value);
RegisterUnsafe <uint, long>((value) => value);
RegisterUnsafe <uint, ulong>((value) => value);
RegisterUnsafe <uint, double>((value) => value);
RegisterUnsafe <uint, float>((value) => value); // possible loss of precision
RegisterUnsafe <uint, decimal>((value) => value);
RegisterUnsafe <long, Slice>(Slice.FromInt64);
RegisterUnsafe <long, byte[]>((value) => Slice.FromInt64(value).GetBytes());
RegisterUnsafe <long, string>(StringConverters.ToString);
RegisterUnsafe <long, bool>((value) => value != 0);
RegisterUnsafe <long, sbyte>((value) => checked ((sbyte)value));
RegisterUnsafe <long, byte>((value) => checked ((byte)value));
RegisterUnsafe <long, short>((value) => checked ((short)value));
RegisterUnsafe <long, ushort>((value) => checked ((ushort)value));
RegisterUnsafe <long, int>((value) => checked ((int)value));
RegisterUnsafe <long, uint>((value) => (uint)value);
RegisterUnsafe <long, ulong>((value) => (ulong)value);
RegisterUnsafe <long, double>((value) => value); // possible loss of precision
RegisterUnsafe <long, float>((value) => value); // possible loss of precision
RegisterUnsafe <long, TimeSpan>(TimeSpan.FromTicks);
RegisterUnsafe <long, Uuid64>((value) => new Uuid64(value));
RegisterUnsafe <long, System.Net.IPAddress>((value) => new System.Net.IPAddress(value));
RegisterUnsafe <long, decimal>((value) => value);
RegisterUnsafe <ulong, Slice>(Slice.FromUInt64);
RegisterUnsafe <ulong, byte[]>((value) => Slice.FromUInt64(value).GetBytes());
RegisterUnsafe <ulong, string>(StringConverters.ToString);
RegisterUnsafe <ulong, bool>((value) => value != 0);
RegisterUnsafe <ulong, sbyte>((value) => checked ((sbyte)value));
RegisterUnsafe <ulong, byte>((value) => checked ((byte)value));
RegisterUnsafe <ulong, short>((value) => checked ((short)value));
RegisterUnsafe <ulong, ushort>((value) => checked ((ushort)value));
RegisterUnsafe <ulong, int>((value) => checked ((int)value));
RegisterUnsafe <ulong, uint>((value) => checked ((uint)value));
RegisterUnsafe <ulong, long>((value) => checked ((long)value));
RegisterUnsafe <ulong, double>((value) => value); // possible loss of precision
RegisterUnsafe <ulong, float>((value) => value); // possible loss of precision
RegisterUnsafe <ulong, Uuid64>((value) => new Uuid64(value));
RegisterUnsafe <ulong, TimeSpan>((value) => TimeSpan.FromTicks(checked ((long)value)));
RegisterUnsafe <ulong, decimal>((value) => value);
RegisterUnsafe <short, Slice>(Slice.FromInt16);
RegisterUnsafe <short, byte[]>((value) => Slice.FromInt16(value).GetBytes());
RegisterUnsafe <short, string>((value) => StringConverters.ToString(value));
RegisterUnsafe <short, bool>((value) => value != 0);
RegisterUnsafe <short, sbyte>((value) => checked ((sbyte)value));
RegisterUnsafe <short, byte>((value) => checked ((byte)value));
RegisterUnsafe <short, ushort>((value) => checked ((ushort)value));
RegisterUnsafe <short, int>((value) => value);
RegisterUnsafe <short, uint>((value) => checked ((uint)value));
RegisterUnsafe <short, long>((value) => value);
RegisterUnsafe <short, ulong>((value) => checked ((ulong)value));
RegisterUnsafe <short, double>((value) => value);
RegisterUnsafe <short, float>((value) => value);
RegisterUnsafe <short, decimal>((value) => value);
RegisterUnsafe <ushort, Slice>(Slice.FromUInt16);
RegisterUnsafe <ushort, byte[]>((value) => Slice.FromUInt16(value).GetBytes());
RegisterUnsafe <ushort, string>((value) => StringConverters.ToString(value));
RegisterUnsafe <ushort, bool>((value) => value != 0);
RegisterUnsafe <ushort, byte>((value) => checked ((byte)value));
RegisterUnsafe <ushort, sbyte>((value) => checked ((sbyte)value));
RegisterUnsafe <ushort, short>((value) => checked ((short)value));
RegisterUnsafe <ushort, int>((value) => value);
RegisterUnsafe <ushort, uint>((value) => value);
RegisterUnsafe <ushort, long>((value) => value);
RegisterUnsafe <ushort, ulong>((value) => value);
RegisterUnsafe <ushort, double>((value) => value);
RegisterUnsafe <ushort, float>((value) => value);
RegisterUnsafe <ushort, decimal>((value) => value);
RegisterUnsafe <byte, Slice>(Slice.FromByte);
RegisterUnsafe <byte, byte[]>((value) => Slice.FromByte(value).GetBytes());
RegisterUnsafe <byte, string>((value) => StringConverters.ToString(value));
RegisterUnsafe <byte, bool>((value) => value != 0);
RegisterUnsafe <byte, sbyte>((value) => checked ((sbyte)value));
RegisterUnsafe <byte, short>((value) => value);
RegisterUnsafe <byte, ushort>((value) => value);
RegisterUnsafe <byte, int>((value) => value);
RegisterUnsafe <byte, uint>((value) => value);
RegisterUnsafe <byte, long>((value) => value);
RegisterUnsafe <byte, ulong>((value) => value);
RegisterUnsafe <byte, double>((value) => value);
RegisterUnsafe <byte, float>((value) => value);
RegisterUnsafe <byte, decimal>((value) => value);
RegisterUnsafe <sbyte, Slice>((value) => Slice.FromInt64(value));
RegisterUnsafe <sbyte, byte[]>((value) => Slice.FromInt64(value).GetBytes());
RegisterUnsafe <sbyte, string>((value) => value.ToString(CultureInfo.InvariantCulture)); //TODO: string table!
RegisterUnsafe <sbyte, bool>((value) => value != 0);
RegisterUnsafe <sbyte, byte>((value) => checked ((byte)value));
RegisterUnsafe <sbyte, short>((value) => value);
RegisterUnsafe <sbyte, ushort>((value) => checked ((ushort)value));
RegisterUnsafe <sbyte, int>((value) => value);
RegisterUnsafe <sbyte, uint>((value) => checked ((uint)value));
RegisterUnsafe <sbyte, long>((value) => value);
RegisterUnsafe <sbyte, ulong>((value) => checked ((ulong)value));
RegisterUnsafe <sbyte, double>((value) => value);
RegisterUnsafe <sbyte, float>((value) => value);
RegisterUnsafe <sbyte, decimal>((value) => value);
RegisterUnsafe <float, Slice>(Slice.FromSingle);
RegisterUnsafe <float, byte[]>((value) => Slice.FromSingle(value).GetBytes());
RegisterUnsafe <float, string>((value) => value.ToString("R", CultureInfo.InvariantCulture));
RegisterUnsafe <float, bool>((value) => !(value == 0f || float.IsNaN(value)));
RegisterUnsafe <float, sbyte>((value) => checked ((sbyte)value));
RegisterUnsafe <float, byte>((value) => checked ((byte)value));
RegisterUnsafe <float, short>((value) => checked ((short)value));
RegisterUnsafe <float, ushort>((value) => checked ((ushort)value));
RegisterUnsafe <float, int>((value) => checked ((int)value));
RegisterUnsafe <float, uint>((value) => (uint)value);
RegisterUnsafe <float, long>((value) => checked ((long)value));
RegisterUnsafe <float, ulong>((value) => (ulong)value);
RegisterUnsafe <float, double>((value) => value);
RegisterUnsafe <float, decimal>((value) => (decimal)value); // possible loss of precision
RegisterUnsafe <double, Slice>((value) => Slice.FromDouble(value));
RegisterUnsafe <double, byte[]>((value) => Slice.FromDouble(value).GetBytes());
RegisterUnsafe <double, string>((value) => value.ToString("R", CultureInfo.InvariantCulture));
RegisterUnsafe <double, bool>((value) => !(value == 0d || double.IsNaN(value)));
RegisterUnsafe <double, sbyte>((value) => checked ((sbyte)value));
RegisterUnsafe <double, byte>((value) => checked ((byte)value));
RegisterUnsafe <double, short>((value) => checked ((short)value));
RegisterUnsafe <double, ushort>((value) => checked ((ushort)value));
RegisterUnsafe <double, int>((value) => checked ((int)value));
RegisterUnsafe <double, uint>((value) => (uint)value);
RegisterUnsafe <double, long>((value) => checked ((long)value));
RegisterUnsafe <double, ulong>((value) => (ulong)value);
RegisterUnsafe <double, float>((value) => (float)value); // possible loss of precision
RegisterUnsafe <double, decimal>((value) => (decimal)value); // possible loss of precision
RegisterUnsafe <string, Slice>((value) => Slice.FromString(value));
RegisterUnsafe <string, byte[]>((value) => Slice.FromString(value).GetBytes()); //REVIEW: string=>byte[] use UTF-8, but byte[]=>string uses Base64 ?
RegisterUnsafe <string, bool>((value) => !string.IsNullOrEmpty(value));
RegisterUnsafe <string, sbyte>((value) => string.IsNullOrEmpty(value) ? default(sbyte) : sbyte.Parse(value, CultureInfo.InvariantCulture));
RegisterUnsafe <string, byte>((value) => string.IsNullOrEmpty(value) ? default(byte) : byte.Parse(value, CultureInfo.InvariantCulture));
RegisterUnsafe <string, short>((value) => string.IsNullOrEmpty(value) ? default(short) : short.Parse(value, CultureInfo.InvariantCulture));
RegisterUnsafe <string, ushort>((value) => string.IsNullOrEmpty(value) ? default(ushort) : ushort.Parse(value, CultureInfo.InvariantCulture));
RegisterUnsafe <string, int>((value) => string.IsNullOrEmpty(value) ? default(int) : int.Parse(value, CultureInfo.InvariantCulture));
RegisterUnsafe <string, uint>((value) => string.IsNullOrEmpty(value) ? default(uint) : uint.Parse(value, CultureInfo.InvariantCulture));
RegisterUnsafe <string, long>((value) => string.IsNullOrEmpty(value) ? default(long) : long.Parse(value, CultureInfo.InvariantCulture));
RegisterUnsafe <string, ulong>((value) => string.IsNullOrEmpty(value) ? default(ulong) : ulong.Parse(value, CultureInfo.InvariantCulture));
RegisterUnsafe <string, float>((value) => string.IsNullOrEmpty(value) ? default(float) : float.Parse(value, NumberStyles.Float, CultureInfo.InvariantCulture));
RegisterUnsafe <string, double>((value) => string.IsNullOrEmpty(value) ? default(double) : double.Parse(value, NumberStyles.Float, CultureInfo.InvariantCulture));
RegisterUnsafe <string, decimal>((value) => string.IsNullOrEmpty(value) ? default(decimal) : decimal.Parse(value, NumberStyles.Float, CultureInfo.InvariantCulture));
RegisterUnsafe <string, Guid>((value) => string.IsNullOrEmpty(value) ? default(Guid) : Guid.Parse(value));
RegisterUnsafe <string, Uuid128>((value) => string.IsNullOrEmpty(value) ? default(Uuid128) : Uuid128.Parse(value));
RegisterUnsafe <string, Uuid64>((value) => string.IsNullOrEmpty(value) ? default(Uuid64) : Uuid64.Parse(value));
RegisterUnsafe <string, System.Net.IPAddress>((value) => string.IsNullOrEmpty(value) ? default(System.Net.IPAddress) : System.Net.IPAddress.Parse(value));
RegisterUnsafe <byte[], Slice>((value) => value.AsSlice());
RegisterUnsafe <byte[], string>((value) => value == null ? default(string) : value.Length == 0 ? string.Empty : System.Convert.ToBase64String(value)); //REVIEW: string=>byte[] use UTF-8, but byte[]=>string uses Base64 ?
RegisterUnsafe <byte[], bool>((value) => value != null && value.Length > 0);
RegisterUnsafe <byte[], sbyte>((value) => value == null ? default(sbyte) : value.AsSlice().ToSByte());
RegisterUnsafe <byte[], byte>((value) => value == null ? default(byte) : value.AsSlice().ToByte());
RegisterUnsafe <byte[], short>((value) => value == null ? default(short) : value.AsSlice().ToInt16());
RegisterUnsafe <byte[], ushort>((value) => value == null ? default(ushort) : value.AsSlice().ToUInt16());
RegisterUnsafe <byte[], int>((value) => value == null ? 0 : value.AsSlice().ToInt32());
RegisterUnsafe <byte[], uint>((value) => value == null ? 0U : value.AsSlice().ToUInt32());
RegisterUnsafe <byte[], long>((value) => value == null ? 0L : value.AsSlice().ToInt64());
RegisterUnsafe <byte[], ulong>((value) => value == null ? 0UL : value.AsSlice().ToUInt64());
RegisterUnsafe <byte[], Guid>((value) => value == null || value.Length == 0 ? default(Guid) : new Uuid128(value).ToGuid());
RegisterUnsafe <byte[], Uuid128>((value) => value == null || value.Length == 0 ? default(Uuid128) : new Uuid128(value));
RegisterUnsafe <byte[], Uuid64>((value) => value != null ? Uuid64.Read(value) : default(Uuid64));
RegisterUnsafe <byte[], TimeSpan>((value) => value == null ? TimeSpan.Zero : TimeSpan.FromTicks(value.AsSlice().ToInt64()));
RegisterUnsafe <byte[], System.Net.IPAddress>((value) => value == null || value.Length == 0 ? default(System.Net.IPAddress) : new System.Net.IPAddress(value));
RegisterUnsafe <Guid, Slice>((value) => Slice.FromGuid(value));
RegisterUnsafe <Guid, byte[]>((value) => Slice.FromGuid(value).GetBytes());
RegisterUnsafe <Guid, string>((value) => value.ToString("D", null));
RegisterUnsafe <Guid, Uuid128>((value) => new Uuid128(value));
RegisterUnsafe <Guid, bool>((value) => value != Guid.Empty);
RegisterUnsafe <Guid, System.Net.IPAddress>((value) => new System.Net.IPAddress(new Uuid128(value).ToByteArray())); //REVIEW: custom converter for Guid=>IPv6?
RegisterUnsafe <Uuid128, Slice>((value) => value.ToSlice());
RegisterUnsafe <Uuid128, byte[]>((value) => value.ToByteArray());
RegisterUnsafe <Uuid128, string>((value) => value.ToString("D", null));
RegisterUnsafe <Uuid128, Guid>((value) => value.ToGuid());
RegisterUnsafe <Uuid128, bool>((value) => value != Uuid128.Empty);
RegisterUnsafe <Uuid128, System.Net.IPAddress>((value) => new System.Net.IPAddress(value.ToByteArray())); //REVIEW: custom converter for Guid=>IPv6?
RegisterUnsafe <Uuid64, Slice>((value) => value.ToSlice());
RegisterUnsafe <Uuid64, byte[]>((value) => value.ToByteArray());
RegisterUnsafe <Uuid64, string>((value) => value.ToString("D", null));
RegisterUnsafe <Uuid64, long>((value) => value.ToInt64());
RegisterUnsafe <Uuid64, ulong>((value) => value.ToUInt64());
RegisterUnsafe <Uuid64, bool>((value) => value.ToInt64() != 0L);
RegisterUnsafe <TimeSpan, Slice>((value) => Slice.FromInt64(value.Ticks));
RegisterUnsafe <TimeSpan, byte[]>((value) => Slice.FromInt64(value.Ticks).GetBytes());
RegisterUnsafe <TimeSpan, long>((value) => value.Ticks);
RegisterUnsafe <TimeSpan, ulong>((value) => checked ((ulong)value.Ticks));
RegisterUnsafe <TimeSpan, double>((value) => value.TotalSeconds);
RegisterUnsafe <TimeSpan, bool>((value) => value == TimeSpan.Zero);
RegisterUnsafe <System.Net.IPAddress, Slice>((value) => (value?.GetAddressBytes()).AsSlice());
RegisterUnsafe <System.Net.IPAddress, byte[]>((value) => value?.GetAddressBytes());
RegisterUnsafe <System.Net.IPAddress, string>((value) => value?.ToString());
#pragma warning disable 618
RegisterUnsafe <System.Net.IPAddress, int>((value) => (int)(value?.Address ?? 0));
#pragma warning restore 618
RegisterUnsafe <Slice, byte[]>((value) => value.GetBytes());
RegisterUnsafe <Slice, string>((value) => value.ToUnicode());
RegisterUnsafe <Slice, bool>((value) => value.ToBool());
RegisterUnsafe <Slice, sbyte>((value) => value.ToSByte());
RegisterUnsafe <Slice, byte>((value) => value.ToByte());
RegisterUnsafe <Slice, short>((value) => value.ToInt16());
RegisterUnsafe <Slice, ushort>((value) => value.ToUInt16());
RegisterUnsafe <Slice, int>((value) => value.ToInt32());
RegisterUnsafe <Slice, uint>((value) => value.ToUInt32());
RegisterUnsafe <Slice, long>((value) => value.ToInt64());
RegisterUnsafe <Slice, ulong>((value) => value.ToUInt64());
RegisterUnsafe <Slice, float>((value) => value.ToSingle());
RegisterUnsafe <Slice, double>((value) => value.ToDouble());
RegisterUnsafe <Slice, decimal>((value) => value.ToDecimal());
RegisterUnsafe <Slice, Guid>((value) => value.ToGuid());
RegisterUnsafe <Slice, Uuid128>((value) => value.ToUuid128());
RegisterUnsafe <Slice, Uuid64>((value) => value.ToUuid64());
RegisterUnsafe <Slice, TimeSpan>((value) => TimeSpan.FromTicks(value.ToInt64()));
RegisterUnsafe <Slice, System.Net.IPAddress>((value) => !value.IsNullOrEmpty ? new System.Net.IPAddress(value.GetBytesOrEmpty()) : null);
}
public void Orientation_Vertical()
{
input = "V";
StringConverters.Orientation(input).Should().Be("vertical");
}
/// <summary>
/// Add's a sensor
/// </summary>
/// <param name="args"></param>
/// <returns></returns>
private IEnumerable <char> AddSensor(params string[] args)
{
if (args.Length < 4)
{
throw new CommandInputException("Invalid command usage, should be : sensor add <model> <side> <sensor> [range]");
}
;
if (args[0] != "add")
{
throw new CommandInputException("Invalid command useage, should be : sensor add <model> <side> <sensor> [range]");
}
;
CarModel model;
Direction side;
CreateSensor sensorFactory;
try
{
model = CarModel.GetModel(args[1]);
}
catch (Exception)
{
throw new CommandInputException("Invalid command: Model doesn't exist.");
}
try
{
side = StringConverters.StringToDirection(args[2]);
}
catch (Exception)
{
throw new CommandInputException("Invalid command: Side is wrong used.");
}
try
{
sensorFactory = StringConverters.GetSensor(args[3]);
}
catch (Exception)
{
throw new CommandInputException("Invalid command: Could not create sensor.");
}
var range = 0;
if (args.Length == 5)
{
try
{
range = int.Parse(args[4]);
}
catch (Exception)
{
throw new CommandInputException("Invalid command: Could not parse range.");
}
}
var sensor = new SensorPrototype
{
Direction = side,
Range = range,
Create = sensorFactory
};
model.Sensors.Add(sensor);
CitySystem.City.Instance.Cars
.FindAll(car => car.Model == model)
.ForEach(car => car.Sensors.Add(sensor.Create(car, sensor.Direction, sensor.Range)));
return($"Added sensor {args[3]} to {model.Name}");
}
public void StringToInt_F()
{
input = "F";
StringConverters.StringToInt(input).Should().Be(6);
}
public void StringToInt_G()
{
input = "G";
StringConverters.StringToInt(input).Should().Be(7);
}
public void ValidateBase64Test()
{
Assert.IsTrue(StringConverters.ValidateBase64("alkjgbaetvarbtalvun82haaebg78o54YSTWSJDYU"));
Assert.IsFalse(StringConverters.ValidateBase64("alteruhlaulaegraerhlgaehrg."));
}
public void StringToInt_H()
{
input = "H";
StringConverters.StringToInt(input).Should().Be(8);
}
public void StringToInt_E()
{
input = "E";
StringConverters.StringToInt(input).Should().Be(5);
}
public void Orientation_InvalidInput()
{
input = "G";
StringConverters.Orientation(input).Should().Be("Error");
}
public void Orientation_Horizontal()
{
input = "H";
StringConverters.Orientation(input).Should().Be("horizontal");
}
