public void Test_GenerateValueLessThan_WhenDateTimeAndRule_WhenRuleMoreRestrictive_ShouldRetValidValue() { //---------------Set up test pack------------------- IPropDef def = new PropDefFake { PropertyType = typeof(DateTime) }; var min = DateTime.Now; var max = DateTime.Today.AddDays(5.0); var overridingMaxValue = RandomValueGen.GetAbsoluteMax <DateTime>().AddDays(-5.0); def.AddPropRule(CreatePropRuleDate(min, max)); var generator = new ValidValueGeneratorDate(def); //---------------Assert Precondition---------------- Assert.AreSame(typeof(DateTime), def.PropertyType); Assert.IsNotEmpty(def.PropRules.OfType <PropRuleDate>().ToList()); var propRule = def.PropRules.OfType <PropRuleDate>().First(); Assert.AreEqual(min, propRule.MinValue); Assert.AreEqual(max.AddDays(1.0).AddMilliseconds(-1.0), propRule.MaxValue); //---------------Execute Test ---------------------- var value = (DateTime)generator.GenerateValidValueLessThan(overridingMaxValue); //---------------Test Result ----------------------- Assert.IsNotNull(value); Assert.GreaterOrEqual(value, min); Assert.LessOrEqual(value, max); Assert.LessOrEqual(value, overridingMaxValue); }
public void Test_GenerateValue_WhenDateTimeAndRule_ShouldRetValidValue() { //---------------Set up test pack------------------- IPropDef def = new PropDefFake { PropertyType = typeof(DateTime) }; var min = RandomValueGen.GetAbsoluteMin <DateTime>().AddDays(5555.0); var max = RandomValueGen.GetAbsoluteMin <DateTime>().AddDays(5565.0); def.AddPropRule(CreatePropRuleDate(min, max)); ValidValueGenerator generator = new ValidValueGeneratorDate(def); //---------------Assert Precondition---------------- Assert.AreSame(typeof(DateTime), def.PropertyType); Assert.IsNotEmpty(def.PropRules.OfType <PropRuleDate>().ToList()); var propRule = def.PropRules.OfType <PropRuleDate>().First(); Assert.AreEqual(min, propRule.MinValue); Assert.AreEqual(max, propRule.MaxValue.Date); //---------------Execute Test ---------------------- var value = (DateTime)generator.GenerateValidValue(); //---------------Test Result ----------------------- Assert.IsNotNull(value); Assert.GreaterOrEqual(value, min); Assert.LessOrEqual(value, max); }
public void Test_GenerateValue_WhenIntAndRule_ShouldRetValidValue() { //---------------Set up test pack------------------- IPropDef def = new PropDefFake { PropertyType = typeof(int) }; def.AddPropRule(CreatePropRuleInt(3, 7)); ValidValueGenerator generator = new ValidValueGeneratorInt(def); //---------------Assert Precondition---------------- Assert.AreSame(typeof(int), def.PropertyType); Assert.IsNotEmpty(def.PropRules.OfType <PropRuleInteger>().ToList()); PropRuleInteger propRule = def.PropRules.OfType <PropRuleInteger>().First(); Assert.AreEqual(3, propRule.MinValue); Assert.AreEqual(7, propRule.MaxValue); int value = (int)generator.GenerateValidValue(); //---------------Test Result ----------------------- Assert.IsNotNull(value); Assert.GreaterOrEqual(value, 3); Assert.LessOrEqual(value, 7); }
public void Test_GenerateValueGreaterThan_WhenShortAndRule_LtNull_ShouldRetValidValueUsingRules() { IPropDef def = new PropDefFake { PropertyType = typeof(short) }; const short minValue = 3; const short maxValue = 20; def.AddPropRule(CreatePropRuleShort(minValue, maxValue)); var generator = CreateValidValueGenerator(def); //---------------Assert Precondition---------------- Assert.AreSame(typeof(short), def.PropertyType); Assert.IsNotEmpty(def.PropRules.OfType <PropRuleShort>().ToList()); PropRuleShort propRule = def.PropRules.OfType <PropRuleShort>().First(); Assert.AreEqual(minValue, propRule.MinValue); Assert.AreEqual(maxValue, propRule.MaxValue); //---------------Execute Test ---------------------- var value = (short)generator.GenerateValidValueGreaterThan(null); //---------------Test Result ----------------------- Assert.IsNotNull(value); Assert.GreaterOrEqual(value, minValue); Assert.LessOrEqual(value, maxValue); }
public void Test_GenerateValueLessThan_WhenIntAndRule_LtNull_ShouldRetValidValueUsingRules() { IPropDef def = new PropDefFake { PropertyType = typeof(int) }; const int maxValue = int.MaxValue - 77; const int minValue = 3; def.AddPropRule(CreatePropRuleInt(minValue, maxValue)); ValidValueGeneratorIncrementalInt generator = new ValidValueGeneratorIncrementalInt(def); //---------------Assert Precondition---------------- Assert.AreSame(typeof(int), def.PropertyType); Assert.IsNotEmpty(def.PropRules.OfType <PropRuleInteger>().ToList()); PropRuleInteger propRule = def.PropRules.OfType <PropRuleInteger>().First(); Assert.AreEqual(minValue, propRule.MinValue); Assert.AreEqual(maxValue, propRule.MaxValue); //---------------Execute Test ---------------------- int value = (int)generator.GenerateValidValueLessThan(null); //---------------Test Result ----------------------- Assert.IsNotNull(value); Assert.GreaterOrEqual(value, minValue); Assert.LessOrEqual(value, maxValue); }
public void Test_GenerateValue_WhenIntAndRule_AndNextValGTMaxVal_ShouldRestartAtMin() { //---------------Set up test pack------------------- IPropDef def = new PropDefFake { PropertyType = typeof(int) }; const int minValue = 3; const int maxValue = 4; def.AddPropRule(CreatePropRuleInt(minValue, maxValue)); ValidValueGenerator generator = new ValidValueGeneratorIncrementalInt(def); //---------------Assert Precondition---------------- Assert.AreSame(typeof(int), def.PropertyType); Assert.IsNotEmpty(def.PropRules.OfType <PropRuleInteger>().ToList()); PropRuleInteger propRule = def.PropRules.OfType <PropRuleInteger>().First(); Assert.AreEqual(minValue, propRule.MinValue); Assert.AreEqual(maxValue, propRule.MaxValue); //---------------Execute Test ---------------------- var value1 = (int)generator.GenerateValidValue(); var value2 = (int)generator.GenerateValidValue(); int value3 = (int)generator.GenerateValidValue(); //---------------Test Result ----------------------- Assert.AreEqual(minValue, value1); Assert.AreEqual(maxValue, value2); Assert.AreEqual(minValue, value3); }
public void Test_GenerateValueLessThan_WhenIntAndRule_WhenRuleMoreRestrictive_ShouldRetValidValue() { IPropDef def = new PropDefFake { PropertyType = typeof(long) }; const int minValue = 3; const int maxValue = 5; const int lessThanValue = int.MaxValue - 77; def.AddPropRule(CreatePropRuleLong(minValue, maxValue)); ValidValueGeneratorLong generator = new ValidValueGeneratorLong(def); //---------------Assert Precondition---------------- Assert.AreSame(typeof(long), def.PropertyType); Assert.IsNotEmpty(def.PropRules.OfType <PropRuleLong>().ToList()); PropRuleLong propRule = def.PropRules.OfType <PropRuleLong>().First(); Assert.AreEqual(minValue, propRule.MinValue); Assert.AreEqual(maxValue, propRule.MaxValue); //---------------Execute Test ---------------------- long value = (long)generator.GenerateValidValueLessThan(lessThanValue); //---------------Test Result ----------------------- Assert.IsNotNull(value); Assert.GreaterOrEqual(value, minValue); Assert.LessOrEqual(value, lessThanValue); Assert.LessOrEqual(value, maxValue); }
public void Test_GenerateValue_WhenDecimapAndRule_ShouldRetValidValue() { IPropDef def = new PropDefFake { PropertyType = typeof(decimal) }; def.AddPropRule(CreatePropRuleDecimal(3.01M, 7.0004M)); ValidValueGenerator generator = new ValidValueGeneratorDecimal(def); Assert.AreSame(typeof(decimal), def.PropertyType); Assert.IsNotEmpty(def.PropRules.OfType<PropRuleDecimal>().ToList()); PropRuleDecimal propRule = def.PropRules.OfType<PropRuleDecimal>().First(); Assert.AreEqual(3.01M, propRule.MinValue); Assert.AreEqual(7.0004M, propRule.MaxValue); decimal value = (decimal) generator.GenerateValidValue(); Assert.IsNotNull(value); Assert.GreaterOrEqual(value, 3.01M); Assert.LessOrEqual(value, 7.0004M); }
public void Test_GenerateValueGreaterThan_WhenDecimalAndRule_LtNull_ShouldRetValidValueUsingRules() { IPropDef def = new PropDefFake { PropertyType = typeof(decimal) }; def.AddPropRule(CreatePropRuleDecimal(3M, decimal.MaxValue - 7)); ValidValueGeneratorDecimal generator = new ValidValueGeneratorDecimal(def); Assert.AreSame(typeof(decimal), def.PropertyType); Assert.IsNotEmpty(def.PropRules.OfType <PropRuleDecimal>().ToList()); PropRuleDecimal propRule = def.PropRules.OfType <PropRuleDecimal>().First(); Assert.AreEqual(3M, propRule.MinValue); Assert.AreEqual(decimal.MaxValue - 7, propRule.MaxValue); decimal value = (decimal)generator.GenerateValidValueGreaterThan(null); Assert.IsNotNull(value); Assert.GreaterOrEqual(value, 3M); Assert.LessOrEqual(value, decimal.MaxValue - 7); }
public void Test_GenerateValue_WhenIntAndRule_ShouldRetValidValue() { //---------------Set up test pack------------------- IPropDef def = new PropDefFake { PropertyType = typeof(int) }; def.AddPropRule(CreatePropRuleInt(3, 7)); ValidValueGenerator generator = new ValidValueGeneratorInt(def); //---------------Assert Precondition---------------- Assert.AreSame(typeof(int), def.PropertyType); Assert.IsNotEmpty(def.PropRules.OfType<PropRuleInteger>().ToList()); PropRuleInteger propRule = def.PropRules.OfType<PropRuleInteger>().First(); Assert.AreEqual(3, propRule.MinValue); Assert.AreEqual(7, propRule.MaxValue); int value = (int)generator.GenerateValidValue(); //---------------Test Result ----------------------- Assert.IsNotNull(value); Assert.GreaterOrEqual(value, 3); Assert.LessOrEqual(value, 7); }
public void Test_GenerateValueGreaterThan_WhenDoubleAndRule_LtNull_ShouldRetValidValueUsingRules() { IPropDef def = new PropDefFake { PropertyType = typeof(double) }; def.AddPropRule(CreatePropRuleDouble(3.0, double.MaxValue)); var generator = new ValidValueGeneratorDouble(def); Assert.AreSame(typeof(double), def.PropertyType); Assert.IsNotEmpty(def.PropRules.OfType <PropRuleDouble>().ToList <PropRuleDouble>()); var propRule = def.PropRules.OfType <PropRuleDouble>().First <PropRuleDouble>(); Assert.AreEqual(3.0, propRule.MinValue); Assert.AreEqual(1.7976931348623157E+308, propRule.MaxValue); var value = (double)generator.GenerateValidValueGreaterThan(null); Assert.IsNotNull(value); Assert.GreaterOrEqual(value, 3.0); Assert.LessOrEqual(value, double.MaxValue); }
public void Test_GenerateValue_WhenStringAndMaxLength_ShouldRetToValidValue() { IPropDef def = new PropDefFake { PropertyType = typeof(string) }; def.AddPropRule(CreatePropRuleString(3, 7)); ValidValueGenerator generator = new ValidValueGeneratorString(def); Assert.AreSame(typeof(string), def.PropertyType); Assert.IsNotEmpty(def.PropRules.OfType <PropRuleString>().ToList()); PropRuleString propRule = def.PropRules.OfType <PropRuleString>().First(); Assert.AreEqual(3, propRule.MinLength); Assert.AreEqual(7, propRule.MaxLength); object value = generator.GenerateValidValue(); Assert.IsNotNull(value); Assert.GreaterOrEqual(value.ToString().Length, 3); Assert.LessOrEqual(value.ToString().Length, 7); }
public void Test_GenerateValue_WhenDecimapAndRule_ShouldRetValidValue() { IPropDef def = new PropDefFake { PropertyType = typeof(decimal) }; def.AddPropRule(CreatePropRuleDecimal(3.01M, 7.0004M)); ValidValueGenerator generator = new ValidValueGeneratorDecimal(def); Assert.AreSame(typeof(decimal), def.PropertyType); Assert.IsNotEmpty(def.PropRules.OfType <PropRuleDecimal>().ToList()); PropRuleDecimal propRule = def.PropRules.OfType <PropRuleDecimal>().First(); Assert.AreEqual(3.01M, propRule.MinValue); Assert.AreEqual(7.0004M, propRule.MaxValue); decimal value = (decimal)generator.GenerateValidValue(); Assert.IsNotNull(value); Assert.GreaterOrEqual(value, 3.01M); Assert.LessOrEqual(value, 7.0004M); }
public void Test_GenerateValue_WhenDateTimeAndRule_ShouldRetValidValue() { IPropDef def = new PropDefFake { PropertyType = typeof(DateTime) }; var min = RandomValueGen.GetAbsoluteMin <DateTime>().AddDays(5555.0); var max = RandomValueGen.GetAbsoluteMin <DateTime>().AddDays(5565.0); def.AddPropRule(CreatePropRuleDate(min, max)); ValidValueGenerator generator = new ValidValueGeneratorDate(def); Assert.AreSame(typeof(DateTime), def.PropertyType); Assert.IsNotEmpty(def.PropRules.OfType <PropRuleDate>().ToList()); PropRuleDate propRule = def.PropRules.OfType <PropRuleDate>().First(); Assert.AreEqual(min, propRule.MinValue); Assert.AreEqual(max.AddDays(1.0).AddMilliseconds(-1.0), propRule.MaxValue); var value = (DateTime)generator.GenerateValidValue(); Assert.IsNotNull(value); Assert.GreaterOrEqual(value, min); Assert.LessOrEqual(value, max); }
public void Test_GenerateValue_WhenDateTimeAndRule_ShouldRetValidValue() { //---------------Set up test pack------------------- IPropDef def = new PropDefFake { PropertyType = typeof(DateTime) }; var min = RandomValueGen.GetAbsoluteMin<DateTime>().AddDays(5555.0); var max = RandomValueGen.GetAbsoluteMin<DateTime>().AddDays(5565.0); def.AddPropRule(CreatePropRuleDate(min, max)); ValidValueGenerator generator = new ValidValueGeneratorDate(def); //---------------Assert Precondition---------------- Assert.AreSame(typeof(DateTime), def.PropertyType); Assert.IsNotEmpty(def.PropRules.OfType<PropRuleDate>().ToList()); var propRule = def.PropRules.OfType<PropRuleDate>().First(); Assert.AreEqual(min, propRule.MinValue); Assert.AreEqual(max, propRule.MaxValue.Date); //---------------Execute Test ---------------------- var value = (DateTime)generator.GenerateValidValue(); //---------------Test Result ----------------------- Assert.IsNotNull(value); Assert.GreaterOrEqual(value, min); Assert.LessOrEqual(value, max); }
public void Test_GenerateValueLessThan_WhenDateTimeAndRule_WhenRuleMoreRestrictive_ShouldRetValidValue() { //---------------Set up test pack------------------- IPropDef def = new PropDefFake { PropertyType = typeof(DateTime) }; var min = DateTime.Now; var max = DateTime.Today.AddDays(5.0); var overridingMaxValue = RandomValueGen.GetAbsoluteMax<DateTime>().AddDays(-5.0); def.AddPropRule(CreatePropRuleDate(min, max)); var generator = new ValidValueGeneratorDate(def); //---------------Assert Precondition---------------- Assert.AreSame(typeof(DateTime), def.PropertyType); Assert.IsNotEmpty(def.PropRules.OfType<PropRuleDate>().ToList()); var propRule = def.PropRules.OfType<PropRuleDate>().First(); Assert.AreEqual(min, propRule.MinValue); Assert.AreEqual(max.AddDays(1.0).AddMilliseconds(-1.0), propRule.MaxValue); //---------------Execute Test ---------------------- var value = (DateTime)generator.GenerateValidValueLessThan(overridingMaxValue); //---------------Test Result ----------------------- Assert.IsNotNull(value); Assert.GreaterOrEqual(value, min); Assert.LessOrEqual(value, max); Assert.LessOrEqual(value, overridingMaxValue); }
public void Test_GenerateValueLessThan_WhenShortAndRule_WhenRuleMoreRestrictive_ShouldRetValidValue() { IPropDef def = new PropDefFake { PropertyType = typeof(short) }; const short minValue = 3; const short maxValue = 5; const short lessThanValue = short.MaxValue - 77; def.AddPropRule(CreatePropRuleShort(minValue, maxValue)); var generator = CreateValidValueGenerator(def); //---------------Assert Precondition---------------- Assert.AreSame(typeof(short), def.PropertyType); Assert.IsNotEmpty(def.PropRules.OfType<PropRuleShort>().ToList()); var propRule = def.PropRules.OfType<PropRuleShort>().First(); Assert.AreEqual(minValue, propRule.MinValue); Assert.AreEqual(maxValue, propRule.MaxValue); //---------------Execute Test ---------------------- var value = (short)generator.GenerateValidValueLessThan(lessThanValue); //---------------Test Result ----------------------- Assert.IsNotNull(value); Assert.GreaterOrEqual(value, minValue); Assert.LessOrEqual(value, lessThanValue); Assert.LessOrEqual(value, maxValue); }
public void Test_GenerateValue_WhenStringAndMaxLength_ShouldRetToValidValue() { IPropDef def = new PropDefFake { PropertyType = typeof(string) }; def.AddPropRule(CreatePropRuleString(3, 7)); ValidValueGenerator generator = new ValidValueGeneratorString(def); Assert.AreSame(typeof(string), def.PropertyType); Assert.IsNotEmpty(def.PropRules.OfType<PropRuleString>().ToList()); PropRuleString propRule = def.PropRules.OfType<PropRuleString>().First(); Assert.AreEqual(3, propRule.MinLength); Assert.AreEqual(7, propRule.MaxLength); object value = generator.GenerateValidValue(); Assert.IsNotNull(value); Assert.GreaterOrEqual(value.ToString().Length, 3); Assert.LessOrEqual(value.ToString().Length, 7); }
public void Test_GenerateValueGreaterThan_WhenDecimalAndRule_LtNull_ShouldRetValidValueUsingRules() { IPropDef def = new PropDefFake { PropertyType = typeof(decimal) }; def.AddPropRule(CreatePropRuleDecimal(3M, decimal.MaxValue - 7)); ValidValueGeneratorDecimal generator = new ValidValueGeneratorDecimal(def); Assert.AreSame(typeof(decimal), def.PropertyType); Assert.IsNotEmpty(def.PropRules.OfType<PropRuleDecimal>().ToList()); PropRuleDecimal propRule = def.PropRules.OfType<PropRuleDecimal>().First(); Assert.AreEqual(3M, propRule.MinValue); Assert.AreEqual(decimal.MaxValue - 7, propRule.MaxValue); decimal value = (decimal) generator.GenerateValidValueGreaterThan(null); Assert.IsNotNull(value); Assert.GreaterOrEqual(value, 3M); Assert.LessOrEqual(value, decimal.MaxValue - 7); }
public void Test_GenerateValueGreaterThan_WhenIntAndRule_LtNull_ShouldRetValidValueUsingRules() { IPropDef def = new PropDefFake { PropertyType = typeof(long) }; const int minValue = 3; const int maxValue = 20; def.AddPropRule(CreatePropRuleLong(minValue, maxValue)); ValidValueGeneratorLong generator = new ValidValueGeneratorLong(def); //---------------Assert Precondition---------------- Assert.AreSame(typeof(long), def.PropertyType); Assert.IsNotEmpty(def.PropRules.OfType<PropRuleLong>().ToList()); PropRuleLong propRule = def.PropRules.OfType<PropRuleLong>().First(); Assert.AreEqual(minValue, propRule.MinValue); Assert.AreEqual(maxValue, propRule.MaxValue); //---------------Execute Test ---------------------- var value = (long)generator.GenerateValidValueGreaterThan(null); //---------------Test Result ----------------------- Assert.IsNotNull(value); Assert.GreaterOrEqual(value, minValue); Assert.LessOrEqual(value,maxValue); }
public void Test_GenerateValue_WhenDateTimeAndRule_ShouldRetValidValue() { IPropDef def = new PropDefFake { PropertyType = typeof(DateTime) }; var min = RandomValueGen.GetAbsoluteMin<DateTime>().AddDays(5555.0); var max = RandomValueGen.GetAbsoluteMin<DateTime>().AddDays(5565.0); def.AddPropRule(CreatePropRuleDate(min, max)); ValidValueGenerator generator = new ValidValueGeneratorDate(def); Assert.AreSame(typeof(DateTime), def.PropertyType); Assert.IsNotEmpty(def.PropRules.OfType<PropRuleDate>().ToList()); PropRuleDate propRule = def.PropRules.OfType<PropRuleDate>().First(); Assert.AreEqual(min, propRule.MinValue); Assert.AreEqual(max.AddDays(1.0).AddMilliseconds(-1.0), propRule.MaxValue); var value = (DateTime) generator.GenerateValidValue(); Assert.IsNotNull(value); Assert.GreaterOrEqual(value, min); Assert.LessOrEqual(value, max); }
public void Test_GetValidPropValue_WhenStringAndMaxLengthWhenPropDef_ShouldRetValidValue() { //---------------Set up test pack------------------- IPropDef def = new PropDefFake { PropertyType = typeof(string) }; def.AddPropRule(CreatePropRuleString(3, 7)); var factory = new BOTestFactory(typeof(FakeBO)); //---------------Assert Precondition---------------- Assert.AreSame(typeof(string), def.PropertyType); Assert.IsNotEmpty(def.PropRules.OfType<PropRuleString>().ToList()); var propRule = def.PropRules.OfType<PropRuleString>().First(); Assert.AreEqual(3, propRule.MinLength); Assert.AreEqual(7, propRule.MaxLength); //---------------Execute Test ---------------------- var validPropValue = factory.GetValidPropValue(def); //---------------Test Result ----------------------- Assert.IsNotNull(validPropValue); Assert.GreaterOrEqual(validPropValue.ToString().Length, 3); Assert.LessOrEqual(validPropValue.ToString().Length, 7); string errMessage = ""; Assert.IsTrue(def.IsValueValid(validPropValue, ref errMessage)); }
public void Test_GetValidPropValue_WhenDateTimeAndMaxValue_WhenPropName_ShouldRetValidValue() { //---------------Set up test pack------------------- IPropDef def = new PropDefFake { PropertyType = typeof(DateTime) }; DateTime min = RandomValueGen.GetAbsoluteMin<DateTime>().AddDays(5555.0); DateTime max = RandomValueGen.GetAbsoluteMin<DateTime>().AddDays(5565.0); def.AddPropRule(TestUtilsFactory.CreatePropRuleDateTime(min, max)); var factory = new BOTestFactory(typeof(FakeBO)); //---------------Assert Precondition---------------- Assert.AreSame(typeof(DateTime), def.PropertyType); Assert.IsNotEmpty(def.PropRules.OfType<PropRuleDate>().ToList()); var propRule = def.PropRules.OfType<PropRuleDate>().First(); Assert.AreEqual(min, propRule.MinValue); Assert.AreEqual(max, propRule.MaxValue.Date); //---------------Execute Test ---------------------- var validPropValue = factory.GetValidPropValue(def); //---------------Test Result ----------------------- Assert.GreaterOrEqual((DateTime) validPropValue, min); Assert.LessOrEqual((DateTime) validPropValue, max); string errMessage = ""; Assert.IsTrue(def.IsValueValid(validPropValue, ref errMessage), errMessage); }
public void Test_GenerateValueGreaterThan_WhenDoubleAndRule_LtNull_ShouldRetValidValueUsingRules() { IPropDef def = new PropDefFake { PropertyType = typeof(double) }; def.AddPropRule(CreatePropRuleDouble(3.0, double.MaxValue)); var generator = new ValidValueGeneratorDouble(def); Assert.AreSame(typeof(double), def.PropertyType); Assert.IsNotEmpty(def.PropRules.OfType<PropRuleDouble>().ToList<PropRuleDouble>()); var propRule = def.PropRules.OfType<PropRuleDouble>().First<PropRuleDouble>(); Assert.AreEqual(3.0, propRule.MinValue); Assert.AreEqual(1.7976931348623157E+308, propRule.MaxValue); var value = (double) generator.GenerateValidValueGreaterThan(null); Assert.IsNotNull(value); Assert.GreaterOrEqual(value, 3.0); Assert.LessOrEqual(value, double.MaxValue); }
public void Test_GenerateValue_WhenIntAndRule_AndNextValGTMaxVal_ShouldRestartAtMin() { //---------------Set up test pack------------------- IPropDef def = new PropDefFake { PropertyType = typeof(int) }; const int minValue = 3; const int maxValue = 4; def.AddPropRule(CreatePropRuleInt(minValue, maxValue)); ValidValueGenerator generator = new ValidValueGeneratorIncrementalInt(def); //---------------Assert Precondition---------------- Assert.AreSame(typeof(int), def.PropertyType); Assert.IsNotEmpty(def.PropRules.OfType<PropRuleInteger>().ToList()); PropRuleInteger propRule = def.PropRules.OfType<PropRuleInteger>().First(); Assert.AreEqual(minValue, propRule.MinValue); Assert.AreEqual(maxValue, propRule.MaxValue); //---------------Execute Test ---------------------- var value1 = (int)generator.GenerateValidValue(); var value2 = (int)generator.GenerateValidValue(); int value3 = (int)generator.GenerateValidValue(); //---------------Test Result ----------------------- Assert.AreEqual(minValue, value1); Assert.AreEqual(maxValue, value2); Assert.AreEqual(minValue, value3); }
public void Test_GenerateValueLessThan_WhenIntAndRule_WhenRuleMoreRestrictive_ShouldRetValidValue() { IPropDef def = new PropDefFake { PropertyType = typeof(int) }; const int minValue = 3; const int maxValue = 5; const int lessThanValue = int.MaxValue - 77; def.AddPropRule(CreatePropRuleInt(minValue, maxValue)); ValidValueGeneratorIncrementalInt generator = new ValidValueGeneratorIncrementalInt(def); //---------------Assert Precondition---------------- Assert.AreSame(typeof(int), def.PropertyType); Assert.IsNotEmpty(def.PropRules.OfType<PropRuleInteger>().ToList()); PropRuleInteger propRule = def.PropRules.OfType<PropRuleInteger>().First(); Assert.AreEqual(minValue, propRule.MinValue); Assert.AreEqual(maxValue, propRule.MaxValue); //---------------Execute Test ---------------------- int value = (int)generator.GenerateValidValueLessThan(lessThanValue); //---------------Test Result ----------------------- Assert.IsNotNull(value); Assert.GreaterOrEqual(value, minValue); Assert.LessOrEqual(value, lessThanValue); Assert.LessOrEqual(value, maxValue); }