public void Min_MinimumIsDoubleAndTheValueIsLessThan_Fails()
{
double value = 0;
var sut = new MinAttribute(1.1);
Assert.IsFalse(sut.IsValid(value));
}
public void Min_MinimumIsIntegerAndTheValueIsGreaterThan_Validates()
{
int value = 2;
var sut = new MinAttribute(1);
Assert.IsTrue(sut.IsValid(value));
}
private static Attribute ConvertToMin(XmlNhvmRuleConverterArgs rule)
{
NhvmMin minRule = (NhvmMin)rule.schemaRule;
long value = 0;
if (minRule.valueSpecified)
{
value = minRule.value;
}
#if NETFX
log.Info(string.Format("Converting to Min attribute with value {0}", value));
#else
Log.Info("Converting to Min attribute with value {0}", value);
#endif
MinAttribute thisAttribute = new MinAttribute();
thisAttribute.Value = value;
if (minRule.message != null)
{
thisAttribute.Message = minRule.message;
}
AssignTagsFromString(thisAttribute, minRule.tags);
return(thisAttribute);
}
public void Min_MinimumIsSpecifiedTypeAndTheValueIsLessThan_Fails()
{
long value = 0;
var sut = new MinAttribute(typeof(long), "1");
Assert.IsFalse(sut.IsValid(value));
}
public void Min_MinimumIsSpecifiedTypeAndTheValueIsEqualTo_Validates()
{
long value = 1;
var sut = new MinAttribute(typeof(long), "1");
Assert.IsTrue(sut.IsValid(value));
}
public void Extreme()
{
var v = new MinAttribute {
Value = -10000
};
Assert.IsTrue(v.IsValid(-10000, null));
Assert.IsTrue(v.IsValid(-10000L, null));
Assert.IsTrue(v.IsValid(123UL, null));
Assert.IsTrue(v.IsValid(123U, null));
Assert.IsTrue(v.IsValid((ushort)5, null));
Assert.IsTrue(v.IsValid((short)5, null));
Assert.IsTrue(v.IsValid(true, null));
Assert.IsTrue(v.IsValid((byte)100, null));
Assert.IsTrue(v.IsValid((sbyte)100, null));
Assert.IsTrue(v.IsValid(AEnum.A, null));
Assert.IsTrue(v.IsValid(CarOptions.Spoiler | CarOptions.FogLights, null));
Assert.IsTrue(v.IsValid('A', null));
Assert.IsTrue(v.IsValid(-9999.99999f, null));
Assert.IsTrue(v.IsValid(-9999.9999999999999999999999999d, null));
Assert.IsFalse(v.IsValid(decimal.MinValue, null));
Assert.IsFalse(v.IsValid(decimal.MinValue.ToString(), null));
Assert.IsFalse(v.IsValid(double.MinValue, null));
Assert.IsFalse(v.IsValid(double.MinValue + "9", null));
}
public override void OnGUI(Rect position,
SerializedProperty property,
GUIContent label)
{
MinAttribute min = attribute as MinAttribute;
if (property.propertyType == SerializedPropertyType.Float)
{
float vf = EditorGUI.FloatField(position,
label.text,
property.floatValue);
property.floatValue = Mathf.Clamp(vf,
min.minValue,
float.MaxValue);
return;
}
if (property.propertyType == SerializedPropertyType.Integer)
{
int vi = EditorGUI.IntField(position,
label.text,
property.intValue);
property.intValue = Mathf.Clamp(vi,
(int)min.minValue,
int.MaxValue);
return;
}
EditorGUI.LabelField(position,
label.text,
"Use range with float or int.");
}
public void Min_MinimumIsIntegerAndTheValueIsLessThan_Fails()
{
int value = 0;
var sut = new MinAttribute(1);
Assert.IsFalse(sut.IsValid(value));
}
public void Min_MinimumIsDoubleAndTheValueIsEqualTo_Validates()
{
double value = 1.1;
var sut = new MinAttribute(1.1);
Assert.IsTrue(sut.IsValid(value));
}
public void Min_MinimumIsDoubleAndTheValueIsGreaterThan_Validates()
{
double value = 2.2;
var sut = new MinAttribute(1.1);
Assert.IsTrue(sut.IsValid(value));
}
public void Min_MinimumIsIntegerAndTheValueIsEqualTo_Validates()
{
int value = 1;
var sut = new MinAttribute(1);
Assert.IsTrue(sut.IsValid(value));
}
public void Min_FormatErrorMessage_ReturnsFormattedErrorMessage()
{
var sut = new MinAttribute(1);
var error = sut.FormatErrorMessage("property");
Assert.IsTrue(!string.IsNullOrEmpty(error));
}
public void Min_FormatErrorMessageWithErrorMessage_ReturnsFormattedErrorMessage()
{
var sut = new MinAttribute(1);
sut.ErrorMessage = "My error.";
var error = sut.FormatErrorMessage("property");
Assert.IsTrue(error == "My error.");
}
public void Min_FormatErrorMessageWithErrorResource_ReturnsFormattedErrorMessage()
{
var sut = new MinAttribute(1);
sut.ErrorMessageResourceName = "MinAttribute_Invalid";
sut.ErrorMessageResourceType = typeof(DataAnnotationsResources);
var error = sut.FormatErrorMessage("property");
Assert.IsTrue(error == string.Format(DataAnnotationsResources.MinAttribute_Invalid, "property", 1));
}
public void ErrorMessageTest()
{
var attribute = new MinAttribute(1);
attribute.ErrorMessage = "SampleErrorMessage";
const string invalidValue = "a";
var result = attribute.GetValidationResult(invalidValue, new ValidationContext(0, null, null));
Assert.AreEqual("SampleErrorMessage", result.ErrorMessage);
}
public void ErrorResourcesTest()
{
var attribute = new MinAttribute(1);
attribute.ErrorMessageResourceName = "ErrorMessage";
attribute.ErrorMessageResourceType = typeof(ErrorResources);
const string invalidValue = "a";
var result = attribute.GetValidationResult(invalidValue, new ValidationContext(0, null, null));
Assert.AreEqual(ErrorResources.ErrorMessage, result.ErrorMessage);
}
public void GlobalizedErrorResourcesTest()
{
System.Threading.Thread.CurrentThread.CurrentUICulture = new CultureInfo("es-MX");
var attribute = new MinAttribute(1);
attribute.ErrorMessageResourceName = "ErrorMessage";
attribute.ErrorMessageResourceType = typeof(ErrorResources);
const string invalidValue = "a";
var result = attribute.GetValidationResult(invalidValue, new ValidationContext(0, null, null));
Assert.AreEqual("mensaje de error", result.ErrorMessage);
}
public void Validate(Config c)
{
var typ = c.GetType();
foreach (var field in typ.GetProperties())
{
MinAttribute min = field.Get <MinAttribute>();
MaxAttribute max = field.Get <MaxAttribute>();
if (min == null && max == null)
{
continue;
}
object value = field.GetValue(c, index: null);
var opt = field.Get <OptAttribute>();
if (min != null)
{
var coercedMinVal = (IComparable)opt.Coerce(min.Value, field.PropertyType);
if (coercedMinVal.CompareTo(value) == 1)
{
throw new Exception(string.Format("invalid {0} ! {1} < {2}", opt.Name, value, coercedMinVal));
}
}
if (max != null)
{
var coercedMaxVal = (IComparable)opt.Coerce(max.Value, field.PropertyType);
if (coercedMaxVal.CompareTo(value) == -1)
{
throw new Exception(string.Format("invalid {0} ! {1} > {2}", opt.Name, value, coercedMaxVal));
}
}
}
if (c.HeartbeatInterval > c.ReadTimeout)
{
throw new Exception(string.Format("HeartbeatInterval {0} must be less than ReadTimeout {1}",
c.HeartbeatInterval, c.ReadTimeout));
}
// TODO: PR go-nsq: this check was removed, seems still valid since the value can be set through code
// https://github.com/bitly/go-nsq/commit/dd8e5fc4ad80922d884ece51f5574af3fa4f14d3#diff-b4bda758a2aef091432646c354b4dc59L376
if (c.BackoffStrategy == null)
{
throw new Exception(string.Format("BackoffStrategy cannot be null"));
}
}
public void IsValid()
{
var v = new MinAttribute();
Assert.IsTrue(v.IsValid(0, null));
v = new MinAttribute(2);
Assert.IsTrue(v.IsValid(3, null));
Assert.IsTrue(v.IsValid(2, null));
Assert.IsTrue(v.IsValid((decimal)200.0, null));
Assert.IsTrue(v.IsValid(null, null));
Assert.IsTrue(v.IsValid("5", null));
Assert.IsTrue(v.IsValid((long)int.MaxValue + 1, null));
Assert.IsFalse(v.IsValid(1, null));
Assert.IsFalse(v.IsValid("aaa", null));
Assert.IsFalse(v.IsValid(new object(), null));
}
public void IsValidDoubleTests()
{
const double min = 3.50f;
var attribute = new MinAttribute(min);
Assert.IsTrue(attribute.IsValid(null)); // Optional values are always valid
Assert.IsTrue(attribute.IsValid("4"));
Assert.IsTrue(attribute.IsValid("4.5"));
Assert.IsTrue(attribute.IsValid(100));
Assert.IsTrue(attribute.IsValid("100.42"));
Assert.IsFalse(attribute.IsValid(3));
Assert.IsFalse(attribute.IsValid("3.498"));
Assert.IsFalse(attribute.IsValid("-5"));
Assert.IsFalse(attribute.IsValid("INVALID STRING"));
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
EditorGUI.BeginChangeCheck();
EditorGUI.DefaultPropertyField(position, property, label);
if (EditorGUI.EndChangeCheck())
{
MinAttribute minAttribute = (MinAttribute)attribute;
if (property.propertyType == SerializedPropertyType.Float)
{
property.floatValue = Mathf.Max(minAttribute.min, property.floatValue);
}
else if (property.propertyType == SerializedPropertyType.Integer)
{
property.intValue = Mathf.Max((int)minAttribute.min, property.intValue);
}
else if (property.propertyType == SerializedPropertyType.Vector2)
{
var value = property.vector2Value;
property.vector2Value = new Vector2(Mathf.Max(minAttribute.min, value.x), Mathf.Max(minAttribute.min, value.y));
}
else if (property.propertyType == SerializedPropertyType.Vector2Int)
{
var value = property.vector2IntValue;
property.vector2IntValue = new Vector2Int(Mathf.Max((int)minAttribute.min, value.x), Mathf.Max((int)minAttribute.min, value.y));
}
else if (property.propertyType == SerializedPropertyType.Vector3)
{
var value = property.vector3Value;
property.vector3Value = new Vector3(Mathf.Max(minAttribute.min, value.x), Mathf.Max(minAttribute.min, value.y), Mathf.Max(minAttribute.min, value.z));
}
else if (property.propertyType == SerializedPropertyType.Vector3Int)
{
var value = property.vector3IntValue;
property.vector3IntValue = new Vector3Int(Mathf.Max((int)minAttribute.min, value.x), Mathf.Max((int)minAttribute.min, value.y), Mathf.Max((int)minAttribute.min, value.z));
}
else if (property.propertyType == SerializedPropertyType.Vector4)
{
var value = property.vector4Value;
property.vector4Value = new Vector4(Mathf.Max(minAttribute.min, value.x), Mathf.Max(minAttribute.min, value.y), Mathf.Max(minAttribute.min, value.z), Mathf.Max(minAttribute.min, value.w));
}
else
{
EditorGUI.LabelField(position, label.text, "Use Min with float, int or Vector.");
}
}
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
MinAttribute attribute = (MinAttribute)base.attribute;
switch (property.propertyType)
{
case SerializedPropertyType.Integer:
int valueI = EditorGUI.IntField(position, label, property.intValue);
property.intValue = Mathf.Max(valueI, attribute.minInt);
break;
case SerializedPropertyType.Float:
float valueF = EditorGUI.FloatField(position, label, property.floatValue);
property.floatValue = Mathf.Max(valueF, attribute.minFloat);
break;
}
}
public void IsValidIntegerTests()
{
const int min = 42;
var attribute = new MinAttribute(min);
Assert.IsTrue(attribute.IsValid(null)); // Optional values are always valid
Assert.IsTrue(attribute.IsValid("42"));
Assert.IsTrue(attribute.IsValid(42.5));
Assert.IsTrue(attribute.IsValid("50"));
Assert.IsTrue(attribute.IsValid(100));
Assert.IsTrue(attribute.IsValid("10000000000"));
Assert.IsFalse(attribute.IsValid("41"));
Assert.IsFalse(attribute.IsValid("10"));
Assert.IsFalse(attribute.IsValid(0));
Assert.IsFalse(attribute.IsValid("-1"));
Assert.IsFalse(attribute.IsValid(-50));
Assert.IsFalse(attribute.IsValid("fifty"));
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
MinAttribute attribute = (MinAttribute)base.attribute;
if (property.propertyType == SerializedPropertyType.Integer)
{
int v = EditorGUI.IntField(position, label, property.intValue);
property.intValue = (int)Mathf.Max(v, attribute.min);
}
else if (property.propertyType == SerializedPropertyType.Float)
{
float v = EditorGUI.FloatField(position, label, property.floatValue);
property.floatValue = Mathf.Max(v, attribute.min);
}
else
{
EditorGUI.LabelField(position, label.text, "Use Min with float or int.");
}
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
MinAttribute min = (MinAttribute)attribute;
if (property.propertyType == SerializedPropertyType.Float || property.propertyType == SerializedPropertyType.Integer)
{
if (property.floatValue < min.min)
{
property.floatValue = min.min;
}
label.text += " (>=" + min.min + ")";
property.floatValue = EditorGUI.FloatField(position, label, property.floatValue);
}
else
{
Debug.LogError("Min Attribute does not support the type of the variable: " + property.name);
}
}
public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
{
MinAttribute attribute = (MinAttribute)base.attribute;
if (property.propertyType == SerializedPropertyType.Integer)
{
int v = EditorGUI.IntField(position, label, property.intValue);
property.intValue = (int)Mathf.Max(v, attribute.min);
}
else if (property.propertyType == SerializedPropertyType.Float)
{
float v = EditorGUI.FloatField(position, label, property.floatValue);
property.floatValue = Mathf.Max(v, attribute.min);
}
else if (property.propertyType == SerializedPropertyType.Vector2)
{
Vector2 v = EditorGUI.Vector2Field(position, label, property.vector2Value);
property.vector2Value = new Vector2(
Mathf.Max(v.x, attribute.min),
Mathf.Max(v.y, attribute.min));
}
else if (property.propertyType == SerializedPropertyType.Vector3)
{
Vector3 v = EditorGUI.Vector2Field(position, label, property.vector3Value);
property.vector3Value = new Vector3(
Mathf.Max(v.x, attribute.min),
Mathf.Max(v.y, attribute.min),
Mathf.Max(v.z, attribute.min));
}
else if (property.propertyType == SerializedPropertyType.Vector4)
{
Vector4 v = EditorGUI.Vector2Field(position, label, property.vector4Value);
property.vector4Value = new Vector4(
Mathf.Max(v.x, attribute.min),
Mathf.Max(v.y, attribute.min),
Mathf.Max(v.z, attribute.min),
Mathf.Max(v.w, attribute.min));
}
else
{
EditorGUI.LabelField(position, label.text, "Use Min with int, float, or vector2/3/4.");
}
}
private static string WriteExtenders(PropertyInfo p, out bool isValidatable)
{
isValidatable = false;
StringBuilder sb = new StringBuilder();
sb.Append(".extend({ editState : false, disableValidation : false, empty : true })");
RequiredAttribute requiredAttribute = p.GetCustomAttribute <RequiredAttribute>();
if (requiredAttribute != null)
{
sb.Append($".extend({{ required: {{ message: \"{requiredAttribute.FormatErrorMessage(p.Name)}\", onlyIf: function() {{ return ko.utils.isPropertyValidatable(self, \"{ p.Name}\"); }} }} }})");
isValidatable = true;
}
MinLengthAttribute minLengthAttribute = p.GetCustomAttribute <MinLengthAttribute>();
if (minLengthAttribute != null)
{
sb.Append(string.Format(".extend({ minLength: { message: \"{0}\", params: {1}, onlyIf: function() { return ko.utils.isPropertyValidatable(self, \"{2}\"); } } })", minLengthAttribute.FormatErrorMessage(p.Name), minLengthAttribute.Length, p.Name));
isValidatable = true;
}
MaxLengthAttribute maxLengthAttribute = p.GetCustomAttribute <MaxLengthAttribute>();
if (maxLengthAttribute != null)
{
sb.Append(string.Format(".extend({ maxLength: { message: \"{0}\", params: {1}, onlyIf: function() { return ko.utils.isPropertyValidatable(self, \"{2}\"); } } })", maxLengthAttribute.FormatErrorMessage(p.Name), maxLengthAttribute.Length, p.Name));
isValidatable = true;
}
RegularExpressionAttribute regularExpressionAttribute = p.GetCustomAttribute <RegularExpressionAttribute>();
if (regularExpressionAttribute != null)
{
sb.Append(string.Format(".extend({ pattern: { message: \"{0}\", params: /{1}/, onlyIf: function() { return ko.utils.isPropertyValidatable(self, \"{2}\"); } } })", regularExpressionAttribute.FormatErrorMessage(p.Name), regularExpressionAttribute.Pattern, p.Name));
isValidatable = true;
}
UrlAttribute urlAttribute = p.GetCustomAttribute <UrlAttribute>();
if (urlAttribute != null)
{
sb.Append(string.Format(".extend({ pattern: { message: \"{0}\", params: /{1}/, onlyIf: function() { return ko.utils.isPropertyValidatable(self, \"{2}\"); } } })", urlAttribute.FormatErrorMessage(p.Name), urlAttribute, p.Name));
isValidatable = true;
}
DateAttribute dateAttribute = p.GetCustomAttribute <DateAttribute>();
if (dateAttribute != null)
{
sb.Append(string.Format(".extend({ date: { message: \"{0}\", onlyIf: function() { return ko.utils.isPropertyValidatable(self, \"{1}\"); } } })", dateAttribute.FormatErrorMessage(p.Name), p.Name));
isValidatable = true;
}
NumericAttribute numericAttribute = p.GetCustomAttribute <NumericAttribute>();
if (numericAttribute != null)
{
sb.Append(
string.Format(".extend({ number: { message: \"{0}\", onlyIf: function() { return ko.utils.isPropertyValidatable(self, \"{1}\"); } } }).extend({ numeric: {2} })",
numericAttribute.FormatErrorMessage(p.Name), p.Name, numericAttribute.Precision));
isValidatable = true;
}
EmailAttribute emailAttribute = p.GetCustomAttribute <EmailAttribute>();
if (emailAttribute != null)
{
sb.Append(string.Format(".extend({ email: { message: \"{0}\", onlyIf: function() { return ko.utils.isPropertyValidatable(self, \"{1}\"); } } })", emailAttribute.FormatErrorMessage(p.Name), p.Name));
isValidatable = true;
}
DigitsAttribute digitsAttribute = p.GetCustomAttribute <DigitsAttribute>();
if (digitsAttribute != null)
{
sb.Append(string.Format(".extend({ digit: { message: \"{0}\", onlyIf: function() { return ko.utils.isPropertyValidatable(self, \"{1}\"); } } }).extend({ numeric: 0 })", digitsAttribute.FormatErrorMessage(p.Name), p.Name));
isValidatable = true;
}
MinAttribute minAttribute = p.GetCustomAttribute <MinAttribute>();
if (minAttribute != null)
{
sb.Append(string.Format(".extend({ min: { message: \"{0}\", params: {1}, onlyIf: function() { return ko.utils.isPropertyValidatable(self, \"{2}\"); } } })", minAttribute.FormatErrorMessage(p.Name), minAttribute.Min, p.Name));
isValidatable = true;
}
MaxAttribute maxAttribute = p.GetCustomAttribute <MaxAttribute>();
if (maxAttribute != null)
{
sb.Append(string.Format(".extend({ max: { message: \"{0}\", params: {1}, onlyIf: function() { return ko.utils.isPropertyValidatable(self, \"{2}\"); } } })", maxAttribute.FormatErrorMessage(p.Name), maxAttribute.Max, p.Name));
isValidatable = true;
}
EqualToAttribute equalToAttribute = p.GetCustomAttribute <EqualToAttribute>();
if (equalToAttribute != null)
{
sb.Append(string.Format(".extend({ equal: { message: \"{0}\", params: {1}, onlyIf: function() { return ko.utils.isPropertyValidatable(self, \"{2}\"); } } })", equalToAttribute.FormatErrorMessage(p.Name), equalToAttribute.OtherProperty, p.Name));
isValidatable = true;
}
CompareAttribute compareAttribute = p.GetCustomAttribute <CompareAttribute>();
if (compareAttribute != null)
{
sb.Append(string.Format(".extend({ equal: { message: \"{0}\", params: \"{1}\", onlyIf: function() { return ko.utils.isPropertyValidatable(self, \"{2}\"); } } })", compareAttribute.FormatErrorMessage(p.Name), compareAttribute.OtherProperty, p.Name));
isValidatable = true;
}
FormatterAttribute formatterAttribute = p.GetCustomAttribute <FormatterAttribute>();
if (formatterAttribute != null)
{
sb.Append(string.Format(".formatted({0}, {1})", formatterAttribute.Formatter, JsonConvert.SerializeObject(formatterAttribute.Arguments)));
}
return(sb.ToString());
}
public void CheckDoubleValidation(double value, bool expected)
{
var attribute = new MinAttribute(0);
Assert.Equal(expected, attribute.IsValid(value));
}
public void Min_EmptyValue_Validates()
{
var sut = new MinAttribute(1);
Assert.IsTrue(sut.IsValid(string.Empty));
}
public void KnownRulesConvertAssing()
{
NhvMapping map = XmlMappingLoader.GetXmlMappingFor(typeof(WellKnownRules));
NhvmClass cm = map.@class[0];
XmlClassMapping rm = new XmlClassMapping(cm);
MemberInfo mi;
List <Attribute> attributes;
mi = typeof(WellKnownRules).GetField("AP");
attributes = new List <Attribute>(rm.GetMemberAttributes(mi));
Assert.AreEqual("A string value", ((ACustomAttribute)attributes[0]).Value1);
Assert.AreEqual(123, ((ACustomAttribute)attributes[0]).Value2);
Assert.AreEqual("custom message", ((ACustomAttribute)attributes[0]).Message);
mi = typeof(WellKnownRules).GetField("StrProp");
attributes = new List <Attribute>(rm.GetMemberAttributes(mi));
NotEmptyAttribute nea = FindAttribute <NotEmptyAttribute>(attributes);
Assert.AreEqual("not-empty message", nea.Message);
NotNullAttribute nna = FindAttribute <NotNullAttribute>(attributes);
Assert.AreEqual("not-null message", nna.Message);
NotNullNotEmptyAttribute nnea = FindAttribute <NotNullNotEmptyAttribute>(attributes);
Assert.AreEqual("notnullnotempty message", nnea.Message);
LengthAttribute la = FindAttribute <LengthAttribute>(attributes);
Assert.AreEqual("length message", la.Message);
Assert.AreEqual(1, la.Min);
Assert.AreEqual(10, la.Max);
PatternAttribute pa = FindAttribute <PatternAttribute>(attributes);
Assert.AreEqual("pattern message", pa.Message);
Assert.AreEqual("[0-9]+", pa.Regex);
Assert.AreEqual(RegexOptions.Compiled, pa.Flags);
EmailAttribute ea = FindAttribute <EmailAttribute>(attributes);
Assert.AreEqual("email message", ea.Message);
IPAddressAttribute ipa = FindAttribute <IPAddressAttribute>(attributes);
Assert.AreEqual("ipAddress message", ipa.Message);
EANAttribute enaa = FindAttribute <EANAttribute>(attributes);
Assert.AreEqual("ean message", enaa.Message);
CreditCardNumberAttribute ccna = FindAttribute <CreditCardNumberAttribute>(attributes);
Assert.AreEqual("creditcardnumber message", ccna.Message);
IBANAttribute iban = FindAttribute <IBANAttribute>(attributes);
Assert.AreEqual("iban message", iban.Message);
mi = typeof(WellKnownRules).GetField("DtProp");
attributes = new List <Attribute>(rm.GetMemberAttributes(mi));
FutureAttribute fa = FindAttribute <FutureAttribute>(attributes);
Assert.AreEqual("future message", fa.Message);
PastAttribute psa = FindAttribute <PastAttribute>(attributes);
Assert.AreEqual("past message", psa.Message);
mi = typeof(WellKnownRules).GetField("DecProp");
attributes = new List <Attribute>(rm.GetMemberAttributes(mi));
DigitsAttribute dga = FindAttribute <DigitsAttribute>(attributes);
Assert.AreEqual("digits message", dga.Message);
Assert.AreEqual(5, dga.IntegerDigits);
Assert.AreEqual(2, dga.FractionalDigits);
MinAttribute mina = FindAttribute <MinAttribute>(attributes);
Assert.AreEqual("min message", mina.Message);
Assert.AreEqual(100, mina.Value);
MaxAttribute maxa = FindAttribute <MaxAttribute>(attributes);
Assert.AreEqual("max message", maxa.Message);
Assert.AreEqual(200, maxa.Value);
DecimalMaxAttribute decimalmaxa = FindAttribute <DecimalMaxAttribute>(attributes);
Assert.AreEqual("decimal max message", decimalmaxa.Message);
Assert.AreEqual(200.1m, decimalmaxa.Value);
DecimalMinAttribute decimalmina = FindAttribute <DecimalMinAttribute>(attributes);
Assert.AreEqual("decimal min message", decimalmina.Message);
Assert.AreEqual(99.9m, decimalmina.Value);
mi = typeof(WellKnownRules).GetField("BProp");
attributes = new List <Attribute>(rm.GetMemberAttributes(mi));
AssertTrueAttribute ata = FindAttribute <AssertTrueAttribute>(attributes);
Assert.AreEqual("asserttrue message", ata.Message);
AssertFalseAttribute afa = FindAttribute <AssertFalseAttribute>(attributes);
Assert.AreEqual("assertfalse message", afa.Message);
mi = typeof(WellKnownRules).GetField("ArrProp");
attributes = new List <Attribute>(rm.GetMemberAttributes(mi));
SizeAttribute sa = FindAttribute <SizeAttribute>(attributes);
Assert.AreEqual("size message", sa.Message);
Assert.AreEqual(2, sa.Min);
Assert.AreEqual(9, sa.Max);
mi = typeof(WellKnownRules).GetField("Pattern");
attributes = new List <Attribute>(rm.GetMemberAttributes(mi));
PatternAttribute spa = FindAttribute <PatternAttribute>(attributes);
Assert.AreEqual("{validator.pattern}", spa.Message);
Assert.AreEqual(@"\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,4}\b", spa.Regex);
Assert.AreEqual(RegexOptions.CultureInvariant | RegexOptions.IgnoreCase, spa.Flags);
}
