public void DoValidateSubmit(ValidationResults results)
 {
     if (this.Modes.Count == 0)
         results.AddResult(new ValidationResult("At least one ground transportation mode is required.",
             typeof(Ground),
             "", "", null));
 }

		public void DoValidateCollectionItemSucceedsForUniqueNamedElements()
		{
			Store store = new Store(typeof(CoreDesignSurfaceDomainModel), typeof(ServiceContractDslDomainModel));
			ServiceContractModel model;

			using (Transaction transaction = store.TransactionManager.BeginTransaction())
			{
				model = store.ElementFactory.CreateElement(ServiceContractModel.DomainClassId) as ServiceContractModel;

				ServiceContract contract = store.ElementFactory.CreateElement(ServiceContract.DomainClassId) as ServiceContract;
				contract.Name = "Contract Name";

				Operation part = store.ElementFactory.CreateElement(Operation.DomainClassId) as Operation;
				part.Name = "Part Name";

				contract.Operations.Add(part);

				TestableOperationElementCollectionValidator target = new TestableOperationElementCollectionValidator();

				ValidationResults results = new ValidationResults();
				target.TestDoValidateCollectionItem(part, contract, String.Empty, results);

				Assert.IsTrue(results.IsValid);

				transaction.Commit();
			}
		}

 /// <summary>
 /// Implements the validation logic for the receiver.
 /// </summary>
 /// <param name="objectToValidate">The object to validate.</param>
 /// <param name="currentTarget">The object on the behalf of which the validation is performed.</param>
 /// <param name="key">The key that identifies the source of <paramref name="objectToValidate"/>.</param>
 /// <param name="validationResults">The validation results to which the outcome of the validation should be stored.</param>
 public override void DoValidate(object objectToValidate, object currentTarget, string key, ValidationResults validationResults)
 {
     if (objectToValidate != null)
     {
         this.wrappedValidator.DoValidate(objectToValidate, currentTarget, key, validationResults);
     }
 }

 /// <summary>
 /// Validates by invoking the self validation method configured for the validator.
 /// </summary>
 /// <param name="objectToValidate">The object to validate.</param>
 /// <param name="currentTarget">The object on the behalf of which the validation is performed.</param>
 /// <param name="key">The key that identifies the source of <paramref name="objectToValidate"/>.</param>
 /// <param name="validationResults">The validation results to which the outcome of the validation should be stored.</param>
 /// <remarks>
 /// A validation failure will be logged by the validator when the following conditions are met without
 /// invoking the self validation method:
 /// <list type="bullet">
 /// <item><term><paramref name="objectToValidate"/> is <see langword="null"/>.</term></item>
 /// <item><term><paramref name="objectToValidate"/> is an instance of a type not compatible with the declaring type for the 
 /// self validation method.</term></item>
 /// </list>
 /// <para/>
 /// A validation failure will also be logged if the validation method throws an exception.
 /// </remarks>
 public override void DoValidate(object objectToValidate,
     object currentTarget,
     string key,
     ValidationResults validationResults)
 {
     if (null == objectToValidate)
     {
         this.LogValidationResult(validationResults, Resources.SelfValidationValidatorMessage, currentTarget, key);
     }
     else if (!this.methodInfo.DeclaringType.IsAssignableFrom(objectToValidate.GetType()))
     {
         this.LogValidationResult(validationResults, Resources.SelfValidationValidatorMessage, currentTarget, key);
     }
     else
     {
         try
         {
             this.methodInfo.Invoke(objectToValidate, new object[] { validationResults });
         }
         catch (Exception)
         {
             this.LogValidationResult(validationResults, Resources.SelfValidationMethodThrownMessage, currentTarget, key);
         }
     }
 }

        /// <summary>
        /// Applies the validation logic represented by the receiver on an object, 
        /// adding the validation results to <paramref name="validationResults"/>.
        /// </summary>
        /// <param name="target">The object to validate.</param>
        /// <param name="validationResults">The validation results to which the outcome of the validation should be stored.</param>
        public void Validate(object target, ValidationResults validationResults)
        {
            if (null == validationResults)
                throw new ArgumentNullException("validationResults");

            DoValidate(target, target, null, validationResults);
        }

        public void ControlValidationMappingsFailureTest()
        {
            IBugzillaPageView viewMock = MockRepository.StrictMock<IBugzillaPageView>();

            Expect.Call(viewMock.Model).PropertyBehavior();
            viewMock.ValidationRequested += null;
            LastCall.IgnoreArguments();
            viewMock.ControlValidationTriggered += null;
            LastCall.IgnoreArguments();
            IEventRaiser raiser = LastCall.GetEventRaiser();
            Expect.Call(FacadeMock.GetSourceList()).Return(new string[0]);
            Expect.Call(viewMock.SourceList).PropertyBehavior().Return(new string[0]);
            Expect.Call(FacadeMock.GetProjectWrapperList()).Return(null);
            Expect.Call(viewMock.VersionOneProjects).PropertyBehavior();
            Expect.Call(FacadeMock.GetVersionOnePriorities()).Return(null);
            Expect.Call(viewMock.VersionOnePriorities).PropertyBehavior();
            viewMock.DataBind();
            ValidationResults results = new ValidationResults();
            ValidationResult generalResult = new ValidationResult(string.Empty, new BugzillaProjectMapping(), null, null, null);
            results.AddResult(generalResult);
            Expect.Call(FacadeMock.ValidateEntity(viewMock.Model)).IgnoreArguments().Return(results);
            viewMock.SetGeneralTabValid(true);
            viewMock.SetMappingTabValid(false);

            MockRepository.ReplayAll();

            BugzillaController controller = CreateController();
            controller.RegisterView(viewMock);
            controller.PrepareView();
            raiser.Raise(viewMock, EventArgs.Empty);

            MockRepository.VerifyAll();
        }

		/// <summary>
		/// Implements the validation logic for the receiver, invoking validation on the composed validators.
		/// </summary>
		/// <param name="objectToValidate">The object to validate.</param>
		/// <param name="currentTarget">The object on the behalf of which the validation is performed.</param>
		/// <param name="key">The key that identifies the source of <paramref name="objectToValidate"/>.</param>
		/// <param name="validationResults">The validation results to which the outcome of the validation should be stored.</param>
		/// <remarks>
		/// The results the generated by the composed validators are logged to <paramref name="validationResults"/>
		/// only if all the validators generate results.
		/// </remarks>
		public override void DoValidate(object objectToValidate,
			object currentTarget,
			string key,
			ValidationResults validationResults)
		{
			List<ValidationResult> childrenValidationResults = new List<ValidationResult>();

			foreach (Validator validator in this.validators)
			{
				ValidationResults childValidationResults = new ValidationResults();
				validator.DoValidate(objectToValidate, currentTarget, key, childValidationResults);
				if (childValidationResults.IsValid)
				{
					// no need to query the rest of the validators
					return;
				}

				childrenValidationResults.AddRange(childValidationResults);
			}

			LogValidationResult(validationResults,
				GetMessage(objectToValidate, key),
				currentTarget, 
				key,
				childrenValidationResults);
		}

        public void EntityValidation(ValidationResults results)
        {
            //--- Required
            if (menu_id == null)
            {
                ValidationResult result = new ValidationResult(string.Format(ErrorMessage.IsRequired, "Menu"), this, string.Empty, string.Empty, null);
                results.AddResult(result);
            }
            if (bill_of_material_head_id == null)
            {
                ValidationResult result = new ValidationResult(string.Format(ErrorMessage.IsRequired, "Bill of Material Head"), this, string.Empty, string.Empty, null);
                results.AddResult(result);
            }
            if (quantity == null)
            {
                ValidationResult result = new ValidationResult(string.Format(ErrorMessage.IsRequired, "Quantity"), this, string.Empty, string.Empty, null);
                results.AddResult(result);
            }

            //---
            if (quantity <= 0)
            {
                ValidationResult result = new ValidationResult(string.Format(ErrorMessage.CompareValueMore, "Quantity", 0), this, string.Empty, string.Empty, null);
                results.AddResult(result);
            }
        }

        protected void SubmitButton_Click(object sender, EventArgs e)
        {
            // Get the token for this authentication process (rendered in a hidden input field, see the view)
            var token = (string)ViewState["Token"];

            // Get an instance of the Authentication class
            var auth = Util.GetRestPkiClient().GetAuthentication();

            // Call the CompleteWithWebPki() method with the token, which finalizes the authentication process. The call yields a
            // ValidationResults which denotes whether the authentication was successful or not.
            var validationResults = auth.CompleteWithWebPki(token);

            // Check the authentication result
            if (!validationResults.IsValid) {
                // If the authentication was not successful, we render a page showing what went wrong
                this.ValidationResults = validationResults;
                Server.Transfer("AuthenticationFail.aspx");
                return;
            }

            // At this point, you have assurance that the certificate is valid according to the TrustArbitrator you
            // selected when starting the authentication and that the user is indeed the certificate's subject. Now,
            // you'd typically query your database for a user that matches one of the certificate's fields, such as
            // userCert.EmailAddress or userCert.PkiBrazil.CPF (the actual field to be used as key depends on your
            // application's business logic) and set the user ID on the auth cookie. For demonstration purposes,
            // we'll just render a page showing some of the user's certificate information.
            this.Certificate = auth.GetCertificate();
            Server.Transfer("AuthenticationSuccess.aspx");
        }

        public void ValidatorWillThrowIfProvidedNulValidationResults()
        {
            Validator validator = new MockValidator(true, "template");
            ValidationResults validationResults = new ValidationResults();

            validator.Validate(this, null);
        }

        /// <summary>
        /// Initializes a new instance of the <see cref="ArgumentValidationException"/> class, storing the validation
        /// results and the name of the parameter that failed.
        /// </summary>
        /// <param name="validationResults">The <see cref="ValidationResults"/> returned from the Validation Application Block.</param>
        /// <param name="paramName">The parameter that failed validation.</param>
        public ArgumentValidationException(ValidationResults validationResults, string paramName)
            : base(Resources.ValidationFailedMessage, paramName)
        {
            this.validationResults = validationResults;

            SerializeObjectState += (s, e) => e.AddSerializedState(new ValidationResultsSerializationData(this.validationResults));
        }

 protected internal override void DoValidate(object objectToValidate, object currentTarget, string key, ValidationResults validationResults)
 {
     foreach (Validator validator in this.validators)
     {
         validator.DoValidate(objectToValidate, currentTarget, key, validationResults);
     }
 }

 public void EntityValidation(ValidationResults results)
 {
     //--- Required
     if (bill_of_material_head_id == null)
     {
         ValidationResult result = new ValidationResult(string.Format(ErrorMessage.IsRequired, "Bill Of Material Head"), this, string.Empty, string.Empty, null);
         results.AddResult(result);
     }
     if (IsCheckedMaterial && material_id == null)
     {
         ValidationResult result = new ValidationResult(string.Format(ErrorMessage.IsRequired, "Material"), this, string.Empty, string.Empty, null);
         results.AddResult(result);
     }
     else if (!IsCheckedMaterial && bill_of_material_head_id_sub == null)
     {
         ValidationResult result = new ValidationResult(string.Format(ErrorMessage.IsRequired, "BOM"), this, string.Empty, string.Empty, null);
         results.AddResult(result);
     }
     if (amount == null)
     {
         ValidationResult result = new ValidationResult(string.Format(ErrorMessage.IsRequired, "Amount"), this, string.Empty, string.Empty, null);
         results.AddResult(result);
     }
     if (lost_factor == null)
     {
         ValidationResult result = new ValidationResult(string.Format(ErrorMessage.IsRequired, "Lost Factor"), this, string.Empty, string.Empty, null);
         results.AddResult(result);
     }
 }

 public void EntityValidation(ValidationResults results)
 {
     //--- Required
     if (string.IsNullOrEmpty(employee_no))
     {
         ValidationResult result = new ValidationResult(string.Format(ErrorMessage.IsRequired, "Employee No"), this, string.Empty, string.Empty, null);
         results.AddResult(result);
     }
     if (string.IsNullOrEmpty(first_name))
     {
         ValidationResult result = new ValidationResult(string.Format(ErrorMessage.IsRequired, "First Name"), this, string.Empty, string.Empty, null);
         results.AddResult(result);
     }
     if (string.IsNullOrEmpty(last_name))
     {
         ValidationResult result = new ValidationResult(string.Format(ErrorMessage.IsRequired, "Last Name"), this, string.Empty, string.Empty, null);
         results.AddResult(result);
     }
     if (string.IsNullOrEmpty(user_name))
     {
         ValidationResult result = new ValidationResult(string.Format(ErrorMessage.IsRequired, "User Name"), this, string.Empty, string.Empty, null);
         results.AddResult(result);
     }
     if (string.IsNullOrEmpty(user_password))
     {
         ValidationResult result = new ValidationResult(string.Format(ErrorMessage.IsRequired, "Password"), this, string.Empty, string.Empty, null);
         results.AddResult(result);
     }
 }

        public void CanValidateGravatar()
        {
            var results = new ValidationResults();
            var widget = new Gravatar();

            // Confirm errors.
            widget.FullName = "123456789012345678901234567890123456789012345678901234567890";
            widget.Rating = "too_long";

            bool success = widget.Validate(results);
            Assert.IsFalse(success);
            Assert.AreEqual(results.Count, 6);

            // Confirm correct
            widget.Header = "about";
            widget.Zone = "right";
            widget.FullName = "kishore reddy";
            widget.Rating = "r";
            widget.Email = "[email protected]";
            widget.Size = 80;

            results.Clear();
            success = widget.Validate(results);
            Assert.IsTrue(success);
            Assert.AreEqual(results.Count, 0);
        }

        protected override void DoValidate(object objectToValidate, object currentTarget, string key, ValidationResults validationResults)
        {
            if(objectToValidate == null)
            {
                // Skipping valudation if optional decimal is a null
                return;
            }

            var number = (decimal)objectToValidate;

            List<DecimalPrecisionValidatorAttribute> attributes = currentTarget.GetType().GetProperty(key).GetCustomAttributesRecursively<DecimalPrecisionValidatorAttribute>().ToList();
            var validatiorAttribute = attributes[0];

            if (number != Decimal.Round(number, validatiorAttribute.Scale))
            {

                LogValidationResult(validationResults, GetString("Validation.Decimal.SymbolsAfterPointAllowed").FormatWith(validatiorAttribute.Scale), currentTarget, key);
                return;
            }

            string str = number.ToString(CultureInfo.InvariantCulture);
            int separatorIndex = str.IndexOf('.');
            if(separatorIndex > 0)
            {
                str = str.Substring(0, separatorIndex);
            }

            if (str.StartsWith("-")) str = str.Substring(1);

            int allowedDigitsBeforeSeparator = validatiorAttribute.Precision - validatiorAttribute.Scale;
            if (str.Length > allowedDigitsBeforeSeparator)
            {
                LogValidationResult(validationResults, GetString("Validation.Decimal.SymbolsBeforePointAllowed").FormatWith(allowedDigitsBeforeSeparator), currentTarget, key);
            }
        }

        /// <summary>
        /// Un curs poate fi ales cel mult o data de catre un student.
        /// </summary>
        /// <param name="student"></param>
        /// <param name="results"></param>
        internal void ValidateCourseCanOnlyBeChoosenASingleTime(Student student, ValidationResults results)
        {
            if (student.Courses.Where(c => c.CourseId != 0).GroupBy(c => c.CourseId).Any(g => g.Count() > 1))
            {
                results.AddResult(new ValidationResult
                    (
                    "The there are duplicate courses (same id) in the list of courses chosen by the student", results, "ValidationMethod", "error", null)
                    );
                return;
            }

            if (student.Courses.Where(c => c.CourseId != 0).GroupBy(c => new { c.Name, c.Description }).Any(g => g.Count() > 1))
            {
                results.AddResult(new ValidationResult
                   (
                   "The there are duplicate courses (same name & description) in the list of courses chosen by the student", results, "ValidationMethod", "error", null)
                   );
                return;
            }

            if (student.Courses.Where(c => c.CourseId != 0).GroupBy(c => c.Name).Any(g => g.Count() > 1))
            {
                 results.AddResult(new ValidationResult
                    (
                    "The there are duplicate courses in the list of courses (same name) chosen by the student", results, "ValidationMethod", "error", null)
                    );
            }
        }

 public void Validate(ValidationResults results)
 {
     var examMetadata = new ExamMetadata();
     examMetadata.ExamValidateDate(this, ExaminationDate, results);
     examMetadata.ValidateAllowedPasses(this, results);
     examMetadata.ValidateGradeCourse(this, results);
 }

		protected override void DoValidate(object objectToValidate, object currentObject, string key, ValidationResults validateResults)
		{
			string typeString = (string)objectToValidate;
			string messageTemplate = string.IsNullOrEmpty(this.MessageTemplate) ? "{0}包含无效或重复的的管理范围类别字符串：{1}" : this.MessageTemplate;
			string[] parts = typeString.Split(AUCommon.Spliter, StringSplitOptions.RemoveEmptyEntries);

			// 准备有效项的集合
			HashSet<string> effected = new HashSet<string>();
			HashSet<string> repeated = new HashSet<string>();
			foreach (var item in SchemaInfo.FilterByCategory("AUScopeItems"))
				effected.Add(item.Name);

			// 检查有效项
			foreach (var item in parts)
			{
				if (effected.Contains(item) == false)
				{
					this.RecordValidationResult(validateResults, string.Format(messageTemplate, AUCommon.DisplayNameFor((SchemaObjectBase)currentObject), item), currentObject, key);
					break;
				}

				if (repeated.Contains(item))
				{
					this.RecordValidationResult(validateResults, string.Format(messageTemplate, AUCommon.DisplayNameFor((SchemaObjectBase)currentObject), item), currentObject, key);
					break;
				}
				else
				{
					repeated.Add(item);
				}
			}
		}

        /// <summary>
        /// Converts <paramref name="results"/> to a list of anonymous objects.
        /// </summary>
        /// <param name="results">The validation results to convert.</param>
        /// <param name="controlList">The control metadata list.</param>
        /// <param name="firstError">When the method returns, will contain the earliest control that has an error.</param>
        /// <returns>A new list of anonymous objects.</returns>
        public static Dictionary<string, List<string>> ConvertValidationResultsToErrorMessages(ValidationResults results, ControlList controlList, out Control firstError)
        {
            int minPos = int.MaxValue;
            firstError = null;

            Dictionary<string, List<string>> errors = new Dictionary<string, List<string>>();
            foreach (ValidationResult result in results)
            {
                string errorKey = Regex.Replace(result.Key, "[" + Regex.Escape(".[") + "\\]]+", "-");
                if (!errors.ContainsKey(errorKey))
                {
                    errors.Add(errorKey, new List<string>());
                }

                errors[errorKey].Add(result.Message);
                string controlName = Regex.Match(errorKey, "[a-z0-9_]+$", RegexOptions.IgnoreCase).Value;
                Control control = controlList.FindRecursive(controlName);
                if (control == null)
                {
                    controlName = Regex.Match(errorKey, "[a-z0-9_]+(?=-" + controlName + "$)", RegexOptions.IgnoreCase).Value;
                    control = controlList.FindRecursive(controlName);
                }

                if (control.Position < minPos)
                {
                    minPos = control.Position;
                    firstError = control;
                }
            }

            return errors;
        }