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);
}
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_WithValueGTMax_ShouldReturnErrorMessage()
{
//---------------Set up test pack-------------------
var rule = new PropRuleInteger("num", "TestMessage", 5, 10);
var errorMessage = "";
Assert.IsFalse(rule.IsPropValueValid("Propname", 12, ref errorMessage));
Assert.IsTrue(errorMessage.Length > 0);
}
public void Test_WithNullValue_ShouldReturnEmptyErrorMessage()
{
//---------------Set up test pack-------------------
var rule = new PropRuleInteger("num", "TestMessage", 5, 10);
var errorMessage = "";
Assert.IsTrue(rule.IsPropValueValid("Propname", null, ref errorMessage));
Assert.IsTrue(errorMessage.Length == 0);
}
public void Test_WithNullValue_ShouldReturnEmptyErrorMessage()
{
//---------------Set up test pack-------------------
var rule = new PropRuleInteger("num", "TestMessage", 5, 10);
var errorMessage = "";
Assert.IsTrue(rule.IsPropValueValid("Propname", null, ref errorMessage));
Assert.IsTrue(errorMessage.Length == 0);
}
public void Test_WithValueGTMax_ShouldReturnErrorMessage()
{
//---------------Set up test pack-------------------
var rule = new PropRuleInteger("num", "TestMessage", 5, 10);
var errorMessage = "";
Assert.IsFalse(rule.IsPropValueValid("Propname", 12, ref errorMessage));
Assert.IsTrue(errorMessage.Length > 0);
}
public void Test_MaxAndMinValueAreSetOnIComparableInterface()
{
//---------------Set up test pack-------------------
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
IPropRuleComparable <int> rule = new PropRuleInteger("num", "TestMessage", 5, 10);
//---------------Test Result -----------------------
Assert.AreEqual(5, rule.MinValue);
Assert.AreEqual(10, rule.MaxValue);
}
public void ConstructWithoutMinOrMax_ShouldUseIntMinAndMax()
{
//---------------Set up test pack-------------------
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
IPropRuleComparable <int> rule = new PropRuleInteger("num", "TestMessage");
//---------------Test Result -----------------------
Assert.AreEqual(int.MinValue, rule.MinValue);
Assert.AreEqual(int.MaxValue, rule.MaxValue);
}
private static IPropRule GetPropRuleInt(int?minInt, int?maxInt)
{
var propRuleInt = new PropRuleInteger("", "")
{
Parameters =
new Dictionary <string, object> {
{ "min", minInt }, { "max", maxInt }
}
};
return(propRuleInt);
}
public void IsPropValueValid_GivenValueOutsideIntRange_ShouldReturnFalse()
{
//---------------Set up test pack-------------------
var rule = new PropRuleInteger("num", "");
var errorMessage = "";
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var valid = rule.IsPropValueValid("num", long.MaxValue, ref errorMessage);
//---------------Test Result -----------------------
Assert.IsFalse(valid);
}
private int GenerateValidValue(int?overridingMinValue, int?overridingMaxValue)
{
PropRuleInteger propRule = base.GetPropRule <PropRuleInteger>();
int intMinValue = GetMinValue(propRule, overridingMinValue);
int intMaxValue = GetMaxValue(propRule, overridingMaxValue);
_latestValue.Remove(base.SingleValueDef);
if (_nextValue < intMinValue)
{
_nextValue = intMinValue;
}
if (_nextValue > intMaxValue)
{
_nextValue = intMinValue;
}
var returnValue = _nextValue;
_latestValue.Add(base.SingleValueDef, ++_nextValue);
return(returnValue);
}
public void Test_MaxAndMinValueAreSetOnIComparableInterface()
{
//---------------Set up test pack-------------------
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
IPropRuleComparable<int> rule = new PropRuleInteger("num", "TestMessage", 5, 10);
//---------------Test Result -----------------------
Assert.AreEqual(5, rule.MinValue);
Assert.AreEqual(10, rule.MaxValue);
}
public void IsPropValueValid_GivenValueOutsideIntRange_ShouldReturnFalse()
{
//---------------Set up test pack-------------------
var rule = new PropRuleInteger("num", "");
var errorMessage = "";
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var valid = rule.IsPropValueValid("num", long.MaxValue, ref errorMessage);
//---------------Test Result -----------------------
Assert.IsFalse(valid);
}
public void ConstructWithoutMinOrMax_ShouldUseIntMinAndMax()
{
//---------------Set up test pack-------------------
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
IPropRuleComparable<int> rule = new PropRuleInteger("num", "TestMessage");
//---------------Test Result -----------------------
Assert.AreEqual(int.MinValue, rule.MinValue);
Assert.AreEqual(int.MaxValue, rule.MaxValue);
}
