예제 #1
0
        public void Max_MaximumIsIntegerAndTheValueIsGreaterThan_Fails()
        {
            int value = 2;
            var sut   = new MaxAttribute(1);

            Assert.IsFalse(sut.IsValid(value));
        }
예제 #2
0
        public void Max_MaximumIsIntegerAndTheValueIsLessThan_Validates()
        {
            int value = 0;
            var sut   = new MaxAttribute(1);

            Assert.IsTrue(sut.IsValid(value));
        }
        public async Task <IActionResult> Edit(int id, [Bind("ID,ObjectName,AttributeName,Description,CreatedDate")] MaxAttribute maxAttr)
        {
            if (id != maxAttr.ID)
            {
                return(NotFound());
            }

            if (ModelState.IsValid)
            {
                try
                {
                    _context.Update(maxAttr);
                    await _context.SaveChangesAsync();
                }
                catch (DbUpdateConcurrencyException)
                {
                    if (!MaxAttrExists(maxAttr.ID))
                    {
                        return(NotFound());
                    }
                    else
                    {
                        throw;
                    }
                }
                return(RedirectToAction(nameof(Index)));
            }
            return(View(maxAttr));
        }
예제 #4
0
        public void Max_MaximumIsDoubleAndTheValueIsLessThan_Validates()
        {
            double value = 0;
            var    sut   = new MaxAttribute(1.1);

            Assert.IsTrue(sut.IsValid(value));
        }
예제 #5
0
        public void Max_MaximumIsSpecifiedTypeAndTheValueIsGreaterThan_Fails()
        {
            long value = 2;
            var  sut   = new MaxAttribute(typeof(long), "1");

            Assert.IsFalse(sut.IsValid(value));
        }
예제 #6
0
        private static Attribute ConvertToMax(XmlNhvmRuleConverterArgs rule)
        {
            NhvmMax maxRule = (NhvmMax)rule.schemaRule;
            long    value   = long.MaxValue;

            if (maxRule.valueSpecified)
            {
                value = maxRule.value;
            }

#if NETFX
            log.Info(string.Format("Converting to Max attribute with value {0}", value));
#else
            Log.Info("Converting to Max attribute with value {0}", value);
#endif
            MaxAttribute thisAttribute = new MaxAttribute();
            thisAttribute.Value = value;

            if (maxRule.message != null)
            {
                thisAttribute.Message = maxRule.message;
            }
            AssignTagsFromString(thisAttribute, maxRule.tags);

            return(thisAttribute);
        }
예제 #7
0
        public void Max_MaximumIsDoubleAndTheValueIsGreaterThan_Fails()
        {
            double value = 2.2;
            var    sut   = new MaxAttribute(1.1);

            Assert.IsFalse(sut.IsValid(value));
        }
예제 #8
0
        public void Max_MaximumIsSpecifiedTypeAndTheValueIsEqualTo_Validates()
        {
            long value = 1;
            var  sut   = new MaxAttribute(typeof(long), "1");

            Assert.IsTrue(sut.IsValid(value));
        }
예제 #9
0
        public void Max_FormatErrorMessage_ReturnsFormattedErrorMessage()
        {
            var sut = new MaxAttribute(1);

            var error = sut.FormatErrorMessage("property");

            Assert.IsTrue(!string.IsNullOrEmpty(error));
        }
예제 #10
0
        public void Max_FormatErrorMessageWithErrorMessage_ReturnsFormattedErrorMessage()
        {
            var sut = new MaxAttribute(1);

            sut.ErrorMessage = "My error.";

            var error = sut.FormatErrorMessage("property");

            Assert.IsTrue(error == "My error.");
        }
예제 #11
0
        public void Max_FormatErrorMessageWithErrorResource_ReturnsFormattedErrorMessage()
        {
            var sut = new MaxAttribute(1);

            sut.ErrorMessageResourceName = "MaxAttribute_Invalid";
            sut.ErrorMessageResourceType = typeof(DataAnnotationsResources);

            var error = sut.FormatErrorMessage("property");

            Assert.IsTrue(error == string.Format(DataAnnotationsResources.MaxAttribute_Invalid, "property", 1));
        }
        public async Task <IActionResult> Create([Bind("ID,Description,ObjectName,AttributeName,Type,Size,Purpose,CreatedDate")] MaxAttribute maxAttr)
        {
            if (ModelState.IsValid)
            {
                _context.Add(maxAttr);
                await _context.SaveChangesAsync();

                return(RedirectToAction(nameof(Index)));
            }
            return(View(maxAttr));
        }
예제 #13
0
        public void ErrorMessageTest()
        {
            var attribute = new MaxAttribute(1);

            attribute.ErrorMessage = "SampleErrorMessage";

            const string invalidValue = "a";

            var result = attribute.GetValidationResult(invalidValue, new ValidationContext(0, null, null));

            Assert.AreEqual("SampleErrorMessage", result.ErrorMessage);
        }
예제 #14
0
        public void ErrorResourcesTest()
        {
            var attribute = new MaxAttribute(1);

            attribute.ErrorMessageResourceName = "ErrorMessage";
            attribute.ErrorMessageResourceType = typeof(ErrorResources);

            const string invalidValue = "a";

            var result = attribute.GetValidationResult(invalidValue, new ValidationContext(0, null, null));

            Assert.AreEqual("error message", result.ErrorMessage);
        }
예제 #15
0
        public void GlobalizedErrorResourcesTest()
        {
            System.Threading.Thread.CurrentThread.CurrentUICulture = new CultureInfo("es-MX");

            var attribute = new MaxAttribute(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);
        }
예제 #16
0
            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"));
                }
            }
