ember-material-icons/.node_modules.ember-try/ember-source/dist/ember-tests.js

Google Material icons for your ember-cli app

;(function() {
/*!
 * @overview  Ember - JavaScript Application Framework
 * @copyright Copyright 2011-2017 Tilde Inc. and contributors
 *            Portions Copyright 2006-2011 Strobe Inc.
 *            Portions Copyright 2008-2011 Apple Inc. All rights reserved.
 * @license   Licensed under MIT license
 *            See https://raw.github.com/emberjs/ember.js/master/LICENSE
 * @version   2.13.2
 */

var enifed, requireModule, Ember;
var mainContext = this; // Used in ember-environment/lib/global.js

(function() {
  var isNode = typeof window === 'undefined' &&
    typeof process !== 'undefined' && {}.toString.call(process) === '[object process]';

  if (!isNode) {
    Ember = this.Ember = this.Ember || {};
  }

  if (typeof Ember === 'undefined') { Ember = {}; }

  if (typeof Ember.__loader === 'undefined') {
    var registry = {};
    var seen = {};

    enifed = function(name, deps, callback) {
      var value = { };

      if (!callback) {
        value.deps = [];
        value.callback = deps;
      } else {
        value.deps = deps;
        value.callback = callback;
      }

      registry[name] = value;
    };

    requireModule = function(name) {
      return internalRequire(name, null);
    };

    // setup `require` module
    requireModule['default'] = requireModule;

    requireModule.has = function registryHas(moduleName) {
      return !!registry[moduleName] || !!registry[moduleName + '/index'];
    };

    function missingModule(name, referrerName) {
      if (referrerName) {
        throw new Error('Could not find module ' + name + ' required by: ' + referrerName);
      } else {
        throw new Error('Could not find module ' + name);
      }
    }

    function internalRequire(_name, referrerName) {
      var name = _name;
      var mod = registry[name];

      if (!mod) {
        name = name + '/index';
        mod = registry[name];
      }

      var exports = seen[name];

      if (exports !== undefined) {
        return exports;
      }

      exports = seen[name] = {};

      if (!mod) {
        missingModule(_name, referrerName);
      }

      var deps = mod.deps;
      var callback = mod.callback;
      var reified = new Array(deps.length);

      for (var i = 0; i < deps.length; i++) {
        if (deps[i] === 'exports') {
          reified[i] = exports;
        } else if (deps[i] === 'require') {
          reified[i] = requireModule;
        } else {
          reified[i] = internalRequire(deps[i], name);
        }
      }

      callback.apply(this, reified);

      return exports;
    }

    requireModule._eak_seen = registry;

    Ember.__loader = {
      define: enifed,
      require: requireModule,
      registry: registry
    };
  } else {
    enifed = Ember.__loader.define;
    requireModule = Ember.__loader.require;
  }
})();

function classCallCheck(instance, Constructor) {
  if (!(instance instanceof Constructor)) {
    throw new TypeError('Cannot call a class as a function');
  }
}

function inherits(subClass, superClass) {
  if (typeof superClass !== 'function' && superClass !== null) {
    throw new TypeError('Super expression must either be null or a function, not ' + typeof superClass);
  }

  subClass.prototype = Object.create(superClass && superClass.prototype, {
    constructor: {
      value: subClass,
      enumerable: false,
      writable: true,
      configurable: true
    }
  });

  if (superClass) Object.setPrototypeOf ? Object.setPrototypeOf(subClass, superClass) : defaults(subClass, superClass);
}

function taggedTemplateLiteralLoose(strings, raw) {
  strings.raw = raw;
  return strings;
}

function defineProperties(target, props) {
  for (var i = 0; i < props.length; i++) {
    var descriptor = props[i];
    descriptor.enumerable = descriptor.enumerable || false;
    descriptor.configurable = true;
    if ('value' in descriptor) descriptor.writable = true;
    Object.defineProperty(target, descriptor.key, descriptor);
  }
}

function createClass(Constructor, protoProps, staticProps) {
  if (protoProps) defineProperties(Constructor.prototype, protoProps);
  if (staticProps) defineProperties(Constructor, staticProps);
  return Constructor;
}

function interopExportWildcard(obj, defaults) {
  var newObj = defaults({}, obj);
  delete newObj['default'];
  return newObj;
}

function defaults(obj, defaults) {
  var keys = Object.getOwnPropertyNames(defaults);
  for (var i = 0; i < keys.length; i++) {
    var key = keys[i];
    var value = Object.getOwnPropertyDescriptor(defaults, key);
    if (value && value.configurable && obj[key] === undefined) {
      Object.defineProperty(obj, key, value);
    }
  }
  return obj;
}

var babelHelpers = {
  classCallCheck: classCallCheck,
  inherits: inherits,
  taggedTemplateLiteralLoose: taggedTemplateLiteralLoose,
  slice: Array.prototype.slice,
  createClass: createClass,
  interopExportWildcard: interopExportWildcard,
  defaults: defaults
};

enifed('container/container.lint-test', ['exports'], function (exports) {
  'use strict';

  QUnit.module('ESLint | container/container.js');
  QUnit.test('should pass ESLint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'container/container.js should pass ESLint\n\n');
  });
});
enifed('container/index.lint-test', ['exports'], function (exports) {
  'use strict';

  QUnit.module('ESLint | container/index.js');
  QUnit.test('should pass ESLint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'container/index.js should pass ESLint\n\n');
  });
});
enifed('container/registry.lint-test', ['exports'], function (exports) {
  'use strict';

  QUnit.module('ESLint | container/registry.js');
  QUnit.test('should pass ESLint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'container/registry.js should pass ESLint\n\n');
  });
});
enifed('container/tests/container_test', ['exports', 'ember-utils', 'ember-environment', 'ember-metal', 'container/index', 'internal-test-helpers', 'ember-debug', 'container'], function (exports, _emberUtils, _emberEnvironment, _emberMetal, _containerIndex, _internalTestHelpers, _emberDebug, _container) {
  'use strict';

  QUnit.module('Container');

  function lookupFactory(name, container, options) {
    return container[_container.LOOKUP_FACTORY](name, options);
  }

  QUnit.test('A registered factory returns the same instance each time', function () {
    var registry = new _containerIndex.Registry();
    var container = registry.container();
    var PostController = _internalTestHelpers.factory();

    registry.register('controller:post', PostController);

    var postController = container.lookup('controller:post');

    ok(postController instanceof PostController, 'The lookup is an instance of the factory');

    equal(postController, container.lookup('controller:post'));
  });

  QUnit.test('A registered factory is returned from lookupFactory', function () {
    var registry = new _containerIndex.Registry();
    var container = registry.container();
    var PostController = _internalTestHelpers.factory();

    registry.register('controller:post', PostController);

    var PostControllerFactory = lookupFactory('controller:post', container);

    ok(PostControllerFactory, 'factory is returned');
    ok(PostControllerFactory.create() instanceof PostController, 'The return of factory.create is an instance of PostController');
  });

  QUnit.test('A registered factory is returned from lookupFactory is the same factory each time', function () {
    var registry = new _containerIndex.Registry();
    var container = registry.container();
    var PostController = _internalTestHelpers.factory();

    registry.register('controller:post', PostController);

    var Post1 = lookupFactory('controller:post', container);
    var Post2 = lookupFactory('controller:post', container);

    deepEqual(Post1, Post2, 'The return of lookupFactory is always the same');
  });

  QUnit.test('A factory returned from lookupFactory has a debugkey', function () {
    var registry = new _containerIndex.Registry();
    var container = registry.container();
    var PostController = _internalTestHelpers.factory();

    registry.register('controller:post', PostController);
    var PostFactory = lookupFactory('controller:post', container);
    equal(PostFactory._debugContainerKey, 'controller:post', 'factory instance receives _debugContainerKey');
  });

  QUnit.test('uses create time injections if factory has no extend', function () {
    var registry = new _containerIndex.Registry();
    var container = registry.container();
    var AppleController = _internalTestHelpers.factory();
    var PostController = _internalTestHelpers.factory();

    PostController.extend = undefined; // remove extend

    registry.register('controller:apple', AppleController);
    registry.register('controller:post', PostController);
    registry.injection('controller:post', 'apple', 'controller:apple');

    var postController = container.lookup('controller:post');

    ok(postController.apple instanceof AppleController, 'instance receives an apple of instance AppleController');
  });

  QUnit.test('The descendants of a factory returned from lookupFactory have a container and debugkey', function () {
    var registry = new _containerIndex.Registry();
    var container = registry.container();
    var PostController = _internalTestHelpers.factory();
    var instance = undefined;

    registry.register('controller:post', PostController);
    instance = lookupFactory('controller:post', container).create();

    equal(instance._debugContainerKey, 'controller:post', 'factory instance receives _debugContainerKey');

    ok(instance instanceof PostController, 'factory instance is instance of factory');
  });

  QUnit.test('A registered factory returns a fresh instance if singleton: false is passed as an option', function () {
    var registry = new _containerIndex.Registry();
    var container = registry.container();
    var PostController = _internalTestHelpers.factory();

    registry.register('controller:post', PostController);

    var postController1 = container.lookup('controller:post');
    var postController2 = container.lookup('controller:post', { singleton: false });
    var postController3 = container.lookup('controller:post', { singleton: false });
    var postController4 = container.lookup('controller:post');

    equal(postController1.toString(), postController4.toString(), 'Singleton factories looked up normally return the same value');
    notEqual(postController1.toString(), postController2.toString(), 'Singleton factories are not equal to factories looked up with singleton: false');
    notEqual(postController2.toString(), postController3.toString(), 'Two factories looked up with singleton: false are not equal');
    notEqual(postController3.toString(), postController4.toString(), 'A singleton factory looked up after a factory called with singleton: false is not equal');

    ok(postController1 instanceof PostController, 'All instances are instances of the registered factory');
    ok(postController2 instanceof PostController, 'All instances are instances of the registered factory');
    ok(postController3 instanceof PostController, 'All instances are instances of the registered factory');
    ok(postController4 instanceof PostController, 'All instances are instances of the registered factory');
  });

  QUnit.test('A factory type with a registered injection\'s instances receive that injection', function () {
    var registry = new _containerIndex.Registry();
    var container = registry.container();
    var PostController = _internalTestHelpers.factory();
    var Store = _internalTestHelpers.factory();

    registry.register('controller:post', PostController);
    registry.register('store:main', Store);

    registry.typeInjection('controller', 'store', 'store:main');

    var postController = container.lookup('controller:post');
    var store = container.lookup('store:main');

    equal(postController.store, store);
  });

  QUnit.test('An individual factory with a registered injection receives the injection', function () {
    var registry = new _containerIndex.Registry();
    var container = registry.container();
    var PostController = _internalTestHelpers.factory();
    var Store = _internalTestHelpers.factory();

    registry.register('controller:post', PostController);
    registry.register('store:main', Store);

    registry.injection('controller:post', 'store', 'store:main');

    var postController = container.lookup('controller:post');
    var store = container.lookup('store:main');

    equal(postController.store, store, 'has the correct store injected');
  });

  QUnit.test('A factory with both type and individual injections', function () {
    var registry = new _containerIndex.Registry();
    var container = registry.container();
    var PostController = _internalTestHelpers.factory();
    var Store = _internalTestHelpers.factory();
    var Router = _internalTestHelpers.factory();

    registry.register('controller:post', PostController);
    registry.register('store:main', Store);
    registry.register('router:main', Router);

    registry.injection('controller:post', 'store', 'store:main');
    registry.typeInjection('controller', 'router', 'router:main');

    var postController = container.lookup('controller:post');
    var store = container.lookup('store:main');
    var router = container.lookup('router:main');

    equal(postController.store, store);
    equal(postController.router, router);
  });

  QUnit.test('A factory with both type and individual factoryInjections', function () {
    var registry = new _containerIndex.Registry();
    var container = registry.container();
    var PostController = _internalTestHelpers.factory();
    var Store = _internalTestHelpers.factory();
    var Router = _internalTestHelpers.factory();

    registry.register('controller:post', PostController);
    registry.register('store:main', Store);
    registry.register('router:main', Router);

    registry.factoryInjection('controller:post', 'store', 'store:main');
    registry.factoryTypeInjection('controller', 'router', 'router:main');

    var PostControllerFactory = lookupFactory('controller:post', container);
    var store = container.lookup('store:main');
    var router = container.lookup('router:main');

    equal(PostControllerFactory.store, store, 'PostControllerFactory has the instance of store');
    equal(PostControllerFactory.router, router, 'PostControllerFactory has the route instance');
  });

  QUnit.test('A non-singleton instance is never cached', function () {
    var registry = new _containerIndex.Registry();
    var container = registry.container();
    var PostView = _internalTestHelpers.factory();

    registry.register('view:post', PostView, { singleton: false });

    var postView1 = container.lookup('view:post');
    var postView2 = container.lookup('view:post');

    ok(postView1 !== postView2, 'Non-singletons are not cached');
  });

  QUnit.test('A non-instantiated property is not instantiated', function () {
    var registry = new _containerIndex.Registry();
    var container = registry.container();

    var template = function () {};
    registry.register('template:foo', template, { instantiate: false });
    equal(container.lookup('template:foo'), template);
  });

  QUnit.test('A failed lookup returns undefined', function () {
    var registry = new _containerIndex.Registry();
    var container = registry.container();

    equal(container.lookup('doesnot:exist'), undefined);
  });

  QUnit.test('An invalid factory throws an error', function () {
    var registry = new _containerIndex.Registry();
    var container = registry.container();

    registry.register('controller:foo', {});

    throws(function () {
      container.lookup('controller:foo');
    }, /Failed to create an instance of \'controller:foo\'/);
  });

  QUnit.test('Injecting a failed lookup raises an error', function () {
    var registry = new _containerIndex.Registry();
    var container = registry.container();

    var fooInstance = {};
    var fooFactory = {};

    var Foo = {
      create: function (args) {
        return fooInstance;
      },
      extend: function (args) {
        return fooFactory;
      }
    };

    registry.register('model:foo', Foo);
    registry.injection('model:foo', 'store', 'store:main');

    throws(function () {
      container.lookup('model:foo');
    });
  });

  QUnit.test('Injecting a falsy value does not raise an error', function () {
    var registry = new _containerIndex.Registry();
    var container = registry.container();
    var ApplicationController = _internalTestHelpers.factory();

    registry.register('controller:application', ApplicationController);
    registry.register('user:current', null, { instantiate: false });
    registry.injection('controller:application', 'currentUser', 'user:current');

    strictEqual(container.lookup('controller:application').currentUser, null);
  });

  QUnit.test('The container returns same value each time even if the value is falsy', function () {
    var registry = new _containerIndex.Registry();
    var container = registry.container();

    registry.register('falsy:value', null, { instantiate: false });

    strictEqual(container.lookup('falsy:value'), container.lookup('falsy:value'));
  });

  QUnit.test('Destroying the container destroys any cached singletons', function () {
    var registry = new _containerIndex.Registry();
    var container = registry.container();
    var PostController = _internalTestHelpers.factory();
    var PostView = _internalTestHelpers.factory();
    var template = function () {};

    registry.register('controller:post', PostController);
    registry.register('view:post', PostView, { singleton: false });
    registry.register('template:post', template, { instantiate: false });

    registry.injection('controller:post', 'postView', 'view:post');

    var postController = container.lookup('controller:post');
    var postView = postController.postView;

    ok(postView instanceof PostView, 'The non-singleton was injected');

    container.destroy();

    ok(postController.isDestroyed, 'Singletons are destroyed');
    ok(!postView.isDestroyed, 'Non-singletons are not destroyed');
  });

  QUnit.test('The container can use a registry hook to resolve factories lazily', function () {
    var registry = new _containerIndex.Registry();
    var container = registry.container();
    var PostController = _internalTestHelpers.factory();

    registry.resolver = {
      resolve: function (fullName) {
        if (fullName === 'controller:post') {
          return PostController;
        }
      }
    };

    var postController = container.lookup('controller:post');

    ok(postController instanceof PostController, 'The correct factory was provided');
  });

  QUnit.test('The container normalizes names before resolving', function () {
    var registry = new _containerIndex.Registry();
    var container = registry.container();
    var PostController = _internalTestHelpers.factory();

    registry.normalizeFullName = function (fullName) {
      return 'controller:post';
    };

    registry.register('controller:post', PostController);
    var postController = container.lookup('controller:normalized');

    ok(postController instanceof PostController, 'Normalizes the name before resolving');
  });

  QUnit.test('The container normalizes names when looking factory up', function () {
    var registry = new _containerIndex.Registry();
    var container = registry.container();
    var PostController = _internalTestHelpers.factory();

    registry.normalizeFullName = function (fullName) {
      return 'controller:post';
    };

    registry.register('controller:post', PostController);
    var fact = lookupFactory('controller:normalized', container);

    equal(fact.toString() === PostController.extend().toString(), true, 'Normalizes the name when looking factory up');
  });

  QUnit.test('Options can be registered that should be applied to a given factory', function () {
    var registry = new _containerIndex.Registry();
    var container = registry.container();
    var PostView = _internalTestHelpers.factory();

    registry.resolver = {
      resolve: function (fullName) {
        if (fullName === 'view:post') {
          return PostView;
        }
      }
    };

    registry.options('view:post', { instantiate: true, singleton: false });

    var postView1 = container.lookup('view:post');
    var postView2 = container.lookup('view:post');

    ok(postView1 instanceof PostView, 'The correct factory was provided');
    ok(postView2 instanceof PostView, 'The correct factory was provided');

    ok(postView1 !== postView2, 'The two lookups are different');
  });

  QUnit.test('Options can be registered that should be applied to all factories for a given type', function () {
    var registry = new _containerIndex.Registry();
    var container = registry.container();
    var PostView = _internalTestHelpers.factory();

    registry.resolver = {
      resolve: function (fullName) {
        if (fullName === 'view:post') {
          return PostView;
        }
      }
    };

    registry.optionsForType('view', { singleton: false });

    var postView1 = container.lookup('view:post');
    var postView2 = container.lookup('view:post');

    ok(postView1 instanceof PostView, 'The correct factory was provided');
    ok(postView2 instanceof PostView, 'The correct factory was provided');

    ok(postView1 !== postView2, 'The two lookups are different');
  });

  QUnit.test('An injected non-singleton instance is never cached', function () {
    var registry = new _containerIndex.Registry();
    var container = registry.container();
    var PostView = _internalTestHelpers.factory();
    var PostViewHelper = _internalTestHelpers.factory();

    registry.register('view:post', PostView, { singleton: false });
    registry.register('view_helper:post', PostViewHelper, { singleton: false });
    registry.injection('view:post', 'viewHelper', 'view_helper:post');

    var postView1 = container.lookup('view:post');
    var postView2 = container.lookup('view:post');

    ok(postView1.viewHelper !== postView2.viewHelper, 'Injected non-singletons are not cached');
  });

  QUnit.test('Factory resolves are cached', function () {
    var registry = new _containerIndex.Registry();
    var container = registry.container();
    var PostController = _internalTestHelpers.factory();
    var resolveWasCalled = [];
    registry.resolve = function (fullName) {
      resolveWasCalled.push(fullName);
      return PostController;
    };

    deepEqual(resolveWasCalled, []);
    lookupFactory('controller:post', container);
    deepEqual(resolveWasCalled, ['controller:post']);

    lookupFactory('controller:post', container);
    deepEqual(resolveWasCalled, ['controller:post']);
  });

  QUnit.test('factory for non extendables (MODEL) resolves are cached', function () {
    var registry = new _containerIndex.Registry();
    var container = registry.container();
    var PostController = _internalTestHelpers.factory();
    var resolveWasCalled = [];
    registry.resolve = function (fullName) {
      resolveWasCalled.push(fullName);
      return PostController;
    };

    deepEqual(resolveWasCalled, []);
    lookupFactory('model:post', container);
    deepEqual(resolveWasCalled, ['model:post']);

    lookupFactory('model:post', container);
    deepEqual(resolveWasCalled, ['model:post']);
  });

  QUnit.test('factory for non extendables resolves are cached', function () {
    var registry = new _containerIndex.Registry();
    var container = registry.container();
    var PostController = {};
    var resolveWasCalled = [];

    registry.resolve = function (fullName) {
      resolveWasCalled.push(fullName);
      return PostController;
    };

    deepEqual(resolveWasCalled, []);
    lookupFactory('foo:post', container);
    deepEqual(resolveWasCalled, ['foo:post']);

    lookupFactory('foo:post', container);
    deepEqual(resolveWasCalled, ['foo:post']);
  });

  QUnit.test('The `_onLookup` hook is called on factories when looked up the first time', function () {
    expect(2);

    var registry = new _containerIndex.Registry();
    var container = registry.container();
    var Apple = _internalTestHelpers.factory();

    Apple.reopenClass({
      _onLookup: function (fullName) {
        equal(fullName, 'apple:main', 'calls lazy injection method with the lookup full name');
        equal(this, Apple, 'calls lazy injection method in the factory context');
      }
    });

    registry.register('apple:main', Apple);

    lookupFactory('apple:main', container);
    lookupFactory('apple:main', container);
  });

  QUnit.test('A factory\'s lazy injections are validated when first instantiated', function () {
    var registry = new _containerIndex.Registry();
    var container = registry.container();
    var Apple = _internalTestHelpers.factory();
    var Orange = _internalTestHelpers.factory();

    Apple.reopenClass({
      _lazyInjections: function () {
        return ['orange:main', 'banana:main'];
      }
    });

    registry.register('apple:main', Apple);
    registry.register('orange:main', Orange);

    throws(function () {
      container.lookup('apple:main');
    }, /Attempting to inject an unknown injection: 'banana:main'/);
  });

  QUnit.test('Lazy injection validations are cached', function () {
    expect(1);

    var registry = new _containerIndex.Registry();
    var container = registry.container();
    var Apple = _internalTestHelpers.factory();
    var Orange = _internalTestHelpers.factory();

    Apple.reopenClass({
      _lazyInjections: function () {
        ok(true, 'should call lazy injection method');
        return ['orange:main'];
      }
    });

    registry.register('apple:main', Apple);
    registry.register('orange:main', Orange);

    container.lookup('apple:main');
    container.lookup('apple:main');
  });

  QUnit.test('An object with its owner pre-set should be returned from ownerInjection', function () {
    var owner = {};
    var registry = new _containerIndex.Registry();
    var container = registry.container({ owner: owner });

    var result = container.ownerInjection();

    equal(result[_emberUtils.OWNER], owner, 'owner is properly included');
  });

  QUnit.test('A deprecated `container` property is appended to every object instantiated from an extendable factory', function () {
    var owner = {};
    var registry = new _containerIndex.Registry();
    var container = owner.__container__ = registry.container({ owner: owner });
    var PostController = _internalTestHelpers.factory();
    registry.register('controller:post', PostController);
    var postController = container.lookup('controller:post');

    expectDeprecation(function () {
      _emberMetal.get(postController, 'container');
    }, 'Using the injected `container` is deprecated. Please use the `getOwner` helper instead to access the owner of this object.');

    expectDeprecation(function () {
      var c = postController.container;
      strictEqual(c, container);
    }, 'Using the injected `container` is deprecated. Please use the `getOwner` helper instead to access the owner of this object.');
  });

  // This is testing that container was passed as an option
  QUnit.test('A deprecated `container` property is appended to every object instantiated from a non-extendable factory, and a fake container is available during instantiation.', function () {
    if (!true) {
      expect(8);
    } else {
      expect(1);
      ok(true, '[SKIPPED] This will be removed when `factoryFor` lands.');
    }

    var owner = {};
    var registry = new _containerIndex.Registry();
    var container = registry.container({ owner: owner });

    // Define a simple non-extendable factory
    function PostController(options) {
      this.container = options.container;
    }

    PostController.create = function (options) {
      ok(options.container, 'fake container has been injected and is available during `create`.');

      expectDeprecation(function () {
        options.container.lookup('abc:one');
      }, 'Using the injected `container` is deprecated. Please use the `getOwner` helper to access the owner of this object and then call `lookup` instead.');

      expectDeprecation(function () {
        options.container.lookupFactory('abc:two');
      }, 'Using the injected `container` is deprecated. Please use the `getOwner` helper to access the owner of this object and then call `_lookupFactory` instead.');

      // non-deprecated usage of `lookup` and `_lookupFactory`
      owner.lookup = function (fullName) {
        equal(fullName, 'abc:one', 'lookup on owner called properly');
      };
      owner._lookupFactory = function (fullName) {
        equal(fullName, 'abc:two', '_lookupFactory on owner called properly');
      };
      var foundOwner = _emberUtils.getOwner(options);
      foundOwner.lookup('abc:one');
      foundOwner._lookupFactory('abc:two');

      return new PostController(options);
    };

    registry.register('controller:post', PostController);

    if (!true) {
      (function () {
        var postController = container.lookup('controller:post');

        expectDeprecation(function () {
          _emberMetal.get(postController, 'container');
        }, 'Using the injected `container` is deprecated. Please use the `getOwner` helper instead to access the owner of this object.');

        expectDeprecation(function () {
          var c = postController.container;
          strictEqual(c, container, 'Injected container is now regular (not fake) container, but access is still deprecated.');
        }, 'Using the injected `container` is deprecated. Please use the `getOwner` helper instead to access the owner of this object.');
      })();
    }
  });

  QUnit.test('An extendable factory can provide `container` upon create, with a deprecation', function (assert) {
    var registry = new _containerIndex.Registry();
    var container = registry.container();

    registry.register('controller:post', _internalTestHelpers.factory());

    var PostController = lookupFactory('controller:post', container);

    var postController = undefined;

    expectDeprecation(function () {
      postController = PostController.create({
        container: 'foo'
      });
    }, /Providing the \`container\` property to .+ is deprecated. Please use \`Ember.setOwner\` or \`owner.ownerInjection\(\)\` instead to provide an owner to the instance being created/);

    expectDeprecation(function () {
      var c = postController.container;
      assert.equal(c, 'foo', 'the `container` provided to `.create`was used');
    }, 'Using the injected `container` is deprecated. Please use the `getOwner` helper instead to access the owner of this object.');
  });

  QUnit.test('lookupFactory passes options through to expandlocallookup', function (assert) {
    var registry = new _containerIndex.Registry();
    var container = registry.container();
    var PostController = _internalTestHelpers.factory();

    registry.register('controller:post', PostController);

    registry.expandLocalLookup = function (fullName, options) {
      assert.ok(true, 'expandLocalLookup was called');
      assert.equal(fullName, 'foo:bar');
      assert.deepEqual(options, { source: 'baz:qux' });

      return 'controller:post';
    };

    var PostControllerFactory = lookupFactory('foo:bar', container, { source: 'baz:qux' });

    assert.ok(PostControllerFactory.create() instanceof PostController, 'The return of factory.create is an instance of PostController');
  });

  QUnit.test('lookup passes options through to expandlocallookup', function (assert) {
    var registry = new _containerIndex.Registry();
    var container = registry.container();
    var PostController = _internalTestHelpers.factory();

    registry.register('controller:post', PostController);
    registry.expandLocalLookup = function (fullName, options) {
      assert.ok(true, 'expandLocalLookup was called');
      assert.equal(fullName, 'foo:bar');
      assert.deepEqual(options, { source: 'baz:qux' });

      return 'controller:post';
    };

    var PostControllerLookupResult = container.lookup('foo:bar', { source: 'baz:qux' });

    assert.ok(PostControllerLookupResult instanceof PostController);
  });

  QUnit.test('#[FACTORY_FOR] class is the injected factory', function (assert) {
    var registry = new _containerIndex.Registry();
    var container = registry.container();

    var Component = _internalTestHelpers.factory();
    registry.register('component:foo-bar', Component);

    var factoryManager = container[_container.FACTORY_FOR]('component:foo-bar');
    if (true) {
      assert.deepEqual(factoryManager.class, Component, 'No double extend');
    } else {
      assert.deepEqual(factoryManager.class, lookupFactory('component:foo-bar', container), 'Double extended class');
    }
  });

  if (true) {
    QUnit.test('#factoryFor must supply a fullname', function (assert) {
      var registry = new _containerIndex.Registry();
      var container = registry.container();
      assert.throws(function () {
        container.factoryFor('chad-bar');
      }, /Invalid Fullname, expected: 'type:name' got: chad-bar/);
    });

    QUnit.test('#factoryFor returns a factory manager', function (assert) {
      var registry = new _containerIndex.Registry();
      var container = registry.container();

      var Component = _internalTestHelpers.factory();
      registry.register('component:foo-bar', Component);

      var factoryManager = container.factoryFor('component:foo-bar');
      assert.ok(factoryManager.create);
      assert.ok(factoryManager.class);
    });

    QUnit.test('#factoryFor returns a cached factory manager for the same type', function (assert) {
      var registry = new _containerIndex.Registry();
      var container = registry.container();

      var Component = _internalTestHelpers.factory();
      registry.register('component:foo-bar', Component);
      registry.register('component:baz-bar', Component);

      var factoryManager1 = container.factoryFor('component:foo-bar');
      var factoryManager2 = container.factoryFor('component:foo-bar');
      var factoryManager3 = container.factoryFor('component:baz-bar');

      assert.equal(factoryManager1, factoryManager2, 'cache hit');
      assert.notEqual(factoryManager1, factoryManager3, 'cache miss');
    });

    QUnit.test('#factoryFor class returns the factory function', function (assert) {
      var registry = new _containerIndex.Registry();
      var container = registry.container();

      var Component = _internalTestHelpers.factory();
      registry.register('component:foo-bar', Component);

      var factoryManager = container.factoryFor('component:foo-bar');
      assert.deepEqual(factoryManager.class, Component, 'No double extend');
    });

    QUnit.test('#factoryFor instance have a common parent', function (assert) {
      var registry = new _containerIndex.Registry();
      var container = registry.container();

      var Component = _internalTestHelpers.factory();
      registry.register('component:foo-bar', Component);

      var factoryManager1 = container.factoryFor('component:foo-bar');
      var factoryManager2 = container.factoryFor('component:foo-bar');
      var instance1 = factoryManager1.create({ foo: 'foo' });
      var instance2 = factoryManager2.create({ bar: 'bar' });

      assert.deepEqual(instance1.constructor, instance2.constructor);
    });

    QUnit.test('#factoryFor created instances come with instance injections', function (assert) {
      var registry = new _containerIndex.Registry();
      var container = registry.container();

      var Component = _internalTestHelpers.factory();
      var Ajax = _internalTestHelpers.factory();
      registry.register('component:foo-bar', Component);
      registry.register('util:ajax', Ajax);
      registry.injection('component:foo-bar', 'ajax', 'util:ajax');

      var componentFactory = container.factoryFor('component:foo-bar');
      var component = componentFactory.create();

      assert.ok(component.ajax);
      assert.ok(component.ajax instanceof Ajax);
    });

    QUnit.test('#factoryFor options passed to create clobber injections', function (assert) {
      var registry = new _containerIndex.Registry();
      var container = registry.container();

      var Component = _internalTestHelpers.factory();
      var Ajax = _internalTestHelpers.factory();
      registry.register('component:foo-bar', Component);
      registry.register('util:ajax', Ajax);
      registry.injection('component:foo-bar', 'ajax', 'util:ajax');

      var componentFactory = container.factoryFor('component:foo-bar');
      var instrance = componentFactory.create({ ajax: 'fetch' });

      assert.equal(instrance.ajax, 'fetch');
    });

    QUnit.test('#factoryFor does not add properties to the object being instantiated when _initFactory is present', function (assert) {
      var owner = {};
      var registry = new _containerIndex.Registry();
      var container = registry.container();

      var factory = undefined;

      var Component = (function () {
        function Component() {
          babelHelpers.classCallCheck(this, Component);
        }

        Component._initFactory = function _initFactory(_factory) {
          factory = _factory;
        };

        Component.create = function create(options) {
          var instance = new this();
          _emberUtils.assign(instance, options);
          return instance;
        };

        return Component;
      })();

      registry.register('component:foo-bar', Component);

      var componentFactory = container.factoryFor('component:foo-bar');
      var instance = componentFactory.create();

      // note: _guid and isDestroyed are being set in the `factory` constructor
      // not via registry/container shenanigans
      assert.deepEqual(Object.keys(instance), []);
    });

    // this is skipped until templates and the glimmer environment do not require `OWNER` to be
    // passed in as constructor args
    QUnit.skip('#factoryFor does not add properties to the object being instantiated', function (assert) {
      var owner = {};
      var registry = new _containerIndex.Registry();
      var container = registry.container();

      var factory = undefined;

      var Component = (function () {
        function Component() {
          babelHelpers.classCallCheck(this, Component);
        }

        Component.create = function create(options) {
          var instance = new this();
          _emberUtils.assign(instance, options);
          return instance;
        };

        return Component;
      })();

      registry.register('component:foo-bar', Component);

      var componentFactory = container.factoryFor('component:foo-bar');
      var instance = componentFactory.create();

      // note: _guid and isDestroyed are being set in the `factory` constructor
      // not via registry/container shenanigans
      assert.deepEqual(Object.keys(instance), []);
    });
  }
});
enifed('container/tests/container_test.lint-test', ['exports'], function (exports) {
  'use strict';

  QUnit.module('ESLint | container/tests/container_test.js');
  QUnit.test('should pass ESLint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'container/tests/container_test.js should pass ESLint\n\n');
  });
});
enifed('container/tests/owner_test', ['exports', 'ember-utils'], function (exports, _emberUtils) {
  'use strict';

  QUnit.module('Owner', {});

  QUnit.test('An owner can be set with `setOwner` and retrieved with `getOwner`', function () {
    var owner = {};
    var obj = {};

    strictEqual(_emberUtils.getOwner(obj), undefined, 'owner has not been set');

    _emberUtils.setOwner(obj, owner);

    strictEqual(_emberUtils.getOwner(obj), owner, 'owner has been set');

    strictEqual(obj[_emberUtils.OWNER], owner, 'owner has been set to the OWNER symbol');
  });
});
enifed('container/tests/owner_test.lint-test', ['exports'], function (exports) {
  'use strict';

  QUnit.module('ESLint | container/tests/owner_test.js');
  QUnit.test('should pass ESLint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'container/tests/owner_test.js should pass ESLint\n\n');
  });
});
enifed('container/tests/registry_test', ['exports', 'container/index', 'internal-test-helpers'], function (exports, _containerIndex, _internalTestHelpers) {
  'use strict';

  QUnit.module('Registry');

  QUnit.test('A registered factory is returned from resolve', function () {
    var registry = new _containerIndex.Registry();
    var PostController = _internalTestHelpers.factory();

    registry.register('controller:post', PostController);

    var PostControllerFactory = registry.resolve('controller:post');

    ok(PostControllerFactory, 'factory is returned');
    ok(PostControllerFactory.create() instanceof PostController, 'The return of factory.create is an instance of PostController');
  });

  QUnit.test('The registered factory returned from resolve is the same factory each time', function () {
    var registry = new _containerIndex.Registry();
    var PostController = _internalTestHelpers.factory();

    registry.register('controller:post', PostController);

    deepEqual(registry.resolve('controller:post'), registry.resolve('controller:post'), 'The return of resolve is always the same');
  });

  QUnit.test('The registered value returned from resolve is the same value each time even if the value is falsy', function () {
    var registry = new _containerIndex.Registry();

    registry.register('falsy:value', null, { instantiate: false });

    strictEqual(registry.resolve('falsy:value'), registry.resolve('falsy:value'), 'The return of resolve is always the same');
  });

  QUnit.test('The value returned from resolver is the same value as the original value even if the value is falsy', function () {
    var resolver = {
      resolve: function (fullName) {
        if (fullName === 'falsy:value') {
          return null;
        }
      }
    };
    var registry = new _containerIndex.Registry({ resolver: resolver });

    strictEqual(registry.resolve('falsy:value'), null);
  });

  QUnit.test('A registered factory returns true for `has` if an item is registered', function () {
    var registry = new _containerIndex.Registry();
    var PostController = _internalTestHelpers.factory();

    registry.register('controller:post', PostController);

    equal(registry.has('controller:post'), true, 'The `has` method returned true for registered factories');
    equal(registry.has('controller:posts'), false, 'The `has` method returned false for unregistered factories');
  });

  QUnit.test('Throw exception when trying to inject `type:thing` on all type(s)', function () {
    var registry = new _containerIndex.Registry();
    var PostController = _internalTestHelpers.factory();

    registry.register('controller:post', PostController);

    throws(function () {
      registry.typeInjection('controller', 'injected', 'controller:post');
    }, /Cannot inject a 'controller:post' on other controller\(s\)\./);
  });

  QUnit.test('The registry can take a hook to resolve factories lazily', function () {
    var PostController = _internalTestHelpers.factory();
    var resolver = {
      resolve: function (fullName) {
        if (fullName === 'controller:post') {
          return PostController;
        }
      }
    };
    var registry = new _containerIndex.Registry({ resolver: resolver });

    strictEqual(registry.resolve('controller:post'), PostController, 'The correct factory was provided');
  });

  QUnit.test('The registry respects the resolver hook for `has`', function () {
    var PostController = _internalTestHelpers.factory();
    var resolver = {
      resolve: function (fullName) {
        if (fullName === 'controller:post') {
          return PostController;
        }
      }
    };
    var registry = new _containerIndex.Registry({ resolver: resolver });

    ok(registry.has('controller:post'), 'the `has` method uses the resolver hook');
  });

  QUnit.test('The registry normalizes names when resolving', function () {
    var registry = new _containerIndex.Registry();
    var PostController = _internalTestHelpers.factory();

    registry.normalizeFullName = function (fullName) {
      return 'controller:post';
    };

    registry.register('controller:post', PostController);
    var type = registry.resolve('controller:normalized');

    strictEqual(type, PostController, 'Normalizes the name when resolving');
  });

  QUnit.test('The registry normalizes names when checking if the factory is registered', function () {
    var registry = new _containerIndex.Registry();
    var PostController = _internalTestHelpers.factory();

    registry.normalizeFullName = function (fullName) {
      return fullName === 'controller:normalized' ? 'controller:post' : fullName;
    };

    registry.register('controller:post', PostController);
    var isPresent = registry.has('controller:normalized');

    equal(isPresent, true, 'Normalizes the name when checking if the factory or instance is present');
  });

  QUnit.test('validateFullName throws an error if name is incorrect', function () {
    expect(2);

    var registry = new _containerIndex.Registry();
    var PostController = _internalTestHelpers.factory();

    registry.normalize = function (fullName) {
      return 'controller:post';
    };

    registry.register('controller:post', PostController);
    throws(function () {
      registry.validateFullName('post');
    }, /TypeError: Invalid Fullname, expected: 'type:name' got: post/);

    throws(function () {
      registry.validateFullName('route:http://foo.bar.com/baz');
    }, /TypeError: Invalid Fullname, expected: 'type:name' got: route:http:\/\/foo.bar.com\/baz/);
  });

  QUnit.test('The registry normalizes names when injecting', function () {
    var registry = new _containerIndex.Registry();
    var PostController = _internalTestHelpers.factory();
    var user = { name: 'Stef' };

    registry.normalize = function (fullName) {
      return 'controller:post';
    };

    registry.register('controller:post', PostController);
    registry.register('user:post', user, { instantiate: false });
    registry.injection('controller:post', 'user', 'controller:normalized');

    deepEqual(registry.resolve('controller:post'), user, 'Normalizes the name when injecting');
  });

  QUnit.test('cannot register an `undefined` factory', function () {
    var registry = new _containerIndex.Registry();

    throws(function () {
      registry.register('controller:apple', undefined);
    }, '');
  });

  QUnit.test('can re-register a factory', function () {
    var registry = new _containerIndex.Registry();
    var FirstApple = _internalTestHelpers.factory('first');
    var SecondApple = _internalTestHelpers.factory('second');

    registry.register('controller:apple', FirstApple);
    registry.register('controller:apple', SecondApple);

    ok(registry.resolve('controller:apple').create() instanceof SecondApple);
  });

  QUnit.test('cannot re-register a factory if it has been resolved', function () {
    var registry = new _containerIndex.Registry();
    var FirstApple = _internalTestHelpers.factory('first');
    var SecondApple = _internalTestHelpers.factory('second');

    registry.register('controller:apple', FirstApple);
    strictEqual(registry.resolve('controller:apple'), FirstApple);

    throws(function () {
      registry.register('controller:apple', SecondApple);
    }, /Cannot re-register: 'controller:apple', as it has already been resolved\./);

    strictEqual(registry.resolve('controller:apple'), FirstApple);
  });

  QUnit.test('registry.has should not accidentally cause injections on that factory to be run. (Mitigate merely on observing)', function () {
    expect(1);

    var registry = new _containerIndex.Registry();
    var FirstApple = _internalTestHelpers.factory('first');
    var SecondApple = _internalTestHelpers.factory('second');

    SecondApple.extend = function (a, b, c) {
      ok(false, 'should not extend or touch the injected model, merely to inspect existence of another');
    };

    registry.register('controller:apple', FirstApple);
    registry.register('controller:second-apple', SecondApple);
    registry.injection('controller:apple', 'badApple', 'controller:second-apple');

    ok(registry.has('controller:apple'));
  });

  QUnit.test('registry.has should not error for invalid fullNames)', function () {
    expect(1);

    var registry = new _containerIndex.Registry();

    ok(!registry.has('foo:bar:baz'));
  });

  QUnit.test('once resolved, always return the same result', function () {
    expect(1);

    var registry = new _containerIndex.Registry();

    registry.resolver = {
      resolve: function () {
        return 'bar';
      }
    };

    var Bar = registry.resolve('models:bar');

    registry.resolver = {
      resolve: function () {
        return 'not bar';
      }
    };

    equal(registry.resolve('models:bar'), Bar);
  });

  QUnit.test('factory resolves are cached', function () {
    var registry = new _containerIndex.Registry();
    var PostController = _internalTestHelpers.factory();
    var resolveWasCalled = [];

    registry.resolver = {
      resolve: function (fullName) {
        resolveWasCalled.push(fullName);
        return PostController;
      }
    };

    deepEqual(resolveWasCalled, []);
    registry.resolve('controller:post');
    deepEqual(resolveWasCalled, ['controller:post']);

    registry.resolve('controller:post');
    deepEqual(resolveWasCalled, ['controller:post']);
  });

  QUnit.test('factory for non extendables (MODEL) resolves are cached', function () {
    var registry = new _containerIndex.Registry();
    var Po