public void ConstructorWithTargetTypeAndMessageTemplateAndNegatedCreatesCorrectInstance()
        {
            TypeConversionValidator validator = new TypeConversionValidator(typeof(int), "my message template", true);

            Assert.AreEqual("my message template", validator.MessageTemplate);
            Assert.AreEqual(true, validator.Negated);
            Assert.AreEqual(typeof(int), validator.TargetType);
        }
        public void ConstructorWithTargetTypeAndNegatedCreatesCorrectInstance()
        {
            TypeConversionValidator validator = new TypeConversionValidator(typeof(int), true);

            Assert.AreEqual(Resources.TypeConversionNegatedDefaultMessageTemplate, validator.MessageTemplate);
            Assert.AreEqual(true, validator.Negated);
            Assert.AreEqual(typeof(int), validator.TargetType);
        }
        public void ConstructorWithTargetTypeAndNegatedCreatesCorrectInstance()
        {
            TypeConversionValidator validator = new TypeConversionValidator(typeof(int), true);

            Assert.AreEqual(Resources.TypeConversionNegatedDefaultMessageTemplate, validator.MessageTemplate);
            Assert.AreEqual(true, validator.Negated);
            Assert.AreEqual(typeof(int), validator.TargetType);
        }
        public void ConstructorWithTargetTypeAndMessageTemplateCreatesCorrectInstance()
        {
            TypeConversionValidator validator = new TypeConversionValidator(typeof(int), "my message template");

            Assert.AreEqual("my message template", validator.MessageTemplate);
            Assert.AreEqual(false, validator.Negated);
            Assert.AreEqual(typeof(int), validator.TargetType);
        }
        public void NonNegatedRejectsNull()
        {
            TypeConversionValidator validator = new TypeConversionValidator(typeof(int), false);

            ValidationResults results = validator.Validate(null);

            Assert.IsFalse(results.IsValid);
        }
        public void NonNegatedAcceptsEmptyStringWithStringType()
        {
            TypeConversionValidator validator = new TypeConversionValidator(typeof(string));

            ValidationResults results = validator.Validate(string.Empty);

            Assert.IsTrue(results.IsValid);
        }
        public void NonNegatedRejectsEmptyStringWithIntType()
        {
            TypeConversionValidator validator = new TypeConversionValidator(typeof(int));

            ValidationResults results = validator.Validate(string.Empty);

            Assert.IsFalse(results.IsValid);
        }
        public void NegatedAcceptsStringWithIntType()
        {
            TypeConversionValidator validator = new TypeConversionValidator(typeof(int), true);

            ValidationResults results = validator.Validate("a");

            Assert.IsTrue(results.IsValid);
        }
        public void NonNegatedRejectsNull()
        {
            TypeConversionValidator validator = new TypeConversionValidator(typeof(int), false);

            ValidationResults results = validator.Validate(null);

            Assert.IsFalse(results.IsValid);
        }
 public TypeConversionValidatorOperation(
     string inKey,
     string resultKey,
     Type targetType,
     bool negated,
     bool ignoreEmpty)
     : base(inKey, resultKey, ignoreEmpty) {
     Validator = new TypeConversionValidator(targetType, string.Empty, negated) { Tag = inKey };
 }
 public TypeConversionValidatorOperation(
     string inKey,
     string resultKey,
     Type targetType,
     bool negated,
     bool ignoreEmpty)
     : base(inKey, resultKey, ignoreEmpty)
 {
     Validator = new TypeConversionValidator(targetType, string.Empty, negated)
     {
         Tag = inKey
     };
 }
Esempio n. 12
0
        public void AttributeWithTargetTypeCreatesValidator()
        {
            ValidatorAttribute attribute = new TypeConversionValidatorAttribute(typeof(double));

            Validator validator = ((IValidatorDescriptor)attribute).CreateValidator(null, null, null);

            Assert.IsNotNull(validator);

            TypeConversionValidator typedValidator = validator as TypeConversionValidator;

            Assert.IsNotNull(typedValidator);

            Assert.AreEqual(false, typedValidator.Negated);
            Assert.AreEqual(typeof(double), typedValidator.TargetType);
        }
        public void SuppliesAppropriateParametersToDefaultNegatedMessage()
        {
            TypeConversionValidator validator = new TypeConversionValidator(typeof(int), true);

            validator.Tag = "tag";
            object target = "10";
            string key    = "key";

            ValidationResults validationResults = new ValidationResults();

            validator.DoValidate(target, null, key, validationResults);

            Assert.IsFalse(validationResults.IsValid);
            ValidationResult validationResult = ValidationTestHelper.GetResultsList(validationResults)[0];
            Match            match            = TemplateStringTester.Match(validator.MessageTemplate, validationResult.Message);

            Assert.IsTrue(match.Success);
            Assert.IsFalse(match.Groups["param0"].Success);
            Assert.IsFalse(match.Groups["param1"].Success);
            Assert.IsFalse(match.Groups["param2"].Success);
            Assert.IsTrue(match.Groups["param3"].Success);
            Assert.AreEqual("System.Int32", match.Groups["param3"].Value);
        }
        public void NonNegatedRejectsEmptyStringWithIntType()
        {
            TypeConversionValidator validator = new TypeConversionValidator(typeof(int));

            ValidationResults results = validator.Validate(string.Empty);

            Assert.IsFalse(results.IsValid);
        }
        public void NonNegatedAcceptsStringWithIntType()
        {
            TypeConversionValidator validator = new TypeConversionValidator(typeof(int), false);

            ValidationResults results = validator.Validate("12");

            Assert.IsTrue(results.IsValid);
        }
        public void NegatedRejectsStringWithIntType()
        {
            TypeConversionValidator validator = new TypeConversionValidator(typeof(int), true);

            ValidationResults results = validator.Validate("12");

            Assert.IsFalse(results.IsValid);
        }
        public void SuppliesAppropriateParametersToDefaultNegatedMessage()
        {
            TypeConversionValidator validator = new TypeConversionValidator(typeof(int), true);
            validator.Tag = "tag";
            object target = "10";
            string key = "key";

            ValidationResults validationResults = new ValidationResults();
            validator.DoValidate(target, null, key, validationResults);

            Assert.IsFalse(validationResults.IsValid);
            ValidationResult validationResult = ValidationTestHelper.GetResultsList(validationResults)[0];
            Match match = TemplateStringTester.Match(validator.MessageTemplate, validationResult.Message);
            Assert.IsTrue(match.Success);
            Assert.IsFalse(match.Groups["param0"].Success);
            Assert.IsFalse(match.Groups["param1"].Success);
            Assert.IsFalse(match.Groups["param2"].Success);
            Assert.IsTrue(match.Groups["param3"].Success);
            Assert.AreEqual("System.Int32", match.Groups["param3"].Value);
        }
        public void NonNegatedAcceptsEmptyStringWithStringType()
        {
            TypeConversionValidator validator = new TypeConversionValidator(typeof(string));

            ValidationResults results = validator.Validate(string.Empty);

            Assert.IsTrue(results.IsValid);
        }