public void Range()
{
var samples = new[]
{
Tuple.Create('a', 'e', 'c', true),
Tuple.Create('a', 'e', 'e', true),
Tuple.Create('a', 'e', 'a', true),
Tuple.Create('a', 'e', 'f', false),
Tuple.Create('b', 'e', 'a', false),
Tuple.Create('b', 'e', 'C', false)
};
for (int i = 0; i != samples.Length; ++i)
{
var first = samples[i].Item1;
var last = samples[i].Item2;
var test = samples[i].Item3;
var isSuccess = samples[i].Item4;
var rule = new RangeRule("Range", null, first, last) as IRule;
var match =
rule.Match(new ExplorerContext(test.ToString())).FirstOrDefault();
if (isSuccess)
{
Assert.IsNotNull(match, $"Success - {i}");
Assert.AreEqual(rule.RuleName, match.Rule.RuleName, $"Rule - {i}");
Assert.AreEqual(1, match.Text.Length, $"MatchLength - {i}");
}
else
{
Assert.IsNull(match, $"Failure - {i}");
}
}
}
public void PotentialInfiniteRecurse()
{
// Equivalent to:
// rule A = "a".."z";
// rule B = C "," C;
// rule C = A | B;
// Try to match "a" with C
var ruleA = new RangeRule("A", null, 'a', 'z');
var proxyC = new RuleProxy();
var ruleB = new SequenceRule("B", null, new[] {
new TaggedRule(proxyC),
new TaggedRule(new LiteralRule(null, null, ",")),
new TaggedRule(proxyC)
});
var ruleC = new DisjunctionRule("C", null, new[] {
new TaggedRule(ruleA),
new TaggedRule(ruleB)
});
proxyC.ReferencedRule = ruleC;
var match = ruleC.Match(new ExplorerContext("a")).FirstOrDefault();
Assert.IsNotNull(match, "Should be a success");
}
private bool Check(long data, RangeRule range)
{
bool isOk = false;
isOk |= ((range._leftState && data >= range._leftInt || !range._leftState && data > range._leftInt) &&
(range._rightState && data <= range._rightInt || !range._rightState && data < range._rightInt));
return(isOk);
}
/// <summary>
/// 验证输入的值的范围
/// </summary>
/// <param name="box">验证框</param>
/// <param name="minValue">最小值</param>
/// <param name="maxValue">最大值</param>
/// <param name="errorMessage">提示信息</param>
/// <returns></returns>
public static ValidBox Range(this ValidBox box, int minValue, int maxValue, string errorMessage)
{
var newBox = new RangeRule(minValue, maxValue)
{
ErrorMessage = errorMessage
}.ToValidBox();
return(ValidBox.Merge(box, newBox));
}
public void Test_Validated()
{
RangeRule val = new RangeRule();
val.Min = 1;
val.Max = 20;
ValidationResult vr = new ValidationResult(true, null);
Assert.AreEqual(val.Validate("5", new System.Globalization.CultureInfo("en-us")), vr);
}
public void Test_Out_Of_Range()
{
RangeRule val = new RangeRule();
val.Min = 1;
val.Max = 20;
ValidationResult vr = new ValidationResult(false, "Please enter a number in the given range.");
Assert.AreEqual(val.Validate("50", new System.Globalization.CultureInfo("en-us")), vr);
}
public void Test_Illegal_Characters()
{
RangeRule val = new RangeRule();
val.Min = 1;
val.Max = 20;
ValidationResult vr = new ValidationResult(false, "Illegal characters");
Assert.AreEqual(val.Validate("ugh", new System.Globalization.CultureInfo("en-us")), vr);
}
public void EvaluateShouldReturnSuccessForValidValue()
{
// arrange
var rule = new RangeRule<int>( 10 );
var property = new Property<int>( "Counter", 5 );
var expected = ValidationResult.Success;
// act
var actual = rule.Evaluate( property );
// assert
Assert.Equal( expected, actual );
}
private bool SwitchData(Data data, string type, RangeRule range, RuleInfo info)
{
bool isOk = true;
switch (type)
{
case Setting.INT:
isOk &= Check((data as FInt).Value, range);
break;
case Setting.LONG:
isOk &= Check((data as FLong).Value, range);
break;
case Setting.FLOAT:
isOk &= Check((data as FFloat).Value, range);
break;
}
return(isOk);
}
private static RangeRule AddArgs(this RangeRule rule, IEnumerable <RuleArgument> args)
{
try
{
rule.Min = RetrieveRangeRuleValue("min", args);
} catch (Exception e)
{
throw new ValidationParseException($"Error parsing minimum value for {rule.RuleType.ToString()}:\r\n {e.Message}", e);
}
try
{
rule.Max = RetrieveRangeRuleValue("max", args);
} catch (Exception e)
{
throw new ValidationParseException($"Error parsing maximum value for {rule.RuleType.ToString()}:\r\n {e.Message}", e);
}
return(rule);
}
public void TestChekingFailedInBadRange()
{
// Arrange
var symbol1 = 'c';
var symbol2 = 'a';
var firstSymbolRule = new SymbolRule(symbol1);
var secondSymbolRule = new SymbolRule(symbol2);
var stream = new MemoryStream().FromString("b");
// Act
var isCheked =
new RangeRule(leftArgumentRule: firstSymbolRule, rightArgumentRule: secondSymbolRule).Check(stream);
// Assert
Assert.IsFalse(isCheked);
}
private void validateMyself()
{
if (Validation.GetHasError(CollectionBoxValue))
{
RangeRule rr = new RangeRule();
ValidationResult vr = rr.Validate(CollectionBoxValue.Text, new CultureInfo("en-US", false));
PrizeLevelConverter plc = new PrizeLevelConverter();
if (vr.Equals(new ValidationResult(false, "Illegal characters")))
{
ucplID = ErrorService.Instance.reportError("005", new List <string> {
(string)plc.Convert(plObject.prizeLevel, typeof(string), null, new System.Globalization.CultureInfo("en-us"))
}, ucplID);
}
else if (vr.Equals(new ValidationResult(false, "Please enter a number in the given range.")))
{
ucplID = ErrorService.Instance.reportError("006", new List <string> {
(string)plc.Convert(plObject.prizeLevel, typeof(string), null, new System.Globalization.CultureInfo("en-us")),
"0",
"20"
}, ucplID);
}
else if (vr.Equals(new ValidationResult(false, "Cannot be nothing")))
{
ucplID = ErrorService.Instance.reportError("008", new List <string> {
(string)plc.Convert(plObject.prizeLevel, typeof(string), null, new System.Globalization.CultureInfo("en-us"))
},
ucplID);
}
}
else
{
ErrorService.Instance.resolveError("005", null, ucplID);
ErrorService.Instance.resolveError("006", null, ucplID);
ErrorService.Instance.resolveError("008", null, ucplID);
}
shout("Update");
}
public void TestChekingSucessInCaseOfSameSymbols()
{
// Arrange
var symbol1 = 'a';
var symbol2 = 'a';
var firstSymbolRule = new SymbolRule(symbol1);
var secondSymbolRule = new SymbolRule(symbol2);
var stream = new MemoryStream().FromString("a");
// Act
var isCheked =
new RangeRule(leftArgumentRule: firstSymbolRule, rightArgumentRule: secondSymbolRule).Check(stream);
// Assert
Assert.IsTrue(isCheked);
}
public void IsMatchTrue()
{
var rule = new RangeRule(0, 5, 1);
rule.IsMatch("2").Should().BeTrue();
}
public void TestRulePriority()
{
var rule = new RangeRule(null, null);
Assert.AreEqual(rule.Priority, RulePriority.RuleRange);
}
private static RangeAttribute Convert(this RangeRule rule) => new RangeAttribute(rule.Min, rule.Max);
/// <summary>
/// 验证输入的值的范围
/// </summary>
/// <param name="box">验证框</param>
/// <param name="minValue">最小值</param>
/// <param name="maxValue">最大值</param>
/// <returns></returns>
public static ValidBox Range(this ValidBox box, int minValue, int maxValue)
{
var newBox = new RangeRule(minValue, maxValue).ToValidBox();
return(ValidBox.Merge(box, newBox));
}
public override bool VerifyRule()
{
bool isOk = base.VerifyRule();
if (_define.IsRaw && !HASH.Contains(_define.OriginalType))
{
Warning($"Range检查规则:基础类型数据类型仅支持int,long,float类型!当前类型:{_define.OriginalType}");
isOk = false;
}
_ranges = new RangeRule[_ruleTable.Length];
for (int i = 0; i < _ruleTable.Length; i++)
{
RuleInfo info = _ruleTable[i];
string rule = info._rule;
if (rule.IsEmpty())
{
Warning($"Range检查规则:表达式为空");
isOk = false;
}
if (rule.Length < 5 || rule.IsEmpty())
{
Warning($"Range检查规则:表达式长度必定大于等于5,而当前长度为{rule.Length}!");
isOk = false;
}
char left = rule[0];
char right = rule[rule.Length - 1];
if (!(left == LEFT_FULL || left == LEFT_HALF || left == NEGATIVE) &&
(right == RIGHT_FULL || right == RIGHT_HALF || right == POSITIVE))
{
Warning("Range检查规则:支持区间标识符错误(),[],(],[)!");
isOk = false;
}
RangeRule range = new RangeRule();
switch (right)
{
case RIGHT_FULL: range._rightState = true; break;
case RIGHT_HALF: range._rightState = false; break;
}
switch (left)
{
case LEFT_FULL: range._leftState = true; break;
case LEFT_HALF: range._leftState = false; break;
}
string content = rule.Trim(ARRAY);
string[] nodes = content.Split(new char[] { ',' }, System.StringSplitOptions.RemoveEmptyEntries);
if (nodes.Length != 2)
{
Warning("Range检查规则:范围参数漏填!");
isOk = false;
}
switch (_define.OriginalType)
{
case Setting.INT:
case Setting.LONG:
case Setting.FLOAT:
isOk = PaserLeftRight(nodes, _define.OriginalType, ref range);
break;
case Setting.LIST:
var item = _define.GetItemDefine();
if (!HASH.Contains(item.OriginalType))
{
Warning($"Range检查规则:list中数据类型仅支持int,long,float类型");
isOk = false;
}
else
{
isOk = PaserLeftRight(nodes, item.OriginalType, ref range);
}
break;
case Setting.DICT:
if (info._isKey)
{
var key = _define.GetKeyDefine();
if (!HASH.Contains(key.FullName))
{
Warning($"Range检查规则:dict.key数据类型仅支持int,long,float类型");
isOk = false;
}
else
{
isOk = PaserLeftRight(nodes, key.FullName, ref range);
}
}
else if (info._isValue)
{
var value = _define.GetValueDefine();
if (!HASH.Contains(value.FullName))
{
Warning($"Range检查规则:dict.value数据类型仅支持int,long,float类型");
isOk = false;
}
else
{
isOk = PaserLeftRight(nodes, value.FullName, ref range);
}
}
break;
}
_ranges[i] = range;
}
return(isOk);
}
public void EvaluateShouldReturnExpectedResultForInvalidValue( int value )
{
// arrange
var rule = new RangeRule<int>( 1, 10 );
var property = new Property<int>( "Counter", value );
// act
var actual = rule.Evaluate( property );
// assert
Assert.Equal( "The Counter field must be between 1 and 10.", actual.ErrorMessage );
Assert.Equal( 1, actual.MemberNames.Count() );
Assert.Equal( "Counter", actual.MemberNames.Single() );
}
public void IsMatchFalse()
{
var rule = new RangeRule(0, 5, 1);
rule.IsMatch("6").Should().BeFalse();
}
private bool PaserLeftRight(string[] nodes, string type, ref RangeRule range)
{
bool isOk = true;
string leftv = nodes[0].Trim();
string rightv = nodes[1].Trim();
switch (type)
{
case Setting.INT:
case Setting.LONG:
if (leftv.Length == 1 && leftv[0] == NEGATIVE)
{
range._leftInt = _define.OriginalType == Setting.INT ? int.MinValue : long.MinValue;
}
else if (!long.TryParse(leftv, out range._leftInt))
{
isOk = false;
}
if (rightv.Length == 1 && rightv[0] == POSITIVE)
{
range._rightInt = _define.OriginalType == Setting.INT ? int.MaxValue : long.MaxValue;
}
else if (!long.TryParse(rightv, out range._rightInt))
{
isOk = false;
}
break;
case Setting.FLOAT:
if (leftv.Length == 1 && leftv[0] == NEGATIVE)
{
range._leftFloat = float.MinValue;
}
else if (!float.TryParse(leftv, out range._leftFloat))
{
isOk = false;
}
if (rightv.Length == 1 && rightv[0] == POSITIVE)
{
range._rightFloat = float.MaxValue;
}
else if (!float.TryParse(rightv, out range._rightFloat))
{
isOk = false;
}
break;
default:
Warning($"Range检查规则:仅支持int,long,float类型!当前类型:{type}.");
isOk = false;
break;
}
if (type == Setting.INT || type == Setting.LONG)
{
if (range._leftInt >= range._rightInt)
{
Warning($"Range检查规则:左值必须小于右值!规则:{_rules}.");
isOk = false;
}
}
else if (type == Setting.FLOAT)
{
if (range._leftFloat >= range._rightFloat)
{
Warning($"Range检查规则:左值必须小于右值!规则:{_rules}.");
isOk = false;
}
}
return(isOk);
}
public void IsMatchWhenFromAndToAreSame()
{
var rule = new RangeRule(65, 65, 2);
rule.IsMatch("65").Should().BeTrue();
}
private static ModelClientValidationRule GetRangeRule(string errorMessage, RangeRule rangeRule)
{
return(new ModelClientValidationRangeRule(errorMessage, rangeRule.Minimum, rangeRule.Maximum));
}
/// <summary>
/// 验证输入的值的范围
/// </summary>
/// <param name="box">验证框</param>
/// <param name="minValue">最小值</param>
/// <param name="maxValue">最大值</param>
/// <param name="errorMessage">提示信息</param>
/// <returns></returns>
public static ValidBox Range(this ValidBox box, int minValue, int maxValue, string errorMessage)
{
var newBox = new RangeRule(minValue, maxValue) { ErrorMessage = errorMessage }.ToValidBox();
return ValidBox.Merge(box, newBox);
}
public void IsMatchDoubleDigitTests(string input, bool expected)
{
var rule = new RangeRule(80, 94, 2);
rule.IsMatch(input).Should().Be(expected);
}
public void IsMatchStrSingleDigitTests(string input, bool expected)
{
var rule = new RangeRule(0, 5, 1);
rule.IsMatch(input).Should().Be(expected);
}
public void DataAnnotationTest()
{
var idRule = new CustomRule(obj => Convert.ToInt32(obj) >= 0, "ID不能小于0");
var requiredRule = FltConfigValidationRules.NotNullOrEmpty;
var cityRule = FltConfigValidationRules.City;
var ageRule = new RangeRule(1, 99, "年龄范围1-99");
var dateRule = new RangeRule(new DateTime(1995, 1, 1), new DateTime(2000, 12, 31), "日期范围错误");
var validator = new FltConfigValidator <DataAnnotationEntity>();
DataAnnotationEntity entity = null;
#region null
var result = validator.Validate(entity);
Assert.IsFalse(result.IsValid);
#endregion
#region ok
entity = DataAnnotationEntity.Create();
result = validator.Validate(entity);
Assert.IsTrue(result.IsValid);
Assert.IsTrue(String.IsNullOrWhiteSpace(result.ErrorMessage));
#endregion
#region ID
entity = DataAnnotationEntity.Create();
entity.ID = -1;
result = validator.Validate(entity);
Assert.IsFalse(result.IsValid);
Assert.AreEqual("ID", result.MemberName);
Assert.AreEqual(idRule.ErrorMessage, result.ErrorMessage);
entity = DataAnnotationEntity.Create();
entity.ID = 0;
result = validator.Validate(entity);
Assert.IsTrue(result.IsValid);
Assert.IsTrue(String.IsNullOrWhiteSpace(result.ErrorMessage));
#endregion
#region City
entity = DataAnnotationEntity.Create();
entity.City = null;
result = validator.Validate(entity);
Assert.IsFalse(result.IsValid);
Assert.AreEqual("City", result.MemberName);
Assert.AreEqual(requiredRule.ErrorMessage, result.ErrorMessage);
entity = DataAnnotationEntity.Create();
entity.City = String.Empty;
result = validator.Validate(entity);
Assert.IsFalse(result.IsValid);
Assert.AreEqual("City", result.MemberName);
Assert.AreEqual(requiredRule.ErrorMessage, result.ErrorMessage);
entity = DataAnnotationEntity.Create();
entity.City = " ";
result = validator.Validate(entity);
Assert.IsFalse(result.IsValid);
Assert.AreEqual("City", result.MemberName);
Assert.AreEqual(requiredRule.ErrorMessage, result.ErrorMessage);
entity = DataAnnotationEntity.Create();
entity.City = "ABC1";
result = validator.Validate(entity);
Assert.IsFalse(result.IsValid);
Assert.AreEqual("City", result.MemberName);
Assert.AreEqual(cityRule.ErrorMessage, result.ErrorMessage);
#endregion
#region Age
entity = DataAnnotationEntity.Create();
entity.Age = Convert.ToInt32(ageRule.Minimum) - 1;
result = validator.Validate(entity);
Assert.IsFalse(result.IsValid);
Assert.AreEqual("Age", result.MemberName);
Assert.AreEqual(ageRule.ErrorMessage, result.ErrorMessage);
entity = DataAnnotationEntity.Create();
entity.Age = Convert.ToInt32(ageRule.Minimum);
result = validator.Validate(entity);
Assert.IsTrue(result.IsValid);
Assert.IsTrue(String.IsNullOrWhiteSpace(result.ErrorMessage));
entity = DataAnnotationEntity.Create();
entity.Age = Convert.ToInt32(ageRule.Maximum);
result = validator.Validate(entity);
Assert.IsTrue(result.IsValid);
Assert.IsTrue(String.IsNullOrWhiteSpace(result.ErrorMessage));
entity = DataAnnotationEntity.Create();
entity.Age = Convert.ToInt32(ageRule.Maximum) + 1;
result = validator.Validate(entity);
Assert.IsFalse(result.IsValid);
Assert.AreEqual("Age", result.MemberName);
Assert.AreEqual(ageRule.ErrorMessage, result.ErrorMessage);
#endregion
#region Date
entity = DataAnnotationEntity.Create();
entity.Date = null;
result = validator.Validate(entity);
Assert.IsFalse(result.IsValid);
Assert.AreEqual("Date", result.MemberName);
Assert.AreEqual(requiredRule.ErrorMessage, result.ErrorMessage);
entity = DataAnnotationEntity.Create();
entity.Date = Convert.ToDateTime(dateRule.Minimum).AddMinutes(-1);
result = validator.Validate(entity);
Assert.IsFalse(result.IsValid);
Assert.AreEqual("Date", result.MemberName);
Assert.AreEqual(dateRule.ErrorMessage, result.ErrorMessage);
entity = DataAnnotationEntity.Create();
entity.Date = Convert.ToDateTime(dateRule.Minimum);
result = validator.Validate(entity);
Assert.IsTrue(result.IsValid);
Assert.IsTrue(String.IsNullOrWhiteSpace(result.ErrorMessage));
entity = DataAnnotationEntity.Create();
entity.Date = Convert.ToDateTime(dateRule.Maximum);
result = validator.Validate(entity);
Assert.IsTrue(result.IsValid);
Assert.IsTrue(String.IsNullOrWhiteSpace(result.ErrorMessage));
entity = DataAnnotationEntity.Create();
entity.Date = Convert.ToDateTime(dateRule.Maximum).AddMinutes(1);
result = validator.Validate(entity);
Assert.IsFalse(result.IsValid);
Assert.AreEqual("Date", result.MemberName);
Assert.AreEqual(dateRule.ErrorMessage, result.ErrorMessage);
#endregion
}
/// <summary>
/// 验证输入的值的范围
/// </summary>
/// <param name="box">验证框</param>
/// <param name="minValue">最小值</param>
/// <param name="maxValue">最大值</param>
/// <returns></returns>
public static ValidBox Range(this ValidBox box, int minValue, int maxValue)
{
var newBox = new RangeRule(minValue, maxValue).ToValidBox();
return ValidBox.Merge(box, newBox);
}
