public void SuccessfullyMapDecimal()
{
var value = ValueTypeMapper.TypeToValue(typeof(decimal));
Assert.NotNull(value as DecimalValue);
Assert.Equal(0, (decimal)value.Value);
}
public void SuccessfullyMapDouble()
{
var value = ValueTypeMapper.TypeToValue(typeof(double));
Assert.NotNull(value as DoubleValue);
Assert.Equal(0, (double)value.Value);
}
public void SuccessfullyMapBoolean()
{
var value = ValueTypeMapper.TypeToValue(typeof(bool));
Assert.NotNull(value as BooleanValue);
Assert.False((bool)value.Value);
}
public void SuccessfullyMapSingle()
{
var value = ValueTypeMapper.TypeToValue(typeof(float));
Assert.NotNull(value as SingleValue);
Assert.Equal(0, (float)value.Value);
}
public void SuccessfullyMapUInt16()
{
var value = ValueTypeMapper.TypeToValue(typeof(ushort));
Assert.NotNull(value as UInt16Value);
Assert.Equal(0, (ushort)value.Value);
}
public void SuccessfullyMapUInt32()
{
var value = ValueTypeMapper.TypeToValue(typeof(uint));
Assert.NotNull(value as UInt32Value);
Assert.Equal <uint>(0, (uint)value.Value);
}
public void SuccessfullyMapBooleanArray()
{
var value = ValueTypeMapper.TypeToArrayValue(typeof(bool[]));
Assert.NotNull(value as BooleanArrayValue);
Assert.Null(value.Value);
}
public void SuccessfullyMapByte()
{
var value = ValueTypeMapper.TypeToValue(typeof(byte));
Assert.NotNull(value as ByteValue);
Assert.Equal(0, (byte)value.Value);
}
public void SuccessfullyMapDateTimeArray()
{
var value = ValueTypeMapper.TypeToArrayValue(typeof(DateTime[]));
Assert.NotNull(value as DateTimeArrayValue);
Assert.Null(value.Value);
}
public void SuccessfullyMapStringArray()
{
var value = ValueTypeMapper.TypeToArrayValue(typeof(string[]));
Assert.NotNull(value as StringArrayValue);
Assert.Null(value.Value);
}
public void SuccessfullyMapDecimalArray()
{
var value = ValueTypeMapper.TypeToArrayValue(typeof(decimal[]));
Assert.NotNull(value as DecimalArrayValue);
Assert.Null(value.Value);
}
public void SuccessfullyMapUInt64()
{
var value = ValueTypeMapper.TypeToValue(typeof(ulong));
Assert.NotNull(value as UInt64Value);
Assert.Equal <ulong>(0, (ulong)value.Value);
}
public void SuccessfullyMapSingleArray()
{
var value = ValueTypeMapper.TypeToArrayValue(typeof(float[]));
Assert.NotNull(value as SingleArrayValue);
Assert.Null(value.Value);
}
public void SuccessfullyMapUInt64Array()
{
var value = ValueTypeMapper.TypeToArrayValue(typeof(ulong[]));
Assert.NotNull(value as UInt64ArrayValue);
Assert.Null(value.Value);
}
public void SuccessfullyMapInt32Array()
{
var value = ValueTypeMapper.TypeToArrayValue(typeof(int[]));
Assert.NotNull(value as Int32ArrayValue);
Assert.Null(value.Value);
}
public void SuccessfullyMapDateTime()
{
var value = ValueTypeMapper.TypeToValue(typeof(DateTime));
Assert.NotNull(value as DateTimeValue);
Assert.Equal(DateTime.MinValue, (DateTime)value.Value);
}
public void SuccessfullyMapInt16WithArguments()
{
var type = typeof(short);
var defaultValue = (short)123;
var name = "foobar";
var description = "foobar description";
var unit = new XCalculateLib.Unit("foobar", "foobars", "fb", "fbs");
var validator = new ValueValidator <short>(i => i > 0 && i < 200);
var value = ValueTypeMapper.TypeToValue(type, () => new object[] { defaultValue, new ValueInfo(name, description, unit), validator });
Assert.NotNull(value as Int16Value);
Assert.Equal(defaultValue, value.Value);
Assert.Equal(type, value.Value.GetType());
Assert.NotNull(value.Info);
Assert.Equal(name, value.Info.Name);
Assert.Equal(description, value.Info.Description);
Assert.Equal(unit, value.Info.Unit);
}
public void SuccessfullyMapDateTimeWithArguments()
{
var type = typeof(DateTime);
var defaultValue = DateTime.Now;
var name = "foobar";
var description = "foobar description";
var unit = new XCalculateLib.Unit("foobar", "foobars", "fb", "fbs");
var validator = new ValueValidator <DateTime>(i => i > DateTime.MinValue && i <= DateTime.Now);
var value = ValueTypeMapper.TypeToValue(type, () => new object[] { defaultValue, new ValueInfo(name, description, unit), validator });
Assert.NotNull(value as DateTimeValue);
Assert.Equal(defaultValue, value.Value);
Assert.Equal(type, value.Value.GetType());
Assert.NotNull(value.Info);
Assert.Equal(name, value.Info.Name);
Assert.Equal(description, value.Info.Description);
Assert.Equal(unit, value.Info.Unit);
}
public void SuccessfullyMapStringWithArguments()
{
var type = typeof(string);
var defaultValue = "hello world";
var name = "foobar";
var description = "foobar description";
var unit = new XCalculateLib.Unit("foobar", "foobars", "fb", "fbs");
var validator = new ValueValidator <string>(i => i.Length > 0 && i.Length < 64);
var value = ValueTypeMapper.TypeToValue(type, () => new object[] { defaultValue, new ValueInfo(name, description, unit), validator });
Assert.NotNull(value as StringValue);
Assert.Equal(defaultValue, value.Value);
Assert.Equal(type, value.Value.GetType());
Assert.NotNull(value.Info);
Assert.Equal(name, value.Info.Name);
Assert.Equal(description, value.Info.Description);
Assert.Equal(unit, value.Info.Unit);
}
public void SuccessfullyMapUInt64ArrayWithArguments()
{
var type = typeof(ulong[]);
var defaultValue = new ulong[] { 0, 1, 3 };
var name = "foobar";
var description = "foobar description";
var unit = new XCalculateLib.Unit("foobar", "foobars", "fb", "fbs");
var range = new Range(0, 127);
var validator = new ValueValidator <ulong[]>(i => i.Length < 64 && i.All(j => j >= 0 && j < 200));
var value = ValueTypeMapper.TypeToArrayValue(type, () => new object[] { defaultValue, new ValueInfo(name, description, unit), validator });
Assert.NotNull(value as UInt64ArrayValue);
Assert.Collection(defaultValue,
i => Assert.Equal(defaultValue[0], i),
i => Assert.Equal(defaultValue[1], i),
i => Assert.Equal(defaultValue[2], i));
Assert.Equal(type, value.Value.GetType());
Assert.NotNull(value.Info);
Assert.Equal(name, value.Info.Name);
Assert.Equal(description, value.Info.Description);
Assert.Equal(unit, value.Info.Unit);
}
public void SuccessfullyMapDateTimeArrayWithArguments()
{
var type = typeof(DateTime[]);
var defaultValue = new DateTime[] { DateTime.Now, DateTime.Now.AddDays(-1), DateTime.Now.AddDays(-2) };
var name = "foobar";
var description = "foobar description";
var unit = new XCalculateLib.Unit("foobar", "foobars", "fb", "fbs");
var range = new Range(0, 127);
var validator = new ValueValidator <DateTime[]>(i => i.Length < 64 && i.All(j => j >= DateTime.MinValue && j <= DateTime.Now));
var value = ValueTypeMapper.TypeToArrayValue(type, () => new object[] { defaultValue, new ValueInfo(name, description, unit), validator });
Assert.NotNull(value as DateTimeArrayValue);
Assert.Collection(defaultValue,
i => Assert.Equal(defaultValue[0], i),
i => Assert.Equal(defaultValue[1], i),
i => Assert.Equal(defaultValue[2], i));
Assert.Equal(type, value.Value.GetType());
Assert.NotNull(value.Info);
Assert.Equal(name, value.Info.Name);
Assert.Equal(description, value.Info.Description);
Assert.Equal(unit, value.Info.Unit);
}
public void SuccessfullyMapStringArrayWithArguments()
{
var type = typeof(string[]);
var defaultValue = new string[] { "hello world1", "hello world2", "hello world3" };
var name = "foobar";
var description = "foobar description";
var unit = new XCalculateLib.Unit("foobar", "foobars", "fb", "fbs");
var range = new Range(0, 127);
var validator = new ValueValidator <string[]>(i => i.Length > 0 && i.Length < 64);
var value = ValueTypeMapper.TypeToArrayValue(type, () => new object[] { defaultValue, new ValueInfo(name, description, unit), validator });
Assert.NotNull(value as StringArrayValue);
Assert.Collection(defaultValue,
i => Assert.Equal(defaultValue[0], i),
i => Assert.Equal(defaultValue[1], i),
i => Assert.Equal(defaultValue[2], i));
Assert.Equal(type, value.Value.GetType());
Assert.NotNull(value.Info);
Assert.Equal(name, value.Info.Name);
Assert.Equal(description, value.Info.Description);
Assert.Equal(unit, value.Info.Unit);
}