예제 #17
0
        public void IsValid()
        {
            var v = new MaxAttribute();

            Assert.IsTrue(v.IsValid(0, null));
            v = new MaxAttribute(1000);
            Assert.IsTrue(v.IsValid(3, null));
            Assert.IsTrue(v.IsValid(200.0m, null));
            Assert.IsTrue(v.IsValid(1000, null));
            Assert.IsTrue(v.IsValid(null, null));
            Assert.IsTrue(v.IsValid("5", null));
            Assert.IsFalse(v.IsValid(1001, null));
            Assert.IsFalse(v.IsValid("aaa", null));
            Assert.IsFalse(v.IsValid(new object(), null));
            Assert.IsFalse(v.IsValid(long.MaxValue, null));
        }
예제 #18
0
        public void IsValidDoubleTests()
        {
            const double max = 3.50f;

            var attribute = new MaxAttribute(max);

            Assert.IsTrue(attribute.IsValid(null));  // Optional values are always valid
            Assert.IsTrue(attribute.IsValid(3));
            Assert.IsTrue(attribute.IsValid("3.498"));
            Assert.IsTrue(attribute.IsValid("-5"));
            Assert.IsFalse(attribute.IsValid(3.51));
            Assert.IsFalse(attribute.IsValid("4"));
            Assert.IsFalse(attribute.IsValid("4.5"));
            Assert.IsFalse(attribute.IsValid(100));
            Assert.IsFalse(attribute.IsValid("100.42"));
            Assert.IsFalse(attribute.IsValid("INVALID STRING"));
        }
예제 #19
0
        public void IsValidIntegerTests()
        {
            const int max       = 42;
            var       attribute = new MaxAttribute(max);

            Assert.IsTrue(attribute.IsValid(null));  // Optional values are always valid
            Assert.IsTrue(attribute.IsValid("41"));
            Assert.IsTrue(attribute.IsValid("10"));
            Assert.IsTrue(attribute.IsValid(0));
            Assert.IsTrue(attribute.IsValid("-1"));
            Assert.IsTrue(attribute.IsValid(-50));
            Assert.IsTrue(attribute.IsValid("42"));
            Assert.IsFalse(attribute.IsValid(42.5));
            Assert.IsFalse(attribute.IsValid(43));
            Assert.IsFalse(attribute.IsValid("50"));
            Assert.IsFalse(attribute.IsValid(100));
            Assert.IsFalse(attribute.IsValid("10000000000"));
            Assert.IsFalse(attribute.IsValid("fifty"));
        }
예제 #20
0
        public void Extreme()
        {
            var v = new MaxAttribute(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.MaxValue, null));
            Assert.IsFalse(v.IsValid(decimal.MaxValue.ToString(), null));
            Assert.IsFalse(v.IsValid(double.MaxValue, null));
            Assert.IsFalse(v.IsValid("1" + double.MaxValue, null));
        }
        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());
        }
예제 #22
0
    public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
    {
        MaxAttribute max = (MaxAttribute)attribute;

        if (fieldInfo.FieldType == typeof(int))
        {
            if (property.intValue > max.intValue)
            {
                property.intValue = max.intValue;
            }
        }
        else if (fieldInfo.FieldType == typeof(long))
        {
            switch (max.valueType)
            {
            case MaxAttribute.ValueType.Int:
                if (property.longValue > max.intValue)
                {
                    property.longValue = max.intValue;
                }
                break;

            case MaxAttribute.ValueType.Long:
                if (property.longValue > max.longValue)
                {
                    property.longValue = max.longValue;
                }
                break;
            }
        }
        else if (fieldInfo.FieldType == typeof(float))
        {
            switch (max.valueType)
            {
            case MaxAttribute.ValueType.Int:
                if (property.floatValue > max.intValue)
                {
                    property.floatValue = max.intValue;
                }
                break;

            case MaxAttribute.ValueType.Long:
                if (property.floatValue > max.longValue)
                {
                    property.floatValue = max.longValue;
                }
                break;

            case MaxAttribute.ValueType.Float:
                if (property.floatValue > max.floatValue)
                {
                    property.floatValue = max.floatValue;
                }
                break;
            }
        }
        else if (fieldInfo.FieldType == typeof(double))
        {
            switch (max.valueType)
            {
            case MaxAttribute.ValueType.Int:
                if (property.doubleValue > max.intValue)
                {
                    property.doubleValue = max.intValue;
                }
                break;

            case MaxAttribute.ValueType.Long:
                if (property.doubleValue > max.longValue)
                {
                    property.doubleValue = max.longValue;
                }
                break;

            case MaxAttribute.ValueType.Float:
                if (property.doubleValue > max.floatValue)
                {
                    property.doubleValue = max.floatValue;
                }
                break;

            case MaxAttribute.ValueType.Double:
                if (property.doubleValue > max.doubleValue)
                {
                    property.doubleValue = max.doubleValue;
                }
                break;

            default:
                break;
            }
        }
    }
        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);
        }
예제 #24
0
        /***************************
         *******   METHODS   *******
         **************************/

        // Make your own IMGUI based GUI for the property
        public override void OnGUI(Rect _position, SerializedProperty _property, GUIContent _label)
        {
            MaxAttribute _attribute = (MaxAttribute)attribute;

            EditorGUIEnhanced.MaxField(_position, _property, _label, _attribute.MaxValue);
        }
예제 #25
0
        public void Max_NullValue_Validates()
        {
            var sut = new MaxAttribute(1);

            Assert.IsTrue(sut.IsValid(null));
        }
예제 #26
0
        public void Max_EmptyValue_Validates()
        {
            var sut = new MaxAttribute(1);

            Assert.IsTrue(sut.IsValid(string.Empty));
        }