private static void ValidateFormat(List<char> delimiters, string numbers, IValidator validator)
 {
     if (!validator.Validate(numbers, delimiters))
     {
         throw new CalculatorFormatException(validator.LastErrorMessage);
     }
 }

        public TestsViewModel(
            ITestQuery queries,
            ITests commands,
            ISubjectQuery subjectQuery,
            IValidator<Test> testValidator,
            IValidator<Question> questionValidator,
            IValidator<Answer> answerValidator,
            IValidator<AssociatedSubject> subjectValidator
        )
            : base()
        {
            _queries = queries;
            _commands = commands;

            _subjectQuery = subjectQuery;

            _testValidator = testValidator;
            _questionValidator = questionValidator;
            _answerValidator = answerValidator;
            _subjectValidator = subjectValidator;


            LoadAllTests();

            _addTestCommand = new RelayCommand(
                () => AddNewTest(),
                () => CanAddNewTest()
            );
        }

 IEnumerable<ModelValidator> GetValidatorsForModel(ModelMetadata metadata, ControllerContext context,IValidator validator)
 {
     if (validator != null)
     {
         yield return new FVModelValidator(metadata, context, validator);
     }
 }

        void GenerateForValidator(IValidator inputValidator, TypeMetaData metaData, string parentKey, bool isParentConcept = false, bool isParentModelRule = false)
        {
            var inputValidatorType = inputValidator.GetType();
            var genericArguments = inputValidatorType.BaseType.GetGenericArguments();

            var descriptor = inputValidator.CreateDescriptor();
            var members = descriptor.GetMembersWithValidators();
            
            foreach (var member in members)
            {
                var rules = descriptor.GetRulesForMember(member.Key);
                foreach (var rule in rules)
                {
                    foreach (var validator in rule.Validators)
                    {
                        var isModelRule = member.Key == ModelRule<string>.ModelRulePropertyName;
                        var currentKey = GetKeyForMember(parentKey, isParentConcept, isParentModelRule, member, isModelRule);

                        if (validator is ChildValidatorAdaptor)
                        {
                            GenerateForChildValidator(metaData, genericArguments, member, validator, isModelRule, currentKey);
                        }
                        else if (validator is IPropertyValidator)
                        {
                            GenerateFor(metaData, currentKey, validator);
                        }
                    }
                }
            }
        }

 public CardService(ICardRepository cardRepository, IValidator validator, IProjectService projectService, ISession session)
 {
     _cardRepository = cardRepository;
     _validator = validator;
     _projectService = projectService;
     _session = session;
 }

 private static IValidationResultCollection GetCompositeResultsPrivate(IResourceManager mgr, string rule, IValidator[] validators)
 {
     ValidationResultCollection results = new ValidationResultCollection(mgr, rule);
     foreach (IValidator validator in validators)
         results.Add(validator.Validate());
     return results;
 }

 /// <summary>
 /// Emit implementation starting point
 /// </summary>
 /// <param name="v">The v.</param>
 /// <param name="sb">The sb.</param>
 /// <returns></returns>
 protected StringBuilder DoEmit(IValidator v, StringBuilder sb)
 {
     if (v.GetType().IsGenericType && typeof(ValidationSite<,>).IsAssignableFrom(v.GetType().GetGenericTypeDefinition()))
         return EmitSites(v, sb);
     else
         return EmitNamespace(v, sb);
 }

 /// <summary>
 /// Initializes a new instance of the <see cref="CommonValidationResult"/> class.
 /// </summary>
 /// <param name="rule">The rule.</param>
 /// <param name="target">The target.</param>
 /// <param name="message">The message.</param>
 /// <param name="success">if set to <c>true</c> [success].</param>
 public CommonValidationResult(IValidator rule, IValidatable target, string message, bool success)
 {
     Rule = rule;
     Target = target;
     Message = message;
     Success = success;
 }

 public override void SetUp()
 {
     base.SetUp();
     _collectionRepository = Substitute.For<IPagedCollectionRepository<Logic.Product.FindPagedCollection.ProductItem, Logic.Product.FindPagedCollection.Query>>();
     _validator = Substitute.For<IValidator<Logic.Product.FindPagedCollection.Query>>();
     _sut = new Logic.Product.FindPagedCollection.QueryHandler(_collectionRepository, _validator);
 }

        public Emitter(IDictionary<string,
            TypeDefinition> typeDefinitions,
            BridgeTypes bridgeTypes,
            List<ITypeInfo> types,
            IValidator validator,
            IMemberResolver resolver,
            Dictionary<string, ITypeInfo> typeInfoDefinitions,
            ILogger logger)
        {
            this.Log = logger;

            this.Resolver = resolver;
            this.TypeDefinitions = typeDefinitions;
            this.TypeInfoDefinitions = typeInfoDefinitions;
            this.Types = types;
            this.BridgeTypes = bridgeTypes;

            this.BridgeTypes.InitItems(this);

            logger.Trace("Sorting types infos by name...");
            this.Types.Sort(this.CompareTypeInfosByName);
            logger.Trace("Sorting types infos by name done");

            this.SortTypesByInheritance();

            this.Validator = validator;
            this.AssignmentType = ICSharpCode.NRefactory.CSharp.AssignmentOperatorType.Any;
            this.UnaryOperatorType = ICSharpCode.NRefactory.CSharp.UnaryOperatorType.Any;
            this.JsDoc = new JsDoc();
        }

 public RuntimeConfiguration(ProviderInfo providerInfo, ConnectionInfo connectionInfo, IValidator validator, ISqlDispatcher sqlDispatcher)
 {
     _providerInfo = providerInfo;
     _connectionInfo = connectionInfo;
     _validator = validator;
     _sqlDispatcher = sqlDispatcher;
 }

        public InvalidMessageTransformer(ConstraintValidatorContext constraintContext, 
            List<InvalidValue> results,
            System.Type @class,
            string propertyName /* nullable */,
            object value /* nullable */,
            object entity /* nullable */,
            IValidator validator,
            DefaultMessageInterpolatorAggregator defaultInterpolator,
            IMessageInterpolator userInterpolator /* nullable */)
        {
            if (constraintContext == null) throw new ArgumentNullException("constraintContext");
            if (results == null) throw new ArgumentNullException("results");
            if (@class == null) throw new ArgumentNullException("class");
            if (validator == null) throw new ArgumentNullException("valitor");
            if (defaultInterpolator == null) throw new ArgumentNullException("defaultInterpolator");

            this.constraintContext = constraintContext;
            this.results = results;
            [email protected] = @class;
            this.propertyName = propertyName;
            this.value = value;
            this.entity = entity;
            this.validator = validator;
            this.defaultInterpolator = defaultInterpolator;
            this.userInterpolator = userInterpolator;
        }

 public override void SetUp()
 {
     base.SetUp();
     _validator = Substitute.For<IValidator<Logic.Product.Delete.Command>>();
     _repository = Substitute.For<Logic.Product.Delete.IDeleteProductRepository>();
     _sut = new Logic.Product.Delete.CommandHandler(_validator, _repository);
 }

        /// <summary>
        /// Emits the sites.
        /// </summary>
        /// <param name="v">The v.</param>
        /// <param name="sb">The sb.</param>
        /// <returns></returns>
        private StringBuilder EmitSites(IValidator v, StringBuilder sb)
        {
            sb
                .Append("{ field: \"")
                .Append(v.Name)
                .Append("\", attributes: [");

            bool found = false;
            foreach (IValidator child in v.Children)
            {
                sb.Append("{ name: \"");
                sb.Append(GetSimpleTypeName(child));
                sb.Append("\"");

                foreach (string key in child.DefiningParams.Keys)
                {
                    sb.Append(",");
                    sb.Append(key);
                    sb.Append(": \"");
                    sb.Append(new NDjango.FiltersCS.EscapeJSFilter().Perform(Convert.ToString(child.DefiningParams[key])));
                    sb.Append("\"");
                }

                sb.Append("},");

                found = true;
            }

            if (found)
                sb.Remove(sb.Length - 1, 1);

            return sb.Append("]}");
        }

		public FluentValidationModelValidator(ModelMetadata metadata, ControllerContext controllerContext, IValidator validator)
			: base(metadata, controllerContext) {
			this.validator = validator;
			
			this.customizations = CustomizeValidatorAttribute.GetFromControllerContext(controllerContext) 
				?? new CustomizeValidatorAttribute();
		}

 public ActivitiesController(IProcessQueries queryProcessor
                           , IHandleCommands<UpdateActivity> profileUpdateHandler
                           , IValidator<CreateImage> validateImage
                           , IHandleCommands<CreateImage> createImage
                           , IValidator<CreateLoadableFile> validateLoadableFile
                           , IHandleCommands<CreateLoadableFile> createLoadableFile
                           , IHandleCommands<CreateActivityDocument> createActivityDocument
                           , IHandleCommands<DeleteActivityDocument> deleteActivityDocument 
                           , IHandleCommands<RenameActivityDocument> renameActivityDocument
                           , IHandleCommands<CopyDeepActivity> copyDeepActivity
                           , IHandleCommands<CreateDeepActivity> createDeepActivity
                           , IHandleCommands<DeleteActivity> deleteActivity
                           , IHandleCommands<UpdateActivity> updateActivity )
 {
     _queryProcessor = queryProcessor;
     _profileUpdateHandler = profileUpdateHandler;
     _validateImage = validateImage;
     _createImage = createImage;
     _validateLoadableFile = validateLoadableFile;
     _createLoadableFile = createLoadableFile; 
     _createActivityDocument = createActivityDocument;
     _deleteActivityDocument = deleteActivityDocument;
     _renameActivityDocument = renameActivityDocument;
     _copyDeepActivity = copyDeepActivity;
     _createDeepActivity = createDeepActivity;
     _deleteActivity = deleteActivity;
     _updateActivity = updateActivity;
 }

 public AccountController(IUserService userService, IValidator<RegisterForm> registerFormValidator, 
     IValidator<ChangePasswordForm> changePasswordFormValidator)
 {
     _userService = userService;
     _registerFormValidator = registerFormValidator;
     _changePasswordFormValidator = changePasswordFormValidator;
 }

 public FileController(IMapHandler newMapHandler, IFileView newFileView, IFileHandler newFileHandler, IValidator newValidator)
 {
     maphandler = newMapHandler;
     fileView = newFileView;
     fileHandler = newFileHandler;
     validator = newValidator;
 }

		IEnumerable<ModelValidator> GetValidatorsForProperty(ModelMetadata metadata, ControllerContext context, IValidator validator) {
			var modelValidators = new List<ModelValidator>();

			if (validator != null) {
				var descriptor = validator.CreateDescriptor();

				var validatorsWithRules = from rule in descriptor.GetRulesForMember(metadata.PropertyName)
										  let propertyRule = (PropertyRule)rule
										  let validators = rule.Validators
										  where validators.Any()
										  from propertyValidator in validators
										  let modelValidatorForProperty = GetModelValidator(metadata, context, propertyRule, propertyValidator)
										  where modelValidatorForProperty != null
										  select modelValidatorForProperty;
					
				modelValidators.AddRange(validatorsWithRules);
			}

			if(validator != null && metadata.IsRequired && AddImplicitRequiredValidator) {
				bool hasRequiredValidators = modelValidators.Any(x => x.IsRequired);

				//If the model is 'Required' then we assume it must have a NotNullValidator. 
				//This is consistent with the behaviour of the DataAnnotationsModelValidatorProvider
				//which silently adds a RequiredAttribute

				if(! hasRequiredValidators) {
					modelValidators.Add(CreateNotNullValidatorForProperty(metadata, context));
				}
			}

			return modelValidators;
		}

 public void AddInterpolator(Attribute attribute, IValidator validator)
 {
     DefaultMessageInterpolator interpolator = new DefaultMessageInterpolator();
     interpolator.Initialize(messageBundle, defaultMessageBundle, culture);
     interpolator.Initialize(attribute);
     interpolators[validator] = interpolator;
 }