public void FixedClass()
{
var datr = new Datr();
var fixedClass = new ValuesClass
{
String = "Fixed String",
DateTime = new DateTime(1991, 05, 11),
Bool = true,
SByte = -5,
Byte = 3,
Short = -20000,
UShort = 50000,
Char = '■',
Double = 3.486,
Float = 0.1234f,
UInt = 4000000000,
Int = -1500000,
Long = 372036854775808,
ULong = 184467440737095516
};
datr.FixedValues = new List <FixedValue>
{
new FixedValue(typeof(ClassWithClassProperty), "ValuesClass", fixedClass)
};
var classWithClassProperty = datr.Create <ClassWithClassProperty>();
Assert.AreEqual <ValuesClass>(fixedClass, classWithClassProperty.ValuesClass);
}
public void SByteRangeLessThan()
{
var datr = new Datr();
datr.SetSByteRange <ValuesClass>("SByte", Range.LessThan, maxValue: (sbyte)100);
for (int i = 0; i < 100; i++)
{
var basicClass = datr.Create <ValuesClass>();
Assert.IsTrue(basicClass.SByte <= (sbyte)100, $"Value generated is {basicClass.SByte}");
}
}
public void ShortRangeOutside()
{
var datr = new Datr();
datr.SetShortRange <ValuesClass>("Short", Range.Outside, (short)5, (short)50);
for (int i = 0; i < 100; i++)
{
var basicClass = datr.Create <ValuesClass>();
Assert.IsTrue(basicClass.Short < (short)5 || basicClass.Short >= (short)50, $"Value generated is {basicClass.Short}");
}
}
public void ShortRangeGreaterThan()
{
var datr = new Datr();
datr.SetShortRange <ValuesClass>("Short", Range.GreaterThan, (short)100);
for (int i = 0; i < 100; i++)
{
var basicClass = datr.Create <ValuesClass>();
Assert.IsTrue(basicClass.Short >= (short)100, $"Value generated is {basicClass.Short}");
}
}
public void IntRangeOutside()
{
var datr = new Datr();
datr.SetIntRange <ValuesClass>("Int", Range.Outside, -50, 50);
for (int i = 0; i < 100; i++)
{
var basicClass = datr.Create <ValuesClass>();
Assert.IsTrue(basicClass.Int < -50 || basicClass.Int >= 50, $"Value generated is {basicClass.Int}");
}
}
public void IntRangeLessThan()
{
var datr = new Datr();
datr.SetIntRange <ValuesClass>("Int", Range.LessThan, maxValue: 100);
for (int i = 0; i < 100; i++)
{
var basicClass = datr.Create <ValuesClass>();
Assert.IsTrue(basicClass.Int <= 100, $"Value generated is {basicClass.Int}");
}
}
public void DecimalRangeOutside()
{
var datr = new Datr();
datr.SetDecimalRange <ValuesClass>("Decimal", Range.Outside, (decimal)5, (decimal)50);
for (int i = 0; i < 100; i++)
{
var basicClass = datr.Create <ValuesClass>();
Assert.IsTrue(basicClass.Decimal < (decimal)5 || basicClass.Decimal >= (decimal)50, $"Value generated is {basicClass.Decimal}");
}
}
public void DecimalRangeGreaterThan()
{
var datr = new Datr();
datr.SetDecimalRange <ValuesClass>("Decimal", Range.GreaterThan, (decimal)100);
for (int i = 0; i < 100; i++)
{
var basicClass = datr.Create <ValuesClass>();
Assert.IsTrue(basicClass.Decimal >= (decimal)100, $"Value generated is {basicClass.Decimal}");
}
}
public void LongRangeGreaterThan()
{
var datr = new Datr();
datr.SetLongRange <ValuesClass>("Long", Range.GreaterThan, (long)100000000000);
for (int i = 0; i < 100; i++)
{
var basicClass = datr.Create <ValuesClass>();
Assert.IsTrue(basicClass.Long >= (long)100000000000, $"Value generated is {basicClass.Long}");
}
}
public void DateTimeRangeGreaterThan()
{
var datr = new Datr();
datr.SetDateTimeRange <ValuesClass>("DateTime", Range.GreaterThan, new DateTime(1991, 05, 11));
for (int i = 0; i < 100; i++)
{
var basicClass = datr.Create <ValuesClass>();
Assert.IsTrue(basicClass.DateTime >= new DateTime(1991, 05, 11), $"Value generated is {basicClass.DateTime}");
}
}
public void UShortRangeLessThan()
{
var datr = new Datr();
datr.SetUShortRange <ValuesClass>("UShort", Range.LessThan, maxValue: (ushort)100);
for (int i = 0; i < 100; i++)
{
var basicClass = datr.Create <ValuesClass>();
Assert.IsTrue(basicClass.UShort <= (ushort)100, $"Value generated is {basicClass.UShort}");
}
}
public void FloatRangeOutside()
{
var datr = new Datr();
datr.SetFloatRange <ValuesClass>("Float", Range.Outside, (float)0.3, (float)0.8);
for (int i = 0; i < 100; i++)
{
var basicClass = datr.Create <ValuesClass>();
Assert.IsTrue(basicClass.Float < (float)0.3 || basicClass.Float >= (float)0.8, $"Value generated is {basicClass.Float}");
}
}
public void InvalidDataThrowsException()
{
var datr = new Datr
{
FixedValues = new List <FixedValue>
{
new FixedValue(typeof(ValuesClass), "Int", "OneTwoThree")
}
};
Assert.ThrowsException <ArgumentException>(() => datr.Create <ValuesClass>());
}
public void UIntRangeGreaterThan()
{
var datr = new Datr();
datr.SetUIntRange <ValuesClass>("UInt", Range.GreaterThan, 100U);
for (int i = 0; i < 100; i++)
{
var basicClass = datr.Create <ValuesClass>();
Assert.IsTrue(basicClass.UInt >= 100U, $"Value generated is {basicClass.UInt}");
}
}
public void ByteRangeOutside()
{
var datr = new Datr();
datr.SetByteRange <ValuesClass>("Byte", Range.Outside, (byte)5, (byte)50);
for (int i = 0; i < 100; i++)
{
var basicClass = datr.Create <ValuesClass>();
Assert.IsTrue(basicClass.Byte < (byte)5 || basicClass.Byte >= (byte)50, $"Value generated is {basicClass.Byte}");
}
}
public void DoubleRangeGreaterThan()
{
var datr = new Datr();
datr.SetDoubleRange <ValuesClass>("Double", Range.GreaterThan, (double)0.3);
for (int i = 0; i < 100; i++)
{
var basicClass = datr.Create <ValuesClass>();
Assert.IsTrue(basicClass.Double >= (double)0.3, $"Value generated is {basicClass.Double}");
}
}
public void ByteRangeGreaterThan()
{
var datr = new Datr();
datr.SetByteRange <ValuesClass>("Byte", Range.GreaterThan, (byte)100);
for (int i = 0; i < 100; i++)
{
var basicClass = datr.Create <ValuesClass>();
Assert.IsTrue(basicClass.Byte >= (byte)100, $"Value generated is {basicClass.Byte}");
}
}
public void DoubleRangeOutside()
{
var datr = new Datr();
datr.SetDoubleRange <ValuesClass>("Double", Range.Outside, (double)0.12345, (double)0.5678);
for (int i = 0; i < 100; i++)
{
var basicClass = datr.Create <ValuesClass>();
Assert.IsTrue(basicClass.Double < (double)0.12345 || basicClass.Double >= (double)0.5678, $"Value generated is {basicClass.Double}");
}
}
public void UIntRangeOutside()
{
var datr = new Datr();
datr.SetUIntRange <ValuesClass>("UInt", Range.Outside, 50U, 500U);
for (int i = 0; i < 100; i++)
{
var basicClass = datr.Create <ValuesClass>();
Assert.IsTrue(basicClass.UInt < 50U || basicClass.UInt >= 500U, $"Value generated is {basicClass.UInt}");
}
}
public void FloatRangeGreaterThan()
{
var datr = new Datr();
datr.SetFloatRange <ValuesClass>("Float", Range.GreaterThan, (float)0.3);
for (int i = 0; i < 100; i++)
{
var basicClass = datr.Create <ValuesClass>();
Assert.IsTrue(basicClass.Float >= (float)0.3, $"Value generated is {basicClass.Float}");
}
}
public void ULongRangeOutside()
{
var datr = new Datr();
datr.SetULongRange <ValuesClass>("ULong", Range.Outside, (ulong)100000000000, (ulong)9000000000000);
for (int i = 0; i < 100; i++)
{
var basicClass = datr.Create <ValuesClass>();
Assert.IsTrue(basicClass.ULong < (ulong)100000000000 || basicClass.ULong >= (ulong)9000000000000, $"Value generated is {basicClass.ULong}");
}
}
public void ULongRangeLessThan()
{
var datr = new Datr();
datr.SetULongRange <ValuesClass>("ULong", Range.LessThan, maxValue: (ulong)100000000000);
for (int i = 0; i < 100; i++)
{
var basicClass = datr.Create <ValuesClass>();
Assert.IsTrue(basicClass.ULong <= (ulong)100000000000, $"Value generated is {basicClass.ULong}");
}
}
public void DateTimeRangeOutside()
{
var datr = new Datr();
datr.SetDateTimeRange <ValuesClass>("DateTime", Range.Outside, new DateTime(1991, 05, 11), new DateTime(1993, 04, 15));
for (int i = 0; i < 100; i++)
{
var basicClass = datr.Create <ValuesClass>();
Assert.IsTrue(basicClass.DateTime < new DateTime(1991, 05, 11) || basicClass.DateTime >= new DateTime(1993, 04, 15), $"Value generated is {basicClass.DateTime}");
}
}
public void SByteRangeBetween()
{
var datr = new Datr();
datr.SetSByteRange <ValuesClass>("SByte", Range.Between, (sbyte)-50, (sbyte)50);
for (int i = 0; i < 100; i++)
{
var basicClass = datr.Create <ValuesClass>();
Assert.IsTrue(basicClass.SByte >= (sbyte)-50, $"Value generated is {basicClass.SByte}");
Assert.IsTrue(basicClass.SByte <= (sbyte)50, $"Value generated is {basicClass.SByte}");
}
}
public void AddUIntRangeToList()
{
var datr = new Datr();
datr.SetUIntRange <ValuesClass>("UInt", Range.GreaterThan, 100U);
Assert.AreEqual(1, datr.FixedRanges.Count);
Assert.AreEqual(typeof(uint), datr.FixedRanges[0].DataType);
Assert.AreEqual(typeof(ValuesClass), datr.FixedRanges[0].ClassType);
Assert.AreEqual(Range.GreaterThan, datr.FixedRanges[0].Range);
Assert.AreEqual(100U, datr.FixedRanges[0].MinValue);
Assert.IsNull(datr.FixedRanges[0].MaxValue);
}
public void AddByteRangeToList()
{
var datr = new Datr();
datr.SetByteRange <ValuesClass>("Byte", Range.GreaterThan, (byte)100);
Assert.AreEqual(1, datr.FixedRanges.Count);
Assert.AreEqual(typeof(byte), datr.FixedRanges[0].DataType);
Assert.AreEqual(typeof(ValuesClass), datr.FixedRanges[0].ClassType);
Assert.AreEqual(Range.GreaterThan, datr.FixedRanges[0].Range);
Assert.AreEqual((byte)100, datr.FixedRanges[0].MinValue);
Assert.IsNull(datr.FixedRanges[0].MaxValue);
}
public void UShortRangeBetween()
{
var datr = new Datr();
datr.SetUShortRange <ValuesClass>("UShort", Range.Between, (ushort)5, (ushort)50);
for (int i = 0; i < 100; i++)
{
var basicClass = datr.Create <ValuesClass>();
Assert.IsTrue(basicClass.UShort >= (ushort)5, $"Value generated is {basicClass.UShort}");
Assert.IsTrue(basicClass.UShort <= (ushort)50, $"Value generated is {basicClass.UShort}");
}
}
public void AddDateTimeRangeToList()
{
var datr = new Datr();
datr.SetDateTimeRange <ValuesClass>("DateTime", Range.GreaterThan, new DateTime(1991, 05, 11));
Assert.AreEqual(1, datr.FixedRanges.Count);
Assert.AreEqual(typeof(DateTime), datr.FixedRanges[0].DataType);
Assert.AreEqual(typeof(ValuesClass), datr.FixedRanges[0].ClassType);
Assert.AreEqual(Range.GreaterThan, datr.FixedRanges[0].Range);
Assert.AreEqual(new DateTime(1991, 05, 11), datr.FixedRanges[0].MinValue);
Assert.IsNull(datr.FixedRanges[0].MaxValue);
}
public void AddFloatRangeToList()
{
var datr = new Datr();
datr.SetFloatRange <ValuesClass>("Float", Range.GreaterThan, (float)0.3);
Assert.AreEqual(1, datr.FixedRanges.Count);
Assert.AreEqual(typeof(float), datr.FixedRanges[0].DataType);
Assert.AreEqual(typeof(ValuesClass), datr.FixedRanges[0].ClassType);
Assert.AreEqual(Range.GreaterThan, datr.FixedRanges[0].Range);
Assert.AreEqual((float)0.3, datr.FixedRanges[0].MinValue);
Assert.IsNull(datr.FixedRanges[0].MaxValue);
}
public void InheritedPropertiesPopulated()
{
var datr = new Datr();
var childClass = datr.Create <ChildClass>();
Assert.IsNotNull(childClass.ChildInt);
Assert.IsNotNull(childClass.ParentInt);
Assert.IsNotNull(childClass.ChildString);
Assert.IsNotNull(childClass.ParentString);
Assert.IsNotNull(childClass.ChildSubClass);
Assert.IsNotNull(childClass.ParentSubClass);
}
