public void FailWithEmptySingularName()
{
Assert.Throws <ArgumentException>(() =>
{
var unit = new XCalculateLib.Unit(string.Empty);
});
}
public void FailWithNullSingularName()
{
Assert.Throws <ArgumentNullException>(() =>
{
var unit = new XCalculateLib.Unit(null);
});
}
public void ReturnFalseWhenComparingAgainstNull()
{
var nameSingular1 = "foobar1";
var namePlural1 = "foobar1s";
var abreviationSingular1 = "fb1";
var abreviationPlural1 = "fb1s";
var unit1 = new XCalculateLib.Unit(nameSingular1, namePlural1, abreviationSingular1, abreviationPlural1);
Assert.False(unit1.Equals(null));
}
public void SuccessfullyCreateObjectWithMinimalArguments()
{
var nameSingular = "Foobar";
var unit = new XCalculateLib.Unit(nameSingular);
Assert.NotNull(unit);
Assert.Equal(nameSingular, unit.NameSingular);
Assert.Null(unit.NamePlural);
Assert.Null(unit.AbreviationPlural);
Assert.Null(unit.AbreviationSingular);
}
public void SuccessfullyFormatValueOfMoreThanOneWithMinimalArgumentsWhenConstructed()
{
var value = 2.0;
var nameSingular = "Foobar";
var unit = new XCalculateLib.Unit(nameSingular);
var nameFormat = unit.Format(value);
var abreviationFormat = unit.Format(value, true);
Assert.Equal($"{value}", nameFormat);
Assert.Equal($"{value}", abreviationFormat);
}
public void FailToCreateObjectWithInvalidValue()
{
var defaultValue = new int[] { 1, 2, 3 };
var name = "foobar";
var description = "foobar description";
var unit = new XCalculateLib.Unit("foobar", "foobars", "fb", "fbs");
bool validator(object i) => ((int[])i).Length >= 0 && ((int[])i).Length < 3;
Assert.Throws <ArgumentException>(() =>
{
var value = new AgnosticArrayValue(defaultValue, new ValueInfo(name, description, unit), validator);
});
}
public void FailWhenValueIsInvalid()
{
var defaultValue = new int[] { 1, 2, 30 };
var name = "foobar";
var description = "foobar description";
var unit = new XCalculateLib.Unit("foobar", "foobars", "fb", "fbs");
bool validator(int[] i) => i.Length >= 0 && i.Length < 10 && i.All(j => j > 0 && j < 10);
Assert.Throws <ArgumentException>(() =>
{
var value = new ArrayValue <int[]>(defaultValue, new ValueInfo(name, description, unit), validator);
});
}
public void FailWhenValueIsInvalid()
{
var defaultValue = 123;
var name = "foobar";
var description = "foobar description";
var unit = new XCalculateLib.Unit("foobar", "foobars", "fb", "fbs");
bool validator(int i) => i >= 0 && i < 100;
Assert.Throws <ArgumentException>(() =>
{
var value = new Value <int>(defaultValue, new ValueInfo(name, description, unit), validator);
});
}
public void FailToCreateObjectWithInvalidValue()
{
var defaultValue = 123;
var name = "foobar";
var description = "foobar description";
var unit = new XCalculateLib.Unit("foobar", "foobars", "fb", "fbs");
bool validator(object i) => (int)i >= 0 && (int)i < 100;
Assert.Throws <ArgumentException>(() =>
{
var value = new AgnosticValue(defaultValue, new ValueInfo(name, description, unit), validator);
});
}
public void SuccessfullyFormatValueOfOne()
{
var value = 1.0;
var nameSingular = "foobar";
var namePlural = "foobars";
var abreviationSingular = "fb";
var abreviationPlural = "fbs";
var unit = new XCalculateLib.Unit(nameSingular, namePlural, abreviationSingular, abreviationPlural);
var nameFormat = unit.Format(value);
var abreviationFormat = unit.Format(value, true);
Assert.Equal($"{value} {nameSingular}", nameFormat);
Assert.Equal($"{value} {abreviationSingular}", abreviationFormat);
}
public void ReturnFalseWhenComparingTwoUnequalUnits()
{
var nameSingular1 = "foobar1";
var namePlural1 = "foobar1s";
var abreviationSingular1 = "fb1";
var abreviationPlural1 = "fb1s";
var nameSingular2 = "foobar2";
var namePlural2 = "foobar2s";
var abreviationSingular2 = "fb2";
var abreviationPlural2 = "fb2s";
var unit1 = new XCalculateLib.Unit(nameSingular1, namePlural1, abreviationSingular1, abreviationPlural1);
var unit2 = new XCalculateLib.Unit(nameSingular2, namePlural2, abreviationSingular2, abreviationPlural2);
Assert.False(unit1.Equals(unit2));
}
public void FailToSetNewValueThatIsInvalid()
{
var defaultValue = 123;
var newValue = 321.0;
var name = "foobar";
var description = "foobar description";
var unit = new XCalculateLib.Unit("foobar", "foobars", "fb", "fbs");
bool validator(object i) => TypeConverter.ToObject <int>(i) > 0 && TypeConverter.ToObject <int>(i) < 200;
var value = new AgnosticValue(defaultValue, new ValueInfo(name, description, unit), validator);
Assert.Throws <ArgumentException>(() =>
{
value.Value = newValue;
});
}
public void ReturnTrueWhenComparingTwoEqualUnits()
{
var nameSingular1 = "foobar";
var namePlural1 = "foobars";
var abreviationSingular1 = "fb";
var abreviationPlural1 = "fbs";
var nameSingular2 = "foobar";
var namePlural2 = "foobars";
var abreviationSingular2 = "fb";
var abreviationPlural2 = "fbs";
var unit1 = new XCalculateLib.Unit(nameSingular1, namePlural1, abreviationSingular1, abreviationPlural1);
var unit2 = new XCalculateLib.Unit(nameSingular2, namePlural2, abreviationSingular2, abreviationPlural2);
Assert.True(unit1.Equals(unit2));
}
public void SuccessfullyCreateObjectWithNullValue()
{
Array defaultValue = null;
var name = "foobar";
var description = "foobar description";
var unit = new XCalculateLib.Unit("foobar", "foobars", "fb", "fbs");
bool validator(object i) => true;
var value = new AgnosticArrayValue(defaultValue, new ValueInfo(name, description, unit), validator);
Assert.NotNull(value);
Assert.Null(value.Value);
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 SuccesfullyCreateObjectWithAllArguments()
{
var defaultValue = 123;
var name = "foobar";
var description = "foobar description";
var unit = new XCalculateLib.Unit("foobar", "foobars", "fb", "fbs");
bool validator(object i) => (int)i >= 0 && (int)i < 200;
var value = new AgnosticValue(defaultValue, new ValueInfo(name, description, unit), validator);
Assert.NotNull(value);
Assert.Equal(defaultValue, value.Value);
Assert.Equal(defaultValue.GetType(), value.ValueType);
Assert.NotNull(value.Info);
Assert.Equal(name, value.Info.Name);
Assert.Equal(description, value.Info.Description);
Assert.Equal(unit, value.Info.Unit);
}
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 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 FailToSetNewValueThatIsInvalid()
{
var defaultValue = new int[] { 1, 2, 3 };
var newValue = new int[] { 4, 5, 6, 7 };
var name = "foobar";
var description = "foobar description";
var unit = new XCalculateLib.Unit("foobar", "foobars", "fb", "fbs");
bool validator(Array i)
{
return(i.Length > 0 && i.Length <= 3);
}
var value = new AgnosticArrayValue(defaultValue, new ValueInfo(name, description, unit), validator);
Assert.Throws <ArgumentException>(() =>
{
value.Value = newValue;
});
}
public void SuccesfullyCreateObjectWithAllArguments()
{
var defaultValue = new int[] { 1, 2, 3 };
var name = "foobar";
var description = "foobar description";
var unit = new XCalculateLib.Unit("foobar", "foobars", "fb", "fbs");
bool validator(object i) => ((int[])i).Length >= 0 && ((int[])i).Length < 200;
var value = new AgnosticArrayValue(defaultValue, new ValueInfo(name, description, unit), validator);
Assert.NotNull(value);
Assert.Collection((int[])value.Value,
i => Assert.Equal(defaultValue[0], i),
i => Assert.Equal(defaultValue[1], i),
i => Assert.Equal(defaultValue[2], i));
Assert.Equal(defaultValue.GetType(), 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);
}
public void SuccessfullyCreateObjectWithAllArguments()
{
var defaultValue = new int[] { 1, 2, 3 };
var name = "foobar";
var description = "foobar description";
var unit = new XCalculateLib.Unit("foobar", "foobars", "fb", "fbs");
bool validator(int[] i) => i.Length >= 0 && i.Length < 10 && i.All(j => j > 0 && j < 10);
var value = new ArrayValue <int[]>(defaultValue, new ValueInfo(name, description, unit), validator);
Assert.NotNull(value);
Assert.Collection(value.Value,
i => Assert.Equal(defaultValue[0], i),
i => Assert.Equal(defaultValue[1], i),
i => Assert.Equal(defaultValue[2], i));
Assert.Equal(defaultValue.GetType(), 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);
Assert.True(value.IsArrayValue);
}
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);
}
