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); }