it('createForCurrentScope', () => {
   const container = new Container();
   const standardValidator = {};
   container.registerInstance(Validator, standardValidator);
   const childContainer = container.createChild();
   const factory = childContainer.get(ValidationControllerFactory);
   const controller = factory.createForCurrentScope();
   expect(controller.validator).toBe(standardValidator);
   expect(container.get(Optional.of(ValidationController))).toBe(null);
   expect(childContainer.get(Optional.of(ValidationController))).toBe(controller);
   const customValidator = {};
   expect(factory.createForCurrentScope(customValidator).validator).toBe(customValidator);
 });

 return function(target, key, desc?) {
     if (!type) {
         // typescript
         type = metadata.get(metadataType, target, key);
     }
     injectFn(target, key, desc, Optional.of(type));
 };

 return function(target, key, desc?) {
     if (type === undefined) {
         // typescript
         type = metadata.get('design:type', target, key);
     }
     inject(Optional.of(type))(target, key, desc ? desc : {});
 };

  public bind(binding: any, source: any, rulesOrController?: ValidationController | any, rules?: any) {
    // identify the target element.
    const target = getTargetDOMElement(binding, source);

    // locate the controller.
    let controller: ValidationController;
    if (rulesOrController instanceof ValidationController) {
      controller = rulesOrController;
    } else {
      controller = source.container.get(Optional.of(ValidationController));
      rules = rulesOrController;
    }
    if (controller === null) {
      throw new Error(`A ValidationController has not been registered.`);
    }

    controller.registerBinding(binding, target, rules);
    binding.validationController = controller;
    const trigger = this.getValidateTrigger(controller);
    // tslint:disable-next-line:no-bitwise
    if (trigger & validateTrigger.change) {
      binding.standardUpdateSource = binding.updateSource;
      // tslint:disable-next-line:only-arrow-functions
      // tslint:disable-next-line:space-before-function-paren
      binding.updateSource = function (value: any) {
        this.standardUpdateSource(value);
        this.validationController.validateBinding(this);
      };
    }

    // tslint:disable-next-line:no-bitwise
    if (trigger & validateTrigger.blur) {
      binding.validateBlurHandler = () => {
        this.taskQueue.queueMicroTask(() => controller.validateBinding(binding));
      };
      binding.validateTarget = target;
      target.addEventListener('blur', binding.validateBlurHandler);
    }

    if (trigger !== validateTrigger.manual) {
      binding.standardUpdateTarget = binding.updateTarget;
      // tslint:disable-next-line:only-arrow-functions
      // tslint:disable-next-line:space-before-function-paren
      binding.updateTarget = function (value: any) {
        this.standardUpdateTarget(value);
        this.validationController.resetBinding(this);
      };
    }
  }

 /**@internal */
 static inject() {
   return [DOM.Element, Animator, Optional.of(DOM.boundary, true)];
 }