/*!
 * @overview  Ember - JavaScript Application Framework
 * @copyright Copyright 2011-2015 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.0.3
 */

(function() {
var enifed, requireModule, eriuqer, requirejs, Ember;
var mainContext = this;

(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;
    };

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

    function internalRequire(name, referrerName) {
      var exports = seen[name];

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

      exports = seen[name] = {};

      if (!registry[name]) {
        if (referrerName) {
          throw new Error('Could not find module ' + name + ' required by: ' + referrerName);
        } else {
          throw new Error('Could not find module ' + name);
        }
      }

      var mod = registry[name];
      var deps = mod.deps;
      var callback = mod.callback;
      var reified = [];
      var length = deps.length;

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

      callback.apply(this, reified);

      return exports;
    };

    function resolve(child, name) {
      if (child.charAt(0) !== '.') {
        return child;
      }
      var parts = child.split('/');
      var parentBase = name.split('/').slice(0, -1);

      for (var i=0, l=parts.length; i<l; i++) {
        var part = parts[i];

        if (part === '..') {
          parentBase.pop();
        } else if (part === '.') {
          continue;
        } else {
          parentBase.push(part);
        }
      }

      return parentBase.join('/');
    }

    requirejs._eak_seen = registry;

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

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

  module('JSCS - .');
  test('container.js should pass jscs', function () {
    ok(true, 'container.js should pass jscs.');
  });
});
enifed('container.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - .');
  QUnit.test('container.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'container.js should pass jshint.');
  });
});
enifed('container/container.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - container');
  test('container/container.js should pass jscs', function () {
    ok(true, 'container/container.js should pass jscs.');
  });
});
enifed('container/container.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - container');
  QUnit.test('container/container.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'container/container.js should pass jshint.');
  });
});
enifed('container/registry.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - container');
  test('container/registry.js should pass jscs', function () {
    ok(true, 'container/registry.js should pass jscs.');
  });
});
enifed('container/registry.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - container');
  QUnit.test('container/registry.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'container/registry.js should pass jshint.');
  });
});
enifed('container/tests/container_helper', ['exports'], function (exports) {
  'use strict';

  var setProperties = function (object, properties) {
    for (var key in properties) {
      if (properties.hasOwnProperty(key)) {
        object[key] = properties[key];
      }
    }
  };

  var guids = 0;

  var factory = function () {
    /*jshint validthis: true */

    var Klass = function (options) {
      setProperties(this, options);
      this._guid = guids++;
    };

    Klass.prototype.constructor = Klass;
    Klass.prototype.destroy = function () {
      this.isDestroyed = true;
    };

    Klass.prototype.toString = function () {
      return '<Factory:' + this._guid + '>';
    };

    Klass.create = create;
    Klass.extend = extend;
    Klass.reopen = extend;
    Klass.reopenClass = reopenClass;

    return Klass;

    function create(options) {
      return new this.prototype.constructor(options);
    }

    function reopenClass(options) {
      setProperties(this, options);
    }

    function extend(options) {
      var Child = function (options) {
        Klass.call(this, options);
      };

      var Parent = this;

      Child.prototype = new Parent();
      Child.prototype.constructor = Child;

      setProperties(Child, Klass);
      setProperties(Child.prototype, options);

      Child.create = create;
      Child.extend = extend;
      Child.reopen = extend;

      Child.reopenClass = reopenClass;

      return Child;
    }
  };

  exports.factory = factory;
  exports.setProperties = setProperties;
});
enifed('container/tests/container_helper.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - container/tests');
  test('container/tests/container_helper.js should pass jscs', function () {
    ok(true, 'container/tests/container_helper.js should pass jscs.');
  });
});
enifed('container/tests/container_helper.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - container/tests');
  QUnit.test('container/tests/container_helper.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'container/tests/container_helper.js should pass jshint.');
  });
});
enifed('container/tests/container_test', ['exports', 'ember-metal/core', 'container/registry', 'container/tests/container_helper'], function (exports, _emberMetalCore, _containerRegistry, _containerTestsContainer_helper) {
  'use strict';

  var originalModelInjections;

  QUnit.module('Container', {
    setup: function () {
      originalModelInjections = _emberMetalCore.default.MODEL_FACTORY_INJECTIONS;
    },
    teardown: function () {
      _emberMetalCore.default.MODEL_FACTORY_INJECTIONS = originalModelInjections;
    }
  });

  QUnit.test('A registered factory returns the same instance each time', function () {
    var registry = new _containerRegistry.default();
    var container = registry.container();
    var PostController = _containerTestsContainer_helper.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 _containerRegistry.default();
    var container = registry.container();
    var PostController = _containerTestsContainer_helper.factory();

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

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

    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 _containerRegistry.default();
    var container = registry.container();
    var PostController = _containerTestsContainer_helper.factory();

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

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

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

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

    ok(!PostFactory.container, 'factory instance receives a container');
    equal(PostFactory._debugContainerKey, 'controller:post', 'factory instance receives _debugContainerKey');
  });

  QUnit.test('fallback for to create time injections if factory has no extend', function () {
    var registry = new _containerRegistry.default();
    var container = registry.container();
    var AppleController = _containerTestsContainer_helper.factory();
    var PostController = _containerTestsContainer_helper.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.container, 'instance receives a container');
    equal(postController.container, container, 'instance receives the correct container');
    equal(postController._debugContainerKey, 'controller:post', 'instance receives _debugContainerKey');
    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 _containerRegistry.default();
    var container = registry.container();
    var PostController = _containerTestsContainer_helper.factory();
    var instance;

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

    ok(instance.container, 'factory instance receives a container');
    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 _containerRegistry.default();
    var container = registry.container();
    var PostController = _containerTestsContainer_helper.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 container lookup has access to the container', function () {
    var registry = new _containerRegistry.default();
    var container = registry.container();
    var PostController = _containerTestsContainer_helper.factory();

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

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

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

  QUnit.test('A factory type with a registered injection\'s instances receive that injection', function () {
    var registry = new _containerRegistry.default();
    var container = registry.container();
    var PostController = _containerTestsContainer_helper.factory();
    var Store = _containerTestsContainer_helper.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 _containerRegistry.default();
    var container = registry.container();
    var PostController = _containerTestsContainer_helper.factory();
    var Store = _containerTestsContainer_helper.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(store.container, container);
    equal(store._debugContainerKey, 'store:main');

    equal(postController.container, container);
    equal(postController._debugContainerKey, 'controller:post');
    equal(postController.store, store, 'has the correct store injected');
  });

  QUnit.test('A factory with both type and individual injections', function () {
    var registry = new _containerRegistry.default();
    var container = registry.container();
    var PostController = _containerTestsContainer_helper.factory();
    var Store = _containerTestsContainer_helper.factory();
    var Router = _containerTestsContainer_helper.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 _containerRegistry.default();
    var container = registry.container();
    var PostController = _containerTestsContainer_helper.factory();
    var Store = _containerTestsContainer_helper.factory();
    var Router = _containerTestsContainer_helper.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 = container.lookupFactory('controller:post');
    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 _containerRegistry.default();
    var container = registry.container();
    var PostView = _containerTestsContainer_helper.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 _containerRegistry.default();
    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 _containerRegistry.default();
    var container = registry.container();

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

  QUnit.test('An invalid factory throws an error', function () {
    var registry = new _containerRegistry.default();
    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 () {
    _emberMetalCore.default.MODEL_FACTORY_INJECTIONS = true;

    var registry = new _containerRegistry.default();
    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 _containerRegistry.default();
    var container = registry.container();
    var ApplicationController = _containerTestsContainer_helper.factory();

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

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

  QUnit.test('Destroying the container destroys any cached singletons', function () {
    var registry = new _containerRegistry.default();
    var container = registry.container();
    var PostController = _containerTestsContainer_helper.factory();
    var PostView = _containerTestsContainer_helper.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 _containerRegistry.default();
    var container = registry.container();
    var PostController = _containerTestsContainer_helper.factory();

    registry.resolver = 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 _containerRegistry.default();
    var container = registry.container();
    var PostController = _containerTestsContainer_helper.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 _containerRegistry.default();
    var container = registry.container();
    var PostController = _containerTestsContainer_helper.factory();

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

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

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

  QUnit.test('The container can get options that should be applied to a given factory', function () {
    var registry = new _containerRegistry.default();
    var container = registry.container();
    var PostView = _containerTestsContainer_helper.factory();

    registry.resolver = 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('The container can get options that should be applied to all factories for a given type', function () {
    var registry = new _containerRegistry.default();
    var container = registry.container();
    var PostView = _containerTestsContainer_helper.factory();

    registry.resolver = 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('factory resolves are cached', function () {
    var registry = new _containerRegistry.default();
    var container = registry.container();
    var PostController = _containerTestsContainer_helper.factory();
    var resolveWasCalled = [];
    registry.resolve = function (fullName) {
      resolveWasCalled.push(fullName);
      return PostController;
    };

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

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

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

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

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

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

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

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

    container.lookupFactory('foo:post');
    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 _containerRegistry.default();
    var container = registry.container();
    var Apple = _containerTestsContainer_helper.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);

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

  QUnit.test('A factory\'s lazy injections are validated when first instantiated', function () {
    var registry = new _containerRegistry.default();
    var container = registry.container();
    var Apple = _containerTestsContainer_helper.factory();
    var Orange = _containerTestsContainer_helper.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 _containerRegistry.default();
    var container = registry.container();
    var Apple = _containerTestsContainer_helper.factory();
    var Orange = _containerTestsContainer_helper.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');
  });
});
enifed('container/tests/container_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - container/tests');
  test('container/tests/container_test.js should pass jscs', function () {
    ok(true, 'container/tests/container_test.js should pass jscs.');
  });
});
enifed('container/tests/container_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - container/tests');
  QUnit.test('container/tests/container_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'container/tests/container_test.js should pass jshint.');
  });
});
enifed('container/tests/registry_test', ['exports', 'ember-metal/core', 'container', 'container/tests/container_helper'], function (exports, _emberMetalCore, _container, _containerTestsContainer_helper) {
  'use strict';

  var originalModelInjections;

  QUnit.module('Registry', {
    setup: function () {
      originalModelInjections = _emberMetalCore.default.MODEL_FACTORY_INJECTIONS;
    },
    teardown: function () {
      _emberMetalCore.default.MODEL_FACTORY_INJECTIONS = originalModelInjections;
    }
  });

  QUnit.test('A registered factory is returned from resolve', function () {
    var registry = new _container.Registry();
    var PostController = _containerTestsContainer_helper.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 _container.Registry();
    var PostController = _containerTestsContainer_helper.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('A registered factory returns true for `has` if an item is registered', function () {
    var registry = new _container.Registry();
    var PostController = _containerTestsContainer_helper.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 _container.Registry();
    var PostController = _containerTestsContainer_helper.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 registry = new _container.Registry();
    var PostController = _containerTestsContainer_helper.factory();

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

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

  QUnit.test('The registry respects the resolver hook for `has`', function () {
    var registry = new _container.Registry();
    var PostController = _containerTestsContainer_helper.factory();

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

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

  QUnit.test('The registry normalizes names when resolving', function () {
    var registry = new _container.Registry();
    var PostController = _containerTestsContainer_helper.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 _container.Registry();
    var PostController = _containerTestsContainer_helper.factory();

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

    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 () {
    var registry = new _container.Registry();
    var PostController = _containerTestsContainer_helper.factory();

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

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

  QUnit.test('The registry normalizes names when injecting', function () {
    var registry = new _container.Registry();
    var PostController = _containerTestsContainer_helper.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 _container.Registry();

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

  QUnit.test('can re-register a factory', function () {
    var registry = new _container.Registry();
    var FirstApple = _containerTestsContainer_helper.factory('first');
    var SecondApple = _containerTestsContainer_helper.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 _container.Registry();
    var FirstApple = _containerTestsContainer_helper.factory('first');
    var SecondApple = _containerTestsContainer_helper.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 _container.Registry();
    var FirstApple = _containerTestsContainer_helper.factory('first');
    var SecondApple = _containerTestsContainer_helper.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('once resolved, always return the same result', function () {
    expect(1);

    var registry = new _container.Registry();

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

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

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

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

  QUnit.test('factory resolves are cached', function () {
    var registry = new _container.Registry();
    var PostController = _containerTestsContainer_helper.factory();
    var resolveWasCalled = [];
    registry.resolver = 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 _container.Registry();
    var PostController = _containerTestsContainer_helper.factory();
    var resolveWasCalled = [];
    registry.resolver = function (fullName) {
      resolveWasCalled.push(fullName);
      return PostController;
    };

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

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

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

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

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

  QUnit.test('registry.container creates a container', function () {
    var registry = new _container.Registry();
    var PostController = _containerTestsContainer_helper.factory();
    registry.register('controller:post', PostController);

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

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

  QUnit.test('`resolve` can be handled by a fallback registry', function () {
    var fallback = new _container.Registry();

    var registry = new _container.Registry({ fallback: fallback });
    var PostController = _containerTestsContainer_helper.factory();

    fallback.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('`has` can be handled by a fallback registry', function () {
    var fallback = new _container.Registry();

    var registry = new _container.Registry({ fallback: fallback });
    var PostController = _containerTestsContainer_helper.factory();

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

    equal(registry.has('controller:post'), true, 'Fallback registry is checked for registration');
  });

  QUnit.test('`getInjections` includes injections from a fallback registry', function () {
    var fallback = new _container.Registry();
    var registry = new _container.Registry({ fallback: fallback });

    equal(registry.getInjections('model:user').length, 0, 'No injections in the primary registry');

    fallback.injection('model:user', 'post', 'model:post');

    equal(registry.getInjections('model:user').length, 1, 'Injections from the fallback registry are merged');
  });

  QUnit.test('`getTypeInjections` includes type injections from a fallback registry', function () {
    var fallback = new _container.Registry();
    var registry = new _container.Registry({ fallback: fallback });

    equal(registry.getTypeInjections('model').length, 0, 'No injections in the primary registry');

    fallback.injection('model', 'source', 'source:main');

    equal(registry.getTypeInjections('model').length, 1, 'Injections from the fallback registry are merged');
  });

  QUnit.test('`getFactoryInjections` includes factory injections from a fallback registry', function () {
    var fallback = new _container.Registry();
    var registry = new _container.Registry({ fallback: fallback });

    equal(registry.getFactoryInjections('model:user').length, 0, 'No factory injections in the primary registry');

    fallback.factoryInjection('model:user', 'store', 'store:main');

    equal(registry.getFactoryInjections('model:user').length, 1, 'Factory injections from the fallback registry are merged');
  });

  QUnit.test('`getFactoryTypeInjections` includes factory type injections from a fallback registry', function () {
    var fallback = new _container.Registry();
    var registry = new _container.Registry({ fallback: fallback });

    equal(registry.getFactoryTypeInjections('model').length, 0, 'No factory type injections in the primary registry');

    fallback.factoryInjection('model', 'store', 'store:main');

    equal(registry.getFactoryTypeInjections('model').length, 1, 'Factory type injections from the fallback registry are merged');
  });

  QUnit.test('`knownForType` contains keys for each item of a given type', function () {
    var registry = new _container.Registry();

    registry.register('foo:bar-baz', 'baz');
    registry.register('foo:qux-fez', 'fez');

    var found = registry.knownForType('foo');

    deepEqual(found, {
      'foo:bar-baz': true,
      'foo:qux-fez': true
    });
  });

  QUnit.test('`knownForType` includes fallback registry results', function () {
    var fallback = new _container.Registry();
    var registry = new _container.Registry({ fallback: fallback });

    registry.register('foo:bar-baz', 'baz');
    registry.register('foo:qux-fez', 'fez');
    fallback.register('foo:zurp-zorp', 'zorp');

    var found = registry.knownForType('foo');

    deepEqual(found, {
      'foo:bar-baz': true,
      'foo:qux-fez': true,
      'foo:zurp-zorp': true
    });
  });

  QUnit.test('`knownForType` is called on the resolver if present', function () {
    expect(3);

    function resolver() {}
    resolver.knownForType = function (type) {
      ok(true, 'knownForType called on the resolver');
      equal(type, 'foo', 'the type was passed through');

      return { 'foo:yorp': true };
    };

    var registry = new _container.Registry({
      resolver: resolver
    });
    registry.register('foo:bar-baz', 'baz');

    var found = registry.knownForType('foo');

    deepEqual(found, {
      'foo:yorp': true,
      'foo:bar-baz': true
    });
  });
});
enifed('container/tests/registry_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - container/tests');
  test('container/tests/registry_test.js should pass jscs', function () {
    ok(true, 'container/tests/registry_test.js should pass jscs.');
  });
});
enifed('container/tests/registry_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - container/tests');
  QUnit.test('container/tests/registry_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'container/tests/registry_test.js should pass jshint.');
  });
});
enifed('ember-application.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - .');
  test('ember-application.js should pass jscs', function () {
    ok(true, 'ember-application.js should pass jscs.');
  });
});
enifed('ember-application.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - .');
  QUnit.test('ember-application.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-application.js should pass jshint.');
  });
});
enifed('ember-application/system/application-instance.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-application/system');
  test('ember-application/system/application-instance.js should pass jscs', function () {
    ok(true, 'ember-application/system/application-instance.js should pass jscs.');
  });
});
enifed('ember-application/system/application-instance.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-application/system');
  QUnit.test('ember-application/system/application-instance.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-application/system/application-instance.js should pass jshint.');
  });
});
enifed('ember-application/system/application.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-application/system');
  test('ember-application/system/application.js should pass jscs', function () {
    ok(true, 'ember-application/system/application.js should pass jscs.');
  });
});
enifed('ember-application/system/application.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-application/system');
  QUnit.test('ember-application/system/application.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-application/system/application.js should pass jshint.');
  });
});
enifed('ember-application/system/resolver.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-application/system');
  test('ember-application/system/resolver.js should pass jscs', function () {
    ok(true, 'ember-application/system/resolver.js should pass jscs.');
  });
});
enifed('ember-application/system/resolver.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-application/system');
  QUnit.test('ember-application/system/resolver.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-application/system/resolver.js should pass jshint.');
  });
});
enifed('ember-application/tests/system/application_test', ['exports', 'ember-metal/core', 'ember-metal/run_loop', 'ember-application/system/application', 'ember-application/system/resolver', 'ember-routing/system/router', 'ember-views/views/view', 'ember-runtime/controllers/controller', 'ember-routing/location/none_location', 'ember-runtime/system/object', 'ember-routing/system/route', 'ember-views/system/jquery', 'ember-template-compiler/system/compile', 'ember-runtime/system/lazy_load'], function (exports, _emberMetalCore, _emberMetalRun_loop, _emberApplicationSystemApplication, _emberApplicationSystemResolver, _emberRoutingSystemRouter, _emberViewsViewsView, _emberRuntimeControllersController, _emberRoutingLocationNone_location, _emberRuntimeSystemObject, _emberRoutingSystemRoute, _emberViewsSystemJquery, _emberTemplateCompilerSystemCompile, _emberRuntimeSystemLazy_load) {
  /*globals EmberDev */

  'use strict';

  var trim = _emberViewsSystemJquery.default.trim;

  var app, application, originalLookup, originalDebug;

  QUnit.module('Ember.Application', {
    setup: function () {
      originalLookup = _emberMetalCore.default.lookup;
      originalDebug = _emberMetalCore.default.debug;

      _emberViewsSystemJquery.default('#qunit-fixture').html('<div id=\'one\'><div id=\'one-child\'>HI</div></div><div id=\'two\'>HI</div>');
      _emberMetalRun_loop.default(function () {
        application = _emberApplicationSystemApplication.default.create({ rootElement: '#one', router: null });
      });
    },

    teardown: function () {
      _emberViewsSystemJquery.default('#qunit-fixture').empty();
      _emberMetalCore.default.debug = originalDebug;

      _emberMetalCore.default.lookup = originalLookup;

      if (application) {
        _emberMetalRun_loop.default(application, 'destroy');
      }

      if (app) {
        _emberMetalRun_loop.default(app, 'destroy');
      }
    }
  });

  QUnit.test('you can make a new application in a non-overlapping element', function () {
    _emberMetalRun_loop.default(function () {
      app = _emberApplicationSystemApplication.default.create({ rootElement: '#two', router: null });
    });

    _emberMetalRun_loop.default(app, 'destroy');
    ok(true, 'should not raise');
  });

  QUnit.test('you cannot make a new application that is a parent of an existing application', function () {
    expectAssertion(function () {
      _emberMetalRun_loop.default(function () {
        _emberApplicationSystemApplication.default.create({ rootElement: '#qunit-fixture' });
      });
    });
  });

  QUnit.test('you cannot make a new application that is a descendent of an existing application', function () {
    expectAssertion(function () {
      _emberMetalRun_loop.default(function () {
        _emberApplicationSystemApplication.default.create({ rootElement: '#one-child' });
      });
    });
  });

  QUnit.test('you cannot make a new application that is a duplicate of an existing application', function () {
    expectAssertion(function () {
      _emberMetalRun_loop.default(function () {
        _emberApplicationSystemApplication.default.create({ rootElement: '#one' });
      });
    });
  });

  QUnit.test('you cannot make two default applications without a rootElement error', function () {
    expectAssertion(function () {
      _emberMetalRun_loop.default(function () {
        _emberApplicationSystemApplication.default.create({ router: false });
      });
    });
  });

  QUnit.test('acts like a namespace', function () {
    var lookup = _emberMetalCore.default.lookup = {};

    _emberMetalRun_loop.default(function () {
      app = lookup.TestApp = _emberApplicationSystemApplication.default.create({ rootElement: '#two', router: false });
    });

    _emberMetalCore.default.BOOTED = false;
    app.Foo = _emberRuntimeSystemObject.default.extend();
    equal(app.Foo.toString(), 'TestApp.Foo', 'Classes pick up their parent namespace');
  });

  QUnit.module('Ember.Application initialization', {
    teardown: function () {
      if (app) {
        _emberMetalRun_loop.default(app, 'destroy');
      }
      _emberMetalCore.default.TEMPLATES = {};
    }
  });

  QUnit.test('initialized application go to initial route', function () {
    _emberMetalRun_loop.default(function () {
      app = _emberApplicationSystemApplication.default.create({
        rootElement: '#qunit-fixture'
      });

      app.Router.reopen({
        location: 'none'
      });

      app.register('template:application', _emberTemplateCompilerSystemCompile.default('{{outlet}}'));

      _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompilerSystemCompile.default('<h1>Hi from index</h1>');
    });

    equal(_emberViewsSystemJquery.default('#qunit-fixture h1').text(), 'Hi from index');
  });

  QUnit.test('ready hook is called before routing begins', function () {
    expect(2);

    _emberMetalRun_loop.default(function () {
      function registerRoute(application, name, callback) {
        var route = _emberRoutingSystemRoute.default.extend({
          activate: callback
        });

        application.register('route:' + name, route);
      }

      var MyApplication = _emberApplicationSystemApplication.default.extend({
        ready: function () {
          registerRoute(this, 'index', function () {
            ok(true, 'last-minite route is activated');
          });
        }
      });

      app = MyApplication.create({
        rootElement: '#qunit-fixture'
      });

      app.Router.reopen({
        location: 'none'
      });

      registerRoute(app, 'application', function () {
        ok(true, 'normal route is activated');
      });
    });
  });

  QUnit.test('initialize application via initialize call', function () {
    _emberMetalRun_loop.default(function () {
      app = _emberApplicationSystemApplication.default.create({
        rootElement: '#qunit-fixture'
      });

      app.Router.reopen({
        location: 'none'
      });

      app.ApplicationView = _emberViewsViewsView.default.extend({
        template: _emberTemplateCompilerSystemCompile.default('<h1>Hello!</h1>')
      });
    });

    // This is not a public way to access the container; we just
    // need to make some assertions about the created router
    var router = app.__container__.lookup('router:main');
    equal(router instanceof _emberRoutingSystemRouter.default, true, 'Router was set from initialize call');
    equal(router.location instanceof _emberRoutingLocationNone_location.default, true, 'Location was set from location implementation name');
  });

  QUnit.test('initialize application with stateManager via initialize call from Router class', function () {
    _emberMetalRun_loop.default(function () {
      app = _emberApplicationSystemApplication.default.create({
        rootElement: '#qunit-fixture'
      });

      app.Router.reopen({
        location: 'none'
      });

      app.register('template:application', _emberTemplateCompilerSystemCompile.default('<h1>Hello!</h1>'));
    });

    var router = app.__container__.lookup('router:main');
    equal(router instanceof _emberRoutingSystemRouter.default, true, 'Router was set from initialize call');
    equal(_emberViewsSystemJquery.default('#qunit-fixture h1').text(), 'Hello!');
  });

  QUnit.test('ApplicationView is inserted into the page', function () {
    _emberMetalRun_loop.default(function () {
      app = _emberApplicationSystemApplication.default.create({
        rootElement: '#qunit-fixture'
      });

      app.ApplicationView = _emberViewsViewsView.default.extend({
        template: _emberTemplateCompilerSystemCompile.default('<h1>Hello!</h1>')
      });

      app.ApplicationController = _emberRuntimeControllersController.default.extend();

      app.Router.reopen({
        location: 'none'
      });
    });

    equal(_emberViewsSystemJquery.default('#qunit-fixture h1').text(), 'Hello!');
  });

  QUnit.test('Minimal Application initialized with just an application template', function () {
    _emberViewsSystemJquery.default('#qunit-fixture').html('<script type="text/x-handlebars">Hello World</script>');
    _emberMetalRun_loop.default(function () {
      app = _emberApplicationSystemApplication.default.create({
        rootElement: '#qunit-fixture'
      });
    });

    equal(trim(_emberViewsSystemJquery.default('#qunit-fixture').text()), 'Hello World');
  });

  QUnit.test('enable log of libraries with an ENV var', function () {
    if (EmberDev && EmberDev.runningProdBuild) {
      ok(true, 'Logging does not occur in production builds');
      return;
    }

    var debug = _emberMetalCore.default.debug;
    var messages = [];

    _emberMetalCore.default.LOG_VERSION = true;

    _emberMetalCore.default.debug = function (message) {
      messages.push(message);
    };

    _emberMetalCore.default.libraries.register('my-lib', '2.0.0a');

    _emberMetalRun_loop.default(function () {
      app = _emberApplicationSystemApplication.default.create({
        rootElement: '#qunit-fixture'
      });
    });

    equal(messages[1], 'Ember  : ' + _emberMetalCore.default.VERSION);
    equal(messages[2], 'jQuery : ' + _emberViewsSystemJquery.default().jquery);
    equal(messages[3], 'my-lib : ' + '2.0.0a');

    _emberMetalCore.default.libraries.deRegister('my-lib');
    _emberMetalCore.default.LOG_VERSION = false;
    _emberMetalCore.default.debug = debug;
  });

  QUnit.test('disable log version of libraries with an ENV var', function () {
    var logged = false;

    _emberMetalCore.default.LOG_VERSION = false;

    _emberMetalCore.default.debug = function (message) {
      logged = true;
    };

    _emberViewsSystemJquery.default('#qunit-fixture').empty();

    _emberMetalRun_loop.default(function () {
      app = _emberApplicationSystemApplication.default.create({
        rootElement: '#qunit-fixture'
      });

      app.Router.reopen({
        location: 'none'
      });
    });

    ok(!logged, 'library version logging skipped');
  });

  QUnit.test('can resolve custom router', function () {
    var CustomRouter = _emberRoutingSystemRouter.default.extend();

    var CustomResolver = _emberApplicationSystemResolver.default.extend({
      resolveMain: function (parsedName) {
        if (parsedName.type === 'router') {
          return CustomRouter;
        } else {
          return this._super(parsedName);
        }
      }
    });

    app = _emberMetalRun_loop.default(function () {
      return _emberApplicationSystemApplication.default.create({
        Resolver: CustomResolver
      });
    });

    ok(app.__container__.lookup('router:main') instanceof CustomRouter, 'application resolved the correct router');
  });

  QUnit.test('can specify custom router', function () {
    var CustomRouter = _emberRoutingSystemRouter.default.extend();

    app = _emberMetalRun_loop.default(function () {
      return _emberApplicationSystemApplication.default.create({
        Router: CustomRouter
      });
    });

    ok(app.__container__.lookup('router:main') instanceof CustomRouter, 'application resolved the correct router');
  });

  QUnit.test('registers controls onto to container', function () {
    _emberMetalRun_loop.default(function () {
      app = _emberApplicationSystemApplication.default.create({
        rootElement: '#qunit-fixture'
      });
    });

    ok(app.__container__.lookup('view:select'), 'Select control is registered into views');
  });

  QUnit.test('does not leak itself in onLoad._loaded', function () {
    equal(_emberRuntimeSystemLazy_load._loaded.application, undefined);
    var app = _emberMetalRun_loop.default(_emberApplicationSystemApplication.default, 'create');
    equal(_emberRuntimeSystemLazy_load._loaded.application, app);
    _emberMetalRun_loop.default(app, 'destroy');
    equal(_emberRuntimeSystemLazy_load._loaded.application, undefined);
  });
});
enifed('ember-application/tests/system/application_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-application/tests/system');
  test('ember-application/tests/system/application_test.js should pass jscs', function () {
    ok(true, 'ember-application/tests/system/application_test.js should pass jscs.');
  });
});
enifed('ember-application/tests/system/application_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-application/tests/system');
  QUnit.test('ember-application/tests/system/application_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-application/tests/system/application_test.js should pass jshint.');
  });
});
enifed('ember-application/tests/system/dependency_injection/custom_resolver_test', ['exports', 'ember-views/system/jquery', 'ember-metal/run_loop', 'ember-application/system/application', 'ember-application/system/resolver', 'ember-template-compiler/system/compile'], function (exports, _emberViewsSystemJquery, _emberMetalRun_loop, _emberApplicationSystemApplication, _emberApplicationSystemResolver, _emberTemplateCompilerSystemCompile) {
  'use strict';

  var application;

  QUnit.module('Ember.Application Dependency Injection – customResolver', {
    setup: function () {
      var fallbackTemplate = _emberTemplateCompilerSystemCompile.default('<h1>Fallback</h1>');

      var Resolver = _emberApplicationSystemResolver.default.extend({
        resolveTemplate: function (resolvable) {
          var resolvedTemplate = this._super(resolvable);
          if (resolvedTemplate) {
            return resolvedTemplate;
          }
          if (resolvable.fullNameWithoutType === 'application') {
            return fallbackTemplate;
          } else {
            return;
          }
        }
      });

      application = _emberMetalRun_loop.default(function () {
        return _emberApplicationSystemApplication.default.create({
          Resolver: Resolver,
          rootElement: '#qunit-fixture'

        });
      });
    },
    teardown: function () {
      _emberMetalRun_loop.default(application, 'destroy');
    }
  });

  QUnit.test('a resolver can be supplied to application', function () {
    equal(_emberViewsSystemJquery.default('h1', application.rootElement).text(), 'Fallback');
  });
});
enifed('ember-application/tests/system/dependency_injection/custom_resolver_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-application/tests/system/dependency_injection');
  test('ember-application/tests/system/dependency_injection/custom_resolver_test.js should pass jscs', function () {
    ok(true, 'ember-application/tests/system/dependency_injection/custom_resolver_test.js should pass jscs.');
  });
});
enifed('ember-application/tests/system/dependency_injection/custom_resolver_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-application/tests/system/dependency_injection');
  QUnit.test('ember-application/tests/system/dependency_injection/custom_resolver_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-application/tests/system/dependency_injection/custom_resolver_test.js should pass jshint.');
  });
});
enifed('ember-application/tests/system/dependency_injection/default_resolver_test', ['exports', 'ember-metal/core', 'ember-metal/run_loop', 'ember-metal/logger', 'ember-runtime/controllers/controller', 'ember-routing/system/route', 'ember-views/views/component', 'ember-views/views/view', 'ember-runtime/system/service', 'ember-runtime/system/object', 'ember-runtime/system/namespace', 'ember-application/system/application', 'ember-htmlbars/helper', 'ember-htmlbars/system/make_bound_helper', 'ember-htmlbars/helpers'], function (exports, _emberMetalCore, _emberMetalRun_loop, _emberMetalLogger, _emberRuntimeControllersController, _emberRoutingSystemRoute, _emberViewsViewsComponent, _emberViewsViewsView, _emberRuntimeSystemService, _emberRuntimeSystemObject, _emberRuntimeSystemNamespace, _emberApplicationSystemApplication, _emberHtmlbarsHelper, _emberHtmlbarsSystemMake_bound_helper, _emberHtmlbarsHelpers) {
  'use strict';

  var registry, locator, application, originalLookup, originalLoggerInfo;

  QUnit.module('Ember.Application Dependency Injection - default resolver', {
    setup: function () {
      originalLookup = _emberMetalCore.default.lookup;
      application = _emberMetalRun_loop.default(_emberApplicationSystemApplication.default, 'create');

      registry = application.registry;
      locator = application.__container__;
      originalLoggerInfo = _emberMetalLogger.default.info;
    },

    teardown: function () {
      _emberMetalCore.default.TEMPLATES = {};
      _emberMetalCore.default.lookup = originalLookup;
      _emberMetalRun_loop.default(application, 'destroy');
      var UserInterfaceNamespace = _emberRuntimeSystemNamespace.default.NAMESPACES_BY_ID['UserInterface'];
      if (UserInterfaceNamespace) {
        _emberMetalRun_loop.default(UserInterfaceNamespace, 'destroy');
      }

      _emberMetalLogger.default.info = originalLoggerInfo;
    }
  });

  QUnit.test('the default resolver can look things up in other namespaces', function () {
    var UserInterface = _emberMetalCore.default.lookup.UserInterface = _emberRuntimeSystemNamespace.default.create();
    UserInterface.NavigationController = _emberRuntimeControllersController.default.extend();

    var nav = locator.lookup('controller:userInterface/navigation');

    ok(nav instanceof UserInterface.NavigationController, 'the result should be an instance of the specified class');
  });

  QUnit.test('the default resolver looks up templates in Ember.TEMPLATES', function () {
    function fooTemplate() {}
    function fooBarTemplate() {}
    function fooBarBazTemplate() {}

    _emberMetalCore.default.TEMPLATES['foo'] = fooTemplate;
    _emberMetalCore.default.TEMPLATES['fooBar'] = fooBarTemplate;
    _emberMetalCore.default.TEMPLATES['fooBar/baz'] = fooBarBazTemplate;

    equal(locator.lookup('template:foo'), fooTemplate, 'resolves template:foo');
    equal(locator.lookup('template:fooBar'), fooBarTemplate, 'resolves template:foo_bar');
    equal(locator.lookup('template:fooBar.baz'), fooBarBazTemplate, 'resolves template:foo_bar.baz');
  });

  QUnit.test('the default resolver looks up basic name as no prefix', function () {
    ok(_emberRuntimeControllersController.default.detect(locator.lookup('controller:basic')), 'locator looksup correct controller');
  });

  function detectEqual(first, second, message) {
    ok(first.detect(second), message);
  }

  QUnit.test('the default resolver looks up arbitrary types on the namespace', function () {
    application.FooManager = _emberRuntimeSystemObject.default.extend({});

    detectEqual(application.FooManager, registry.resolver('manager:foo'), 'looks up FooManager on application');
  });

  QUnit.test('the default resolver resolves models on the namespace', function () {
    application.Post = _emberRuntimeSystemObject.default.extend({});

    detectEqual(application.Post, locator.lookupFactory('model:post'), 'looks up Post model on application');
  });

  QUnit.test('the default resolver resolves *:main on the namespace', function () {
    application.FooBar = _emberRuntimeSystemObject.default.extend({});

    detectEqual(application.FooBar, locator.lookupFactory('foo-bar:main'), 'looks up FooBar type without name on application');
  });

  QUnit.test('the default resolver resolves helpers', function () {
    expect(2);

    function fooresolvertestHelper() {
      ok(true, 'found fooresolvertestHelper');
    }
    function barBazResolverTestHelper() {
      ok(true, 'found barBazResolverTestHelper');
    }
    _emberHtmlbarsHelpers.registerHelper('fooresolvertest', fooresolvertestHelper);
    _emberHtmlbarsHelpers.registerHelper('bar-baz-resolver-test', barBazResolverTestHelper);

    fooresolvertestHelper();
    barBazResolverTestHelper();
  });

  QUnit.test('the default resolver resolves container-registered helpers', function () {
    var shorthandHelper = _emberHtmlbarsHelper.helper(function () {});
    var helper = _emberHtmlbarsHelper.default.extend();

    application.register('helper:shorthand', shorthandHelper);
    application.register('helper:complete', helper);

    var lookedUpShorthandHelper = locator.lookupFactory('helper:shorthand');
    ok(lookedUpShorthandHelper.isHelperInstance, 'shorthand helper isHelper');

    var lookedUpHelper = locator.lookupFactory('helper:complete');
    ok(lookedUpHelper.isHelperFactory, 'complete helper is factory');
    ok(helper.detect(lookedUpHelper), 'looked up complete helper');
  });

  QUnit.test('the default resolver resolves helpers on the namespace', function () {
    var ShorthandHelper = _emberHtmlbarsHelper.helper(function () {});
    var CompleteHelper = _emberHtmlbarsHelper.default.extend();
    var LegacyHTMLBarsBoundHelper = undefined;

    expectDeprecation(function () {
      LegacyHTMLBarsBoundHelper = _emberHtmlbarsSystemMake_bound_helper.default(function () {});
    }, 'Using `Ember.HTMLBars.makeBoundHelper` is deprecated. Please refactor to using `Ember.Helper` or `Ember.Helper.helper`.');

    application.ShorthandHelper = ShorthandHelper;
    application.CompleteHelper = CompleteHelper;
    application.LegacyHtmlBarsBoundHelper = LegacyHTMLBarsBoundHelper; // Must use lowered "tml" in "HTMLBars" for resolver to find this

    var resolvedShorthand = registry.resolve('helper:shorthand');
    var resolvedComplete = registry.resolve('helper:complete');
    var resolvedLegacyHTMLBars = registry.resolve('helper:legacy-html-bars-bound');

    equal(resolvedShorthand, ShorthandHelper, 'resolve fetches the shorthand helper factory');
    equal(resolvedComplete, CompleteHelper, 'resolve fetches the complete helper factory');
    equal(resolvedLegacyHTMLBars, LegacyHTMLBarsBoundHelper, 'resolves legacy HTMLBars bound helper');
  });

  QUnit.test('the default resolver resolves to the same instance no matter the notation ', function () {
    application.NestedPostController = _emberRuntimeControllersController.default.extend({});

    equal(locator.lookup('controller:nested-post'), locator.lookup('controller:nested_post'), 'looks up NestedPost controller on application');
  });

  QUnit.test('the default resolver throws an error if the fullName to resolve is invalid', function () {
    throws(function () {
      registry.resolve(undefined);
    }, TypeError, /Invalid fullName/);
    throws(function () {
      registry.resolve(null);
    }, TypeError, /Invalid fullName/);
    throws(function () {
      registry.resolve('');
    }, TypeError, /Invalid fullName/);
    throws(function () {
      registry.resolve('');
    }, TypeError, /Invalid fullName/);
    throws(function () {
      registry.resolve(':');
    }, TypeError, /Invalid fullName/);
    throws(function () {
      registry.resolve('model');
    }, TypeError, /Invalid fullName/);
    throws(function () {
      registry.resolve('model:');
    }, TypeError, /Invalid fullName/);
    throws(function () {
      registry.resolve(':type');
    }, TypeError, /Invalid fullName/);
  });

  QUnit.test('the default resolver logs hits if `LOG_RESOLVER` is set', function () {
    expect(3);

    application.LOG_RESOLVER = true;
    application.ScoobyDoo = _emberRuntimeSystemObject.default.extend();
    application.toString = function () {
      return 'App';
    };

    _emberMetalLogger.default.info = function (symbol, name, padding, lookupDescription) {
      equal(symbol, '[✓]', 'proper symbol is printed when a module is found');
      equal(name, 'doo:scooby', 'proper lookup value is logged');
      equal(lookupDescription, 'App.ScoobyDoo');
    };

    registry.resolve('doo:scooby');
  });

  QUnit.test('the default resolver logs misses if `LOG_RESOLVER` is set', function () {
    expect(3);

    application.LOG_RESOLVER = true;
    application.toString = function () {
      return 'App';
    };

    _emberMetalLogger.default.info = function (symbol, name, padding, lookupDescription) {
      equal(symbol, '[ ]', 'proper symbol is printed when a module is not found');
      equal(name, 'doo:scooby', 'proper lookup value is logged');
      equal(lookupDescription, 'App.ScoobyDoo');
    };

    registry.resolve('doo:scooby');
  });

  QUnit.test('doesn\'t log without LOG_RESOLVER', function () {
    var infoCount = 0;

    application.ScoobyDoo = _emberRuntimeSystemObject.default.extend();

    _emberMetalLogger.default.info = function (symbol, name) {
      infoCount = infoCount + 1;
    };

    registry.resolve('doo:scooby');
    registry.resolve('doo:scrappy');
    equal(infoCount, 0, 'Logger.info should not be called if LOG_RESOLVER is not set');
  });

  QUnit.test('lookup description', function () {
    application.toString = function () {
      return 'App';
    };

    equal(registry.describe('controller:foo'), 'App.FooController', 'Type gets appended at the end');
    equal(registry.describe('controller:foo.bar'), 'App.FooBarController', 'dots are removed');
    equal(registry.describe('model:foo'), 'App.Foo', 'models don\'t get appended at the end');
  });

  QUnit.test('assertion for routes without isRouteFactory property', function () {
    application.FooRoute = _emberViewsViewsComponent.default.extend();

    expectAssertion(function () {
      registry.resolve('route:foo');
    }, /to resolve to an Ember.Route/, 'Should assert');
  });

  QUnit.test('no assertion for routes that extend from Ember.Route', function () {
    expect(0);
    application.FooRoute = _emberRoutingSystemRoute.default.extend();
    registry.resolve('route:foo');
  });

  QUnit.test('deprecation warning for service factories without isServiceFactory property', function () {
    expectDeprecation(/service factories must have an `isServiceFactory` property/);
    application.FooService = _emberRuntimeSystemObject.default.extend();
    registry.resolve('service:foo');
  });

  QUnit.test('no deprecation warning for service factories that extend from Ember.Service', function () {
    expectNoDeprecation();
    application.FooService = _emberRuntimeSystemService.default.extend();
    registry.resolve('service:foo');
  });

  QUnit.test('deprecation warning for view factories without isViewFactory property', function () {
    expectDeprecation(/view factories must have an `isViewFactory` property/);
    application.FooView = _emberRuntimeSystemObject.default.extend();
    registry.resolve('view:foo');
  });

  QUnit.test('no deprecation warning for view factories that extend from Ember.View', function () {
    expectNoDeprecation();
    application.FooView = _emberViewsViewsView.default.extend();
    registry.resolve('view:foo');
  });

  QUnit.test('deprecation warning for component factories without isComponentFactory property', function () {
    expectDeprecation(/component factories must have an `isComponentFactory` property/);
    application.FooComponent = _emberViewsViewsView.default.extend();
    registry.resolve('component:foo');
  });

  QUnit.test('no deprecation warning for component factories that extend from Ember.Component', function () {
    expectNoDeprecation();
    application.FooView = _emberViewsViewsComponent.default.extend();
    registry.resolve('component:foo');
  });

  QUnit.test('knownForType returns each item for a given type found', function () {
    application.FooBarHelper = 'foo';
    application.BazQuxHelper = 'bar';

    var found = registry.resolver.knownForType('helper');

    deepEqual(found, {
      'helper:foo-bar': true,
      'helper:baz-qux': true
    });
  });

  QUnit.test('knownForType is not required to be present on the resolver', function () {
    delete registry.resolver.__resolver__.knownForType;

    registry.resolver.knownForType('helper', function () {});

    ok(true, 'does not error');
  });
});
// Ember.TEMPLATES
enifed('ember-application/tests/system/dependency_injection/default_resolver_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-application/tests/system/dependency_injection');
  test('ember-application/tests/system/dependency_injection/default_resolver_test.js should pass jscs', function () {
    ok(true, 'ember-application/tests/system/dependency_injection/default_resolver_test.js should pass jscs.');
  });
});
enifed('ember-application/tests/system/dependency_injection/default_resolver_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-application/tests/system/dependency_injection');
  QUnit.test('ember-application/tests/system/dependency_injection/default_resolver_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-application/tests/system/dependency_injection/default_resolver_test.js should pass jshint.');
  });
});
enifed('ember-application/tests/system/dependency_injection/normalization_test', ['exports', 'ember-metal/run_loop', 'ember-application/system/application'], function (exports, _emberMetalRun_loop, _emberApplicationSystemApplication) {
  'use strict';

  var application, registry;

  QUnit.module('Ember.Application Dependency Injection – normalization', {
    setup: function () {
      application = _emberMetalRun_loop.default(_emberApplicationSystemApplication.default, 'create');
      registry = application.registry;
    },

    teardown: function () {
      _emberMetalRun_loop.default(application, 'destroy');
    }
  });

  QUnit.test('normalization', function () {
    ok(registry.normalize, 'registry#normalize is present');

    equal(registry.normalize('foo:bar'), 'foo:bar');

    equal(registry.normalize('controller:posts'), 'controller:posts');
    equal(registry.normalize('controller:posts_index'), 'controller:postsIndex');
    equal(registry.normalize('controller:posts.index'), 'controller:postsIndex');
    equal(registry.normalize('controller:posts-index'), 'controller:postsIndex');
    equal(registry.normalize('controller:posts.post.index'), 'controller:postsPostIndex');
    equal(registry.normalize('controller:posts_post.index'), 'controller:postsPostIndex');
    equal(registry.normalize('controller:posts.post_index'), 'controller:postsPostIndex');
    equal(registry.normalize('controller:posts.post-index'), 'controller:postsPostIndex');
    equal(registry.normalize('controller:postsIndex'), 'controller:postsIndex');
    equal(registry.normalize('controller:blogPosts.index'), 'controller:blogPostsIndex');
    equal(registry.normalize('controller:blog/posts.index'), 'controller:blog/postsIndex');
    equal(registry.normalize('controller:blog/posts-index'), 'controller:blog/postsIndex');
    equal(registry.normalize('controller:blog/posts.post.index'), 'controller:blog/postsPostIndex');
    equal(registry.normalize('controller:blog/posts_post.index'), 'controller:blog/postsPostIndex');
    equal(registry.normalize('controller:blog/posts_post-index'), 'controller:blog/postsPostIndex');

    equal(registry.normalize('template:blog/posts_index'), 'template:blog/posts_index');
  });

  QUnit.test('normalization is indempotent', function () {
    var examples = ['controller:posts', 'controller:posts.post.index', 'controller:blog/posts.post_index', 'template:foo_bar'];

    examples.forEach(function (example) {
      equal(registry.normalize(registry.normalize(example)), registry.normalize(example));
    });
  });
});
enifed('ember-application/tests/system/dependency_injection/normalization_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-application/tests/system/dependency_injection');
  test('ember-application/tests/system/dependency_injection/normalization_test.js should pass jscs', function () {
    ok(true, 'ember-application/tests/system/dependency_injection/normalization_test.js should pass jscs.');
  });
});
enifed('ember-application/tests/system/dependency_injection/normalization_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-application/tests/system/dependency_injection');
  QUnit.test('ember-application/tests/system/dependency_injection/normalization_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-application/tests/system/dependency_injection/normalization_test.js should pass jshint.');
  });
});
enifed('ember-application/tests/system/dependency_injection/to_string_test', ['exports', 'ember-metal/core', 'ember-metal/run_loop', 'ember-application/system/application', 'ember-runtime/system/object', 'ember-application/system/resolver', 'ember-metal/utils'], function (exports, _emberMetalCore, _emberMetalRun_loop, _emberApplicationSystemApplication, _emberRuntimeSystemObject, _emberApplicationSystemResolver, _emberMetalUtils) {
  'use strict';

  var originalLookup, App, originalModelInjections;

  QUnit.module('Ember.Application Dependency Injection – toString', {
    setup: function () {
      originalModelInjections = _emberMetalCore.default.MODEL_FACTORY_INJECTIONS;
      _emberMetalCore.default.MODEL_FACTORY_INJECTIONS = true;

      originalLookup = _emberMetalCore.default.lookup;

      _emberMetalRun_loop.default(function () {
        App = _emberApplicationSystemApplication.default.create();
        _emberMetalCore.default.lookup = {
          App: App
        };
      });

      App.Post = _emberRuntimeSystemObject.default.extend();
    },

    teardown: function () {
      _emberMetalCore.default.lookup = originalLookup;
      _emberMetalRun_loop.default(App, 'destroy');
      _emberMetalCore.default.MODEL_FACTORY_INJECTIONS = originalModelInjections;
    }
  });

  QUnit.test('factories', function () {
    var PostFactory = App.__container__.lookupFactory('model:post');
    equal(PostFactory.toString(), 'App.Post', 'expecting the model to be post');
  });

  QUnit.test('instances', function () {
    var post = App.__container__.lookup('model:post');
    var guid = _emberMetalUtils.guidFor(post);

    equal(post.toString(), '<App.Post:' + guid + '>', 'expecting the model to be post');
  });

  QUnit.test('with a custom resolver', function () {
    _emberMetalRun_loop.default(App, 'destroy');

    _emberMetalRun_loop.default(function () {
      App = _emberApplicationSystemApplication.default.create({
        Resolver: _emberApplicationSystemResolver.default.extend({
          makeToString: function (factory, fullName) {
            return fullName;
          }
        })
      });
    });

    App.registry.register('model:peter', _emberRuntimeSystemObject.default.extend());

    var peter = App.__container__.lookup('model:peter');
    var guid = _emberMetalUtils.guidFor(peter);

    equal(peter.toString(), '<model:peter:' + guid + '>', 'expecting the supermodel to be peter');
  });
});
// lookup, etc
enifed('ember-application/tests/system/dependency_injection/to_string_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-application/tests/system/dependency_injection');
  test('ember-application/tests/system/dependency_injection/to_string_test.js should pass jscs', function () {
    ok(true, 'ember-application/tests/system/dependency_injection/to_string_test.js should pass jscs.');
  });
});
enifed('ember-application/tests/system/dependency_injection/to_string_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-application/tests/system/dependency_injection');
  QUnit.test('ember-application/tests/system/dependency_injection/to_string_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-application/tests/system/dependency_injection/to_string_test.js should pass jshint.');
  });
});
enifed('ember-application/tests/system/dependency_injection_test', ['exports', 'ember-metal/core', 'ember-metal/run_loop', 'ember-runtime/system/object', 'ember-application/system/application'], function (exports, _emberMetalCore, _emberMetalRun_loop, _emberRuntimeSystemObject, _emberApplicationSystemApplication) {
  'use strict';

  var EmberApplication = _emberApplicationSystemApplication.default;

  var originalLookup = _emberMetalCore.default.lookup;
  var registry, locator, lookup, application, originalModelInjections;

  QUnit.module('Ember.Application Dependency Injection', {
    setup: function () {
      originalModelInjections = _emberMetalCore.default.MODEL_FACTORY_INJECTIONS;
      _emberMetalCore.default.MODEL_FACTORY_INJECTIONS = true;

      application = _emberMetalRun_loop.default(EmberApplication, 'create');

      application.Person = _emberRuntimeSystemObject.default.extend({});
      application.Orange = _emberRuntimeSystemObject.default.extend({});
      application.Email = _emberRuntimeSystemObject.default.extend({});
      application.User = _emberRuntimeSystemObject.default.extend({});
      application.PostIndexController = _emberRuntimeSystemObject.default.extend({});

      application.register('model:person', application.Person, { singleton: false });
      application.register('model:user', application.User, { singleton: false });
      application.register('fruit:favorite', application.Orange);
      application.register('communication:main', application.Email, { singleton: false });
      application.register('controller:postIndex', application.PostIndexController, { singleton: true });

      registry = application.registry;
      locator = application.__container__;

      lookup = _emberMetalCore.default.lookup = {};
    },
    teardown: function () {
      _emberMetalRun_loop.default(application, 'destroy');
      application = locator = null;
      _emberMetalCore.default.lookup = originalLookup;
      _emberMetalCore.default.MODEL_FACTORY_INJECTIONS = originalModelInjections;
    }
  });

  QUnit.test('container lookup is normalized', function () {
    var dotNotationController = locator.lookup('controller:post.index');
    var camelCaseController = locator.lookup('controller:postIndex');

    ok(dotNotationController instanceof application.PostIndexController);
    ok(camelCaseController instanceof application.PostIndexController);

    equal(dotNotationController, camelCaseController);
  });

  QUnit.test('registered entities can be looked up later', function () {
    equal(registry.resolve('model:person'), application.Person);
    equal(registry.resolve('model:user'), application.User);
    equal(registry.resolve('fruit:favorite'), application.Orange);
    equal(registry.resolve('communication:main'), application.Email);
    equal(registry.resolve('controller:postIndex'), application.PostIndexController);

    equal(locator.lookup('fruit:favorite'), locator.lookup('fruit:favorite'), 'singleton lookup worked');
    ok(locator.lookup('model:user') !== locator.lookup('model:user'), 'non-singleton lookup worked');
  });

  QUnit.test('injections', function () {
    application.inject('model', 'fruit', 'fruit:favorite');
    application.inject('model:user', 'communication', 'communication:main');

    var user = locator.lookup('model:user');
    var person = locator.lookup('model:person');
    var fruit = locator.lookup('fruit:favorite');

    equal(user.get('fruit'), fruit);
    equal(person.get('fruit'), fruit);

    ok(application.Email.detectInstance(user.get('communication')));
  });
});
enifed('ember-application/tests/system/dependency_injection_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-application/tests/system');
  test('ember-application/tests/system/dependency_injection_test.js should pass jscs', function () {
    ok(true, 'ember-application/tests/system/dependency_injection_test.js should pass jscs.');
  });
});
enifed('ember-application/tests/system/dependency_injection_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-application/tests/system');
  QUnit.test('ember-application/tests/system/dependency_injection_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-application/tests/system/dependency_injection_test.js should pass jshint.');
  });
});
enifed('ember-application/tests/system/initializers_test', ['exports', 'ember-metal/core', 'ember-metal/run_loop', 'ember-application/system/application', 'ember-views/system/jquery', 'container/registry'], function (exports, _emberMetalCore, _emberMetalRun_loop, _emberApplicationSystemApplication, _emberViewsSystemJquery, _containerRegistry) {
  'use strict';

  var app;

  QUnit.module('Ember.Application initializers', {
    setup: function () {},

    teardown: function () {
      if (app) {
        _emberMetalRun_loop.default(function () {
          app.destroy();
        });
      }
    }
  });

  QUnit.test('initializers require proper \'name\' and \'initialize\' properties', function () {
    var MyApplication = _emberApplicationSystemApplication.default.extend();

    expectAssertion(function () {
      _emberMetalRun_loop.default(function () {
        MyApplication.initializer({ name: 'initializer' });
      });
    });

    expectAssertion(function () {
      _emberMetalRun_loop.default(function () {
        MyApplication.initializer({ initialize: _emberMetalCore.default.K });
      });
    });
  });

  QUnit.test('initializers are passed a registry and App', function () {
    var MyApplication = _emberApplicationSystemApplication.default.extend();

    MyApplication.initializer({
      name: 'initializer',
      initialize: function (registry, App) {
        ok(registry instanceof _containerRegistry.default, 'initialize is passed a registry');
        ok(App instanceof _emberApplicationSystemApplication.default, 'initialize is passed an Application');
      }
    });

    _emberMetalRun_loop.default(function () {
      app = MyApplication.create({
        router: false,
        rootElement: '#qunit-fixture'
      });
    });
  });

  QUnit.test('initializers can be registered in a specified order', function () {
    var order = [];
    var MyApplication = _emberApplicationSystemApplication.default.extend();
    MyApplication.initializer({
      name: 'fourth',
      after: 'third',
      initialize: function (registry) {
        order.push('fourth');
      }
    });

    MyApplication.initializer({
      name: 'second',
      after: 'first',
      before: 'third',
      initialize: function (registry) {
        order.push('second');
      }
    });

    MyApplication.initializer({
      name: 'fifth',
      after: 'fourth',
      before: 'sixth',
      initialize: function (registry) {
        order.push('fifth');
      }
    });

    MyApplication.initializer({
      name: 'first',
      before: 'second',
      initialize: function (registry) {
        order.push('first');
      }
    });

    MyApplication.initializer({
      name: 'third',
      initialize: function (registry) {
        order.push('third');
      }
    });

    MyApplication.initializer({
      name: 'sixth',
      initialize: function (registry) {
        order.push('sixth');
      }
    });

    _emberMetalRun_loop.default(function () {
      app = MyApplication.create({
        router: false,
        rootElement: '#qunit-fixture'
      });
    });

    deepEqual(order, ['first', 'second', 'third', 'fourth', 'fifth', 'sixth']);
  });

  QUnit.test('initializers can be registered in a specified order as an array', function () {
    var order = [];
    var MyApplication = _emberApplicationSystemApplication.default.extend();

    MyApplication.initializer({
      name: 'third',
      initialize: function (registry) {
        order.push('third');
      }
    });

    MyApplication.initializer({
      name: 'second',
      after: 'first',
      before: ['third', 'fourth'],
      initialize: function (registry) {
        order.push('second');
      }
    });

    MyApplication.initializer({
      name: 'fourth',
      after: ['second', 'third'],
      initialize: function (registry) {
        order.push('fourth');
      }
    });

    MyApplication.initializer({
      name: 'fifth',
      after: 'fourth',
      before: 'sixth',
      initialize: function (registry) {
        order.push('fifth');
      }
    });

    MyApplication.initializer({
      name: 'first',
      before: ['second'],
      initialize: function (registry) {
        order.push('first');
      }
    });

    MyApplication.initializer({
      name: 'sixth',
      initialize: function (registry) {
        order.push('sixth');
      }
    });

    _emberMetalRun_loop.default(function () {
      app = MyApplication.create({
        router: false,
        rootElement: '#qunit-fixture'
      });
    });

    deepEqual(order, ['first', 'second', 'third', 'fourth', 'fifth', 'sixth']);
  });

  QUnit.test('initializers can have multiple dependencies', function () {
    var order = [];
    var a = {
      name: 'a',
      before: 'b',
      initialize: function (registry) {
        order.push('a');
      }
    };
    var b = {
      name: 'b',
      initialize: function (registry) {
        order.push('b');
      }
    };
    var c = {
      name: 'c',
      after: 'b',
      initialize: function (registry) {
        order.push('c');
      }
    };
    var afterB = {
      name: 'after b',
      after: 'b',
      initialize: function (registry) {
        order.push('after b');
      }
    };
    var afterC = {
      name: 'after c',
      after: 'c',
      initialize: function (registry) {
        order.push('after c');
      }
    };

    _emberApplicationSystemApplication.default.initializer(b);
    _emberApplicationSystemApplication.default.initializer(a);
    _emberApplicationSystemApplication.default.initializer(afterC);
    _emberApplicationSystemApplication.default.initializer(afterB);
    _emberApplicationSystemApplication.default.initializer(c);

    _emberMetalRun_loop.default(function () {
      app = _emberApplicationSystemApplication.default.create({
        router: false,
        rootElement: '#qunit-fixture'
      });
    });

    ok(order.indexOf(a.name) < order.indexOf(b.name), 'a < b');
    ok(order.indexOf(b.name) < order.indexOf(c.name), 'b < c');
    ok(order.indexOf(b.name) < order.indexOf(afterB.name), 'b < afterB');
    ok(order.indexOf(c.name) < order.indexOf(afterC.name), 'c < afterC');
  });

  QUnit.test('initializers set on Application subclasses should not be shared between apps', function () {
    var firstInitializerRunCount = 0;
    var secondInitializerRunCount = 0;
    var FirstApp = _emberApplicationSystemApplication.default.extend();
    var firstApp, secondApp;
    FirstApp.initializer({
      name: 'first',
      initialize: function (registry) {
        firstInitializerRunCount++;
      }
    });
    var SecondApp = _emberApplicationSystemApplication.default.extend();
    SecondApp.initializer({
      name: 'second',
      initialize: function (registry) {
        secondInitializerRunCount++;
      }
    });
    _emberViewsSystemJquery.default('#qunit-fixture').html('<div id="first"></div><div id="second"></div>');
    _emberMetalRun_loop.default(function () {
      firstApp = FirstApp.create({
        router: false,
        rootElement: '#qunit-fixture #first'
      });
    });
    equal(firstInitializerRunCount, 1, 'first initializer only was run');
    equal(secondInitializerRunCount, 0, 'first initializer only was run');
    _emberMetalRun_loop.default(function () {
      secondApp = SecondApp.create({
        router: false,
        rootElement: '#qunit-fixture #second'
      });
    });
    equal(firstInitializerRunCount, 1, 'second initializer only was run');
    equal(secondInitializerRunCount, 1, 'second initializer only was run');
    _emberMetalRun_loop.default(function () {
      firstApp.destroy();
      secondApp.destroy();
    });
  });

  QUnit.test('initializers are concatenated', function () {
    var firstInitializerRunCount = 0;
    var secondInitializerRunCount = 0;
    var FirstApp = _emberApplicationSystemApplication.default.extend();
    var firstApp, secondApp;
    FirstApp.initializer({
      name: 'first',
      initialize: function (registry) {
        firstInitializerRunCount++;
      }
    });

    var SecondApp = FirstApp.extend();
    SecondApp.initializer({
      name: 'second',
      initialize: function (registry) {
        secondInitializerRunCount++;
      }
    });

    _emberViewsSystemJquery.default('#qunit-fixture').html('<div id="first"></div><div id="second"></div>');
    _emberMetalRun_loop.default(function () {
      firstApp = FirstApp.create({
        router: false,
        rootElement: '#qunit-fixture #first'
      });
    });
    equal(firstInitializerRunCount, 1, 'first initializer only was run when base class created');
    equal(secondInitializerRunCount, 0, 'first initializer only was run when base class created');
    firstInitializerRunCount = 0;
    _emberMetalRun_loop.default(function () {
      secondApp = SecondApp.create({
        router: false,
        rootElement: '#qunit-fixture #second'
      });
    });
    equal(firstInitializerRunCount, 1, 'first initializer was run when subclass created');
    equal(secondInitializerRunCount, 1, 'second initializers was run when subclass created');
    _emberMetalRun_loop.default(function () {
      firstApp.destroy();
      secondApp.destroy();
    });
  });

  QUnit.test('initializers are per-app', function () {
    expect(0);
    var FirstApp = _emberApplicationSystemApplication.default.extend();
    FirstApp.initializer({
      name: 'shouldNotCollide',
      initialize: function (registry) {}
    });

    var SecondApp = _emberApplicationSystemApplication.default.extend();
    SecondApp.initializer({
      name: 'shouldNotCollide',
      initialize: function (registry) {}
    });
  });

  QUnit.test('initializers should be executed in their own context', function () {
    expect(1);
    var MyApplication = _emberApplicationSystemApplication.default.extend();

    MyApplication.initializer({
      name: 'coolInitializer',
      myProperty: 'cool',
      initialize: function (registry, application) {
        equal(this.myProperty, 'cool', 'should have access to its own context');
      }
    });

    _emberMetalRun_loop.default(function () {
      app = MyApplication.create({
        router: false,
        rootElement: '#qunit-fixture'
      });
    });
  });
});
enifed('ember-application/tests/system/initializers_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-application/tests/system');
  test('ember-application/tests/system/initializers_test.js should pass jscs', function () {
    ok(true, 'ember-application/tests/system/initializers_test.js should pass jscs.');
  });
});
enifed('ember-application/tests/system/initializers_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-application/tests/system');
  QUnit.test('ember-application/tests/system/initializers_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-application/tests/system/initializers_test.js should pass jshint.');
  });
});
enifed('ember-application/tests/system/instance_initializers_test', ['exports', 'ember-metal/core', 'ember-metal/run_loop', 'ember-application/system/application', 'ember-application/system/application-instance', 'ember-views/system/jquery'], function (exports, _emberMetalCore, _emberMetalRun_loop, _emberApplicationSystemApplication, _emberApplicationSystemApplicationInstance, _emberViewsSystemJquery) {
  'use strict';

  var app;

  QUnit.module('Ember.Application instance initializers', {
    setup: function () {},

    teardown: function () {
      if (app) {
        _emberMetalRun_loop.default(function () {
          app.destroy();
        });
      }
    }
  });

  QUnit.test('initializers require proper \'name\' and \'initialize\' properties', function () {
    var MyApplication = _emberApplicationSystemApplication.default.extend();

    expectAssertion(function () {
      _emberMetalRun_loop.default(function () {
        MyApplication.instanceInitializer({ name: 'initializer' });
      });
    });

    expectAssertion(function () {
      _emberMetalRun_loop.default(function () {
        MyApplication.instanceInitializer({ initialize: _emberMetalCore.default.K });
      });
    });
  });

  QUnit.test('initializers are passed an app instance', function () {
    var MyApplication = _emberApplicationSystemApplication.default.extend();

    MyApplication.instanceInitializer({
      name: 'initializer',
      initialize: function (instance) {
        ok(instance instanceof _emberApplicationSystemApplicationInstance.default, 'initialize is passed an application instance');
      }
    });

    _emberMetalRun_loop.default(function () {
      app = MyApplication.create({
        router: false,
        rootElement: '#qunit-fixture'
      });
    });
  });

  QUnit.test('initializers can be registered in a specified order', function () {
    var order = [];
    var MyApplication = _emberApplicationSystemApplication.default.extend();
    MyApplication.instanceInitializer({
      name: 'fourth',
      after: 'third',
      initialize: function (registry) {
        order.push('fourth');
      }
    });

    MyApplication.instanceInitializer({
      name: 'second',
      after: 'first',
      before: 'third',
      initialize: function (registry) {
        order.push('second');
      }
    });

    MyApplication.instanceInitializer({
      name: 'fifth',
      after: 'fourth',
      before: 'sixth',
      initialize: function (registry) {
        order.push('fifth');
      }
    });

    MyApplication.instanceInitializer({
      name: 'first',
      before: 'second',
      initialize: function (registry) {
        order.push('first');
      }
    });

    MyApplication.instanceInitializer({
      name: 'third',
      initialize: function (registry) {
        order.push('third');
      }
    });

    MyApplication.instanceInitializer({
      name: 'sixth',
      initialize: function (registry) {
        order.push('sixth');
      }
    });

    _emberMetalRun_loop.default(function () {
      app = MyApplication.create({
        router: false,
        rootElement: '#qunit-fixture'
      });
    });

    deepEqual(order, ['first', 'second', 'third', 'fourth', 'fifth', 'sixth']);
  });

  QUnit.test('initializers can be registered in a specified order as an array', function () {
    var order = [];
    var MyApplication = _emberApplicationSystemApplication.default.extend();

    MyApplication.instanceInitializer({
      name: 'third',
      initialize: function (registry) {
        order.push('third');
      }
    });

    MyApplication.instanceInitializer({
      name: 'second',
      after: 'first',
      before: ['third', 'fourth'],
      initialize: function (registry) {
        order.push('second');
      }
    });

    MyApplication.instanceInitializer({
      name: 'fourth',
      after: ['second', 'third'],
      initialize: function (registry) {
        order.push('fourth');
      }
    });

    MyApplication.instanceInitializer({
      name: 'fifth',
      after: 'fourth',
      before: 'sixth',
      initialize: function (registry) {
        order.push('fifth');
      }
    });

    MyApplication.instanceInitializer({
      name: 'first',
      before: ['second'],
      initialize: function (registry) {
        order.push('first');
      }
    });

    MyApplication.instanceInitializer({
      name: 'sixth',
      initialize: function (registry) {
        order.push('sixth');
      }
    });

    _emberMetalRun_loop.default(function () {
      app = MyApplication.create({
        router: false,
        rootElement: '#qunit-fixture'
      });
    });

    deepEqual(order, ['first', 'second', 'third', 'fourth', 'fifth', 'sixth']);
  });

  QUnit.test('initializers can have multiple dependencies', function () {
    var order = [];
    var a = {
      name: 'a',
      before: 'b',
      initialize: function (registry) {
        order.push('a');
      }
    };
    var b = {
      name: 'b',
      initialize: function (registry) {
        order.push('b');
      }
    };
    var c = {
      name: 'c',
      after: 'b',
      initialize: function (registry) {
        order.push('c');
      }
    };
    var afterB = {
      name: 'after b',
      after: 'b',
      initialize: function (registry) {
        order.push('after b');
      }
    };
    var afterC = {
      name: 'after c',
      after: 'c',
      initialize: function (registry) {
        order.push('after c');
      }
    };

    _emberApplicationSystemApplication.default.instanceInitializer(b);
    _emberApplicationSystemApplication.default.instanceInitializer(a);
    _emberApplicationSystemApplication.default.instanceInitializer(afterC);
    _emberApplicationSystemApplication.default.instanceInitializer(afterB);
    _emberApplicationSystemApplication.default.instanceInitializer(c);

    _emberMetalRun_loop.default(function () {
      app = _emberApplicationSystemApplication.default.create({
        router: false,
        rootElement: '#qunit-fixture'
      });
    });

    ok(order.indexOf(a.name) < order.indexOf(b.name), 'a < b');
    ok(order.indexOf(b.name) < order.indexOf(c.name), 'b < c');
    ok(order.indexOf(b.name) < order.indexOf(afterB.name), 'b < afterB');
    ok(order.indexOf(c.name) < order.indexOf(afterC.name), 'c < afterC');
  });

  QUnit.test('initializers set on Application subclasses should not be shared between apps', function () {
    var firstInitializerRunCount = 0;
    var secondInitializerRunCount = 0;
    var FirstApp = _emberApplicationSystemApplication.default.extend();
    var firstApp, secondApp;

    FirstApp.instanceInitializer({
      name: 'first',
      initialize: function (registry) {
        firstInitializerRunCount++;
      }
    });
    var SecondApp = _emberApplicationSystemApplication.default.extend();
    SecondApp.instanceInitializer({
      name: 'second',
      initialize: function (registry) {
        secondInitializerRunCount++;
      }
    });
    _emberViewsSystemJquery.default('#qunit-fixture').html('<div id="first"></div><div id="second"></div>');
    _emberMetalRun_loop.default(function () {
      firstApp = FirstApp.create({
        router: false,
        rootElement: '#qunit-fixture #first'
      });
    });
    equal(firstInitializerRunCount, 1, 'first initializer only was run');
    equal(secondInitializerRunCount, 0, 'first initializer only was run');
    _emberMetalRun_loop.default(function () {
      secondApp = SecondApp.create({
        router: false,
        rootElement: '#qunit-fixture #second'
      });
    });
    equal(firstInitializerRunCount, 1, 'second initializer only was run');
    equal(secondInitializerRunCount, 1, 'second initializer only was run');
    _emberMetalRun_loop.default(function () {
      firstApp.destroy();
      secondApp.destroy();
    });
  });

  QUnit.test('initializers are concatenated', function () {
    var firstInitializerRunCount = 0;
    var secondInitializerRunCount = 0;
    var FirstApp = _emberApplicationSystemApplication.default.extend();
    var firstApp, secondApp;

    FirstApp.instanceInitializer({
      name: 'first',
      initialize: function (registry) {
        firstInitializerRunCount++;
      }
    });

    var SecondApp = FirstApp.extend();
    SecondApp.instanceInitializer({
      name: 'second',
      initialize: function (registry) {
        secondInitializerRunCount++;
      }
    });

    _emberViewsSystemJquery.default('#qunit-fixture').html('<div id="first"></div><div id="second"></div>');
    _emberMetalRun_loop.default(function () {
      firstApp = FirstApp.create({
        router: false,
        rootElement: '#qunit-fixture #first'
      });
    });
    equal(firstInitializerRunCount, 1, 'first initializer only was run when base class created');
    equal(secondInitializerRunCount, 0, 'first initializer only was run when base class created');
    firstInitializerRunCount = 0;
    _emberMetalRun_loop.default(function () {
      secondApp = SecondApp.create({
        router: false,
        rootElement: '#qunit-fixture #second'
      });
    });
    equal(firstInitializerRunCount, 1, 'first initializer was run when subclass created');
    equal(secondInitializerRunCount, 1, 'second initializers was run when subclass created');
    _emberMetalRun_loop.default(function () {
      firstApp.destroy();
      secondApp.destroy();
    });
  });

  QUnit.test('initializers are per-app', function () {
    expect(0);
    var FirstApp = _emberApplicationSystemApplication.default.extend();
    FirstApp.instanceInitializer({
      name: 'shouldNotCollide',
      initialize: function (registry) {}
    });

    var SecondApp = _emberApplicationSystemApplication.default.extend();
    SecondApp.instanceInitializer({
      name: 'shouldNotCollide',
      initialize: function (registry) {}
    });
  });

  QUnit.test('initializers are run before ready hook', function () {
    expect(2);

    var readyWasCalled = false;

    var MyApplication = _emberApplicationSystemApplication.default.extend({
      ready: function () {
        ok(true, 'ready is called');
        readyWasCalled = true;
      }
    });

    MyApplication.instanceInitializer({
      name: 'initializer',
      initialize: function () {
        ok(!readyWasCalled, 'ready is not yet called');
      }
    });

    _emberMetalRun_loop.default(function () {
      app = MyApplication.create({
        router: false,
        rootElement: '#qunit-fixture'
      });
    });
  });

  QUnit.test('initializers should be executed in their own context', function () {
    expect(1);

    var MyApplication = _emberApplicationSystemApplication.default.extend();

    MyApplication.instanceInitializer({
      name: 'coolInitializer',
      myProperty: 'cool',
      initialize: function (registry, application) {
        equal(this.myProperty, 'cool', 'should have access to its own context');
      }
    });

    _emberMetalRun_loop.default(function () {
      app = MyApplication.create({
        router: false,
        rootElement: '#qunit-fixture'
      });
    });
  });

  QUnit.test('Initializers get an instance on app reset', function () {
    expect(2);

    var MyApplication = _emberApplicationSystemApplication.default.extend();

    MyApplication.instanceInitializer({
      name: 'giveMeAnInstance',
      initialize: function (instance) {
        ok(!!instance, 'Initializer got an instance');
      }
    });

    _emberMetalRun_loop.default(function () {
      app = MyApplication.create({
        router: false,
        rootElement: '#qunit-fixture'
      });
    });

    _emberMetalRun_loop.default(app, 'reset');
  });
});
enifed('ember-application/tests/system/instance_initializers_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-application/tests/system');
  test('ember-application/tests/system/instance_initializers_test.js should pass jscs', function () {
    ok(true, 'ember-application/tests/system/instance_initializers_test.js should pass jscs.');
  });
});
enifed('ember-application/tests/system/instance_initializers_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-application/tests/system');
  QUnit.test('ember-application/tests/system/instance_initializers_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-application/tests/system/instance_initializers_test.js should pass jshint.');
  });
});
enifed('ember-application/tests/system/logging_test', ['exports', 'ember-metal/core', 'ember-metal/run_loop', 'ember-application/system/application', 'ember-views/views/view', 'ember-runtime/controllers/controller', 'ember-routing/system/route', 'ember-runtime/ext/rsvp', 'ember-template-compiler/system/compile', 'ember-routing'], function (exports, _emberMetalCore, _emberMetalRun_loop, _emberApplicationSystemApplication, _emberViewsViewsView, _emberRuntimeControllersController, _emberRoutingSystemRoute, _emberRuntimeExtRsvp, _emberTemplateCompilerSystemCompile, _emberRouting) {
  /*globals EmberDev */

  'use strict';

  var App, logs, originalLogger;

  QUnit.module('Ember.Application – logging of generated classes', {
    setup: function () {
      logs = {};

      originalLogger = _emberMetalCore.default.Logger.info;

      _emberMetalCore.default.Logger.info = function () {
        var fullName = arguments[1].fullName;

        logs[fullName] = logs[fullName] || 0;
        logs[fullName]++;
      };

      _emberMetalRun_loop.default(function () {
        App = _emberApplicationSystemApplication.default.create({
          LOG_ACTIVE_GENERATION: true
        });

        App.Router.reopen({
          location: 'none'
        });

        App.Router.map(function () {
          this.route('posts', { resetNamespace: true });
        });

        App.deferReadiness();
      });
    },

    teardown: function () {
      _emberMetalCore.default.Logger.info = originalLogger;

      _emberMetalRun_loop.default(App, 'destroy');

      logs = App = null;
    }
  });

  function visit(path) {
    QUnit.stop();

    var promise = _emberMetalRun_loop.default(function () {
      return new _emberRuntimeExtRsvp.default.Promise(function (resolve, reject) {
        var router = App.__container__.lookup('router:main');

        resolve(router.handleURL(path).then(function (value) {
          QUnit.start();
          ok(true, 'visited: `' + path + '`');
          return value;
        }, function (reason) {
          QUnit.start();
          ok(false, 'failed to visit:`' + path + '` reason: `' + QUnit.jsDump.parse(reason));
          throw reason;
        }));
      });
    });

    return {
      then: function (resolve, reject) {
        _emberMetalRun_loop.default(promise, 'then', resolve, reject);
      }
    };
  }

  QUnit.test('log class generation if logging enabled', function () {
    if (EmberDev && EmberDev.runningProdBuild) {
      ok(true, 'Logging does not occur in production builds');
      return;
    }

    _emberMetalRun_loop.default(App, 'advanceReadiness');

    visit('/posts').then(function () {
      equal(Object.keys(logs).length, 6, 'expected logs');
    });
  });

  QUnit.test('do NOT log class generation if logging disabled', function () {
    App.reopen({
      LOG_ACTIVE_GENERATION: false
    });

    _emberMetalRun_loop.default(App, 'advanceReadiness');

    visit('/posts').then(function () {
      equal(Object.keys(logs).length, 0, 'expected no logs');
    });
  });

  QUnit.test('actively generated classes get logged', function () {
    if (EmberDev && EmberDev.runningProdBuild) {
      ok(true, 'Logging does not occur in production builds');
      return;
    }

    _emberMetalRun_loop.default(App, 'advanceReadiness');

    visit('/posts').then(function () {
      equal(logs['controller:application'], 1, 'expected: ApplicationController was generated');
      equal(logs['controller:posts'], 1, 'expected: PostsController was generated');

      equal(logs['route:application'], 1, 'expected: ApplicationRoute was generated');
      equal(logs['route:posts'], 1, 'expected: PostsRoute was generated');
    });
  });

  QUnit.test('predefined classes do not get logged', function () {
    App.ApplicationController = _emberRuntimeControllersController.default.extend();
    App.PostsController = _emberRuntimeControllersController.default.extend();

    App.ApplicationRoute = _emberRoutingSystemRoute.default.extend();
    App.PostsRoute = _emberRoutingSystemRoute.default.extend();

    _emberMetalRun_loop.default(App, 'advanceReadiness');

    visit('/posts').then(function () {
      ok(!logs['controller:application'], 'did not expect: ApplicationController was generated');
      ok(!logs['controller:posts'], 'did not expect: PostsController was generated');

      ok(!logs['route:application'], 'did not expect: ApplicationRoute was generated');
      ok(!logs['route:posts'], 'did not expect: PostsRoute was generated');
    });
  });

  QUnit.module('Ember.Application – logging of view lookups', {
    setup: function () {
      logs = {};

      originalLogger = _emberMetalCore.default.Logger.info;

      _emberMetalCore.default.Logger.info = function () {
        var fullName = arguments[1].fullName;

        logs[fullName] = logs[fullName] || 0;
        logs[fullName]++;
      };

      _emberMetalRun_loop.default(function () {
        App = _emberApplicationSystemApplication.default.create({
          LOG_VIEW_LOOKUPS: true
        });

        App.Router.reopen({
          location: 'none'
        });

        App.Router.map(function () {
          this.route('posts', { resetNamespace: true });
        });

        App.deferReadiness();
      });
    },

    teardown: function () {
      _emberMetalCore.default.Logger.info = originalLogger;

      _emberMetalRun_loop.default(App, 'destroy');

      logs = App = null;
    }
  });

  QUnit.test('log when template and view are missing when flag is active', function () {
    if (EmberDev && EmberDev.runningProdBuild) {
      ok(true, 'Logging does not occur in production builds');
      return;
    }

    App.register('template:application', _emberTemplateCompilerSystemCompile.default('{{outlet}}'));
    _emberMetalRun_loop.default(App, 'advanceReadiness');

    visit('/posts').then(function () {
      equal(logs['template:application'], undefined, 'expected: Should not log template:application since it exists.');
      equal(logs['template:index'], 1, 'expected: Could not find "index" template or view.');
      equal(logs['template:posts'], 1, 'expected: Could not find "posts" template or view.');
    });
  });

  QUnit.test('do not log when template and view are missing when flag is not true', function () {
    App.reopen({
      LOG_VIEW_LOOKUPS: false
    });

    _emberMetalRun_loop.default(App, 'advanceReadiness');

    visit('/posts').then(function () {
      equal(Object.keys(logs).length, 0, 'expected no logs');
    });
  });

  QUnit.test('log which view is used with a template', function () {
    if (EmberDev && EmberDev.runningProdBuild) {
      ok(true, 'Logging does not occur in production builds');
      return;
    }

    App.register('template:application', _emberTemplateCompilerSystemCompile.default('{{outlet}}'));
    App.register('template:foo', _emberTemplateCompilerSystemCompile.default('Template with custom view'));
    App.register('view:posts', _emberViewsViewsView.default.extend({ templateName: 'foo' }));
    _emberMetalRun_loop.default(App, 'advanceReadiness');

    visit('/posts').then(function () {
      equal(logs['view:application'], 1, 'toplevel view always get an element');
      equal(logs['view:index'], undefined, 'expected: Should not log when index is not present.');
      equal(logs['view:posts'], 1, 'expected: Rendering posts with PostsView.');
    });
  });

  QUnit.test('do not log which views are used with templates when flag is not true', function () {
    App.reopen({
      LOG_VIEW_LOOKUPS: false
    });

    _emberMetalRun_loop.default(App, 'advanceReadiness');

    visit('/posts').then(function () {
      equal(Object.keys(logs).length, 0, 'expected no logs');
    });
  });
});
enifed('ember-application/tests/system/logging_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-application/tests/system');
  test('ember-application/tests/system/logging_test.js should pass jscs', function () {
    ok(true, 'ember-application/tests/system/logging_test.js should pass jscs.');
  });
});
enifed('ember-application/tests/system/logging_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-application/tests/system');
  QUnit.test('ember-application/tests/system/logging_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-application/tests/system/logging_test.js should pass jshint.');
  });
});
enifed('ember-application/tests/system/readiness_test', ['exports', 'ember-metal/run_loop', 'ember-application/system/application'], function (exports, _emberMetalRun_loop, _emberApplicationSystemApplication) {
  'use strict';

  var jQuery, application, Application;
  var readyWasCalled, domReady, readyCallbacks;

  // We are using a small mock of jQuery because jQuery is third-party code with
  // very well-defined semantics, and we want to confirm that a jQuery stub run
  // in a more minimal server environment that implements this behavior will be
  // sufficient for Ember's requirements.

  QUnit.module('Application readiness', {
    setup: function () {
      readyWasCalled = 0;
      readyCallbacks = [];

      var jQueryInstance = {
        ready: function (callback) {
          readyCallbacks.push(callback);
          if (jQuery.isReady) {
            domReady();
          }
        }
      };

      jQuery = function () {
        return jQueryInstance;
      };
      jQuery.isReady = false;

      var domReadyCalled = 0;
      domReady = function () {
        if (domReadyCalled !== 0) {
          return;
        }
        domReadyCalled++;
        var i;
        for (i = 0; i < readyCallbacks.length; i++) {
          readyCallbacks[i]();
        }
      };

      Application = _emberApplicationSystemApplication.default.extend({
        $: jQuery,

        ready: function () {
          readyWasCalled++;
        }
      });
    },

    teardown: function () {
      if (application) {
        _emberMetalRun_loop.default(function () {
          application.destroy();
        });
      }
    }
  });

  // These tests are confirming that if the callbacks passed into jQuery's ready hook is called
  // synchronously during the application's initialization, we get the same behavior as if
  // it was triggered after initialization.

  QUnit.test('Ember.Application\'s ready event is called right away if jQuery is already ready', function () {
    jQuery.isReady = true;

    _emberMetalRun_loop.default(function () {
      application = Application.create({ router: false });

      equal(readyWasCalled, 0, 'ready is not called until later');
    });

    equal(readyWasCalled, 1, 'ready was called');

    domReady();

    equal(readyWasCalled, 1, 'application\'s ready was not called again');
  });

  QUnit.test('Ember.Application\'s ready event is called after the document becomes ready', function () {
    _emberMetalRun_loop.default(function () {
      application = Application.create({ router: false });
    });

    equal(readyWasCalled, 0, 'ready wasn\'t called yet');

    domReady();

    equal(readyWasCalled, 1, 'ready was called now that DOM is ready');
  });

  QUnit.test('Ember.Application\'s ready event can be deferred by other components', function () {
    _emberMetalRun_loop.default(function () {
      application = Application.create({ router: false });
      application.deferReadiness();
    });

    equal(readyWasCalled, 0, 'ready wasn\'t called yet');

    domReady();

    equal(readyWasCalled, 0, 'ready wasn\'t called yet');

    _emberMetalRun_loop.default(function () {
      application.advanceReadiness();
      equal(readyWasCalled, 0);
    });

    equal(readyWasCalled, 1, 'ready was called now all readiness deferrals are advanced');
  });

  QUnit.test('Ember.Application\'s ready event can be deferred by other components', function () {
    jQuery.isReady = false;

    _emberMetalRun_loop.default(function () {
      application = Application.create({ router: false });
      application.deferReadiness();
      equal(readyWasCalled, 0, 'ready wasn\'t called yet');
    });

    domReady();

    equal(readyWasCalled, 0, 'ready wasn\'t called yet');

    _emberMetalRun_loop.default(function () {
      application.advanceReadiness();
    });

    equal(readyWasCalled, 1, 'ready was called now all readiness deferrals are advanced');

    expectAssertion(function () {
      application.deferReadiness();
    });
  });
});
enifed('ember-application/tests/system/readiness_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-application/tests/system');
  test('ember-application/tests/system/readiness_test.js should pass jscs', function () {
    ok(true, 'ember-application/tests/system/readiness_test.js should pass jscs.');
  });
});
enifed('ember-application/tests/system/readiness_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-application/tests/system');
  QUnit.test('ember-application/tests/system/readiness_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-application/tests/system/readiness_test.js should pass jshint.');
  });
});
enifed('ember-application/tests/system/reset_test', ['exports', 'ember-metal/run_loop', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-application/system/application', 'ember-runtime/system/object', 'ember-routing/system/router', 'ember-views/views/view', 'ember-runtime/controllers/controller', 'ember-views/system/jquery', 'container/registry'], function (exports, _emberMetalRun_loop, _emberMetalProperty_get, _emberMetalProperty_set, _emberApplicationSystemApplication, _emberRuntimeSystemObject, _emberRoutingSystemRouter, _emberViewsViewsView, _emberRuntimeControllersController, _emberViewsSystemJquery, _containerRegistry) {
  'use strict';

  var application, Application;

  QUnit.module('Ember.Application - resetting', {
    setup: function () {
      Application = _emberApplicationSystemApplication.default.extend({
        name: 'App',
        rootElement: '#qunit-fixture'
      });
    },
    teardown: function () {
      Application = null;
      if (application) {
        _emberMetalRun_loop.default(application, 'destroy');
      }
    }
  });

  QUnit.test('Brings its own run-loop if not provided', function () {
    application = _emberMetalRun_loop.default(Application, 'create');
    application.ready = function () {
      QUnit.start();
      ok(true, 'app booted');
    };

    QUnit.stop();
    application.reset();
  });

  QUnit.test('does not bring its own run loop if one is already provided', function () {
    expect(3);

    var didBecomeReady = false;

    application = _emberMetalRun_loop.default(Application, 'create');

    _emberMetalRun_loop.default(function () {

      application.ready = function () {
        didBecomeReady = true;
      };

      application.reset();

      application.deferReadiness();
      ok(!didBecomeReady, 'app is not ready');
    });

    ok(!didBecomeReady, 'app is not ready');
    _emberMetalRun_loop.default(application, 'advanceReadiness');
    ok(didBecomeReady, 'app is ready');
  });

  QUnit.test('When an application is reset, new instances of controllers are generated', function () {
    _emberMetalRun_loop.default(function () {
      application = Application.create();
      application.AcademicController = _emberRuntimeControllersController.default.extend();
    });

    var firstController = application.__container__.lookup('controller:academic');
    var secondController = application.__container__.lookup('controller:academic');

    application.reset();

    var thirdController = application.__container__.lookup('controller:academic');

    strictEqual(firstController, secondController, 'controllers looked up in succession should be the same instance');

    ok(firstController.isDestroying, 'controllers are destroyed when their application is reset');

    notStrictEqual(firstController, thirdController, 'controllers looked up after the application is reset should not be the same instance');
  });

  QUnit.test('When an application is reset, the eventDispatcher is destroyed and recreated', function () {
    var eventDispatcherWasSetup, eventDispatcherWasDestroyed;

    eventDispatcherWasSetup = 0;
    eventDispatcherWasDestroyed = 0;

    var mock_event_dispatcher = {
      create: function () {
        return {
          setup: function () {
            eventDispatcherWasSetup++;
          },
          destroy: function () {
            eventDispatcherWasDestroyed++;
          }
        };
      }
    };

    // this is pretty awful. We should make this less Global-ly.
    var originalRegister = _containerRegistry.default.prototype.register;
    _containerRegistry.default.prototype.register = function (name, type, options) {
      if (name === 'event_dispatcher:main') {
        return mock_event_dispatcher;
      } else {
        return originalRegister.call(this, name, type, options);
      }
    };

    try {
      _emberMetalRun_loop.default(function () {
        application = Application.create();

        equal(eventDispatcherWasSetup, 0);
        equal(eventDispatcherWasDestroyed, 0);
      });

      equal(eventDispatcherWasSetup, 1);
      equal(eventDispatcherWasDestroyed, 0);

      application.reset();

      equal(eventDispatcherWasDestroyed, 1);
      equal(eventDispatcherWasSetup, 2, 'setup called after reset');
    } catch (error) {
      _containerRegistry.default.prototype.register = originalRegister;
    }

    _containerRegistry.default.prototype.register = originalRegister;
  });

  QUnit.test('When an application is reset, the ApplicationView is torn down', function () {
    _emberMetalRun_loop.default(function () {
      application = Application.create();
      application.ApplicationView = _emberViewsViewsView.default.extend({
        elementId: 'application-view'
      });
    });

    equal(_emberViewsSystemJquery.default('#qunit-fixture #application-view').length, 1, 'precond - the application view is rendered');

    var originalView = _emberViewsViewsView.default.views['application-view'];

    application.reset();

    var resettedView = _emberViewsViewsView.default.views['application-view'];

    equal(_emberViewsSystemJquery.default('#qunit-fixture #application-view').length, 1, 'the application view is rendered');

    notStrictEqual(originalView, resettedView, 'The view object has changed');
  });

  QUnit.test('When an application is reset, the router URL is reset to `/`', function () {
    var location, router;

    _emberMetalRun_loop.default(function () {
      application = Application.create();
      application.Router = _emberRoutingSystemRouter.default.extend({
        location: 'none'
      });

      application.Router.map(function () {
        this.route('one');
        this.route('two');
      });
    });

    router = application.__container__.lookup('router:main');

    location = router.get('location');

    _emberMetalRun_loop.default(function () {
      location.handleURL('/one');
    });

    application.reset();

    var applicationController = application.__container__.lookup('controller:application');
    router = application.__container__.lookup('router:main');
    location = router.get('location');

    equal(location.getURL(), '');

    equal(_emberMetalProperty_get.get(applicationController, 'currentPath'), 'index');

    location = application.__container__.lookup('router:main').get('location');
    _emberMetalRun_loop.default(function () {
      location.handleURL('/one');
    });

    equal(_emberMetalProperty_get.get(applicationController, 'currentPath'), 'one');
  });

  QUnit.test('When an application with advance/deferReadiness is reset, the app does correctly become ready after reset', function () {
    var readyCallCount;

    readyCallCount = 0;

    _emberMetalRun_loop.default(function () {
      application = Application.create({
        ready: function () {
          readyCallCount++;
        }
      });

      application.deferReadiness();
      equal(readyCallCount, 0, 'ready has not yet been called');
    });

    _emberMetalRun_loop.default(function () {
      application.advanceReadiness();
    });

    equal(readyCallCount, 1, 'ready was called once');

    application.reset();

    equal(readyCallCount, 2, 'ready was called twice');
  });

  QUnit.test('With ember-data like initializer and constant', function () {
    var readyCallCount;

    readyCallCount = 0;

    var DS = {
      Store: _emberRuntimeSystemObject.default.extend({
        init: function () {
          if (!_emberMetalProperty_get.get(DS, 'defaultStore')) {
            _emberMetalProperty_set.set(DS, 'defaultStore', this);
          }

          this._super.apply(this, arguments);
        },
        willDestroy: function () {
          if (_emberMetalProperty_get.get(DS, 'defaultStore') === this) {
            _emberMetalProperty_set.set(DS, 'defaultStore', null);
          }
        }
      })
    };

    Application.initializer({
      name: 'store',
      initialize: function (registry, application) {
        registry.unregister('store:main');
        registry.register('store:main', application.Store);

        application.__container__.lookup('store:main');
      }
    });

    _emberMetalRun_loop.default(function () {
      application = Application.create();
      application.Store = DS.Store;
    });

    ok(DS.defaultStore, 'has defaultStore');

    application.reset();

    ok(DS.defaultStore, 'still has defaultStore');
    ok(application.__container__.lookup('store:main'), 'store is still present');
  });

  QUnit.test('Ensure that the hashchange event listener is removed', function () {
    var listeners;

    _emberViewsSystemJquery.default(window).off('hashchange'); // ensure that any previous listeners are cleared

    _emberMetalRun_loop.default(function () {
      application = Application.create();
    });

    listeners = _emberViewsSystemJquery.default._data(_emberViewsSystemJquery.default(window)[0], 'events');
    equal(listeners['hashchange'].length, 1, 'hashchange event listener was setup');

    application.reset();

    listeners = _emberViewsSystemJquery.default._data(_emberViewsSystemJquery.default(window)[0], 'events');
    equal(listeners['hashchange'].length, 1, 'hashchange event only exists once');
  });
});
enifed('ember-application/tests/system/reset_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-application/tests/system');
  test('ember-application/tests/system/reset_test.js should pass jscs', function () {
    ok(true, 'ember-application/tests/system/reset_test.js should pass jscs.');
  });
});
enifed('ember-application/tests/system/reset_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-application/tests/system');
  QUnit.test('ember-application/tests/system/reset_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-application/tests/system/reset_test.js should pass jshint.');
  });
});
enifed('ember-application/tests/system/visit_test', ['exports', 'ember-metal/core', 'ember-metal/features', 'ember-metal/run_loop', 'ember-application/system/application', 'ember-application/system/application-instance', 'ember-routing/system/router', 'ember-views/views/view', 'ember-template-compiler/system/compile'], function (exports, _emberMetalCore, _emberMetalFeatures, _emberMetalRun_loop, _emberApplicationSystemApplication, _emberApplicationSystemApplicationInstance, _emberRoutingSystemRouter, _emberViewsViewsView, _emberTemplateCompilerSystemCompile) {
  'use strict';

  function createApplication() {
    var App = _emberApplicationSystemApplication.default.extend().create({
      autoboot: false,
      LOG_TRANSITIONS: true,
      LOG_TRANSITIONS_INTERNAL: true,
      LOG_ACTIVE_GENERATION: true
    });

    App.Router = _emberRoutingSystemRouter.default.extend();

    return App;
  }
});

// This tests whether the application is "autobooted" by registering an
// instance initializer and asserting it never gets run. Since this is
// inherently testing that async behavior *doesn't* happen, we set a
// 500ms timeout to verify that when autoboot is set to false, the
// instance initializer that would normally get called on DOM ready
// does not fire.

// Start the timeout

// Create an instance initializer that should *not* get run.
enifed('ember-application/tests/system/visit_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-application/tests/system');
  test('ember-application/tests/system/visit_test.js should pass jscs', function () {
    ok(true, 'ember-application/tests/system/visit_test.js should pass jscs.');
  });
});
enifed('ember-application/tests/system/visit_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-application/tests/system');
  QUnit.test('ember-application/tests/system/visit_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-application/tests/system/visit_test.js should pass jshint.');
  });
});
enifed('ember-application/utils/validate-type.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-application/utils');
  test('ember-application/utils/validate-type.js should pass jscs', function () {
    ok(true, 'ember-application/utils/validate-type.js should pass jscs.');
  });
});
enifed('ember-application/utils/validate-type.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-application/utils');
  QUnit.test('ember-application/utils/validate-type.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-application/utils/validate-type.js should pass jshint.');
  });
});
enifed('ember-debug.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - .');
  test('ember-debug.js should pass jscs', function () {
    ok(true, 'ember-debug.js should pass jscs.');
  });
});
enifed('ember-debug.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - .');
  QUnit.test('ember-debug.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-debug.js should pass jshint.');
  });
});
enifed('ember-debug/deprecation-manager.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-debug');
  test('ember-debug/deprecation-manager.js should pass jscs', function () {
    ok(true, 'ember-debug/deprecation-manager.js should pass jscs.');
  });
});
enifed('ember-debug/deprecation-manager.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-debug');
  QUnit.test('ember-debug/deprecation-manager.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-debug/deprecation-manager.js should pass jshint.');
  });
});
enifed('ember-debug/tests/main_test', ['exports', 'ember-metal/core', 'ember-debug/deprecation-manager'], function (exports, _emberMetalCore, _emberDebugDeprecationManager) {
  'use strict';

  var originalEnvValue = undefined;
  var originalDeprecationDefault = undefined;
  var originalDeprecationLevels = undefined;

  QUnit.module('ember-debug', {
    setup: function () {
      originalDeprecationDefault = _emberDebugDeprecationManager.default.defaultLevel;
      originalDeprecationLevels = _emberDebugDeprecationManager.default.individualLevels;
      originalEnvValue = _emberMetalCore.default.ENV.RAISE_ON_DEPRECATION;

      _emberMetalCore.default.ENV.RAISE_ON_DEPRECATION = false;
      _emberDebugDeprecationManager.default.setDefaultLevel(_emberDebugDeprecationManager.deprecationLevels.RAISE);
    },

    teardown: function () {
      _emberDebugDeprecationManager.default.defaultLevel = originalDeprecationDefault;
      _emberDebugDeprecationManager.default.individualLevels = originalDeprecationLevels;
      _emberMetalCore.default.ENV.RAISE_ON_DEPRECATION = originalEnvValue;
    }
  });

  QUnit.test('Ember.deprecate does not throw if default level is silence', function (assert) {
    assert.expect(1);
    _emberDebugDeprecationManager.default.setDefaultLevel(_emberDebugDeprecationManager.deprecationLevels.SILENCE);

    try {
      _emberMetalCore.default.deprecate('Should not throw', false);
      assert.ok(true, 'Ember.deprecate did not throw');
    } catch (e) {
      assert.ok(false, 'Expected Ember.deprecate not to throw but it did: ' + e.message);
    }
  });

  QUnit.test('Ember.deprecate re-sets deprecation level to RAISE if ENV.RAISE_ON_DEPRECATION is set', function (assert) {
    assert.expect(2);

    _emberDebugDeprecationManager.default.setDefaultLevel(_emberDebugDeprecationManager.deprecationLevels.SILENCE);

    _emberMetalCore.default.ENV.RAISE_ON_DEPRECATION = true;

    assert.throws(function () {
      _emberMetalCore.default.deprecate('Should throw', false);
    }, /Should throw/);

    assert.equal(_emberDebugDeprecationManager.default.defaultLevel, _emberDebugDeprecationManager.deprecationLevels.RAISE, 'default level re-set to RAISE');
  });

  QUnit.test('When ENV.RAISE_ON_DEPRECATION is true, it is still possible to silence a deprecation by id', function (assert) {
    assert.expect(3);

    _emberMetalCore.default.ENV.RAISE_ON_DEPRECATION = true;
    _emberDebugDeprecationManager.default.setLevel('my-deprecation', _emberDebugDeprecationManager.deprecationLevels.SILENCE);

    try {
      _emberMetalCore.default.deprecate('should be silenced with matching id', false, { id: 'my-deprecation' });
      assert.ok(true, 'Did not throw when level is set by id');
    } catch (e) {
      assert.ok(false, 'Expected Ember.deprecate not to throw but it did: ' + e.message);
    }

    assert.throws(function () {
      _emberMetalCore.default.deprecate('Should throw with no id', false);
    }, /Should throw with no id/);

    assert.throws(function () {
      _emberMetalCore.default.deprecate('Should throw with non-matching id', false, { id: 'other-id' });
    }, /Should throw with non-matching id/);
  });

  QUnit.test('Ember.deprecate throws deprecation if second argument is falsy', function () {
    expect(3);

    throws(function () {
      _emberMetalCore.default.deprecate('Deprecation is thrown', false);
    });

    throws(function () {
      _emberMetalCore.default.deprecate('Deprecation is thrown', '');
    });

    throws(function () {
      _emberMetalCore.default.deprecate('Deprecation is thrown', 0);
    });
  });

  QUnit.test('Ember.deprecate does not throw deprecation if second argument is a function and it returns true', function () {
    expect(1);

    _emberMetalCore.default.deprecate('Deprecation is thrown', function () {
      return true;
    });

    ok(true, 'deprecation was not thrown');
  });

  QUnit.test('Ember.deprecate throws if second argument is a function and it returns false', function () {
    expect(1);
    throws(function () {
      _emberMetalCore.default.deprecate('Deprecation is thrown', function () {
        return false;
      });
    });
  });

  QUnit.test('Ember.deprecate does not throw deprecations if second argument is truthy', function () {
    expect(1);

    _emberMetalCore.default.deprecate('Deprecation is thrown', true);
    _emberMetalCore.default.deprecate('Deprecation is thrown', '1');
    _emberMetalCore.default.deprecate('Deprecation is thrown', 1);

    ok(true, 'deprecations were not thrown');
  });

  QUnit.test('Ember.assert throws if second argument is falsy', function () {
    expect(3);

    throws(function () {
      _emberMetalCore.default.assert('Assertion is thrown', false);
    });

    throws(function () {
      _emberMetalCore.default.assert('Assertion is thrown', '');
    });

    throws(function () {
      _emberMetalCore.default.assert('Assertion is thrown', 0);
    });
  });

  QUnit.test('Ember.assert does not throw if second argument is a function and it returns true', function () {
    expect(1);

    _emberMetalCore.default.assert('Assertion is thrown', function () {
      return true;
    });

    ok(true, 'assertion was not thrown');
  });

  QUnit.test('Ember.assert throws if second argument is a function and it returns false', function () {
    expect(1);
    throws(function () {
      _emberMetalCore.default.assert('Assertion is thrown', function () {
        return false;
      });
    });
  });

  QUnit.test('Ember.assert does not throw if second argument is truthy', function () {
    expect(1);

    _emberMetalCore.default.assert('Assertion is thrown', true);
    _emberMetalCore.default.assert('Assertion is thrown', '1');
    _emberMetalCore.default.assert('Assertion is thrown', 1);

    ok(true, 'assertions were not thrown');
  });

  QUnit.test('Ember.assert does not throw if second argument is an object', function () {
    expect(1);
    var Igor = _emberMetalCore.default.Object.extend();

    _emberMetalCore.default.assert('is truthy', Igor);
    _emberMetalCore.default.assert('is truthy', Igor.create());

    ok(true, 'assertions were not thrown');
  });

  QUnit.test('Ember.deprecate does not throw a deprecation at log and silence levels', function () {
    expect(4);
    var id = 'ABC';

    _emberDebugDeprecationManager.default.setLevel(id, _emberDebugDeprecationManager.deprecationLevels.LOG);
    try {
      _emberMetalCore.default.deprecate('Deprecation for testing purposes', false, { id: id });
      ok(true, 'Deprecation did not throw');
    } catch (e) {
      ok(false, 'Deprecation was thrown despite being added to blacklist');
    }

    _emberDebugDeprecationManager.default.setLevel(id, _emberDebugDeprecationManager.deprecationLevels.SILENCE);
    try {
      _emberMetalCore.default.deprecate('Deprecation for testing purposes', false, { id: id });
      ok(true, 'Deprecation did not throw');
    } catch (e) {
      ok(false, 'Deprecation was thrown despite being added to blacklist');
    }

    _emberDebugDeprecationManager.default.setLevel(id, _emberDebugDeprecationManager.deprecationLevels.RAISE);

    throws(function () {
      _emberMetalCore.default.deprecate('Deprecation is thrown', false, { id: id });
    });

    _emberDebugDeprecationManager.default.setLevel(id, null);

    throws(function () {
      _emberMetalCore.default.deprecate('Deprecation is thrown', false, { id: id });
    });
  });
});
enifed('ember-debug/tests/main_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-debug/tests');
  test('ember-debug/tests/main_test.js should pass jscs', function () {
    ok(true, 'ember-debug/tests/main_test.js should pass jscs.');
  });
});
enifed('ember-debug/tests/main_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-debug/tests');
  QUnit.test('ember-debug/tests/main_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-debug/tests/main_test.js should pass jshint.');
  });
});
enifed('ember-debug/tests/warn_if_using_stripped_feature_flags_test', ['exports', 'ember-metal/core', 'ember-debug'], function (exports, _emberMetalCore, _emberDebug) {
  'use strict';

  var oldWarn, oldRunInDebug, origEnvFeatures, origEnableAll, origEnableOptional;

  function confirmWarns(expectedMsg) {
    var featuresWereStripped = true;
    var FEATURES = _emberMetalCore.default.ENV.FEATURES;

    _emberMetalCore.default.warn = function (msg, test) {
      if (!test) {
        equal(msg, expectedMsg);
      }
    };

    _emberMetalCore.default.runInDebug = function (func) {
      func();
    };

    // Should trigger our 1 warning
    _emberDebug._warnIfUsingStrippedFeatureFlags(FEATURES, featuresWereStripped);

    // Shouldn't trigger any warnings now that we're "in canary"
    featuresWereStripped = false;
    _emberDebug._warnIfUsingStrippedFeatureFlags(FEATURES, featuresWereStripped);
  }

  QUnit.module('ember-debug - _warnIfUsingStrippedFeatureFlags', {
    setup: function () {
      oldWarn = _emberMetalCore.default.warn;
      oldRunInDebug = _emberMetalCore.default.runInDebug;
      origEnvFeatures = _emberMetalCore.default.ENV.FEATURES;
      origEnableAll = _emberMetalCore.default.ENV.ENABLE_ALL_FEATURES;
      origEnableOptional = _emberMetalCore.default.ENV.ENABLE_OPTIONAL_FEATURES;
    },

    teardown: function () {
      _emberMetalCore.default.warn = oldWarn;
      _emberMetalCore.default.runInDebug = oldRunInDebug;
      _emberMetalCore.default.ENV.FEATURES = origEnvFeatures;
      _emberMetalCore.default.ENV.ENABLE_ALL_FEATURES = origEnableAll;
      _emberMetalCore.default.ENV.ENABLE_OPTIONAL_FEATURES = origEnableOptional;
    }
  });

  QUnit.test('Setting Ember.ENV.ENABLE_ALL_FEATURES truthy in non-canary, debug build causes a warning', function () {
    expect(1);

    _emberMetalCore.default.ENV.ENABLE_ALL_FEATURES = true;
    _emberMetalCore.default.ENV.ENABLE_OPTIONAL_FEATURES = false;
    _emberMetalCore.default.ENV.FEATURES = {};

    confirmWarns('Ember.ENV.ENABLE_ALL_FEATURES is only available in canary builds.');
  });

  QUnit.test('Setting Ember.ENV.ENABLE_OPTIONAL_FEATURES truthy in non-canary, debug build causes a warning', function () {
    expect(1);

    _emberMetalCore.default.ENV.ENABLE_ALL_FEATURES = false;
    _emberMetalCore.default.ENV.ENABLE_OPTIONAL_FEATURES = true;
    _emberMetalCore.default.ENV.FEATURES = {};

    confirmWarns('Ember.ENV.ENABLE_OPTIONAL_FEATURES is only available in canary builds.');
  });

  QUnit.test('Enabling a FEATURES flag in non-canary, debug build causes a warning', function () {
    expect(1);

    _emberMetalCore.default.ENV.ENABLE_ALL_FEATURES = false;
    _emberMetalCore.default.ENV.ENABLE_OPTIONAL_FEATURES = false;
    _emberMetalCore.default.ENV.FEATURES = {
      'fred': true,
      'barney': false,
      'wilma': null
    };

    confirmWarns('FEATURE["fred"] is set as enabled, but FEATURE flags are only available in canary builds.');
  });
});
enifed('ember-debug/tests/warn_if_using_stripped_feature_flags_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-debug/tests');
  test('ember-debug/tests/warn_if_using_stripped_feature_flags_test.js should pass jscs', function () {
    ok(true, 'ember-debug/tests/warn_if_using_stripped_feature_flags_test.js should pass jscs.');
  });
});
enifed('ember-debug/tests/warn_if_using_stripped_feature_flags_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-debug/tests');
  QUnit.test('ember-debug/tests/warn_if_using_stripped_feature_flags_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-debug/tests/warn_if_using_stripped_feature_flags_test.js should pass jshint.');
  });
});
enifed("ember-dev/test-helper/assertion", ["exports", "./method-call-expectation", "./utils"], function (exports, _methodCallExpectation, _utils) {
  /* globals QUnit */

  "use strict";

  function AssertExpectation(Ember, message) {
    _methodCallExpectation.default.call(this, Ember, 'assert');
    this.expectedMessage = message;
  }
  AssertExpectation.Error = function () {};
  AssertExpectation.prototype = _utils.o_create(_methodCallExpectation.default.prototype);
  AssertExpectation.prototype.handleCall = function (message, test) {
    var noAssertion = typeof test === 'function' ? test() : test;

    this.sawCall = true;

    if (noAssertion) {
      return;
    }

    this.actualMessage = message;
    // Halt execution
    throw new AssertExpectation.Error();
  };
  AssertExpectation.prototype.assert = function (fn) {
    try {
      this.runWithStub(fn);
    } catch (e) {
      if (!(e instanceof AssertExpectation.Error)) {
        throw e;
      }
    }

    // Run assertions in an order that is useful when debugging a test failure.
    //
    if (!this.sawCall) {
      QUnit.ok(false, "Expected Ember.assert to be called (Not called with any value).");
    } else if (!this.actualMessage) {
      QUnit.ok(false, 'Expected a failing Ember.assert (Ember.assert called, but without a failing test).');
    } else {
      if (this.expectedMessage) {
        if (this.expectedMessage instanceof RegExp) {
          QUnit.ok(this.expectedMessage.test(this.actualMessage), "Expected failing Ember.assert: '" + this.expectedMessage + "', but got '" + this.actualMessage + "'.");
        } else {
          QUnit.equal(this.actualMessage, this.expectedMessage, "Expected failing Ember.assert: '" + this.expectedMessage + "', but got '" + this.actualMessage + "'.");
        }
      } else {
        // Positive assertion that assert was called
        QUnit.ok(true, 'Expected a failing Ember.assert.');
      }
    }
  };

  var AssertionAssert = function (env) {
    this.env = env;
  };

  AssertionAssert.prototype = {

    reset: function () {},

    inject: function () {

      var assertion = this;

      // Looks for an exception raised within the fn.
      //
      // expectAssertion(function(){
      //   Ember.assert("Homie don't roll like that");
      // } /* , optionalMessageStringOrRegex */);
      //
      window.expectAssertion = function expectAssertion(fn, message) {
        if (assertion.env.runningProdBuild) {
          QUnit.ok(true, 'Assertions disabled in production builds.');
          return;
        }

        // do not assert as the production builds do not contain Ember.assert
        new AssertExpectation(assertion.env.Ember, message).assert(fn);
      };

      window.ignoreAssertion = function ignoreAssertion(fn) {
        var stubber = new _methodCallExpectation.default(assertion.env.Ember, 'assert'),
            noop = function () {};

        stubber.runWithStub(fn, noop);
      };
    },

    assert: function () {},

    restore: function () {
      window.expectAssertion = null;
      window.ignoreAssertion = null;
    }

  };

  exports.default = AssertionAssert;
});
enifed('ember-dev/test-helper/deprecation', ['exports', './method-call-expectation'], function (exports, _methodCallExpectation) {
  /* globals QUnit */

  'use strict';

  var NONE = function () {};

  var DeprecationAssert = function (env) {
    this.env = env;

    this.reset();
  };

  DeprecationAssert.prototype = {

    reset: function () {
      this.expecteds = null;
      this.actuals = null;
    },

    stubEmber: function () {
      if (!this._previousEmberDeprecate && this._previousEmberDeprecate !== this.env.Ember.deprecate) {
        this._previousEmberDeprecate = this.env.Ember.deprecate;
      }
      var assertion = this;
      this.env.Ember.deprecate = function (msg, test) {
        var resultOfTest = typeof test === 'function' ? test() : test;
        var shouldDeprecate = !resultOfTest;

        assertion.actuals = assertion.actuals || [];
        if (shouldDeprecate) {
          assertion.actuals.push([msg, resultOfTest]);
        }
      };
    },

    inject: function () {
      var assertion = this;

      // Expects no deprecation to happen from the time of calling until
      // the end of the test.
      //
      // expectNoDeprecation(/* optionalStringOrRegex */);
      // Ember.deprecate("Old And Busted");
      //
      window.expectNoDeprecation = function () {
        if (assertion.expecteds != null && typeof assertion.expecteds === 'object') {
          throw new Error("expectNoDeprecation was called after expectDeprecation was called!");
        }
        assertion.stubEmber();
        assertion.expecteds = NONE;
      };

      // Expect a deprecation to happen within a function, or if no function
      // is pass, from the time of calling until the end of the test. Can be called
      // multiple times to assert deprecations with different specific messages
      // were fired.
      //
      // expectDeprecation(function(){
      //   Ember.deprecate("Old And Busted");
      // }, /* optionalStringOrRegex */);
      //
      // expectDeprecation(/* optionalStringOrRegex */);
      // Ember.deprecate("Old And Busted");
      //
      window.expectDeprecation = function (fn, message) {
        var originalExpecteds, originalActuals;

        if (assertion.expecteds === NONE) {
          throw new Error("expectDeprecation was called after expectNoDeprecation was called!");
        }
        assertion.stubEmber();
        assertion.expecteds = assertion.expecteds || [];
        if (fn && typeof fn !== 'function') {
          // fn is a message
          assertion.expecteds.push(fn);
        } else {
          originalExpecteds = assertion.expecteds.slice();
          originalActuals = assertion.actuals ? assertion.actuals.slice() : assertion.actuals;

          assertion.expecteds.push(message || /.*/);

          if (fn) {
            fn();
            assertion.assert();

            assertion.expecteds = originalExpecteds;
            assertion.actuals = originalActuals;
          }
        }
      };

      window.ignoreDeprecation = function ignoreDeprecation(fn) {
        var stubber = new _methodCallExpectation.default(assertion.env.Ember, 'deprecate'),
            noop = function () {};

        stubber.runWithStub(fn, noop);
      };
    },

    // Forces an assert the deprecations occurred, and resets the globals
    // storing asserts for the next run.
    //
    // expectNoDeprecation(/Old/);
    // setTimeout(function(){
    //   Ember.deprecate("Old And Busted");
    //   assertDeprecation();
    // });
    //
    // assertDeprecation is called after each test run to catch any expectations
    // without explicit asserts.
    //
    assert: function () {
      var expecteds = this.expecteds || [],
          actuals = this.actuals || [];
      var o, i;

      if (expecteds !== NONE && expecteds.length === 0 && actuals.length === 0) {
        return;
      }

      if (this.env.runningProdBuild) {
        QUnit.ok(true, 'deprecations disabled in production builds.');
        return;
      }

      if (expecteds === NONE) {
        var actualMessages = [];
        for (i = 0; i < actuals.length; i++) {
          actualMessages.push(actuals[i][0]);
        }
        QUnit.ok(actuals.length === 0, "Expected no deprecation calls, got " + actuals.length + ": " + actualMessages.join(', '));
        return;
      }

      var expected, actual, match;

      for (o = 0; o < expecteds.length; o++) {
        expected = expecteds[o];
        for (i = 0; i < actuals.length; i++) {
          actual = actuals[i];
          if (!actual[1]) {
            if (expected instanceof RegExp) {
              if (expected.test(actual[0])) {
                match = actual;
                break;
              }
            } else {
              if (expected === actual[0]) {
                match = actual;
                break;
              }
            }
          }
        }

        if (!actual) {
          QUnit.ok(false, "Recieved no deprecate calls at all, expecting: " + expected);
        } else if (match && !match[1]) {
          QUnit.ok(true, "Recieved failing deprecation with message: " + match[0]);
        } else if (match && match[1]) {
          QUnit.ok(false, "Expected failing deprecation, got succeeding with message: " + match[0]);
        } else if (actual[1]) {
          QUnit.ok(false, "Did not receive failing deprecation matching '" + expected + "', last was success with '" + actual[0] + "'");
        } else if (!actual[1]) {
          QUnit.ok(false, "Did not receive failing deprecation matching '" + expected + "', last was failure with '" + actual[0] + "'");
        }
      }
    },

    restore: function () {
      if (this._previousEmberDeprecate) {
        this.env.Ember.deprecate = this._previousEmberDeprecate;
        this._previousEmberDeprecate = null;
      }
      window.expectNoDeprecation = null;
    }

  };

  exports.default = DeprecationAssert;
});
enifed("ember-dev/test-helper/index", ["exports", "./deprecation", "./remaining-view", "./remaining-template", "./assertion", "./run-loop", "./utils"], function (exports, _deprecation, _remainingView, _remainingTemplate, _assertion, _runLoop, _utils) {
  "use strict";

  var EmberDevTestHelperAssert = _utils.buildCompositeAssert([_deprecation.default, _remainingView.default, _remainingTemplate.default, _assertion.default, _runLoop.default]);

  exports.default = EmberDevTestHelperAssert;
});
enifed("ember-dev/test-helper/method-call-expectation", ["exports"], function (exports) {
  /* globals QUnit */

  // A light class for stubbing
  //
  "use strict";

  function MethodCallExpectation(target, property) {
    this.target = target;
    this.property = property;
  }

  MethodCallExpectation.prototype = {
    handleCall: function () {
      this.sawCall = true;
      return this.originalMethod.apply(this.target, arguments);
    },
    stubMethod: function (replacementFunc) {
      var context = this,
          property = this.property;

      this.originalMethod = this.target[property];

      if (typeof replacementFunc === 'function') {
        this.target[property] = replacementFunc;
      } else {
        this.target[property] = function () {
          return context.handleCall.apply(context, arguments);
        };
      }
    },
    restoreMethod: function () {
      this.target[this.property] = this.originalMethod;
    },
    runWithStub: function (fn, replacementFunc) {
      try {
        this.stubMethod(replacementFunc);
        fn();
      } finally {
        this.restoreMethod();
      }
    },
    assert: function () {
      this.runWithStub.apply(this, arguments);
      QUnit.ok(this.sawCall, "Expected " + this.property + " to be called.");
    }
  };

  exports.default = MethodCallExpectation;
});
enifed("ember-dev/test-helper/remaining-template", ["exports"], function (exports) {
  /* globals QUnit */

  "use strict";

  var RemainingTemplateAssert = function (env) {
    this.env = env;
  };

  RemainingTemplateAssert.prototype = {
    reset: function () {},
    inject: function () {},
    assert: function () {
      if (this.env.Ember && this.env.Ember.TEMPLATES) {
        var templateNames = [],
            name;
        for (name in this.env.Ember.TEMPLATES) {
          if (this.env.Ember.TEMPLATES[name] != null) {
            templateNames.push(name);
          }
        }

        if (templateNames.length > 0) {
          QUnit.deepEqual(templateNames, [], "Ember.TEMPLATES should be empty");
          this.env.Ember.TEMPLATES = {};
        }
      }
    },
    restore: function () {}
  };

  exports.default = RemainingTemplateAssert;
});
enifed("ember-dev/test-helper/remaining-view", ["exports"], function (exports) {
  /* globals QUnit */

  "use strict";

  var RemainingViewAssert = function (env) {
    this.env = env;
  };

  RemainingViewAssert.prototype = {
    reset: function () {},
    inject: function () {},
    assert: function () {
      if (this.env.Ember && this.env.Ember.View) {
        var viewIds = [],
            id;
        for (id in this.env.Ember.View.views) {
          if (this.env.Ember.View.views[id] != null) {
            viewIds.push(id);
          }
        }

        if (viewIds.length > 0) {
          QUnit.deepEqual(viewIds, [], "Ember.View.views should be empty");
          this.env.Ember.View.views = [];
        }
      }
    },
    restore: function () {}
  };

  exports.default = RemainingViewAssert;
});
enifed("ember-dev/test-helper/run-loop", ["exports"], function (exports) {
  /* globals QUnit */

  "use strict";

  function RunLoopAssertion(env) {
    this.env = env;
  }

  RunLoopAssertion.prototype = {
    reset: function () {},
    inject: function () {},
    assert: function () {
      var run = this.env.Ember.run;

      if (run.currentRunLoop) {
        QUnit.ok(false, "Should not be in a run loop at end of test");
        while (run.currentRunLoop) {
          run.end();
        }
      }

      if (run.hasScheduledTimers()) {
        QUnit.ok(false, "Ember run should not have scheduled timers at end of test");
        run.cancelTimers();
      }
    },
    restore: function () {}
  };

  exports.default = RunLoopAssertion;
});
enifed("ember-dev/test-helper/setup-qunit", ["exports"], function (exports) {
  /* globals QUnit */

  "use strict";

  exports.default = setupQUnit;

  function setupQUnit(assertion, _qunitGlobal) {
    var qunitGlobal = QUnit;

    if (_qunitGlobal) {
      qunitGlobal = _qunitGlobal;
    }

    var originalModule = qunitGlobal.module;

    qunitGlobal.module = function (name, _options) {
      var options = _options || {};
      var originalSetup = options.setup || function () {};
      var originalTeardown = options.teardown || function () {};

      options.setup = function () {
        assertion.reset();
        assertion.inject();

        originalSetup.call(this);
      };

      options.teardown = function () {
        originalTeardown.call(this);

        assertion.assert();
        assertion.restore();
      };

      return originalModule(name, options);
    };
  }
});
enifed('ember-dev/test-helper/utils', ['exports'], function (exports) {
  'use strict';

  exports.buildCompositeAssert = buildCompositeAssert;
  function callForEach(prop, func) {
    return function () {
      for (var i = 0, l = this[prop].length; i < l; i++) {
        this[prop][i][func]();
      }
    };
  }

  function buildCompositeAssert(klasses) {
    var Composite = function (emberKlass, runningProdBuild) {
      this.asserts = [];
      for (var i = 0, l = klasses.length; i < l; i++) {
        this.asserts.push(new klasses[i]({
          Ember: emberKlass,
          runningProdBuild: runningProdBuild
        }));
      }
    };

    Composite.prototype = {
      reset: callForEach('asserts', 'reset'),
      inject: callForEach('asserts', 'inject'),
      assert: callForEach('asserts', 'assert'),
      restore: callForEach('asserts', 'restore')
    };

    return Composite;
  }

  var o_create = Object.create || (function () {
    function F() {}

    return function (o) {
      if (arguments.length !== 1) {
        throw new Error('Object.create implementation only accepts one parameter.');
      }
      F.prototype = o;
      return new F();
    };
  })();

  var o_create;
  exports.o_create = o_create;
});
enifed('ember-extension-support.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - .');
  test('ember-extension-support.js should pass jscs', function () {
    ok(true, 'ember-extension-support.js should pass jscs.');
  });
});
enifed('ember-extension-support.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - .');
  QUnit.test('ember-extension-support.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-extension-support.js should pass jshint.');
  });
});
enifed('ember-extension-support/container_debug_adapter.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-extension-support');
  test('ember-extension-support/container_debug_adapter.js should pass jscs', function () {
    ok(true, 'ember-extension-support/container_debug_adapter.js should pass jscs.');
  });
});
enifed('ember-extension-support/container_debug_adapter.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-extension-support');
  QUnit.test('ember-extension-support/container_debug_adapter.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-extension-support/container_debug_adapter.js should pass jshint.');
  });
});
enifed('ember-extension-support/data_adapter.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-extension-support');
  test('ember-extension-support/data_adapter.js should pass jscs', function () {
    ok(true, 'ember-extension-support/data_adapter.js should pass jscs.');
  });
});
enifed('ember-extension-support/data_adapter.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-extension-support');
  QUnit.test('ember-extension-support/data_adapter.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-extension-support/data_adapter.js should pass jshint.');
  });
});
enifed('ember-extension-support/tests/container_debug_adapter_test', ['exports', 'ember-metal/run_loop', 'ember-runtime/controllers/controller', 'ember-extension-support', 'ember-application/system/application'], function (exports, _emberMetalRun_loop, _emberRuntimeControllersController, _emberExtensionSupport, _emberApplicationSystemApplication) {
  'use strict';

  var adapter, App;

  function boot() {
    _emberMetalRun_loop.default(App, 'advanceReadiness');
  }

  QUnit.module('Container Debug Adapter', {
    setup: function () {
      _emberMetalRun_loop.default(function () {
        App = _emberApplicationSystemApplication.default.create(); // ES6TODO: this comes from the ember-application package NOT ember-runtime
        App.toString = function () {
          return 'App';
        };
        App.deferReadiness();
      });
      boot();
      _emberMetalRun_loop.default(function () {
        adapter = App.__container__.lookup('container-debug-adapter:main');
      });
    },
    teardown: function () {
      _emberMetalRun_loop.default(function () {
        adapter.destroy();
        App.destroy();
        App = null;
      });
    }
  });

  QUnit.test('the default ContainerDebugAdapter cannot catalog certain entries by type', function () {
    equal(adapter.canCatalogEntriesByType('model'), false, 'canCatalogEntriesByType should return false for model');
    equal(adapter.canCatalogEntriesByType('template'), false, 'canCatalogEntriesByType should return false for template');
  });

  QUnit.test('the default ContainerDebugAdapter can catalog typical entries by type', function () {
    equal(adapter.canCatalogEntriesByType('controller'), true, 'canCatalogEntriesByType should return true for controller');
    equal(adapter.canCatalogEntriesByType('route'), true, 'canCatalogEntriesByType should return true for route');
    equal(adapter.canCatalogEntriesByType('view'), true, 'canCatalogEntriesByType should return true for view');
  });

  QUnit.test('the default ContainerDebugAdapter catalogs controller entries', function () {
    App.PostController = _emberRuntimeControllersController.default.extend();
    var controllerClasses = adapter.catalogEntriesByType('controller');

    equal(controllerClasses.length, 1, 'found 1 class');
    equal(controllerClasses[0], 'post', 'found the right class');
  });
});
// Must be required to export Ember.ContainerDebugAdapter
enifed('ember-extension-support/tests/container_debug_adapter_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-extension-support/tests');
  test('ember-extension-support/tests/container_debug_adapter_test.js should pass jscs', function () {
    ok(true, 'ember-extension-support/tests/container_debug_adapter_test.js should pass jscs.');
  });
});
enifed('ember-extension-support/tests/container_debug_adapter_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-extension-support/tests');
  QUnit.test('ember-extension-support/tests/container_debug_adapter_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-extension-support/tests/container_debug_adapter_test.js should pass jshint.');
  });
});
enifed('ember-extension-support/tests/data_adapter_test', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/run_loop', 'ember-metal/observer', 'ember-runtime/system/object', 'ember-extension-support/data_adapter', 'ember-application/system/application', 'ember-application/system/resolver'], function (exports, _emberMetalCore, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalRun_loop, _emberMetalObserver, _emberRuntimeSystemObject, _emberExtensionSupportData_adapter, _emberApplicationSystemApplication, _emberApplicationSystemResolver) {
  'use strict';

  var adapter, App;
  var Model = _emberRuntimeSystemObject.default.extend();

  var DataAdapter = _emberExtensionSupportData_adapter.default.extend({
    detect: function (klass) {
      return klass !== Model && Model.detect(klass);
    }
  });

  QUnit.module('Data Adapter', {
    setup: function () {
      _emberMetalRun_loop.default(function () {
        App = _emberApplicationSystemApplication.default.create();
        App.toString = function () {
          return 'App';
        };
        App.deferReadiness();
        App.registry.register('data-adapter:main', DataAdapter);
      });
    },
    teardown: function () {
      _emberMetalRun_loop.default(function () {
        adapter.destroy();
        App.destroy();
      });
    }
  });

  QUnit.test('Model types added with DefaultResolver', function () {
    App.Post = Model.extend();

    adapter = App.__container__.lookup('data-adapter:main');
    adapter.reopen({
      getRecords: function () {
        return _emberMetalCore.default.A([1, 2, 3]);
      },
      columnsForType: function () {
        return [{ name: 'title', desc: 'Title' }];
      }
    });

    _emberMetalRun_loop.default(App, 'advanceReadiness');

    var modelTypesAdded = function (types) {

      equal(types.length, 1);
      var postType = types[0];
      equal(postType.name, 'post', 'Correctly sets the name');
      equal(postType.count, 3, 'Correctly sets the record count');
      strictEqual(postType.object, App.Post, 'Correctly sets the object');
      deepEqual(postType.columns, [{ name: 'title', desc: 'Title' }], 'Correctly sets the columns');
    };

    adapter.watchModelTypes(modelTypesAdded);
  });

  QUnit.test('getRecords gets a model name as second argument', function () {
    App.Post = Model.extend();

    adapter = App.__container__.lookup('data-adapter:main');
    adapter.reopen({
      getRecords: function (klass, name) {
        equal(name, 'post');
        return _emberMetalCore.default.A([]);
      }
    });

    adapter.watchModelTypes(function () {});
  });

  QUnit.test('Model types added with custom container-debug-adapter', function () {
    var PostClass = Model.extend();
    var StubContainerDebugAdapter = _emberApplicationSystemResolver.default.extend({
      canCatalogEntriesByType: function (type) {
        return true;
      },
      catalogEntriesByType: function (type) {
        return [PostClass];
      }
    });
    App.registry.register('container-debug-adapter:main', StubContainerDebugAdapter);

    adapter = App.__container__.lookup('data-adapter:main');
    adapter.reopen({
      getRecords: function () {
        return _emberMetalCore.default.A([1, 2, 3]);
      },
      columnsForType: function () {
        return [{ name: 'title', desc: 'Title' }];
      }
    });

    _emberMetalRun_loop.default(App, 'advanceReadiness');

    var modelTypesAdded = function (types) {

      equal(types.length, 1);
      var postType = types[0];

      equal(postType.name, PostClass.toString(), 'Correctly sets the name');
      equal(postType.count, 3, 'Correctly sets the record count');
      strictEqual(postType.object, PostClass, 'Correctly sets the object');
      deepEqual(postType.columns, [{ name: 'title', desc: 'Title' }], 'Correctly sets the columns');
    };

    adapter.watchModelTypes(modelTypesAdded);
  });

  QUnit.test('Model Types Updated', function () {
    App.Post = Model.extend();

    adapter = App.__container__.lookup('data-adapter:main');
    var records = _emberMetalCore.default.A([1, 2, 3]);
    adapter.reopen({
      getRecords: function () {
        return records;
      }
    });

    _emberMetalRun_loop.default(App, 'advanceReadiness');

    var modelTypesAdded = function () {
      _emberMetalRun_loop.default(function () {
        records.pushObject(4);
      });
    };

    var modelTypesUpdated = function (types) {

      var postType = types[0];
      equal(postType.count, 4, 'Correctly updates the count');
    };

    adapter.watchModelTypes(modelTypesAdded, modelTypesUpdated);
  });

  QUnit.test('Records Added', function () {
    expect(8);
    var countAdded = 1;

    App.Post = Model.extend();

    var post = App.Post.create();
    var recordList = _emberMetalCore.default.A([post]);

    adapter = App.__container__.lookup('data-adapter:main');
    adapter.reopen({
      getRecords: function () {
        return recordList;
      },
      getRecordColor: function () {
        return 'blue';
      },
      getRecordColumnValues: function () {
        return { title: 'Post ' + countAdded };
      },
      getRecordKeywords: function () {
        return ['Post ' + countAdded];
      }
    });

    var recordsAdded = function (records) {
      var record = records[0];
      equal(record.color, 'blue', 'Sets the color correctly');
      deepEqual(record.columnValues, { title: 'Post ' + countAdded }, 'Sets the column values correctly');
      deepEqual(record.searchKeywords, ['Post ' + countAdded], 'Sets search keywords correctly');
      strictEqual(record.object, post, 'Sets the object to the record instance');
    };

    adapter.watchRecords(App.Post, recordsAdded);
    countAdded++;
    post = App.Post.create();
    recordList.pushObject(post);
  });

  QUnit.test('Observes and releases a record correctly', function () {
    var updatesCalled = 0;
    App.Post = Model.extend();

    var post = App.Post.create({ title: 'Post' });
    var recordList = _emberMetalCore.default.A([post]);

    adapter = App.__container__.lookup('data-adapter:main');
    adapter.reopen({
      getRecords: function () {
        return recordList;
      },
      observeRecord: function (record, recordUpdated) {
        var self = this;
        var callback = function () {
          recordUpdated(self.wrapRecord(record));
        };
        _emberMetalObserver.addObserver(record, 'title', callback);
        return function () {
          _emberMetalObserver.removeObserver(record, 'title', callback);
        };
      },
      getRecordColumnValues: function (record) {
        return { title: _emberMetalProperty_get.get(record, 'title') };
      }
    });

    var recordsAdded = function () {
      _emberMetalProperty_set.set(post, 'title', 'Post Modified');
    };

    var recordsUpdated = function (records) {
      updatesCalled++;
      equal(records[0].columnValues.title, 'Post Modified');
    };

    var release = adapter.watchRecords(App.Post, recordsAdded, recordsUpdated);
    release();
    _emberMetalProperty_set.set(post, 'title', 'New Title');
    equal(updatesCalled, 1, 'Release function removes observers');
  });
});
enifed('ember-extension-support/tests/data_adapter_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-extension-support/tests');
  test('ember-extension-support/tests/data_adapter_test.js should pass jscs', function () {
    ok(true, 'ember-extension-support/tests/data_adapter_test.js should pass jscs.');
  });
});
enifed('ember-extension-support/tests/data_adapter_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-extension-support/tests');
  QUnit.test('ember-extension-support/tests/data_adapter_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-extension-support/tests/data_adapter_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - .');
  test('ember-htmlbars.js should pass jscs', function () {
    ok(true, 'ember-htmlbars.js should pass jscs.');
  });
});
enifed('ember-htmlbars.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - .');
  QUnit.test('ember-htmlbars.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars.js should pass jshint.');
  });
});
enifed('ember-htmlbars/compat.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars');
  test('ember-htmlbars/compat.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/compat.js should pass jscs.');
  });
});
enifed('ember-htmlbars/compat.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars');
  QUnit.test('ember-htmlbars/compat.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/compat.js should pass jshint.');
  });
});
enifed('ember-htmlbars/env.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars');
  test('ember-htmlbars/env.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/env.js should pass jscs.');
  });
});
enifed('ember-htmlbars/env.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars');
  QUnit.test('ember-htmlbars/env.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/env.js should pass jshint.');
  });
});
enifed('ember-htmlbars/helper.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars');
  test('ember-htmlbars/helper.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/helper.js should pass jscs.');
  });
});
enifed('ember-htmlbars/helper.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars');
  QUnit.test('ember-htmlbars/helper.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/helper.js should pass jshint.');
  });
});
enifed('ember-htmlbars/helpers.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars');
  test('ember-htmlbars/helpers.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/helpers.js should pass jscs.');
  });
});
enifed('ember-htmlbars/helpers.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars');
  QUnit.test('ember-htmlbars/helpers.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/helpers.js should pass jshint.');
  });
});
enifed('ember-htmlbars/helpers/-concat.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/helpers');
  test('ember-htmlbars/helpers/-concat.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/helpers/-concat.js should pass jscs.');
  });
});
enifed('ember-htmlbars/helpers/-concat.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/helpers');
  QUnit.test('ember-htmlbars/helpers/-concat.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/helpers/-concat.js should pass jshint.');
  });
});
enifed('ember-htmlbars/helpers/-html-safe.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/helpers');
  test('ember-htmlbars/helpers/-html-safe.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/helpers/-html-safe.js should pass jscs.');
  });
});
enifed('ember-htmlbars/helpers/-html-safe.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/helpers');
  QUnit.test('ember-htmlbars/helpers/-html-safe.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/helpers/-html-safe.js should pass jshint.');
  });
});
enifed('ember-htmlbars/helpers/-join-classes.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/helpers');
  test('ember-htmlbars/helpers/-join-classes.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/helpers/-join-classes.js should pass jscs.');
  });
});
enifed('ember-htmlbars/helpers/-join-classes.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/helpers');
  QUnit.test('ember-htmlbars/helpers/-join-classes.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/helpers/-join-classes.js should pass jshint.');
  });
});
enifed('ember-htmlbars/helpers/-legacy-each-with-controller.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/helpers');
  test('ember-htmlbars/helpers/-legacy-each-with-controller.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/helpers/-legacy-each-with-controller.js should pass jscs.');
  });
});
enifed('ember-htmlbars/helpers/-legacy-each-with-controller.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/helpers');
  QUnit.test('ember-htmlbars/helpers/-legacy-each-with-controller.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/helpers/-legacy-each-with-controller.js should pass jshint.');
  });
});
enifed('ember-htmlbars/helpers/-legacy-each-with-keyword.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/helpers');
  test('ember-htmlbars/helpers/-legacy-each-with-keyword.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/helpers/-legacy-each-with-keyword.js should pass jscs.');
  });
});
enifed('ember-htmlbars/helpers/-legacy-each-with-keyword.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/helpers');
  QUnit.test('ember-htmlbars/helpers/-legacy-each-with-keyword.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/helpers/-legacy-each-with-keyword.js should pass jshint.');
  });
});
enifed('ember-htmlbars/helpers/-normalize-class.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/helpers');
  test('ember-htmlbars/helpers/-normalize-class.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/helpers/-normalize-class.js should pass jscs.');
  });
});
enifed('ember-htmlbars/helpers/-normalize-class.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/helpers');
  QUnit.test('ember-htmlbars/helpers/-normalize-class.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/helpers/-normalize-class.js should pass jshint.');
  });
});
enifed('ember-htmlbars/helpers/each-in.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/helpers');
  test('ember-htmlbars/helpers/each-in.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/helpers/each-in.js should pass jscs.');
  });
});
enifed('ember-htmlbars/helpers/each-in.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/helpers');
  QUnit.test('ember-htmlbars/helpers/each-in.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/helpers/each-in.js should pass jshint.');
  });
});
enifed('ember-htmlbars/helpers/each.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/helpers');
  test('ember-htmlbars/helpers/each.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/helpers/each.js should pass jscs.');
  });
});
enifed('ember-htmlbars/helpers/each.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/helpers');
  QUnit.test('ember-htmlbars/helpers/each.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/helpers/each.js should pass jshint.');
  });
});
enifed('ember-htmlbars/helpers/if_unless.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/helpers');
  test('ember-htmlbars/helpers/if_unless.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/helpers/if_unless.js should pass jscs.');
  });
});
enifed('ember-htmlbars/helpers/if_unless.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/helpers');
  QUnit.test('ember-htmlbars/helpers/if_unless.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/helpers/if_unless.js should pass jshint.');
  });
});
enifed('ember-htmlbars/helpers/loc.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/helpers');
  test('ember-htmlbars/helpers/loc.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/helpers/loc.js should pass jscs.');
  });
});
enifed('ember-htmlbars/helpers/loc.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/helpers');
  QUnit.test('ember-htmlbars/helpers/loc.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/helpers/loc.js should pass jshint.');
  });
});
enifed('ember-htmlbars/helpers/log.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/helpers');
  test('ember-htmlbars/helpers/log.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/helpers/log.js should pass jscs.');
  });
});
enifed('ember-htmlbars/helpers/log.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/helpers');
  QUnit.test('ember-htmlbars/helpers/log.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/helpers/log.js should pass jshint.');
  });
});
enifed('ember-htmlbars/helpers/with.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/helpers');
  test('ember-htmlbars/helpers/with.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/helpers/with.js should pass jscs.');
  });
});
enifed('ember-htmlbars/helpers/with.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/helpers');
  QUnit.test('ember-htmlbars/helpers/with.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/helpers/with.js should pass jshint.');
  });
});
enifed('ember-htmlbars/hooks/bind-local.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/hooks');
  test('ember-htmlbars/hooks/bind-local.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/hooks/bind-local.js should pass jscs.');
  });
});
enifed('ember-htmlbars/hooks/bind-local.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/hooks');
  QUnit.test('ember-htmlbars/hooks/bind-local.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/hooks/bind-local.js should pass jshint.');
  });
});
enifed('ember-htmlbars/hooks/bind-scope.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/hooks');
  test('ember-htmlbars/hooks/bind-scope.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/hooks/bind-scope.js should pass jscs.');
  });
});
enifed('ember-htmlbars/hooks/bind-scope.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/hooks');
  QUnit.test('ember-htmlbars/hooks/bind-scope.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/hooks/bind-scope.js should pass jshint.');
  });
});
enifed('ember-htmlbars/hooks/bind-self.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/hooks');
  test('ember-htmlbars/hooks/bind-self.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/hooks/bind-self.js should pass jscs.');
  });
});
enifed('ember-htmlbars/hooks/bind-self.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/hooks');
  QUnit.test('ember-htmlbars/hooks/bind-self.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/hooks/bind-self.js should pass jshint.');
  });
});
enifed('ember-htmlbars/hooks/bind-shadow-scope.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/hooks');
  test('ember-htmlbars/hooks/bind-shadow-scope.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/hooks/bind-shadow-scope.js should pass jscs.');
  });
});
enifed('ember-htmlbars/hooks/bind-shadow-scope.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/hooks');
  QUnit.test('ember-htmlbars/hooks/bind-shadow-scope.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/hooks/bind-shadow-scope.js should pass jshint.');
  });
});
enifed('ember-htmlbars/hooks/classify.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/hooks');
  test('ember-htmlbars/hooks/classify.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/hooks/classify.js should pass jscs.');
  });
});
enifed('ember-htmlbars/hooks/classify.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/hooks');
  QUnit.test('ember-htmlbars/hooks/classify.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/hooks/classify.js should pass jshint.');
  });
});
enifed('ember-htmlbars/hooks/cleanup-render-node.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/hooks');
  test('ember-htmlbars/hooks/cleanup-render-node.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/hooks/cleanup-render-node.js should pass jscs.');
  });
});
enifed('ember-htmlbars/hooks/cleanup-render-node.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/hooks');
  QUnit.test('ember-htmlbars/hooks/cleanup-render-node.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/hooks/cleanup-render-node.js should pass jshint.');
  });
});
enifed('ember-htmlbars/hooks/component.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/hooks');
  test('ember-htmlbars/hooks/component.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/hooks/component.js should pass jscs.');
  });
});
enifed('ember-htmlbars/hooks/component.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/hooks');
  QUnit.test('ember-htmlbars/hooks/component.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/hooks/component.js should pass jshint.');
  });
});
enifed('ember-htmlbars/hooks/concat.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/hooks');
  test('ember-htmlbars/hooks/concat.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/hooks/concat.js should pass jscs.');
  });
});
enifed('ember-htmlbars/hooks/concat.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/hooks');
  QUnit.test('ember-htmlbars/hooks/concat.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/hooks/concat.js should pass jshint.');
  });
});
enifed('ember-htmlbars/hooks/create-fresh-scope.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/hooks');
  test('ember-htmlbars/hooks/create-fresh-scope.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/hooks/create-fresh-scope.js should pass jscs.');
  });
});
enifed('ember-htmlbars/hooks/create-fresh-scope.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/hooks');
  QUnit.test('ember-htmlbars/hooks/create-fresh-scope.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/hooks/create-fresh-scope.js should pass jshint.');
  });
});
enifed('ember-htmlbars/hooks/destroy-render-node.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/hooks');
  test('ember-htmlbars/hooks/destroy-render-node.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/hooks/destroy-render-node.js should pass jscs.');
  });
});
enifed('ember-htmlbars/hooks/destroy-render-node.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/hooks');
  QUnit.test('ember-htmlbars/hooks/destroy-render-node.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/hooks/destroy-render-node.js should pass jshint.');
  });
});
enifed('ember-htmlbars/hooks/did-cleanup-tree.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/hooks');
  test('ember-htmlbars/hooks/did-cleanup-tree.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/hooks/did-cleanup-tree.js should pass jscs.');
  });
});
enifed('ember-htmlbars/hooks/did-cleanup-tree.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/hooks');
  QUnit.test('ember-htmlbars/hooks/did-cleanup-tree.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/hooks/did-cleanup-tree.js should pass jshint.');
  });
});
enifed('ember-htmlbars/hooks/did-render-node.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/hooks');
  test('ember-htmlbars/hooks/did-render-node.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/hooks/did-render-node.js should pass jscs.');
  });
});
enifed('ember-htmlbars/hooks/did-render-node.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/hooks');
  QUnit.test('ember-htmlbars/hooks/did-render-node.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/hooks/did-render-node.js should pass jshint.');
  });
});
enifed('ember-htmlbars/hooks/element.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/hooks');
  test('ember-htmlbars/hooks/element.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/hooks/element.js should pass jscs.');
  });
});
enifed('ember-htmlbars/hooks/element.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/hooks');
  QUnit.test('ember-htmlbars/hooks/element.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/hooks/element.js should pass jshint.');
  });
});
enifed('ember-htmlbars/hooks/get-cell-or-value.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/hooks');
  test('ember-htmlbars/hooks/get-cell-or-value.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/hooks/get-cell-or-value.js should pass jscs.');
  });
});
enifed('ember-htmlbars/hooks/get-cell-or-value.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/hooks');
  QUnit.test('ember-htmlbars/hooks/get-cell-or-value.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/hooks/get-cell-or-value.js should pass jshint.');
  });
});
enifed('ember-htmlbars/hooks/get-child.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/hooks');
  test('ember-htmlbars/hooks/get-child.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/hooks/get-child.js should pass jscs.');
  });
});
enifed('ember-htmlbars/hooks/get-child.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/hooks');
  QUnit.test('ember-htmlbars/hooks/get-child.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/hooks/get-child.js should pass jshint.');
  });
});
enifed('ember-htmlbars/hooks/get-root.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/hooks');
  test('ember-htmlbars/hooks/get-root.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/hooks/get-root.js should pass jscs.');
  });
});
enifed('ember-htmlbars/hooks/get-root.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/hooks');
  QUnit.test('ember-htmlbars/hooks/get-root.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/hooks/get-root.js should pass jshint.');
  });
});
enifed('ember-htmlbars/hooks/get-value.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/hooks');
  test('ember-htmlbars/hooks/get-value.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/hooks/get-value.js should pass jscs.');
  });
});
enifed('ember-htmlbars/hooks/get-value.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/hooks');
  QUnit.test('ember-htmlbars/hooks/get-value.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/hooks/get-value.js should pass jshint.');
  });
});
enifed('ember-htmlbars/hooks/has-helper.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/hooks');
  test('ember-htmlbars/hooks/has-helper.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/hooks/has-helper.js should pass jscs.');
  });
});
enifed('ember-htmlbars/hooks/has-helper.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/hooks');
  QUnit.test('ember-htmlbars/hooks/has-helper.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/hooks/has-helper.js should pass jshint.');
  });
});
enifed('ember-htmlbars/hooks/invoke-helper.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/hooks');
  test('ember-htmlbars/hooks/invoke-helper.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/hooks/invoke-helper.js should pass jscs.');
  });
});
enifed('ember-htmlbars/hooks/invoke-helper.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/hooks');
  QUnit.test('ember-htmlbars/hooks/invoke-helper.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/hooks/invoke-helper.js should pass jshint.');
  });
});
enifed('ember-htmlbars/hooks/link-render-node.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/hooks');
  test('ember-htmlbars/hooks/link-render-node.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/hooks/link-render-node.js should pass jscs.');
  });
});
enifed('ember-htmlbars/hooks/link-render-node.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/hooks');
  QUnit.test('ember-htmlbars/hooks/link-render-node.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/hooks/link-render-node.js should pass jshint.');
  });
});
enifed('ember-htmlbars/hooks/lookup-helper.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/hooks');
  test('ember-htmlbars/hooks/lookup-helper.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/hooks/lookup-helper.js should pass jscs.');
  });
});
enifed('ember-htmlbars/hooks/lookup-helper.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/hooks');
  QUnit.test('ember-htmlbars/hooks/lookup-helper.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/hooks/lookup-helper.js should pass jshint.');
  });
});
enifed('ember-htmlbars/hooks/subexpr.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/hooks');
  test('ember-htmlbars/hooks/subexpr.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/hooks/subexpr.js should pass jscs.');
  });
});
enifed('ember-htmlbars/hooks/subexpr.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/hooks');
  QUnit.test('ember-htmlbars/hooks/subexpr.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/hooks/subexpr.js should pass jshint.');
  });
});
enifed('ember-htmlbars/hooks/update-self.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/hooks');
  test('ember-htmlbars/hooks/update-self.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/hooks/update-self.js should pass jscs.');
  });
});
enifed('ember-htmlbars/hooks/update-self.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/hooks');
  QUnit.test('ember-htmlbars/hooks/update-self.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/hooks/update-self.js should pass jshint.');
  });
});
enifed('ember-htmlbars/hooks/will-cleanup-tree.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/hooks');
  test('ember-htmlbars/hooks/will-cleanup-tree.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/hooks/will-cleanup-tree.js should pass jscs.');
  });
});
enifed('ember-htmlbars/hooks/will-cleanup-tree.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/hooks');
  QUnit.test('ember-htmlbars/hooks/will-cleanup-tree.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/hooks/will-cleanup-tree.js should pass jshint.');
  });
});
enifed('ember-htmlbars/keywords.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars');
  test('ember-htmlbars/keywords.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/keywords.js should pass jscs.');
  });
});
enifed('ember-htmlbars/keywords.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars');
  QUnit.test('ember-htmlbars/keywords.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/keywords.js should pass jshint.');
  });
});
enifed('ember-htmlbars/keywords/collection.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/keywords');
  test('ember-htmlbars/keywords/collection.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/keywords/collection.js should pass jscs.');
  });
});
enifed('ember-htmlbars/keywords/collection.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/keywords');
  QUnit.test('ember-htmlbars/keywords/collection.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/keywords/collection.js should pass jshint.');
  });
});
enifed('ember-htmlbars/keywords/component.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/keywords');
  test('ember-htmlbars/keywords/component.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/keywords/component.js should pass jscs.');
  });
});
enifed('ember-htmlbars/keywords/component.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/keywords');
  QUnit.test('ember-htmlbars/keywords/component.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/keywords/component.js should pass jshint.');
  });
});
enifed('ember-htmlbars/keywords/debugger.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/keywords');
  test('ember-htmlbars/keywords/debugger.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/keywords/debugger.js should pass jscs.');
  });
});
enifed('ember-htmlbars/keywords/debugger.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/keywords');
  QUnit.test('ember-htmlbars/keywords/debugger.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/keywords/debugger.js should pass jshint.');
  });
});
enifed('ember-htmlbars/keywords/each.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/keywords');
  test('ember-htmlbars/keywords/each.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/keywords/each.js should pass jscs.');
  });
});
enifed('ember-htmlbars/keywords/each.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/keywords');
  QUnit.test('ember-htmlbars/keywords/each.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/keywords/each.js should pass jshint.');
  });
});
enifed('ember-htmlbars/keywords/get.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/keywords');
  test('ember-htmlbars/keywords/get.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/keywords/get.js should pass jscs.');
  });
});
enifed('ember-htmlbars/keywords/get.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/keywords');
  QUnit.test('ember-htmlbars/keywords/get.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/keywords/get.js should pass jshint.');
  });
});
enifed('ember-htmlbars/keywords/input.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/keywords');
  test('ember-htmlbars/keywords/input.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/keywords/input.js should pass jscs.');
  });
});
enifed('ember-htmlbars/keywords/input.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/keywords');
  QUnit.test('ember-htmlbars/keywords/input.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/keywords/input.js should pass jshint.');
  });
});
enifed('ember-htmlbars/keywords/legacy-yield.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/keywords');
  test('ember-htmlbars/keywords/legacy-yield.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/keywords/legacy-yield.js should pass jscs.');
  });
});
enifed('ember-htmlbars/keywords/legacy-yield.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/keywords');
  QUnit.test('ember-htmlbars/keywords/legacy-yield.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/keywords/legacy-yield.js should pass jshint.');
  });
});
enifed('ember-htmlbars/keywords/mut.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/keywords');
  test('ember-htmlbars/keywords/mut.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/keywords/mut.js should pass jscs.');
  });
});
enifed('ember-htmlbars/keywords/mut.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/keywords');
  QUnit.test('ember-htmlbars/keywords/mut.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/keywords/mut.js should pass jshint.');
  });
});
enifed('ember-htmlbars/keywords/outlet.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/keywords');
  test('ember-htmlbars/keywords/outlet.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/keywords/outlet.js should pass jscs.');
  });
});
enifed('ember-htmlbars/keywords/outlet.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/keywords');
  QUnit.test('ember-htmlbars/keywords/outlet.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/keywords/outlet.js should pass jshint.');
  });
});
enifed('ember-htmlbars/keywords/partial.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/keywords');
  test('ember-htmlbars/keywords/partial.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/keywords/partial.js should pass jscs.');
  });
});
enifed('ember-htmlbars/keywords/partial.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/keywords');
  QUnit.test('ember-htmlbars/keywords/partial.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/keywords/partial.js should pass jshint.');
  });
});
enifed('ember-htmlbars/keywords/readonly.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/keywords');
  test('ember-htmlbars/keywords/readonly.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/keywords/readonly.js should pass jscs.');
  });
});
enifed('ember-htmlbars/keywords/readonly.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/keywords');
  QUnit.test('ember-htmlbars/keywords/readonly.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/keywords/readonly.js should pass jshint.');
  });
});
enifed('ember-htmlbars/keywords/textarea.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/keywords');
  test('ember-htmlbars/keywords/textarea.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/keywords/textarea.js should pass jscs.');
  });
});
enifed('ember-htmlbars/keywords/textarea.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/keywords');
  QUnit.test('ember-htmlbars/keywords/textarea.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/keywords/textarea.js should pass jshint.');
  });
});
enifed('ember-htmlbars/keywords/unbound.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/keywords');
  test('ember-htmlbars/keywords/unbound.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/keywords/unbound.js should pass jscs.');
  });
});
enifed('ember-htmlbars/keywords/unbound.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/keywords');
  QUnit.test('ember-htmlbars/keywords/unbound.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/keywords/unbound.js should pass jshint.');
  });
});
enifed('ember-htmlbars/keywords/view.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/keywords');
  test('ember-htmlbars/keywords/view.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/keywords/view.js should pass jscs.');
  });
});
enifed('ember-htmlbars/keywords/view.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/keywords');
  QUnit.test('ember-htmlbars/keywords/view.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/keywords/view.js should pass jshint.');
  });
});
enifed('ember-htmlbars/keywords/with.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/keywords');
  test('ember-htmlbars/keywords/with.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/keywords/with.js should pass jscs.');
  });
});
enifed('ember-htmlbars/keywords/with.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/keywords');
  QUnit.test('ember-htmlbars/keywords/with.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/keywords/with.js should pass jshint.');
  });
});
enifed('ember-htmlbars/morphs/attr-morph.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/morphs');
  test('ember-htmlbars/morphs/attr-morph.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/morphs/attr-morph.js should pass jscs.');
  });
});
enifed('ember-htmlbars/morphs/attr-morph.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/morphs');
  QUnit.test('ember-htmlbars/morphs/attr-morph.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/morphs/attr-morph.js should pass jshint.');
  });
});
enifed('ember-htmlbars/morphs/morph.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/morphs');
  test('ember-htmlbars/morphs/morph.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/morphs/morph.js should pass jscs.');
  });
});
enifed('ember-htmlbars/morphs/morph.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/morphs');
  QUnit.test('ember-htmlbars/morphs/morph.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/morphs/morph.js should pass jshint.');
  });
});
enifed('ember-htmlbars/node-managers/component-node-manager.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/node-managers');
  test('ember-htmlbars/node-managers/component-node-manager.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/node-managers/component-node-manager.js should pass jscs.');
  });
});
enifed('ember-htmlbars/node-managers/component-node-manager.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/node-managers');
  QUnit.test('ember-htmlbars/node-managers/component-node-manager.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/node-managers/component-node-manager.js should pass jshint.');
  });
});
enifed('ember-htmlbars/node-managers/view-node-manager.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/node-managers');
  test('ember-htmlbars/node-managers/view-node-manager.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/node-managers/view-node-manager.js should pass jscs.');
  });
});
enifed('ember-htmlbars/node-managers/view-node-manager.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/node-managers');
  QUnit.test('ember-htmlbars/node-managers/view-node-manager.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/node-managers/view-node-manager.js should pass jshint.');
  });
});
enifed('ember-htmlbars/streams/built-in-helper.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/streams');
  test('ember-htmlbars/streams/built-in-helper.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/streams/built-in-helper.js should pass jscs.');
  });
});
enifed('ember-htmlbars/streams/built-in-helper.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/streams');
  QUnit.test('ember-htmlbars/streams/built-in-helper.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/streams/built-in-helper.js should pass jshint.');
  });
});
enifed('ember-htmlbars/streams/helper-factory.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/streams');
  test('ember-htmlbars/streams/helper-factory.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/streams/helper-factory.js should pass jscs.');
  });
});
enifed('ember-htmlbars/streams/helper-factory.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/streams');
  QUnit.test('ember-htmlbars/streams/helper-factory.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/streams/helper-factory.js should pass jshint.');
  });
});
enifed('ember-htmlbars/streams/helper-instance.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/streams');
  test('ember-htmlbars/streams/helper-instance.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/streams/helper-instance.js should pass jscs.');
  });
});
enifed('ember-htmlbars/streams/helper-instance.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/streams');
  QUnit.test('ember-htmlbars/streams/helper-instance.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/streams/helper-instance.js should pass jshint.');
  });
});
enifed('ember-htmlbars/streams/utils.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/streams');
  test('ember-htmlbars/streams/utils.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/streams/utils.js should pass jscs.');
  });
});
enifed('ember-htmlbars/streams/utils.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/streams');
  QUnit.test('ember-htmlbars/streams/utils.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/streams/utils.js should pass jshint.');
  });
});
enifed('ember-htmlbars/system/append-templated-view.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/system');
  test('ember-htmlbars/system/append-templated-view.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/system/append-templated-view.js should pass jscs.');
  });
});
enifed('ember-htmlbars/system/append-templated-view.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/system');
  QUnit.test('ember-htmlbars/system/append-templated-view.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/system/append-templated-view.js should pass jshint.');
  });
});
enifed('ember-htmlbars/system/bootstrap.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/system');
  test('ember-htmlbars/system/bootstrap.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/system/bootstrap.js should pass jscs.');
  });
});
enifed('ember-htmlbars/system/bootstrap.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/system');
  QUnit.test('ember-htmlbars/system/bootstrap.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/system/bootstrap.js should pass jshint.');
  });
});
enifed('ember-htmlbars/system/discover-known-helpers.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/system');
  test('ember-htmlbars/system/discover-known-helpers.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/system/discover-known-helpers.js should pass jscs.');
  });
});
enifed('ember-htmlbars/system/discover-known-helpers.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/system');
  QUnit.test('ember-htmlbars/system/discover-known-helpers.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/system/discover-known-helpers.js should pass jshint.');
  });
});
enifed('ember-htmlbars/system/dom-helper.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/system');
  test('ember-htmlbars/system/dom-helper.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/system/dom-helper.js should pass jscs.');
  });
});
enifed('ember-htmlbars/system/dom-helper.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/system');
  QUnit.test('ember-htmlbars/system/dom-helper.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/system/dom-helper.js should pass jshint.');
  });
});
enifed('ember-htmlbars/system/instrumentation-support.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/system');
  test('ember-htmlbars/system/instrumentation-support.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/system/instrumentation-support.js should pass jscs.');
  });
});
enifed('ember-htmlbars/system/instrumentation-support.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/system');
  QUnit.test('ember-htmlbars/system/instrumentation-support.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/system/instrumentation-support.js should pass jshint.');
  });
});
enifed('ember-htmlbars/system/invoke-helper.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/system');
  test('ember-htmlbars/system/invoke-helper.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/system/invoke-helper.js should pass jscs.');
  });
});
enifed('ember-htmlbars/system/invoke-helper.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/system');
  QUnit.test('ember-htmlbars/system/invoke-helper.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/system/invoke-helper.js should pass jshint.');
  });
});
enifed('ember-htmlbars/system/lookup-helper.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/system');
  test('ember-htmlbars/system/lookup-helper.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/system/lookup-helper.js should pass jscs.');
  });
});
enifed('ember-htmlbars/system/lookup-helper.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/system');
  QUnit.test('ember-htmlbars/system/lookup-helper.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/system/lookup-helper.js should pass jshint.');
  });
});
enifed('ember-htmlbars/system/make_bound_helper.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/system');
  test('ember-htmlbars/system/make_bound_helper.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/system/make_bound_helper.js should pass jscs.');
  });
});
enifed('ember-htmlbars/system/make_bound_helper.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/system');
  QUnit.test('ember-htmlbars/system/make_bound_helper.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/system/make_bound_helper.js should pass jshint.');
  });
});
enifed('ember-htmlbars/system/render-env.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/system');
  test('ember-htmlbars/system/render-env.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/system/render-env.js should pass jscs.');
  });
});
enifed('ember-htmlbars/system/render-env.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/system');
  QUnit.test('ember-htmlbars/system/render-env.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/system/render-env.js should pass jshint.');
  });
});
enifed('ember-htmlbars/system/render-view.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/system');
  test('ember-htmlbars/system/render-view.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/system/render-view.js should pass jscs.');
  });
});
enifed('ember-htmlbars/system/render-view.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/system');
  QUnit.test('ember-htmlbars/system/render-view.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/system/render-view.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/attr_nodes/boolean_test', ['exports', 'ember-metal/features', 'ember-views/views/view', 'ember-metal/run_loop', 'ember-template-compiler/system/compile', 'htmlbars-test-helpers'], function (exports, _emberMetalFeatures, _emberViewsViewsView, _emberMetalRun_loop, _emberTemplateCompilerSystemCompile, _htmlbarsTestHelpers) {
  'use strict';

  var view;

  function appendView(view) {
    _emberMetalRun_loop.default(function () {
      view.appendTo('#qunit-fixture');
    });
  }

  // jscs:disable validateIndentation

  QUnit.module('ember-htmlbars: boolean attribute', {
    teardown: function () {
      if (view) {
        _emberMetalRun_loop.default(view, view.destroy);
      }
    }
  });

  QUnit.test('disabled property can be set true', function () {
    view = _emberViewsViewsView.default.create({
      context: { isDisabled: true },
      template: _emberTemplateCompilerSystemCompile.default('<input disabled={{isDisabled}}>')
    });
    appendView(view);

    equal(view.element.firstChild.hasAttribute('disabled'), true, 'attribute is output');
    equal(view.element.firstChild.disabled, true, 'boolean property is set true');
  });

  QUnit.test('disabled property can be set false with a blank string', function () {
    view = _emberViewsViewsView.default.create({
      context: { isDisabled: '' },
      template: _emberTemplateCompilerSystemCompile.default('<input disabled={{isDisabled}}>')
    });
    appendView(view);

    equal(view.element.firstChild.hasAttribute('disabled'), false, 'attribute is not output');
    equal(view.element.firstChild.disabled, false, 'boolean property is set false');
  });

  QUnit.test('disabled property can be set false', function () {
    view = _emberViewsViewsView.default.create({
      context: { isDisabled: false },
      template: _emberTemplateCompilerSystemCompile.default('<input disabled={{isDisabled}}>')
    });
    appendView(view);

    _htmlbarsTestHelpers.equalInnerHTML(view.element, '<input>', 'attribute is not output');
    equal(view.element.firstChild.disabled, false, 'boolean property is set false');
  });

  QUnit.test('disabled property can be set true with a string', function () {
    view = _emberViewsViewsView.default.create({
      context: { isDisabled: 'oh, no a string' },
      template: _emberTemplateCompilerSystemCompile.default('<input disabled={{isDisabled}}>')
    });
    appendView(view);

    equal(view.element.firstChild.hasAttribute('disabled'), true, 'attribute is output');
    equal(view.element.firstChild.disabled, true, 'boolean property is set true');
  });

  QUnit.test('disabled attribute turns a value to a string', function () {
    view = _emberViewsViewsView.default.create({
      context: { isDisabled: false },
      template: _emberTemplateCompilerSystemCompile.default('<input disabled=\'{{isDisabled}}\'>')
    });
    appendView(view);

    equal(view.element.firstChild.hasAttribute('disabled'), true, 'attribute is output');
    equal(view.element.firstChild.disabled, true, 'boolean property is set true');
  });

  QUnit.test('disabled attribute preserves a blank string value', function () {
    view = _emberViewsViewsView.default.create({
      context: { isDisabled: '' },
      template: _emberTemplateCompilerSystemCompile.default('<input disabled=\'{{isDisabled}}\'>')
    });
    appendView(view);

    _htmlbarsTestHelpers.equalInnerHTML(view.element, '<input>', 'attribute is not output');
    equal(view.element.firstChild.disabled, false, 'boolean property is set false');
  });

  // jscs:enable validateIndentation
});
enifed('ember-htmlbars/tests/attr_nodes/boolean_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/attr_nodes');
  test('ember-htmlbars/tests/attr_nodes/boolean_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/attr_nodes/boolean_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/attr_nodes/boolean_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/attr_nodes');
  QUnit.test('ember-htmlbars/tests/attr_nodes/boolean_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/attr_nodes/boolean_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/attr_nodes/class_test', ['exports', 'ember-metal/features', 'ember-views/views/view', 'ember-metal/run_loop', 'ember-template-compiler/system/compile', 'htmlbars-test-helpers'], function (exports, _emberMetalFeatures, _emberViewsViewsView, _emberMetalRun_loop, _emberTemplateCompilerSystemCompile, _htmlbarsTestHelpers) {
  'use strict';

  var view;

  function appendView(view) {
    _emberMetalRun_loop.default(function () {
      view.appendTo('#qunit-fixture');
    });
  }

  var isInlineIfEnabled = false;

  isInlineIfEnabled = true;

  // jscs:disable validateIndentation

  QUnit.module('ember-htmlbars: class attribute', {
    teardown: function () {
      if (view) {
        _emberMetalRun_loop.default(view, view.destroy);
      }
    }
  });

  QUnit.test('class renders before didInsertElement', function () {
    var matchingElement;
    view = _emberViewsViewsView.default.create({
      didInsertElement: function () {
        matchingElement = this.$('div.blue');
      },
      context: { color: 'blue' },
      template: _emberTemplateCompilerSystemCompile.default('<div class={{color}}>Hi!</div>')
    });
    appendView(view);

    equal(view.element.firstChild.className, 'blue', 'attribute is output');
    equal(matchingElement.length, 1, 'element is in the DOM when didInsertElement');
  });

  QUnit.test('class property can contain multiple classes', function () {
    view = _emberViewsViewsView.default.create({
      context: { classes: 'large blue' },
      template: _emberTemplateCompilerSystemCompile.default('<div class={{classes}}></div>')
    });
    appendView(view);

    _htmlbarsTestHelpers.equalInnerHTML(view.element, '<div class="large blue"></div>', 'attribute is output');
    ok(view.$('.large')[0], 'first class found');
    ok(view.$('.blue')[0], 'second class found');
  });

  QUnit.test('class property is removed when updated with a null value', function () {
    view = _emberViewsViewsView.default.create({
      context: { class: 'large' },
      template: _emberTemplateCompilerSystemCompile.default('<div class={{class}}></div>')
    });
    appendView(view);

    equal(view.element.firstChild.className, 'large', 'attribute is output');

    _emberMetalRun_loop.default(view, view.set, 'context.class', null);

    equal(view.element.firstChild.className, '', 'attribute is removed');
  });

  QUnit.test('class attribute concats bound values', function () {
    view = _emberViewsViewsView.default.create({
      context: { size: 'large', color: 'blue' },
      template: _emberTemplateCompilerSystemCompile.default('<div class=\'{{size}} {{color}} round\'></div>')
    });
    appendView(view);

    strictEqual(view.element.firstChild.className, 'large blue round', 'classes are set');
  });

  if (isInlineIfEnabled) {

    QUnit.test('class attribute accepts nested helpers, and updates', function () {
      view = _emberViewsViewsView.default.create({
        context: {
          size: 'large',
          hasColor: true,
          hasShape: false,
          shape: 'round'
        },
        template: _emberTemplateCompilerSystemCompile.default('<div class=\'{{if true size}} {{if hasColor \'blue\'}} {{if hasShape shape \'no-shape\'}}\'></div>')
      });
      appendView(view);

      strictEqual(view.element.firstChild.className, 'large blue no-shape', 'classes are set');

      _emberMetalRun_loop.default(view, view.set, 'context.hasColor', false);
      _emberMetalRun_loop.default(view, view.set, 'context.hasShape', true);

      strictEqual(view.element.firstChild.className, 'large  round', 'classes are updated');
    });
  }

  QUnit.test('class attribute can accept multiple classes from a single value, and update', function () {
    view = _emberViewsViewsView.default.create({
      context: {
        size: 'large small'
      },
      template: _emberTemplateCompilerSystemCompile.default('<div class=\'{{size}}\'></div>')
    });
    appendView(view);

    strictEqual(view.element.firstChild.className, 'large small', 'classes are set');

    _emberMetalRun_loop.default(view, view.set, 'context.size', 'medium');

    strictEqual(view.element.firstChild.className, 'medium', 'classes are updated');
  });

  QUnit.test('class attribute can grok concatted classes, and update', function () {
    view = _emberViewsViewsView.default.create({
      context: {
        size: 'large',
        prefix: 'pre-pre pre',
        postfix: 'post'
      },
      template: _emberTemplateCompilerSystemCompile.default('<div class=\'btn-{{size}} {{prefix}}-{{postfix}}    whoop\'></div>')
    });
    appendView(view);

    strictEqual(view.element.firstChild.className, 'btn-large pre-pre pre-post    whoop', 'classes are set');

    _emberMetalRun_loop.default(view, view.set, 'context.prefix', '');

    strictEqual(view.element.firstChild.className, 'btn-large -post    whoop', 'classes are updated');
  });

  QUnit.test('class attribute stays in order', function () {
    view = _emberViewsViewsView.default.create({
      context: {
        showA: 'a',
        showB: 'b'
      },
      template: _emberTemplateCompilerSystemCompile.default('<div class=\'r {{showB}} {{showA}} c\'></div>')
    });
    appendView(view);

    _emberMetalRun_loop.default(view, view.set, 'context.showB', false);
    _emberMetalRun_loop.default(view, view.set, 'context.showB', 'b');

    strictEqual(view.element.firstChild.className, 'r b a c', 'classes are in the right order');
  });

  // jscs:enable validateIndentation
});
enifed('ember-htmlbars/tests/attr_nodes/class_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/attr_nodes');
  test('ember-htmlbars/tests/attr_nodes/class_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/attr_nodes/class_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/attr_nodes/class_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/attr_nodes');
  QUnit.test('ember-htmlbars/tests/attr_nodes/class_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/attr_nodes/class_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/attr_nodes/data_test', ['exports', 'ember-metal/features', 'ember-views/views/view', 'ember-metal/run_loop', 'ember-runtime/system/object', 'ember-template-compiler/system/compile', 'ember-metal-views/renderer', 'htmlbars-test-helpers', 'ember-htmlbars/env', 'ember-runtime/tests/utils'], function (exports, _emberMetalFeatures, _emberViewsViewsView, _emberMetalRun_loop, _emberRuntimeSystemObject, _emberTemplateCompilerSystemCompile, _emberMetalViewsRenderer, _htmlbarsTestHelpers, _emberHtmlbarsEnv, _emberRuntimeTestsUtils) {
  'use strict';

  var view, originalSetAttribute, setAttributeCalls, renderer;

  QUnit.module('ember-htmlbars: data attribute', {
    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(view);
    }
  });

  QUnit.test('property is output', function () {
    view = _emberViewsViewsView.default.create({
      context: { name: 'erik' },
      template: _emberTemplateCompilerSystemCompile.default('<div data-name={{name}}>Hi!</div>')
    });
    _emberRuntimeTestsUtils.runAppend(view);

    _htmlbarsTestHelpers.equalInnerHTML(view.element, '<div data-name="erik">Hi!</div>', 'attribute is output');
  });

  QUnit.test('property set before didInsertElement', function () {
    var matchingElement;
    view = _emberViewsViewsView.default.create({
      didInsertElement: function () {
        matchingElement = this.$('div[data-name=erik]');
      },
      context: { name: 'erik' },
      template: _emberTemplateCompilerSystemCompile.default('<div data-name={{name}}>Hi!</div>')
    });
    _emberRuntimeTestsUtils.runAppend(view);

    _htmlbarsTestHelpers.equalInnerHTML(view.element, '<div data-name="erik">Hi!</div>', 'attribute is output');
    equal(matchingElement.length, 1, 'element is in the DOM when didInsertElement');
  });

  QUnit.test('quoted attributes are concatenated', function () {
    view = _emberViewsViewsView.default.create({
      context: { firstName: 'max', lastName: 'jackson' },
      template: _emberTemplateCompilerSystemCompile.default('<div data-name=\'{{firstName}} {{lastName}}\'>Hi!</div>')
    });
    _emberRuntimeTestsUtils.runAppend(view);

    _htmlbarsTestHelpers.equalInnerHTML(view.element, '<div data-name="max jackson">Hi!</div>', 'attribute is output');
  });

  QUnit.test('quoted attributes are updated when changed', function () {
    view = _emberViewsViewsView.default.create({
      context: { firstName: 'max', lastName: 'jackson' },
      template: _emberTemplateCompilerSystemCompile.default('<div data-name=\'{{firstName}} {{lastName}}\'>Hi!</div>')
    });
    _emberRuntimeTestsUtils.runAppend(view);

    _htmlbarsTestHelpers.equalInnerHTML(view.element, '<div data-name="max jackson">Hi!</div>', 'precond - attribute is output');

    _emberMetalRun_loop.default(view, view.set, 'context.firstName', 'james');

    _htmlbarsTestHelpers.equalInnerHTML(view.element, '<div data-name="james jackson">Hi!</div>', 'attribute is output');
  });

  QUnit.test('quoted attributes are not removed when value is null', function () {
    view = _emberViewsViewsView.default.create({
      context: { firstName: 'max', lastName: 'jackson' },
      template: _emberTemplateCompilerSystemCompile.default('<div data-name=\'{{firstName}}\'>Hi!</div>')
    });
    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.element.firstChild.getAttribute('data-name'), 'max', 'precond - attribute is output');

    _emberMetalRun_loop.default(view, view.set, 'context.firstName', null);

    equal(view.element.firstChild.getAttribute('data-name'), '', 'attribute is output');
  });

  QUnit.test('unquoted attributes are removed when value is null', function () {
    view = _emberViewsViewsView.default.create({
      context: { firstName: 'max' },
      template: _emberTemplateCompilerSystemCompile.default('<div data-name={{firstName}}>Hi!</div>')
    });
    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.element.firstChild.getAttribute('data-name'), 'max', 'precond - attribute is output');

    _emberMetalRun_loop.default(view, view.set, 'context.firstName', null);

    ok(!view.element.firstChild.hasAttribute('data-name'), 'attribute is removed output');
  });

  QUnit.test('unquoted attributes that are null are not added', function () {
    view = _emberViewsViewsView.default.create({
      context: { firstName: null },
      template: _emberTemplateCompilerSystemCompile.default('<div data-name={{firstName}}>Hi!</div>')
    });
    _emberRuntimeTestsUtils.runAppend(view);

    _htmlbarsTestHelpers.equalInnerHTML(view.element, '<div>Hi!</div>', 'attribute is not present');
  });

  QUnit.test('unquoted attributes are added when changing from null', function () {
    view = _emberViewsViewsView.default.create({
      context: { firstName: null },
      template: _emberTemplateCompilerSystemCompile.default('<div data-name={{firstName}}>Hi!</div>')
    });
    _emberRuntimeTestsUtils.runAppend(view);

    _htmlbarsTestHelpers.equalInnerHTML(view.element, '<div>Hi!</div>', 'precond - attribute is not present');

    _emberMetalRun_loop.default(view, view.set, 'context.firstName', 'max');

    _htmlbarsTestHelpers.equalInnerHTML(view.element, '<div data-name="max">Hi!</div>', 'attribute is added output');
  });

  QUnit.test('property value is directly added to attribute', function () {
    view = _emberViewsViewsView.default.create({
      context: { name: '"" data-foo="blah"' },
      template: _emberTemplateCompilerSystemCompile.default('<div data-name={{name}}>Hi!</div>')
    });
    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.element.firstChild.getAttribute('data-name'), '"" data-foo="blah"', 'attribute is output');
  });

  QUnit.test('path is output', function () {
    view = _emberViewsViewsView.default.create({
      context: { name: { firstName: 'erik' } },
      template: _emberTemplateCompilerSystemCompile.default('<div data-name={{name.firstName}}>Hi!</div>')
    });
    _emberRuntimeTestsUtils.runAppend(view);

    _htmlbarsTestHelpers.equalInnerHTML(view.element, '<div data-name="erik">Hi!</div>', 'attribute is output');
  });

  QUnit.test('changed property updates', function () {
    var context = _emberRuntimeSystemObject.default.create({ name: 'erik' });
    view = _emberViewsViewsView.default.create({
      context: context,
      template: _emberTemplateCompilerSystemCompile.default('<div data-name={{name}}>Hi!</div>')
    });
    _emberRuntimeTestsUtils.runAppend(view);

    _htmlbarsTestHelpers.equalInnerHTML(view.element, '<div data-name="erik">Hi!</div>', 'precond - attribute is output');

    _emberMetalRun_loop.default(context, context.set, 'name', 'mmun');

    _htmlbarsTestHelpers.equalInnerHTML(view.element, '<div data-name="mmun">Hi!</div>', 'attribute is updated output');
  });

  QUnit.test('updates are scheduled in the render queue', function () {
    expect(4);

    var context = _emberRuntimeSystemObject.default.create({ name: 'erik' });
    view = _emberViewsViewsView.default.create({
      context: context,
      template: _emberTemplateCompilerSystemCompile.default('<div data-name={{name}}>Hi!</div>')
    });
    _emberRuntimeTestsUtils.runAppend(view);

    _htmlbarsTestHelpers.equalInnerHTML(view.element, '<div data-name="erik">Hi!</div>', 'precond - attribute is output');

    _emberMetalRun_loop.default(function () {
      _emberMetalRun_loop.default.schedule('render', function () {
        _htmlbarsTestHelpers.equalInnerHTML(view.element, '<div data-name="erik">Hi!</div>', 'precond - attribute is not updated sync');
      });

      context.set('name', 'mmun');

      _emberMetalRun_loop.default.schedule('render', function () {
        _htmlbarsTestHelpers.equalInnerHTML(view.element, '<div data-name="mmun">Hi!</div>', 'attribute is updated output');
      });
    });

    _htmlbarsTestHelpers.equalInnerHTML(view.element, '<div data-name="mmun">Hi!</div>', 'attribute is updated output');
  });

  QUnit.test('updates fail silently after an element is destroyed', function () {
    var context = _emberRuntimeSystemObject.default.create({ name: 'erik' });
    view = _emberViewsViewsView.default.create({
      context: context,
      template: _emberTemplateCompilerSystemCompile.default('<div data-name={{name}}>Hi!</div>')
    });
    _emberRuntimeTestsUtils.runAppend(view);

    _htmlbarsTestHelpers.equalInnerHTML(view.element, '<div data-name="erik">Hi!</div>', 'precond - attribute is output');

    _emberMetalRun_loop.default(function () {
      context.set('name', 'mmun');
      _emberRuntimeTestsUtils.runDestroy(view);
    });
  });

  QUnit.module('ember-htmlbars: {{attribute}} helper -- setAttribute', {
    setup: function () {
      renderer = new _emberMetalViewsRenderer.default(_emberHtmlbarsEnv.domHelper);

      originalSetAttribute = _emberHtmlbarsEnv.domHelper.setAttribute;
      _emberHtmlbarsEnv.domHelper.setAttribute = function (element, name, value) {
        if (name.substr(0, 5) === 'data-') {
          setAttributeCalls.push([name, value]);
        }

        originalSetAttribute.call(_emberHtmlbarsEnv.domHelper, element, name, value);
      };

      setAttributeCalls = [];
    },

    teardown: function () {
      _emberHtmlbarsEnv.domHelper.setAttribute = originalSetAttribute;

      _emberRuntimeTestsUtils.runDestroy(view);
    }
  });

  QUnit.test('calls setAttribute for new values', function () {
    var context = _emberRuntimeSystemObject.default.create({ name: 'erik' });
    view = _emberViewsViewsView.default.create({
      renderer: renderer,
      context: context,
      template: _emberTemplateCompilerSystemCompile.default('<div data-name={{name}}>Hi!</div>')
    });
    _emberRuntimeTestsUtils.runAppend(view);

    _emberMetalRun_loop.default(context, context.set, 'name', 'mmun');

    var expected = [['data-name', 'erik'], ['data-name', 'mmun']];

    deepEqual(setAttributeCalls, expected);
  });

  QUnit.test('does not call setAttribute if the same value is set', function () {
    var context = _emberRuntimeSystemObject.default.create({ name: 'erik' });
    view = _emberViewsViewsView.default.create({
      renderer: renderer,
      context: context,
      template: _emberTemplateCompilerSystemCompile.default('<div data-name={{name}}>Hi!</div>')
    });
    _emberRuntimeTestsUtils.runAppend(view);

    _emberMetalRun_loop.default(function () {
      context.set('name', 'mmun');
      context.set('name', 'erik');
    });

    var expected = [['data-name', 'erik']];

    deepEqual(setAttributeCalls, expected);
  });
});
enifed('ember-htmlbars/tests/attr_nodes/data_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/attr_nodes');
  test('ember-htmlbars/tests/attr_nodes/data_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/attr_nodes/data_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/attr_nodes/data_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/attr_nodes');
  QUnit.test('ember-htmlbars/tests/attr_nodes/data_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/attr_nodes/data_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/attr_nodes/href_test', ['exports', 'ember-metal/features', 'ember-views/views/view', 'ember-metal/run_loop', 'ember-template-compiler/system/compile', 'htmlbars-test-helpers'], function (exports, _emberMetalFeatures, _emberViewsViewsView, _emberMetalRun_loop, _emberTemplateCompilerSystemCompile, _htmlbarsTestHelpers) {
  'use strict';

  var view;

  function appendView(view) {
    _emberMetalRun_loop.default(function () {
      view.appendTo('#qunit-fixture');
    });
  }

  // jscs:disable validateIndentation

  QUnit.module('ember-htmlbars: href attribute', {
    teardown: function () {
      if (view) {
        _emberMetalRun_loop.default(view, view.destroy);
      }
    }
  });

  QUnit.test('href is set', function () {
    view = _emberViewsViewsView.default.create({
      context: { url: 'http://example.com' },
      template: _emberTemplateCompilerSystemCompile.default('<a href={{url}}></a>')
    });
    appendView(view);

    _htmlbarsTestHelpers.equalInnerHTML(view.element, '<a href="http://example.com"></a>', 'attribute is output');
  });

  // jscs:enable validateIndentation
});
enifed('ember-htmlbars/tests/attr_nodes/href_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/attr_nodes');
  test('ember-htmlbars/tests/attr_nodes/href_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/attr_nodes/href_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/attr_nodes/href_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/attr_nodes');
  QUnit.test('ember-htmlbars/tests/attr_nodes/href_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/attr_nodes/href_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/attr_nodes/property_test', ['exports', 'ember-metal/core', 'ember-metal/features', 'ember-views/views/view', 'ember-metal/run_loop', 'ember-template-compiler/system/compile'], function (exports, _emberMetalCore, _emberMetalFeatures, _emberViewsViewsView, _emberMetalRun_loop, _emberTemplateCompilerSystemCompile) {
  'use strict';

  var view;

  function appendView(view) {
    _emberMetalRun_loop.default(function () {
      view.appendTo('#qunit-fixture');
    });
  }

  function canSetFalsyMaxLength() {
    var input = document.createElement('input');
    input.maxLength = 0;

    return input.maxLength === 0;
  }

  // jscs:disable validateIndentation

  QUnit.module('ember-htmlbars: property', {
    teardown: function () {
      if (view) {
        _emberMetalRun_loop.default(view, view.destroy);
      }
    }
  });

  QUnit.test('maxlength sets the property and attribute', function () {
    view = _emberViewsViewsView.default.create({
      context: { length: 5 },
      template: _emberTemplateCompilerSystemCompile.default('<input maxlength={{length}}>')
    });

    appendView(view);
    equal(view.element.firstChild.maxLength, 5);

    _emberMetalCore.default.run(view, view.set, 'context.length', 1);
    equal(view.element.firstChild.maxLength, 1);
  });

  QUnit.test('quoted maxlength sets the attribute and is reflected as a property', function () {
    view = _emberViewsViewsView.default.create({
      context: { length: 5 },
      template: _emberTemplateCompilerSystemCompile.default('<input maxlength=\'{{length}}\'>')
    });

    appendView(view);
    equal(view.element.firstChild.maxLength, '5');

    if (canSetFalsyMaxLength()) {
      _emberMetalCore.default.run(view, view.set, 'context.length', null);
      equal(view.element.firstChild.maxLength, document.createElement('input').maxLength);
    } else {
      _emberMetalCore.default.run(view, view.set, 'context.length', 1);
      equal(view.element.firstChild.maxLength, 1);
    }
  });

  QUnit.test('array value can be set as property', function () {
    view = _emberViewsViewsView.default.create({
      context: {},
      template: _emberTemplateCompilerSystemCompile.default('<input value={{items}}>')
    });

    appendView(view);

    _emberMetalCore.default.run(view, view.set, 'context.items', [4, 5]);
    ok(true, 'no legacy assertion prohibited setting an array');
  });

  // jscs:enable validateIndentation
});
enifed('ember-htmlbars/tests/attr_nodes/property_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/attr_nodes');
  test('ember-htmlbars/tests/attr_nodes/property_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/attr_nodes/property_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/attr_nodes/property_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/attr_nodes');
  QUnit.test('ember-htmlbars/tests/attr_nodes/property_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/attr_nodes/property_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/attr_nodes/sanitized_test', ['exports', 'ember-metal/features', 'ember-views/views/view', 'ember-template-compiler/system/compile', 'ember-htmlbars/utils/string', 'ember-runtime/tests/utils', 'ember-metal/environment'], function (exports, _emberMetalFeatures, _emberViewsViewsView, _emberTemplateCompilerSystemCompile, _emberHtmlbarsUtilsString, _emberRuntimeTestsUtils, _emberMetalEnvironment) {
  /* jshint scripturl:true */

  'use strict';

  var view;

  QUnit.module('ember-htmlbars: sanitized attribute', {
    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(view);
    }
  });

  // jscs:disable validateIndentation
  // jscs:disable disallowTrailingWhitespace

  var badTags = [{ tag: 'a', attr: 'href',
    unquotedTemplate: _emberTemplateCompilerSystemCompile.default('<a href={{url}}></a>'),
    quotedTemplate: _emberTemplateCompilerSystemCompile.default('<a href=\'{{url}}\'></a>'),
    multipartTemplate: _emberTemplateCompilerSystemCompile.default('<a href=\'{{protocol}}{{path}}\'></a>') }, { tag: 'base', attr: 'href',
    unquotedTemplate: _emberTemplateCompilerSystemCompile.default('<base href={{url}} />'),
    quotedTemplate: _emberTemplateCompilerSystemCompile.default('<base href=\'{{url}}\'/>'),
    multipartTemplate: _emberTemplateCompilerSystemCompile.default('<base href=\'{{protocol}}{{path}}\'/>') }, { tag: 'embed', attr: 'src',
    unquotedTemplate: _emberTemplateCompilerSystemCompile.default('<embed src={{url}} />'),
    quotedTemplate: _emberTemplateCompilerSystemCompile.default('<embed src=\'{{url}}\'/>'),
    multipartTemplate: _emberTemplateCompilerSystemCompile.default('<embed src=\'{{protocol}}{{path}}\'/>') }, { tag: 'body', attr: 'background',
    unquotedTemplate: _emberTemplateCompilerSystemCompile.default('<body background={{url}}></body>'),
    quotedTemplate: _emberTemplateCompilerSystemCompile.default('<body background=\'{{url}}\'></body>'),
    multipartTemplate: _emberTemplateCompilerSystemCompile.default('<body background=\'{{protocol}}{{path}}\'></body>') }, { tag: 'link', attr: 'href',
    unquotedTemplate: _emberTemplateCompilerSystemCompile.default('<link href={{url}}>'),
    quotedTemplate: _emberTemplateCompilerSystemCompile.default('<link href=\'{{url}}\'>'),
    multipartTemplate: _emberTemplateCompilerSystemCompile.default('<link href=\'{{protocol}}{{path}}\'>') }, { tag: 'img', attr: 'src',
    unquotedTemplate: _emberTemplateCompilerSystemCompile.default('<img src={{url}}>'),
    quotedTemplate: _emberTemplateCompilerSystemCompile.default('<img src=\'{{url}}\'>'),
    multipartTemplate: _emberTemplateCompilerSystemCompile.default('<img src=\'{{protocol}}{{path}}\'>') }, { tag: 'iframe', attr: 'src',
    // Setting an iframe with a bad protocol results in the browser
    // being redirected. in IE8. Skip the iframe tests on that platform.
    skip: _emberMetalEnvironment.default.hasDOM && document.documentMode && document.documentMode <= 8,
    unquotedTemplate: _emberTemplateCompilerSystemCompile.default('<iframe src={{url}}></iframe>'),
    quotedTemplate: _emberTemplateCompilerSystemCompile.default('<iframe src=\'{{url}}\'></iframe>'),
    multipartTemplate: _emberTemplateCompilerSystemCompile.default('<iframe src=\'{{protocol}}{{path}}\'></iframe>') }];

  for (var i = 0, l = badTags.length; i < l; i++) {
    (function () {
      var subject = badTags[i];

      if (subject.skip) {
        return;
      }

      QUnit.test(subject.tag + ' ' + subject.attr + ' is sanitized when using blacklisted protocol', function () {
        view = _emberViewsViewsView.default.create({
          context: { url: 'javascript://example.com' },
          template: subject.unquotedTemplate
        });

        view.createElement();

        equal(view.element.firstChild.getAttribute(subject.attr), 'unsafe:javascript://example.com', 'attribute is output');
      });

      QUnit.test(subject.tag + ' ' + subject.attr + ' is sanitized when using quoted non-whitelisted protocol', function () {
        view = _emberViewsViewsView.default.create({
          context: { url: 'javascript://example.com' },
          template: subject.quotedTemplate
        });

        view.createElement();

        equal(view.element.firstChild.getAttribute(subject.attr), 'unsafe:javascript://example.com', 'attribute is output');
      });

      QUnit.test(subject.tag + ' ' + subject.attr + ' is not sanitized when using non-whitelisted protocol with a SafeString', function () {
        view = _emberViewsViewsView.default.create({
          context: { url: new _emberHtmlbarsUtilsString.SafeString('javascript://example.com') },
          template: subject.unquotedTemplate
        });

        try {
          view.createElement();

          equal(view.element.firstChild.getAttribute(subject.attr), 'javascript://example.com', 'attribute is output');
        } catch (e) {
          // IE does not allow javascript: to be set on img src
          ok(true, 'caught exception ' + e);
        }
      });

      QUnit.test(subject.tag + ' ' + subject.attr + ' is sanitized when using quoted+concat non-whitelisted protocol', function () {
        view = _emberViewsViewsView.default.create({
          context: { protocol: 'javascript:', path: '//example.com' },
          template: subject.multipartTemplate
        });
        view.createElement();

        equal(view.element.firstChild.getAttribute(subject.attr), 'unsafe:javascript://example.com', 'attribute is output');
      });
    })(); //jshint ignore:line
  }

  // jscs:enable disallowTrailingWhitespace
  // jscs:enable validateIndentation
});
enifed('ember-htmlbars/tests/attr_nodes/sanitized_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/attr_nodes');
  test('ember-htmlbars/tests/attr_nodes/sanitized_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/attr_nodes/sanitized_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/attr_nodes/sanitized_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/attr_nodes');
  QUnit.test('ember-htmlbars/tests/attr_nodes/sanitized_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(false, 'ember-htmlbars/tests/attr_nodes/sanitized_test.js should pass jshint.\nember-htmlbars/tests/attr_nodes/sanitized_test.js: line 63, col 6, Don\'t make functions within a loop.\n\n1 error');
  });
});
enifed('ember-htmlbars/tests/attr_nodes/style_test', ['exports', 'ember-metal/core', 'ember-metal/features', 'ember-views/views/view', 'ember-template-compiler/system/compile', 'ember-htmlbars/utils/string', 'ember-runtime/tests/utils', 'ember-htmlbars/morphs/attr-morph'], function (exports, _emberMetalCore, _emberMetalFeatures, _emberViewsViewsView, _emberTemplateCompilerSystemCompile, _emberHtmlbarsUtilsString, _emberRuntimeTestsUtils, _emberHtmlbarsMorphsAttrMorph) {
  /* globals EmberDev */

  'use strict';

  var view, originalWarn, warnings;

  QUnit.module('ember-htmlbars: style attribute', {
    setup: function () {
      warnings = [];
      originalWarn = _emberMetalCore.default.warn;
      _emberMetalCore.default.warn = function (message, test) {
        if (!test) {
          warnings.push(message);
        }
      };
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(view);
      _emberMetalCore.default.warn = originalWarn;
    }
  });

  // jscs:disable validateIndentation

  if (!EmberDev.runningProdBuild) {
    QUnit.test('specifying `<div style={{userValue}}></div>` generates a warning', function () {
      view = _emberViewsViewsView.default.create({
        userValue: 'width: 42px',
        template: _emberTemplateCompilerSystemCompile.default('<div style={{view.userValue}}></div>')
      });

      _emberRuntimeTestsUtils.runAppend(view);

      deepEqual(warnings, [_emberHtmlbarsMorphsAttrMorph.styleWarning]);
    });

    QUnit.test('specifying `attributeBindings: ["style"]` generates a warning', function () {
      view = _emberViewsViewsView.default.create({
        userValue: 'width: 42px',
        template: _emberTemplateCompilerSystemCompile.default('<div style={{view.userValue}}></div>')
      });

      _emberRuntimeTestsUtils.runAppend(view);

      deepEqual(warnings, [_emberHtmlbarsMorphsAttrMorph.styleWarning]);
    });
  }

  QUnit.test('specifying `<div style={{{userValue}}}></div>` works properly without a warning', function () {
    view = _emberViewsViewsView.default.create({
      userValue: 'width: 42px',
      template: _emberTemplateCompilerSystemCompile.default('<div style={{{view.userValue}}}></div>')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    deepEqual(warnings, []);
  });

  QUnit.test('specifying `<div style={{userValue}}></div>` works properly with a SafeString', function () {
    view = _emberViewsViewsView.default.create({
      userValue: new _emberHtmlbarsUtilsString.SafeString('width: 42px'),
      template: _emberTemplateCompilerSystemCompile.default('<div style={{view.userValue}}></div>')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    deepEqual(warnings, []);
  });

  // jscs:enable validateIndentation
});
enifed('ember-htmlbars/tests/attr_nodes/style_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/attr_nodes');
  test('ember-htmlbars/tests/attr_nodes/style_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/attr_nodes/style_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/attr_nodes/style_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/attr_nodes');
  QUnit.test('ember-htmlbars/tests/attr_nodes/style_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/attr_nodes/style_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/attr_nodes/svg_test', ['exports', 'ember-metal/core', 'ember-metal/features', 'ember-views/views/view', 'ember-metal/run_loop', 'ember-template-compiler/system/compile', 'htmlbars-test-helpers'], function (exports, _emberMetalCore, _emberMetalFeatures, _emberViewsViewsView, _emberMetalRun_loop, _emberTemplateCompilerSystemCompile, _htmlbarsTestHelpers) {
  'use strict';

  var view;

  function appendView(view) {
    _emberMetalRun_loop.default(function () {
      view.appendTo('#qunit-fixture');
    });
  }

  // jscs:disable validateIndentation

  QUnit.module('ember-htmlbars: svg attribute', {
    teardown: function () {
      if (view) {
        _emberMetalRun_loop.default(view, view.destroy);
      }
    }
  });

  QUnit.test('unquoted viewBox property is output', function () {
    var viewBoxString = '0 0 100 100';
    view = _emberViewsViewsView.default.create({
      context: { viewBoxString: viewBoxString },
      template: _emberTemplateCompilerSystemCompile.default('<svg viewBox={{viewBoxString}}></svg>')
    });
    appendView(view);

    _htmlbarsTestHelpers.equalInnerHTML(view.element, '<svg viewBox="' + viewBoxString + '"></svg>', 'attribute is output');

    _emberMetalCore.default.run(view, view.set, 'context.viewBoxString', null);
    equal(view.element.getAttribute('svg'), null, 'attribute is removed');
  });

  QUnit.test('quoted viewBox property is output', function () {
    var viewBoxString = '0 0 100 100';
    view = _emberViewsViewsView.default.create({
      context: { viewBoxString: viewBoxString },
      template: _emberTemplateCompilerSystemCompile.default('<svg viewBox=\'{{viewBoxString}}\'></svg>')
    });
    appendView(view);

    _htmlbarsTestHelpers.equalInnerHTML(view.element, '<svg viewBox="' + viewBoxString + '"></svg>', 'attribute is output');
  });

  QUnit.test('quoted viewBox property is concat', function () {
    var viewBoxString = '100 100';
    view = _emberViewsViewsView.default.create({
      context: { viewBoxString: viewBoxString },
      template: _emberTemplateCompilerSystemCompile.default('<svg viewBox=\'0 0 {{viewBoxString}}\'></svg>')
    });
    appendView(view);

    _htmlbarsTestHelpers.equalInnerHTML(view.element, '<svg viewBox="0 0 ' + viewBoxString + '"></svg>', 'attribute is output');

    var newViewBoxString = '200 200';
    _emberMetalCore.default.run(view, view.set, 'context.viewBoxString', newViewBoxString);

    _htmlbarsTestHelpers.equalInnerHTML(view.element, '<svg viewBox="0 0 ' + newViewBoxString + '"></svg>', 'attribute is output');
  });

  QUnit.test('class is output', function () {
    view = _emberViewsViewsView.default.create({
      context: { color: 'blue' },
      template: _emberTemplateCompilerSystemCompile.default('<svg class=\'{{color}} tall\'></svg>')
    });
    appendView(view);

    _htmlbarsTestHelpers.equalInnerHTML(view.element, '<svg class="blue tall"></svg>', 'attribute is output');

    _emberMetalCore.default.run(view, view.set, 'context.color', 'red');

    _htmlbarsTestHelpers.equalInnerHTML(view.element, '<svg class="red tall"></svg>', 'attribute is output');
  });

  // jscs:enable validateIndentation
});
enifed('ember-htmlbars/tests/attr_nodes/svg_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/attr_nodes');
  test('ember-htmlbars/tests/attr_nodes/svg_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/attr_nodes/svg_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/attr_nodes/svg_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/attr_nodes');
  QUnit.test('ember-htmlbars/tests/attr_nodes/svg_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/attr_nodes/svg_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/attr_nodes/value_test', ['exports', 'ember-metal/features', 'ember-views/views/view', 'ember-metal/run_loop', 'ember-template-compiler/system/compile'], function (exports, _emberMetalFeatures, _emberViewsViewsView, _emberMetalRun_loop, _emberTemplateCompilerSystemCompile) {
  'use strict';

  var view;

  function appendView(view) {
    _emberMetalRun_loop.default(function () {
      view.appendTo('#qunit-fixture');
    });
  }

  // jscs:disable validateIndentation

  QUnit.module('ember-htmlbars: value attribute', {
    teardown: function () {
      if (view) {
        _emberMetalRun_loop.default(view, view.destroy);
      }
    }
  });

  QUnit.test('property is output', function () {
    view = _emberViewsViewsView.default.create({
      context: { name: 'rick' },
      template: _emberTemplateCompilerSystemCompile.default('<input value={{name}}>')
    });
    appendView(view);

    equal(view.element.firstChild.tagName, 'INPUT', 'input element is created');
    equal(view.element.firstChild.value, 'rick', 'property is set true');
  });

  QUnit.test('string property is output', function () {
    view = _emberViewsViewsView.default.create({
      context: { name: 'rick' },
      template: _emberTemplateCompilerSystemCompile.default('<input value=\'{{name}}\'>')
    });
    appendView(view);

    equal(view.element.firstChild.tagName, 'INPUT', 'input element is created');
    equal(view.element.firstChild.value, 'rick', 'property is set true');
  });

  QUnit.test('blank property is output', function () {
    view = _emberViewsViewsView.default.create({
      context: { name: '' },
      template: _emberTemplateCompilerSystemCompile.default('<input value={{name}}>')
    });
    appendView(view);

    equal(view.element.firstChild.tagName, 'INPUT', 'input element is created');
    equal(view.element.firstChild.value, '', 'property is set true');
  });

  // jscs:enable validateIndentation
});
enifed('ember-htmlbars/tests/attr_nodes/value_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/attr_nodes');
  test('ember-htmlbars/tests/attr_nodes/value_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/attr_nodes/value_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/attr_nodes/value_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/attr_nodes');
  QUnit.test('ember-htmlbars/tests/attr_nodes/value_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/attr_nodes/value_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/compat/controller_keyword_test', ['exports', 'ember-metal/core', 'ember-views/views/component', 'ember-runtime/tests/utils', 'ember-template-compiler/system/compile', 'ember-htmlbars/tests/utils', 'ember-template-compiler/plugins/transform-each-into-collection', 'ember-template-compiler/plugins/assert-no-view-and-controller-paths'], function (exports, _emberMetalCore, _emberViewsViewsComponent, _emberRuntimeTestsUtils, _emberTemplateCompilerSystemCompile, _emberHtmlbarsTestsUtils, _emberTemplateCompilerPluginsTransformEachIntoCollection, _emberTemplateCompilerPluginsAssertNoViewAndControllerPaths) {
  'use strict';

  var component = undefined;

  QUnit.module('ember-htmlbars: compat - controller keyword (use as a path)', {
    setup: function () {
      _emberMetalCore.default.ENV._ENABLE_LEGACY_CONTROLLER_SUPPORT = false;
      _emberHtmlbarsTestsUtils.registerAstPlugin(_emberTemplateCompilerPluginsAssertNoViewAndControllerPaths.default);

      component = null;
    },
    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(component);

      _emberHtmlbarsTestsUtils.removeAstPlugin(_emberTemplateCompilerPluginsAssertNoViewAndControllerPaths.default);
      _emberMetalCore.default.ENV._ENABLE_LEGACY_CONTROLLER_SUPPORT = true;
    }
  });

  QUnit.test('reading the controller keyword fails assertion', function () {
    var text = 'a-prop';
    expectAssertion(function () {
      component = _emberViewsViewsComponent.default.extend({
        prop: text,
        layout: _emberTemplateCompilerSystemCompile.default('{{controller.prop}}')
      }).create();

      _emberRuntimeTestsUtils.runAppend(component);
    }, /Using `{{controller}}` or any path based on it .*/);
  });

  QUnit.module('ember-htmlbars: compat - controller keyword (use as a path) [LEGACY]', {
    setup: function () {
      _emberHtmlbarsTestsUtils.registerAstPlugin(_emberTemplateCompilerPluginsTransformEachIntoCollection.default);

      component = null;
    },
    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(component);

      _emberHtmlbarsTestsUtils.removeAstPlugin(_emberTemplateCompilerPluginsTransformEachIntoCollection.default);
    }
  });

  QUnit.test('reading the controller keyword works [LEGACY]', function () {
    var text = 'a-prop';
    ignoreAssertion(function () {
      component = _emberViewsViewsComponent.default.extend({
        prop: text,
        layout: _emberTemplateCompilerSystemCompile.default('{{controller.prop}}')
      }).create();
    }, /Using `{{controller}}` or any path based on it .*/);

    _emberRuntimeTestsUtils.runAppend(component);
    equal(component.$().text(), text, 'controller keyword is read');
  });

  QUnit.test('reading the controller keyword for hash [LEGACY]', function () {
    ignoreAssertion(function () {
      component = _emberViewsViewsComponent.default.extend({
        prop: true,
        layout: _emberTemplateCompilerSystemCompile.default('{{if true \'hiho\' option=controller.prop}}')
      }).create();

      _emberRuntimeTestsUtils.runAppend(component);
    }, /Using `{{controller}}` or any path based on it .*/);
    ok(true, 'access keyword');
  });

  QUnit.test('reading the controller keyword for param [LEGACY]', function () {
    var text = 'a-prop';
    ignoreAssertion(function () {
      component = _emberViewsViewsComponent.default.extend({
        prop: true,
        layout: _emberTemplateCompilerSystemCompile.default('{{if controller.prop \'' + text + '\'}}')
      }).create();

      _emberRuntimeTestsUtils.runAppend(component);
    }, /Using `{{controller}}` or any path based on it .*/);
    equal(component.$().text(), text, 'controller keyword is read');
  });

  QUnit.test('reading the controller keyword for param with block fails assertion [LEGACY]', function () {
    ignoreAssertion(function () {
      component = _emberViewsViewsComponent.default.extend({
        prop: true,
        layout: _emberTemplateCompilerSystemCompile.default('{{#each controller as |things|}}{{/each}}')
      }).create();

      _emberRuntimeTestsUtils.runAppend(component);
    }, /Using `{{controller}}` or any path based on it .*/);
    ok(true, 'access keyword');
  });
});
enifed('ember-htmlbars/tests/compat/controller_keyword_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/compat');
  test('ember-htmlbars/tests/compat/controller_keyword_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/compat/controller_keyword_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/compat/controller_keyword_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/compat');
  QUnit.test('ember-htmlbars/tests/compat/controller_keyword_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/compat/controller_keyword_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/compat/view_helper_test', ['exports', 'ember-metal/core', 'ember-views/views/component', 'ember-views/views/view', 'ember-views/views/select', 'ember-runtime/tests/utils', 'ember-template-compiler/system/compile', 'container/registry', 'ember-htmlbars/tests/utils', 'ember-template-compiler/plugins/assert-no-view-helper', 'ember-htmlbars/keywords/view'], function (exports, _emberMetalCore, _emberViewsViewsComponent, _emberViewsViewsView, _emberViewsViewsSelect, _emberRuntimeTestsUtils, _emberTemplateCompilerSystemCompile, _containerRegistry, _emberHtmlbarsTestsUtils, _emberTemplateCompilerPluginsAssertNoViewHelper, _emberHtmlbarsKeywordsView) {
  'use strict';

  var component = undefined,
      registry = undefined,
      container = undefined,
      originalViewKeyword = undefined;

  QUnit.module('ember-htmlbars: compat - view helper', {
    setup: function () {
      _emberMetalCore.default.ENV._ENABLE_LEGACY_VIEW_SUPPORT = false;
      _emberHtmlbarsTestsUtils.registerAstPlugin(_emberTemplateCompilerPluginsAssertNoViewHelper.default);

      originalViewKeyword = _emberHtmlbarsTestsUtils.registerKeyword('view', _emberHtmlbarsKeywordsView.default);

      registry = new _containerRegistry.default();
      container = registry.container();
    },
    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(component);
      _emberRuntimeTestsUtils.runDestroy(container);
      _emberHtmlbarsTestsUtils.removeAstPlugin(_emberTemplateCompilerPluginsAssertNoViewHelper.default);
      _emberMetalCore.default.ENV._ENABLE_LEGACY_VIEW_SUPPORT = true;
      registry = container = component = null;

      _emberHtmlbarsTestsUtils.resetKeyword('view', originalViewKeyword);
    }
  });

  QUnit.test('using the view helper fails assertion', function (assert) {
    var ViewClass = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('fooView')
    });
    registry.register('view:foo', ViewClass);

    expectAssertion(function () {
      component = _emberViewsViewsComponent.default.extend({
        layout: _emberTemplateCompilerSystemCompile.default('{{view \'foo\'}}'),
        container: container
      }).create();

      _emberRuntimeTestsUtils.runAppend(component);
    }, /Using the `{{view "string"}}` helper/);
  });

  QUnit.module('ember-htmlbars: compat - view helper [LEGACY]', {
    setup: function () {
      originalViewKeyword = _emberHtmlbarsTestsUtils.registerKeyword('view', _emberHtmlbarsKeywordsView.default);

      registry = new _containerRegistry.default();
      container = registry.container();
    },
    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(component);
      _emberRuntimeTestsUtils.runDestroy(container);
      registry = container = component = null;

      _emberHtmlbarsTestsUtils.resetKeyword('view', originalViewKeyword);
    }
  });

  QUnit.test('using the view helper with a string (inline form) fails assertion [LEGACY]', function (assert) {
    var ViewClass = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('fooView')
    });
    registry.register('view:foo', ViewClass);

    ignoreAssertion(function () {
      component = _emberViewsViewsComponent.default.extend({
        layout: _emberTemplateCompilerSystemCompile.default('{{view \'foo\'}}'),
        container: container
      }).create();

      _emberRuntimeTestsUtils.runAppend(component);
    });

    assert.equal(component.$().text(), 'fooView', 'view helper is still rendered');
  });

  QUnit.test('using the view helper with a string (block form) fails assertion [LEGACY]', function (assert) {
    var ViewClass = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('Foo says: {{yield}}')
    });
    registry.register('view:foo', ViewClass);

    ignoreAssertion(function () {
      component = _emberViewsViewsComponent.default.extend({
        layout: _emberTemplateCompilerSystemCompile.default('{{#view \'foo\'}}I am foo{{/view}}'),
        container: container
      }).create();

      _emberRuntimeTestsUtils.runAppend(component);
    });

    assert.equal(component.$().text(), 'Foo says: I am foo', 'view helper is still rendered');
  });

  QUnit.test('using the view helper with string "select" fails assertion [LEGACY]', function (assert) {
    registry.register('view:select', _emberViewsViewsSelect.default);

    ignoreAssertion(function () {
      component = _emberViewsViewsComponent.default.extend({
        layout: _emberTemplateCompilerSystemCompile.default('{{view \'select\'}}'),
        container: container
      }).create();

      _emberRuntimeTestsUtils.runAppend(component);
    });

    assert.ok(!!component.$('select').length, 'still renders select');
  });
});
enifed('ember-htmlbars/tests/compat/view_helper_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/compat');
  test('ember-htmlbars/tests/compat/view_helper_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/compat/view_helper_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/compat/view_helper_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/compat');
  QUnit.test('ember-htmlbars/tests/compat/view_helper_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/compat/view_helper_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/compat/view_keyword_test', ['exports', 'ember-metal/core', 'ember-views/views/component', 'ember-runtime/tests/utils', 'ember-template-compiler/system/compile', 'ember-htmlbars/tests/utils', 'ember-template-compiler/plugins/assert-no-view-and-controller-paths'], function (exports, _emberMetalCore, _emberViewsViewsComponent, _emberRuntimeTestsUtils, _emberTemplateCompilerSystemCompile, _emberHtmlbarsTestsUtils, _emberTemplateCompilerPluginsAssertNoViewAndControllerPaths) {
  'use strict';

  var component = undefined;

  QUnit.module('ember-htmlbars: compat - view keyword (use as a path)', {
    setup: function () {
      _emberMetalCore.default.ENV._ENABLE_LEGACY_VIEW_SUPPORT = false;
      _emberHtmlbarsTestsUtils.registerAstPlugin(_emberTemplateCompilerPluginsAssertNoViewAndControllerPaths.default);
      component = null;
    },
    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(component);
      _emberHtmlbarsTestsUtils.removeAstPlugin(_emberTemplateCompilerPluginsAssertNoViewAndControllerPaths.default);
      _emberMetalCore.default.ENV._ENABLE_LEGACY_VIEW_SUPPORT = true;
    }
  });

  QUnit.test('reading the view keyword fails assertion', function () {
    var text = 'a-prop';
    expectAssertion(function () {
      component = _emberViewsViewsComponent.default.extend({
        prop: text,
        layout: _emberTemplateCompilerSystemCompile.default('{{view.prop}}')
      }).create();

      _emberRuntimeTestsUtils.runAppend(component);
    }, /Using `{{view}}` or any path based on it .*/);
  });
});
enifed('ember-htmlbars/tests/compat/view_keyword_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/compat');
  test('ember-htmlbars/tests/compat/view_keyword_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/compat/view_keyword_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/compat/view_keyword_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/compat');
  QUnit.test('ember-htmlbars/tests/compat/view_keyword_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/compat/view_keyword_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/helpers/-html-safe-test', ['exports', 'ember-metal/core', 'ember-runtime/system/container', 'ember-views/views/component', 'ember-template-compiler/system/compile', 'ember-runtime/tests/utils'], function (exports, _emberMetalCore, _emberRuntimeSystemContainer, _emberViewsViewsComponent, _emberTemplateCompilerSystemCompile, _emberRuntimeTestsUtils) {
  /* globals EmberDev */
  'use strict';

  var component, registry, container, warnings, originalWarn;

  QUnit.module('ember-htmlbars: {{-html-safe}} helper', {
    setup: function () {
      registry = new _emberRuntimeSystemContainer.Registry();
      container = registry.container();
      registry.optionsForType('helper', { instantiate: false });

      warnings = [];
      originalWarn = _emberMetalCore.default.warn;
      _emberMetalCore.default.warn = function (message, test) {
        if (!test) {
          warnings.push(message);
        }
      };
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(container);
      _emberRuntimeTestsUtils.runDestroy(component);
      _emberMetalCore.default.warn = originalWarn;
    }
  });

  QUnit.test('adds the attribute to the element', function () {
    component = _emberViewsViewsComponent.default.create({
      container: container,

      layout: _emberTemplateCompilerSystemCompile.default('<div style={{-html-safe "display: none;"}}></div>')
    });

    _emberRuntimeTestsUtils.runAppend(component);

    equal(component.$('div').css('display'), 'none', 'attribute was set');
  });

  if (!EmberDev.runningProdBuild) {

    QUnit.test('no warnings are triggered from setting style attribute', function () {
      component = _emberViewsViewsComponent.default.create({
        container: container,

        layout: _emberTemplateCompilerSystemCompile.default('<div style={{-html-safe "display: none;"}}></div>')
      });

      _emberRuntimeTestsUtils.runAppend(component);

      deepEqual(warnings, [], 'no warnings were triggered');
    });
  }
});
enifed('ember-htmlbars/tests/helpers/-html-safe-test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/helpers');
  test('ember-htmlbars/tests/helpers/-html-safe-test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/helpers/-html-safe-test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/helpers/-html-safe-test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/helpers');
  QUnit.test('ember-htmlbars/tests/helpers/-html-safe-test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/helpers/-html-safe-test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/helpers/collection_test', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/run_loop', 'ember-metal/computed', 'ember-runtime/system/object', 'ember-runtime/system/array_proxy', 'ember-runtime/system/namespace', 'ember-runtime/system/container', 'ember-runtime/system/native_array', 'ember-runtime/tests/utils', 'ember-views/views/collection_view', 'ember-views/views/view', 'ember-views/system/jquery', 'ember-template-compiler/system/compile', 'ember-htmlbars/tests/utils', 'ember-htmlbars/keywords/view'], function (exports, _emberMetalCore, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalRun_loop, _emberMetalComputed, _emberRuntimeSystemObject, _emberRuntimeSystemArray_proxy, _emberRuntimeSystemNamespace, _emberRuntimeSystemContainer, _emberRuntimeSystemNative_array, _emberRuntimeTestsUtils, _emberViewsViewsCollection_view, _emberViewsViewsView, _emberViewsSystemJquery, _emberTemplateCompilerSystemCompile, _emberHtmlbarsTestsUtils, _emberHtmlbarsKeywordsView) {
  /*jshint newcap:false*/
  'use strict';

  var trim = _emberViewsSystemJquery.default.trim;

  var view;

  var originalLookup = _emberMetalCore.default.lookup;
  var TemplateTests, registry, container, lookup, originalViewKeyword;

  function nthChild(view, nth) {
    return _emberMetalProperty_get.get(view, 'childViews').objectAt(nth || 0);
  }

  var firstChild = nthChild;

  function firstGrandchild(view) {
    return _emberMetalProperty_get.get(_emberMetalProperty_get.get(view, 'childViews').objectAt(0), 'childViews').objectAt(0);
  }

  QUnit.module('collection helper [LEGACY]', {
    setup: function () {
      originalViewKeyword = _emberHtmlbarsTestsUtils.registerKeyword('view', _emberHtmlbarsKeywordsView.default);

      _emberMetalCore.default.lookup = lookup = {};
      lookup.TemplateTests = TemplateTests = _emberRuntimeSystemNamespace.default.create();
      registry = new _emberRuntimeSystemContainer.Registry();
      container = registry.container();

      registry.optionsForType('template', { instantiate: false });
      registry.register('view:toplevel', _emberViewsViewsView.default.extend());
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(container);
      _emberRuntimeTestsUtils.runDestroy(view);
      registry = container = view = null;

      _emberMetalCore.default.lookup = lookup = originalLookup;
      TemplateTests = null;

      _emberHtmlbarsTestsUtils.resetKeyword('view', originalViewKeyword);
    }
  });

  QUnit.test('Collection views that specify an example view class have their children be of that class', function () {
    var ExampleViewCollection = _emberViewsViewsCollection_view.default.extend({
      itemViewClass: _emberViewsViewsView.default.extend({
        isCustom: true
      }),

      content: _emberRuntimeSystemNative_array.A(['foo'])
    });

    view = _emberViewsViewsView.default.create({
      exampleViewCollection: ExampleViewCollection,
      template: _emberTemplateCompilerSystemCompile.default('{{#collection view.exampleViewCollection}}OHAI{{/collection}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    ok(firstGrandchild(view).isCustom, 'uses the example view class');
  });

  QUnit.test('itemViewClass works in the #collection helper with a property', function () {
    var ExampleItemView = _emberViewsViewsView.default.extend({
      isAlsoCustom: true
    });

    var ExampleCollectionView = _emberViewsViewsCollection_view.default;

    view = _emberViewsViewsView.default.create({
      possibleItemView: ExampleItemView,
      exampleCollectionView: ExampleCollectionView,
      exampleController: _emberRuntimeSystemArray_proxy.default.create({
        content: _emberRuntimeSystemNative_array.A(['alpha'])
      }),
      template: _emberTemplateCompilerSystemCompile.default('{{#collection view.exampleCollectionView content=view.exampleController itemViewClass=view.possibleItemView}}beta{{/collection}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    ok(firstGrandchild(view).isAlsoCustom, 'uses the example view class specified in the #collection helper');
  });

  QUnit.test('itemViewClass works in the #collection via container', function () {
    registry.register('view:example-item', _emberViewsViewsView.default.extend({
      isAlsoCustom: true
    }));

    view = _emberViewsViewsView.default.create({
      container: container,
      exampleCollectionView: _emberViewsViewsCollection_view.default.extend(),
      exampleController: _emberRuntimeSystemArray_proxy.default.create({
        content: _emberRuntimeSystemNative_array.A(['alpha'])
      }),
      template: _emberTemplateCompilerSystemCompile.default('{{#collection view.exampleCollectionView content=view.exampleController itemViewClass="example-item"}}beta{{/collection}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    ok(firstGrandchild(view).isAlsoCustom, 'uses the example view class specified in the #collection helper');
  });

  QUnit.test('passing a block to the collection helper sets it as the template for example views', function () {
    var CollectionTestView = _emberViewsViewsCollection_view.default.extend({
      tagName: 'ul',
      content: _emberRuntimeSystemNative_array.A(['foo', 'bar', 'baz'])
    });

    view = _emberViewsViewsView.default.create({
      collectionTestView: CollectionTestView,
      template: _emberTemplateCompilerSystemCompile.default('{{#collection view.collectionTestView}} <label></label> {{/collection}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('label').length, 3, 'one label element is created for each content item');
  });

  QUnit.test('collection helper should try to use container to resolve view', function () {
    var registry = new _emberRuntimeSystemContainer.Registry();
    var container = registry.container();

    var ACollectionView = _emberViewsViewsCollection_view.default.extend({
      tagName: 'ul',
      content: _emberRuntimeSystemNative_array.A(['foo', 'bar', 'baz'])
    });

    registry.register('view:collectionTest', ACollectionView);

    view = _emberViewsViewsView.default.create({
      container: container,
      template: _emberTemplateCompilerSystemCompile.default('{{#collection "collectionTest"}} <label></label> {{/collection}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('label').length, 3, 'one label element is created for each content item');
  });

  QUnit.test('collection helper should accept relative paths', function () {
    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('{{#collection view.collection}} <label></label> {{/collection}}'),
      collection: _emberViewsViewsCollection_view.default.extend({
        tagName: 'ul',
        content: _emberRuntimeSystemNative_array.A(['foo', 'bar', 'baz'])
      })
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('label').length, 3, 'one label element is created for each content item');
  });

  QUnit.test('empty views should be removed when content is added to the collection (regression, ht: msofaer)', function () {
    var EmptyView = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('<td>No Rows Yet</td>')
    });

    var ListView = _emberViewsViewsCollection_view.default.extend({
      emptyView: EmptyView
    });

    var listController = _emberRuntimeSystemArray_proxy.default.create({
      content: _emberRuntimeSystemNative_array.A()
    });

    view = _emberViewsViewsView.default.create({
      _viewRegistry: {},
      listView: ListView,
      listController: listController,
      template: _emberTemplateCompilerSystemCompile.default('{{#collection view.listView content=view.listController tagName="table"}} <td>{{view.content.title}}</td> {{/collection}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('tr').length, 1, 'Make sure the empty view is there (regression)');

    _emberMetalRun_loop.default(function () {
      listController.pushObject({ title: 'Go Away, Placeholder Row!' });
    });

    equal(view.$('tr').length, 1, 'has one row');
    equal(view.$('tr:nth-child(1) td').text(), 'Go Away, Placeholder Row!', 'The content is the updated data.');
  });

  QUnit.test('should be able to specify which class should be used for the empty view', function () {
    var registry = new _emberRuntimeSystemContainer.Registry();
    var App;

    _emberMetalRun_loop.default(function () {
      lookup.App = App = _emberRuntimeSystemNamespace.default.create();
    });

    var EmptyView = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('This is an empty view')
    });

    registry.register('view:empty-view', EmptyView);

    view = _emberViewsViewsView.default.create({
      container: registry.container(),
      template: _emberTemplateCompilerSystemCompile.default('{{collection emptyViewClass="empty-view"}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'This is an empty view', 'Empty view should be rendered.');

    _emberRuntimeTestsUtils.runDestroy(App);
  });

  QUnit.test('if no content is passed, and no \'else\' is specified, nothing is rendered', function () {
    var CollectionTestView = _emberViewsViewsCollection_view.default.extend({
      tagName: 'ul',
      content: _emberRuntimeSystemNative_array.A()
    });

    view = _emberViewsViewsView.default.create({
      collectionTestView: CollectionTestView,
      template: _emberTemplateCompilerSystemCompile.default('{{#collection view.collectionTestView}} <aside></aside> {{/collection}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('li').length, 0, 'if no "else" is specified, nothing is rendered');
  });

  QUnit.test('if no content is passed, and \'else\' is specified, the else block is rendered', function () {
    var CollectionTestView = _emberViewsViewsCollection_view.default.extend({
      tagName: 'ul',
      content: _emberRuntimeSystemNative_array.A()
    });

    view = _emberViewsViewsView.default.create({
      collectionTestView: CollectionTestView,
      template: _emberTemplateCompilerSystemCompile.default('{{#collection view.collectionTestView}} <aside></aside> {{ else }} <del></del> {{/collection}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('li:has(del)').length, 1, 'the else block is rendered');
  });

  QUnit.test('a block passed to a collection helper defaults to the content property of the context', function () {
    var CollectionTestView = _emberViewsViewsCollection_view.default.extend({
      tagName: 'ul',
      content: _emberRuntimeSystemNative_array.A(['foo', 'bar', 'baz'])
    });

    view = _emberViewsViewsView.default.create({
      collectionTestView: CollectionTestView,
      template: _emberTemplateCompilerSystemCompile.default('{{#collection view.collectionTestView}} <label>{{view.content}}</label> {{/collection}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('li:nth-child(1) label').length, 1);
    equal(view.$('li:nth-child(1) label').text(), 'foo');
    equal(view.$('li:nth-child(2) label').length, 1);
    equal(view.$('li:nth-child(2) label').text(), 'bar');
    equal(view.$('li:nth-child(3) label').length, 1);
    equal(view.$('li:nth-child(3) label').text(), 'baz');
  });

  QUnit.test('a block passed to a collection helper defaults to the view', function () {
    var CollectionTestView = _emberViewsViewsCollection_view.default.extend({
      tagName: 'ul',
      content: _emberRuntimeSystemNative_array.A(['foo', 'bar', 'baz'])
    });

    view = _emberViewsViewsView.default.create({
      collectionTestView: CollectionTestView,
      template: _emberTemplateCompilerSystemCompile.default('{{#collection view.collectionTestView}} <label>{{view.content}}</label> {{/collection}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    // Preconds
    equal(view.$('li:nth-child(1) label').length, 1);
    equal(view.$('li:nth-child(1) label').text(), 'foo');
    equal(view.$('li:nth-child(2) label').length, 1);
    equal(view.$('li:nth-child(2) label').text(), 'bar');
    equal(view.$('li:nth-child(3) label').length, 1);
    equal(view.$('li:nth-child(3) label').text(), 'baz');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(firstChild(view), 'content', _emberRuntimeSystemNative_array.A());
    });
    equal(view.$('label').length, 0, 'all list item views should be removed from DOM');
  });

  QUnit.test('should include an id attribute if id is set in the options hash', function () {
    var CollectionTestView = _emberViewsViewsCollection_view.default.extend({
      tagName: 'ul',
      content: _emberRuntimeSystemNative_array.A(['foo', 'bar', 'baz'])
    });

    view = _emberViewsViewsView.default.create({
      collectionTestView: CollectionTestView,
      template: _emberTemplateCompilerSystemCompile.default('{{#collection view.collectionTestView id="baz"}}foo{{/collection}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('ul#baz').length, 1, 'adds an id attribute');
  });

  QUnit.test('should give its item views the class specified by itemClass', function () {
    var ItemClassTestCollectionView = _emberViewsViewsCollection_view.default.extend({
      tagName: 'ul',
      content: _emberRuntimeSystemNative_array.A(['foo', 'bar', 'baz'])
    });
    view = _emberViewsViewsView.default.create({
      itemClassTestCollectionView: ItemClassTestCollectionView,
      template: _emberTemplateCompilerSystemCompile.default('{{#collection view.itemClassTestCollectionView itemClass="baz"}}foo{{/collection}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('ul li.baz').length, 3, 'adds class attribute');
  });

  QUnit.test('should give its item views the class specified by itemClass binding', function () {
    var ItemClassBindingTestCollectionView = _emberViewsViewsCollection_view.default.extend({
      tagName: 'ul',
      content: _emberRuntimeSystemNative_array.A([_emberRuntimeSystemObject.default.create({ isBaz: false }), _emberRuntimeSystemObject.default.create({ isBaz: true }), _emberRuntimeSystemObject.default.create({ isBaz: true })])
    });

    view = _emberViewsViewsView.default.create({
      itemClassBindingTestCollectionView: ItemClassBindingTestCollectionView,
      isBar: true,
      template: _emberTemplateCompilerSystemCompile.default('{{#collection view.itemClassBindingTestCollectionView itemClass=view.isBar}}foo{{/collection}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('ul li.is-bar').length, 3, 'adds class on initial rendering');

    // NOTE: in order to bind an item's class to a property of the item itself (e.g. `isBaz` above), it will be necessary
    // to introduce a new keyword that could be used from within `itemClassBinding`. For instance, `itemClassBinding="item.isBaz"`.
  });

  QUnit.test('should give its item views the property specified by itemProperty', function () {
    var registry = new _emberRuntimeSystemContainer.Registry();

    var ItemPropertyBindingTestItemView = _emberViewsViewsView.default.extend({
      tagName: 'li'
    });

    registry.register('view:item-property-binding-test-item-view', ItemPropertyBindingTestItemView);

    // Use preserveContext=false so the itemView handlebars context is the view context
    // Set itemView bindings using item*
    view = _emberViewsViewsView.default.create({
      baz: 'baz',
      content: _emberRuntimeSystemNative_array.A([_emberRuntimeSystemObject.default.create(), _emberRuntimeSystemObject.default.create(), _emberRuntimeSystemObject.default.create()]),
      container: registry.container(),
      template: _emberTemplateCompilerSystemCompile.default('{{#collection content=view.content tagName="ul" itemViewClass="item-property-binding-test-item-view" itemProperty=view.baz preserveContext=false}}{{view.property}}{{/collection}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('ul li').length, 3, 'adds 3 itemView');

    view.$('ul li').each(function (i, li) {
      equal(_emberViewsSystemJquery.default(li).text(), 'baz', 'creates the li with the property = baz');
    });

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'baz', 'yobaz');
    });

    equal(view.$('ul li:first').text(), 'yobaz', 'change property of sub view');
  });

  QUnit.test('should work inside a bound {{#if}}', function () {
    var testData = _emberRuntimeSystemNative_array.A([_emberRuntimeSystemObject.default.create({ isBaz: false }), _emberRuntimeSystemObject.default.create({ isBaz: true }), _emberRuntimeSystemObject.default.create({ isBaz: true })]);
    var IfTestCollectionView = _emberViewsViewsCollection_view.default.extend({
      tagName: 'ul',
      content: testData
    });

    view = _emberViewsViewsView.default.create({
      ifTestCollectionView: IfTestCollectionView,
      template: _emberTemplateCompilerSystemCompile.default('{{#if view.shouldDisplay}}{{#collection view.ifTestCollectionView}}{{content.isBaz}}{{/collection}}{{/if}}'),
      shouldDisplay: true
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('ul li').length, 3, 'renders collection when conditional is true');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'shouldDisplay', false);
    });
    equal(view.$('ul li').length, 0, 'removes collection when conditional changes to false');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'shouldDisplay', true);
    });
    equal(view.$('ul li').length, 3, 'collection renders when conditional changes to true');
  });

  QUnit.test('should pass content as context when using {{#each}} helper [DEPRECATED]', function () {
    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('{{#each view.releases as |release|}}Mac OS X {{release.version}}: {{release.name}} {{/each}}'),

      releases: _emberRuntimeSystemNative_array.A([{ version: '10.7',
        name: 'Lion' }, { version: '10.6',
        name: 'Snow Leopard' }, { version: '10.5',
        name: 'Leopard' }])
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'Mac OS X 10.7: Lion Mac OS X 10.6: Snow Leopard Mac OS X 10.5: Leopard ', 'prints each item in sequence');
  });

  QUnit.test('should re-render when the content object changes', function () {
    var RerenderTest = _emberViewsViewsCollection_view.default.extend({
      tagName: 'ul',
      content: _emberRuntimeSystemNative_array.A()
    });

    view = _emberViewsViewsView.default.create({
      rerenderTestView: RerenderTest,
      template: _emberTemplateCompilerSystemCompile.default('{{#collection view.rerenderTestView}}{{view.content}}{{/collection}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(firstChild(view), 'content', _emberRuntimeSystemNative_array.A(['bing', 'bat', 'bang']));
    });

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(firstChild(view), 'content', _emberRuntimeSystemNative_array.A(['ramalamadingdong']));
    });

    equal(view.$('li').length, 1, 'rerenders with correct number of items');
    equal(trim(view.$('li:eq(0)').text()), 'ramalamadingdong');
  });

  QUnit.test('select tagName on collection helper automatically sets child tagName to option', function () {
    var RerenderTest = _emberViewsViewsCollection_view.default.extend({
      content: _emberRuntimeSystemNative_array.A(['foo'])
    });

    view = _emberViewsViewsView.default.create({
      rerenderTestView: RerenderTest,
      template: _emberTemplateCompilerSystemCompile.default('{{#collection view.rerenderTestView tagName="select"}}{{view.content}}{{/collection}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('option').length, 1, 'renders the correct child tag name');
  });

  QUnit.test('tagName works in the #collection helper', function () {
    var RerenderTest = _emberViewsViewsCollection_view.default.extend({
      content: _emberRuntimeSystemNative_array.A(['foo', 'bar'])
    });

    view = _emberViewsViewsView.default.create({
      rerenderTestView: RerenderTest,
      template: _emberTemplateCompilerSystemCompile.default('{{#collection view.rerenderTestView tagName="ol"}}{{view.content}}{{/collection}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('ol').length, 1, 'renders the correct tag name');
    equal(view.$('li').length, 2, 'rerenders with correct number of items');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(firstChild(view), 'content', _emberRuntimeSystemNative_array.A(['bing', 'bat', 'bang']));
    });

    equal(view.$('li').length, 3, 'rerenders with correct number of items');
    equal(trim(view.$('li:eq(0)').text()), 'bing');
  });

  QUnit.test('itemClassNames adds classes to items', function () {
    view = _emberViewsViewsView.default.create({
      context: { list: _emberRuntimeSystemNative_array.A(['one', 'two']) },
      template: _emberTemplateCompilerSystemCompile.default('{{#collection content=list itemClassNames="some-class"}}{{/collection}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('div > .some-class').length, 2, 'should have two items with the class');
  });

  QUnit.test('should render nested collections', function () {
    var registry = new _emberRuntimeSystemContainer.Registry();
    var container = registry.container();
    registry.register('view:inner-list', _emberViewsViewsCollection_view.default.extend({
      tagName: 'ul',
      content: _emberRuntimeSystemNative_array.A(['one', 'two', 'three'])
    }));

    registry.register('view:outer-list', _emberViewsViewsCollection_view.default.extend({
      tagName: 'ul',
      content: _emberRuntimeSystemNative_array.A(['foo'])
    }));

    view = _emberViewsViewsView.default.create({
      container: container,
      template: _emberTemplateCompilerSystemCompile.default('{{#collection "outer-list" class="outer"}}{{content}}{{#collection "inner-list" class="inner"}}{{content}}{{/collection}}{{/collection}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('ul.outer > li').length, 1, 'renders the outer list with correct number of items');
    equal(view.$('ul.inner').length, 1, 'the inner list exsits');
    equal(view.$('ul.inner > li').length, 3, 'renders the inner list with correct number of items');
  });

  QUnit.test('should render multiple, bound nested collections (#68)', function () {
    var view;

    _emberMetalRun_loop.default(function () {
      TemplateTests.contentController = _emberRuntimeSystemArray_proxy.default.create({
        content: _emberRuntimeSystemNative_array.A(['foo', 'bar'])
      });

      var InnerList = _emberViewsViewsCollection_view.default.extend({
        tagName: 'ul',
        contentBinding: 'parentView.innerListContent'
      });

      var OuterListItem = _emberViewsViewsView.default.extend({
        innerListView: InnerList,
        template: _emberTemplateCompilerSystemCompile.default('{{#collection view.innerListView class="inner"}}{{content}}{{/collection}}{{content}}'),
        innerListContent: _emberMetalComputed.computed(function () {
          return _emberRuntimeSystemNative_array.A([1, 2, 3]);
        })
      });

      var OuterList = _emberViewsViewsCollection_view.default.extend({
        tagName: 'ul',
        contentBinding: 'TemplateTests.contentController',
        itemViewClass: OuterListItem
      });

      view = _emberViewsViewsView.default.create({
        outerListView: OuterList,
        template: _emberTemplateCompilerSystemCompile.default('{{collection view.outerListView class="outer"}}')
      });
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('ul.outer > li').length, 2, 'renders the outer list with correct number of items');
    equal(view.$('ul.inner').length, 2, 'renders the correct number of inner lists');
    equal(view.$('ul.inner:first > li').length, 3, 'renders the first inner list with correct number of items');
    equal(view.$('ul.inner:last > li').length, 3, 'renders the second list with correct number of items');

    _emberRuntimeTestsUtils.runDestroy(view);
  });

  QUnit.test('should allow view objects to be swapped out without throwing an error (#78)', function () {
    var view, dataset, secondDataset;

    _emberMetalRun_loop.default(function () {
      TemplateTests.datasetController = _emberRuntimeSystemObject.default.create();

      var ExampleCollectionView = _emberViewsViewsCollection_view.default.extend({
        contentBinding: 'parentView.items',
        tagName: 'ul',
        _itemViewTemplate: _emberTemplateCompilerSystemCompile.default('{{view.content}}')
      });

      var ReportingView = _emberViewsViewsView.default.extend({
        exampleCollectionView: ExampleCollectionView,
        datasetBinding: 'TemplateTests.datasetController.dataset',
        readyBinding: 'dataset.ready',
        itemsBinding: 'dataset.items',
        template: _emberTemplateCompilerSystemCompile.default('{{#if view.ready}}{{collection view.exampleCollectionView}}{{else}}Loading{{/if}}')
      });

      view = ReportingView.create();
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'Loading', 'renders the loading text when the dataset is not ready');

    _emberMetalRun_loop.default(function () {
      dataset = _emberRuntimeSystemObject.default.create({
        ready: true,
        items: _emberRuntimeSystemNative_array.A([1, 2, 3])
      });
      TemplateTests.datasetController.set('dataset', dataset);
    });

    equal(view.$('ul > li').length, 3, 'renders the collection with the correct number of items when the dataset is ready');

    _emberMetalRun_loop.default(function () {
      secondDataset = _emberRuntimeSystemObject.default.create({ ready: false });
      TemplateTests.datasetController.set('dataset', secondDataset);
    });

    equal(view.$().text(), 'Loading', 'renders the loading text when the second dataset is not ready');

    _emberRuntimeTestsUtils.runDestroy(view);
  });

  QUnit.test('context should be content', function () {
    var view;

    registry = new _emberRuntimeSystemContainer.Registry();
    container = registry.container();

    var items = _emberRuntimeSystemNative_array.A([_emberRuntimeSystemObject.default.create({ name: 'Dave' }), _emberRuntimeSystemObject.default.create({ name: 'Mary' }), _emberRuntimeSystemObject.default.create({ name: 'Sara' })]);

    registry.register('view:an-item', _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('Greetings {{name}}')
    }));

    view = _emberViewsViewsView.default.create({
      container: container,
      controller: {
        items: items
      },
      template: _emberTemplateCompilerSystemCompile.default('{{collection content=items itemViewClass="an-item"}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'Greetings DaveGreetings MaryGreetings Sara');

    _emberRuntimeTestsUtils.runDestroy(view);
  });
});
enifed('ember-htmlbars/tests/helpers/collection_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/helpers');
  test('ember-htmlbars/tests/helpers/collection_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/helpers/collection_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/helpers/collection_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/helpers');
  QUnit.test('ember-htmlbars/tests/helpers/collection_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/helpers/collection_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/helpers/component_test', ['exports', 'ember-metal/core', 'ember-metal/features', 'ember-metal/property_set', 'ember-metal/property_get', 'ember-metal/run_loop', 'container/registry', 'ember-runtime/tests/utils', 'ember-views/component_lookup', 'ember-views/views/view', 'ember-views/views/component', 'ember-template-compiler/system/compile', 'ember-metal/computed'], function (exports, _emberMetalCore, _emberMetalFeatures, _emberMetalProperty_set, _emberMetalProperty_get, _emberMetalRun_loop, _containerRegistry, _emberRuntimeTestsUtils, _emberViewsComponent_lookup, _emberViewsViewsView, _emberViewsViewsComponent, _emberTemplateCompilerSystemCompile, _emberMetalComputed) {
  'use strict';

  var view, registry, container;

  QUnit.module('ember-htmlbars: {{#component}} helper', {
    setup: function () {
      registry = new _containerRegistry.default();
      container = registry.container();

      registry.optionsForType('template', { instantiate: false });
      registry.register('component-lookup:main', _emberViewsComponent_lookup.default);
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(view);
      _emberRuntimeTestsUtils.runDestroy(container);
      registry = container = view = null;
    }
  });

  QUnit.test('component helper with bound properties are updating correctly in init of component', function () {
    registry.register('component:foo-bar', _emberViewsViewsComponent.default.extend({
      init: function () {
        this._super.apply(this, arguments);

        equal(_emberMetalProperty_get.get(this, 'location'), 'Caracas', 'location is bound on init');
      }
    }));
    registry.register('component:baz-qux', _emberViewsViewsComponent.default.extend({
      init: function () {
        this._super.apply(this, arguments);

        equal(_emberMetalProperty_get.get(this, 'location'), 'Loisaida', 'location is bound on init');
      }
    }));
    registry.register('template:components/foo-bar', _emberTemplateCompilerSystemCompile.default('yippie! {{location}} {{yield}}'));
    registry.register('template:components/baz-qux', _emberTemplateCompilerSystemCompile.default('yummy {{location}} {{yield}}'));

    view = _emberViewsViewsView.default.extend({
      container: container,
      dynamicComponent: _emberMetalComputed.default('location', function () {
        var location = _emberMetalProperty_get.get(this, 'location');

        if (location === 'Caracas') {
          return 'foo-bar';
        } else {
          return 'baz-qux';
        }
      }),
      location: 'Caracas',
      template: _emberTemplateCompilerSystemCompile.default('{{#component view.dynamicComponent location=view.location}}arepas!{{/component}}')
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);
    equal(view.$().text(), 'yippie! Caracas arepas!', 'component was looked up and rendered');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'location', 'Loisaida');
    });
    equal(view.$().text(), 'yummy Loisaida arepas!', 'component was updated and re-rendered');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'location', 'Caracas');
    });
    equal(view.$().text(), 'yippie! Caracas arepas!', 'component was updated up and rendered');
  });

  QUnit.test('component helper with unquoted string is bound', function () {
    registry.register('template:components/foo-bar', _emberTemplateCompilerSystemCompile.default('yippie! {{attrs.location}} {{yield}}'));
    registry.register('template:components/baz-qux', _emberTemplateCompilerSystemCompile.default('yummy {{attrs.location}} {{yield}}'));

    view = _emberViewsViewsView.default.create({
      container: container,
      dynamicComponent: 'foo-bar',
      location: 'Caracas',
      template: _emberTemplateCompilerSystemCompile.default('{{#component view.dynamicComponent location=view.location}}arepas!{{/component}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);
    equal(view.$().text(), 'yippie! Caracas arepas!', 'component was looked up and rendered');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'dynamicComponent', 'baz-qux');
      _emberMetalProperty_set.set(view, 'location', 'Loisaida');
    });
    equal(view.$().text(), 'yummy Loisaida arepas!', 'component was updated and re-rendered');
  });

  QUnit.test('component helper destroys underlying component when it is swapped out', function () {
    var currentComponent;
    var destroyCalls = 0;
    registry.register('component:foo-bar', _emberViewsViewsComponent.default.extend({
      init: function () {
        this._super.apply(this, arguments);
        currentComponent = 'foo-bar';
      },
      willDestroy: function () {
        destroyCalls++;
      }
    }));
    registry.register('component:baz-qux', _emberViewsViewsComponent.default.extend({
      init: function () {
        this._super.apply(this, arguments);
        currentComponent = 'baz-qux';
      },
      willDestroy: function () {
        destroyCalls++;
      }
    }));

    view = _emberViewsViewsView.default.create({
      container: container,
      dynamicComponent: 'foo-bar',
      template: _emberTemplateCompilerSystemCompile.default('{{component view.dynamicComponent}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(currentComponent, 'foo-bar', 'precond - instantiates the proper component');
    equal(destroyCalls, 0, 'precond - nothing destroyed yet');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'dynamicComponent', 'baz-qux');
    });

    equal(currentComponent, 'baz-qux', 'changing bound value instantiates the proper component');
    equal(destroyCalls, 1, 'prior component should be destroyed');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'dynamicComponent', 'foo-bar');
    });

    equal(currentComponent, 'foo-bar', 'changing bound value instantiates the proper component');
    equal(destroyCalls, 2, 'prior components destroyed');
  });

  QUnit.test('component helper with actions', function () {
    registry.register('template:components/foo-bar', _emberTemplateCompilerSystemCompile.default('yippie! {{yield}}'));
    registry.register('component:foo-bar', _emberViewsViewsComponent.default.extend({
      classNames: 'foo-bar',
      didInsertElement: function () {
        // trigger action on click in absence of app's EventDispatcher
        var self = this;
        this.$().on('click', function () {
          self.sendAction('fooBarred');
        });
      },
      willDestroyElement: function () {
        this.$().off('click');
      }
    }));

    var actionTriggered = 0;
    var controller = _emberMetalCore.default.Controller.extend({
      dynamicComponent: 'foo-bar',
      actions: {
        mappedAction: function () {
          actionTriggered++;
        }
      }
    }).create();
    view = _emberViewsViewsView.default.create({
      container: container,
      controller: controller,
      template: _emberTemplateCompilerSystemCompile.default('{{#component dynamicComponent fooBarred="mappedAction"}}arepas!{{/component}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);
    _emberMetalRun_loop.default(function () {
      view.$('.foo-bar').trigger('click');
    });
    equal(actionTriggered, 1, 'action was triggered');
  });

  QUnit.test('component helper maintains expected logical parentView', function () {
    registry.register('template:components/foo-bar', _emberTemplateCompilerSystemCompile.default('yippie! {{yield}}'));
    var componentInstance;
    registry.register('component:foo-bar', _emberViewsViewsComponent.default.extend({
      didInsertElement: function () {
        componentInstance = this;
      }
    }));

    view = _emberViewsViewsView.default.create({
      container: container,
      dynamicComponent: 'foo-bar',
      template: _emberTemplateCompilerSystemCompile.default('{{#component view.dynamicComponent}}arepas!{{/component}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);
    equal(_emberMetalProperty_get.get(componentInstance, 'parentView'), view, 'component\'s parentView is the view invoking the helper');
  });

  QUnit.test('nested component helpers', function () {
    registry.register('template:components/foo-bar', _emberTemplateCompilerSystemCompile.default('yippie! {{attrs.location}} {{yield}}'));
    registry.register('template:components/baz-qux', _emberTemplateCompilerSystemCompile.default('yummy {{attrs.location}} {{yield}}'));
    registry.register('template:components/corge-grault', _emberTemplateCompilerSystemCompile.default('delicious {{attrs.location}} {{yield}}'));

    view = _emberViewsViewsView.default.create({
      container: container,
      dynamicComponent1: 'foo-bar',
      dynamicComponent2: 'baz-qux',
      location: 'Caracas',
      template: _emberTemplateCompilerSystemCompile.default('{{#component view.dynamicComponent1 location=view.location}}{{#component view.dynamicComponent2 location=view.location}}arepas!{{/component}}{{/component}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);
    equal(view.$().text(), 'yippie! Caracas yummy Caracas arepas!', 'components were looked up and rendered');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'dynamicComponent1', 'corge-grault');
      _emberMetalProperty_set.set(view, 'location', 'Loisaida');
    });
    equal(view.$().text(), 'delicious Loisaida yummy Loisaida arepas!', 'components were updated and re-rendered');
  });

  QUnit.test('component helper can be used with a quoted string (though you probably would not do this)', function () {
    registry.register('template:components/foo-bar', _emberTemplateCompilerSystemCompile.default('yippie! {{attrs.location}} {{yield}}'));

    view = _emberViewsViewsView.default.create({
      container: container,
      location: 'Caracas',
      template: _emberTemplateCompilerSystemCompile.default('{{#component "foo-bar" location=view.location}}arepas!{{/component}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'yippie! Caracas arepas!', 'component was looked up and rendered');
  });

  QUnit.test('component with unquoted param resolving to non-existent component', function () {
    view = _emberViewsViewsView.default.create({
      container: container,
      dynamicComponent: 'does-not-exist',
      location: 'Caracas',
      template: _emberTemplateCompilerSystemCompile.default('{{#component view.dynamicComponent location=view.location}}arepas!{{/component}}')
    });

    expectAssertion(function () {
      _emberRuntimeTestsUtils.runAppend(view);
    }, /HTMLBars error: Could not find component named "does-not-exist"./, 'Expected missing component to generate an exception');
  });

  QUnit.test('component with unquoted param resolving to a component, then non-existent component', function () {
    registry.register('template:components/foo-bar', _emberTemplateCompilerSystemCompile.default('yippie! {{attrs.location}} {{yield}}'));
    view = _emberViewsViewsView.default.create({
      container: container,
      dynamicComponent: 'foo-bar',
      location: 'Caracas',
      template: _emberTemplateCompilerSystemCompile.default('{{#component view.dynamicComponent location=view.location}}arepas!{{/component}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'yippie! Caracas arepas!', 'component was looked up and rendered');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'dynamicComponent', undefined);
    });

    equal(view.$().text(), '', 'component correctly deals with falsey values set post-render');
  });

  QUnit.test('component with quoted param for non-existent component', function () {
    view = _emberViewsViewsView.default.create({
      container: container,
      location: 'Caracas',
      template: _emberTemplateCompilerSystemCompile.default('{{#component "does-not-exist" location=view.location}}arepas!{{/component}}')
    });

    expectAssertion(function () {
      _emberRuntimeTestsUtils.runAppend(view);
    }, /HTMLBars error: Could not find component named "does-not-exist"./);
  });

  QUnit.test('component helper properly invalidates hash params inside an {{each}} invocation #11044', function () {
    registry.register('component:foo-bar', _emberViewsViewsComponent.default.extend({
      willRender: function () {
        // store internally available name to ensure that the name available in `this.attrs.name`
        // matches the template lookup name
        _emberMetalProperty_set.set(this, 'internalName', this.attrs.name);
      }
    }));
    registry.register('template:components/foo-bar', _emberTemplateCompilerSystemCompile.default('{{internalName}} - {{attrs.name}}|'));

    view = _emberViewsViewsView.default.create({
      container: container,
      items: [{ name: 'Robert' }, { name: 'Jacquie' }],
      template: _emberTemplateCompilerSystemCompile.default('{{#each view.items as |item|}}{{component "foo-bar" name=item.name}}{{/each}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);
    equal(view.$().text(), 'Robert - Robert|Jacquie - Jacquie|', 'component was rendered');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'items', [{ name: 'Max' }, { name: 'James' }]);
    });
    equal(view.$().text(), 'Max - Max|James - James|', 'component was updated and re-rendered');
  });

  QUnit.test('dashless components should not be found', function () {
    expect(1);

    registry.register('template:components/dashless', _emberTemplateCompilerSystemCompile.default('Do not render me!'));

    view = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('{{component "dashless"}}'),
      container: container
    }).create();

    expectAssertion(function () {
      _emberRuntimeTestsUtils.runAppend(view);
    }, /You cannot use 'dashless' as a component name. Component names must contain a hyphen./);
  });
});
enifed('ember-htmlbars/tests/helpers/component_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/helpers');
  test('ember-htmlbars/tests/helpers/component_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/helpers/component_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/helpers/component_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/helpers');
  QUnit.test('ember-htmlbars/tests/helpers/component_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/helpers/component_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/helpers/concat-test', ['exports', 'ember-metal/run_loop', 'ember-runtime/system/container', 'ember-views/views/component', 'ember-template-compiler/system/compile', 'ember-htmlbars/helper', 'ember-runtime/tests/utils'], function (exports, _emberMetalRun_loop, _emberRuntimeSystemContainer, _emberViewsViewsComponent, _emberTemplateCompilerSystemCompile, _emberHtmlbarsHelper, _emberRuntimeTestsUtils) {
  'use strict';

  var component, registry, container;

  QUnit.module('ember-htmlbars: {{concat}} helper', {
    setup: function () {
      registry = new _emberRuntimeSystemContainer.Registry();
      container = registry.container();
      registry.optionsForType('helper', { instantiate: false });
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(container);
      _emberRuntimeTestsUtils.runDestroy(component);
    }
  });

  QUnit.test('concats provided params', function () {
    component = _emberViewsViewsComponent.default.create({
      container: container,

      layout: _emberTemplateCompilerSystemCompile.default('{{concat "foo" " " "bar" " " "baz"}}')
    });

    _emberRuntimeTestsUtils.runAppend(component);

    equal(component.$().text(), 'foo bar baz');
  });

  QUnit.test('updates for bound params', function () {
    component = _emberViewsViewsComponent.default.create({
      container: container,

      firstParam: 'one',
      secondParam: 'two',

      layout: _emberTemplateCompilerSystemCompile.default('{{concat firstParam secondParam}}')
    });

    _emberRuntimeTestsUtils.runAppend(component);

    equal(component.$().text(), 'onetwo');

    _emberMetalRun_loop.default(function () {
      component.set('firstParam', 'three');
    });

    equal(component.$().text(), 'threetwo');

    _emberMetalRun_loop.default(function () {
      component.set('secondParam', 'four');
    });

    equal(component.$().text(), 'threefour');
  });

  QUnit.test('can be used as a sub-expression', function () {
    function eq(_ref) {
      var actual = _ref[0];
      var expected = _ref[1];

      return actual === expected;
    }
    registry.register('helper:x-eq', _emberHtmlbarsHelper.helper(eq));

    component = _emberViewsViewsComponent.default.create({
      container: container,

      firstParam: 'one',
      secondParam: 'two',

      layout: _emberTemplateCompilerSystemCompile.default('{{#if (x-eq (concat firstParam secondParam) "onetwo")}}Truthy!{{else}}False{{/if}}')
    });

    _emberRuntimeTestsUtils.runAppend(component);

    equal(component.$().text(), 'Truthy!');

    _emberMetalRun_loop.default(function () {
      component.set('firstParam', 'three');
    });

    equal(component.$().text(), 'False');
  });
});
enifed('ember-htmlbars/tests/helpers/concat-test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/helpers');
  test('ember-htmlbars/tests/helpers/concat-test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/helpers/concat-test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/helpers/concat-test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/helpers');
  QUnit.test('ember-htmlbars/tests/helpers/concat-test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/helpers/concat-test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/helpers/custom_helper_test', ['exports', 'ember-metal/core', 'ember-views/views/component', 'ember-htmlbars/helper', 'ember-template-compiler/system/compile', 'ember-runtime/tests/utils', 'container/registry', 'ember-metal/run_loop', 'ember-views/component_lookup'], function (exports, _emberMetalCore, _emberViewsViewsComponent, _emberHtmlbarsHelper, _emberTemplateCompilerSystemCompile, _emberRuntimeTestsUtils, _containerRegistry, _emberMetalRun_loop, _emberViewsComponent_lookup) {
  'use strict';

  var registry = undefined,
      container = undefined,
      component = undefined;

  QUnit.module('ember-htmlbars: custom app helpers', {
    setup: function () {
      registry = new _containerRegistry.default();
      registry.optionsForType('template', { instantiate: false });
      registry.optionsForType('helper', { singleton: false });
      container = registry.container();
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(component);
      _emberRuntimeTestsUtils.runDestroy(container);
      registry = container = component = null;
    }
  });

  QUnit.test('dashed shorthand helper is resolved from container', function () {
    var HelloWorld = _emberHtmlbarsHelper.helper(function () {
      return 'hello world';
    });
    registry.register('helper:hello-world', HelloWorld);
    component = _emberViewsViewsComponent.default.extend({
      container: container,
      layout: _emberTemplateCompilerSystemCompile.default('{{hello-world}}')
    }).create();

    _emberRuntimeTestsUtils.runAppend(component);
    equal(component.$().text(), 'hello world');
  });

  QUnit.test('dashed helper is resolved from container', function () {
    var HelloWorld = _emberHtmlbarsHelper.default.extend({
      compute: function () {
        return 'hello world';
      }
    });
    registry.register('helper:hello-world', HelloWorld);
    component = _emberViewsViewsComponent.default.extend({
      container: container,
      layout: _emberTemplateCompilerSystemCompile.default('{{hello-world}}')
    }).create();

    _emberRuntimeTestsUtils.runAppend(component);
    equal(component.$().text(), 'hello world');
  });

  QUnit.test('dashed helper can recompute a new value', function () {
    var destroyCount = 0;
    var count = 0;
    var helper;
    var HelloWorld = _emberHtmlbarsHelper.default.extend({
      init: function () {
        this._super.apply(this, arguments);
        helper = this;
      },
      compute: function () {
        return ++count;
      },
      destroy: function () {
        destroyCount++;
        this._super();
      }
    });
    registry.register('helper:hello-world', HelloWorld);
    component = _emberViewsViewsComponent.default.extend({
      container: container,
      layout: _emberTemplateCompilerSystemCompile.default('{{hello-world}}')
    }).create();

    _emberRuntimeTestsUtils.runAppend(component);
    equal(component.$().text(), '1');
    _emberMetalRun_loop.default(function () {
      helper.recompute();
    });
    equal(component.$().text(), '2');
    equal(destroyCount, 0, 'destroy is not called on recomputation');
  });

  QUnit.test('dashed helper with arg can recompute a new value', function () {
    var destroyCount = 0;
    var count = 0;
    var helper;
    var HelloWorld = _emberHtmlbarsHelper.default.extend({
      init: function () {
        this._super.apply(this, arguments);
        helper = this;
      },
      compute: function () {
        return ++count;
      },
      destroy: function () {
        destroyCount++;
        this._super();
      }
    });
    registry.register('helper:hello-world', HelloWorld);
    component = _emberViewsViewsComponent.default.extend({
      container: container,
      layout: _emberTemplateCompilerSystemCompile.default('{{hello-world "whut"}}')
    }).create();

    _emberRuntimeTestsUtils.runAppend(component);
    equal(component.$().text(), '1');
    _emberMetalRun_loop.default(function () {
      helper.recompute();
    });
    equal(component.$().text(), '2');
    equal(destroyCount, 0, 'destroy is not called on recomputation');
  });

  QUnit.test('dashed shorthand helper is called for param changes', function () {
    var count = 0;
    var HelloWorld = _emberHtmlbarsHelper.helper(function () {
      return ++count;
    });
    registry.register('helper:hello-world', HelloWorld);
    component = _emberViewsViewsComponent.default.extend({
      container: container,
      name: 'bob',
      layout: _emberTemplateCompilerSystemCompile.default('{{hello-world name}}')
    }).create();

    _emberRuntimeTestsUtils.runAppend(component);
    equal(component.$().text(), '1');
    _emberMetalRun_loop.default(function () {
      component.set('name', 'sal');
    });
    equal(component.$().text(), '2');
  });

  QUnit.test('dashed helper compute is called for param changes', function () {
    var count = 0;
    var createCount = 0;
    var HelloWorld = _emberHtmlbarsHelper.default.extend({
      init: function () {
        this._super.apply(this, arguments);
        // FIXME: Ideally, the helper instance does not need to be recreated
        // for change of params.
        createCount++;
      },
      compute: function () {
        return ++count;
      }
    });
    registry.register('helper:hello-world', HelloWorld);
    component = _emberViewsViewsComponent.default.extend({
      container: container,
      name: 'bob',
      layout: _emberTemplateCompilerSystemCompile.default('{{hello-world name}}')
    }).create();

    _emberRuntimeTestsUtils.runAppend(component);
    equal(component.$().text(), '1');
    _emberMetalRun_loop.default(function () {
      component.set('name', 'sal');
    });
    equal(component.$().text(), '2');
    equal(createCount, 1, 'helper is only created once');
  });

  QUnit.test('dashed shorthand helper receives params, hash', function () {
    var params, hash;
    var HelloWorld = _emberHtmlbarsHelper.helper(function (_params, _hash) {
      params = _params;
      hash = _hash;
    });
    registry.register('helper:hello-world', HelloWorld);
    component = _emberViewsViewsComponent.default.extend({
      container: container,
      name: 'bob',
      layout: _emberTemplateCompilerSystemCompile.default('{{hello-world name "rich" last="sam"}}')
    }).create();

    _emberRuntimeTestsUtils.runAppend(component);

    equal(params[0], 'bob', 'first argument is bob');
    equal(params[1], 'rich', 'second argument is rich');
    equal(hash.last, 'sam', 'hash.last argument is sam');
  });

  QUnit.test('dashed helper receives params, hash', function () {
    var params, hash;
    var HelloWorld = _emberHtmlbarsHelper.default.extend({
      compute: function (_params, _hash) {
        params = _params;
        hash = _hash;
      }
    });
    registry.register('helper:hello-world', HelloWorld);
    component = _emberViewsViewsComponent.default.extend({
      container: container,
      name: 'bob',
      layout: _emberTemplateCompilerSystemCompile.default('{{hello-world name "rich" last="sam"}}')
    }).create();

    _emberRuntimeTestsUtils.runAppend(component);

    equal(params[0], 'bob', 'first argument is bob');
    equal(params[1], 'rich', 'second argument is rich');
    equal(hash.last, 'sam', 'hash.last argument is sam');
  });

  QUnit.test('dashed helper usable in subexpressions', function () {
    var JoinWords = _emberHtmlbarsHelper.default.extend({
      compute: function (params) {
        return params.join(' ');
      }
    });
    registry.register('helper:join-words', JoinWords);
    component = _emberViewsViewsComponent.default.extend({
      container: container,
      layout: _emberTemplateCompilerSystemCompile.default('{{join-words "Who"\n                   (join-words "overcomes" "by")\n                   "force"\n                   (join-words (join-words "hath overcome but" "half"))\n                   (join-words "his" (join-words "foe"))}}')
    }).create();

    _emberRuntimeTestsUtils.runAppend(component);

    equal(component.$().text(), 'Who overcomes by force hath overcome but half his foe');
  });

  QUnit.test('dashed helper not usable with a block', function () {
    var SomeHelper = _emberHtmlbarsHelper.helper(function () {});
    registry.register('helper:some-helper', SomeHelper);
    component = _emberViewsViewsComponent.default.extend({
      container: container,
      layout: _emberTemplateCompilerSystemCompile.default('{{#some-helper}}{{/some-helper}}')
    }).create();

    expectAssertion(function () {
      _emberRuntimeTestsUtils.runAppend(component);
    }, /Helpers may not be used in the block form/);
  });

  QUnit.test('dashed helper not usable within element', function () {
    var SomeHelper = _emberHtmlbarsHelper.helper(function () {});
    registry.register('helper:some-helper', SomeHelper);
    component = _emberViewsViewsComponent.default.extend({
      container: container,
      layout: _emberTemplateCompilerSystemCompile.default('<div {{some-helper}}></div>')
    }).create();

    expectAssertion(function () {
      _emberRuntimeTestsUtils.runAppend(component);
    }, /Helpers may not be used in the element form/);
  });

  QUnit.test('dashed helper is torn down', function () {
    var destroyCalled = 0;
    var SomeHelper = _emberHtmlbarsHelper.default.extend({
      destroy: function () {
        destroyCalled++;
        this._super.apply(this, arguments);
      },
      compute: function () {
        return 'must define a compute';
      }
    });
    registry.register('helper:some-helper', SomeHelper);
    component = _emberViewsViewsComponent.default.extend({
      container: container,
      layout: _emberTemplateCompilerSystemCompile.default('{{some-helper}}')
    }).create();

    _emberRuntimeTestsUtils.runAppend(component);
    _emberRuntimeTestsUtils.runDestroy(component);

    equal(destroyCalled, 1, 'destroy called once');
  });

  QUnit.test('dashed helper used in subexpression can recompute', function () {
    var helper;
    var phrase = 'overcomes by';
    var DynamicSegment = _emberHtmlbarsHelper.default.extend({
      init: function () {
        this._super.apply(this, arguments);
        helper = this;
      },
      compute: function () {
        return phrase;
      }
    });
    var JoinWords = _emberHtmlbarsHelper.default.extend({
      compute: function (params) {
        return params.join(' ');
      }
    });
    registry.register('helper:dynamic-segment', DynamicSegment);
    registry.register('helper:join-words', JoinWords);
    component = _emberViewsViewsComponent.default.extend({
      container: container,
      layout: _emberTemplateCompilerSystemCompile.default('{{join-words "Who"\n                   (dynamic-segment)\n                   "force"\n                   (join-words (join-words "hath overcome but" "half"))\n                   (join-words "his" (join-words "foe"))}}')
    }).create();

    _emberRuntimeTestsUtils.runAppend(component);

    equal(component.$().text(), 'Who overcomes by force hath overcome but half his foe');

    phrase = 'believes his';
    _emberMetalCore.default.run(function () {
      helper.recompute();
    });

    equal(component.$().text(), 'Who believes his force hath overcome but half his foe');
  });

  QUnit.test('dashed helper used in subexpression can recompute component', function () {
    var helper;
    var phrase = 'overcomes by';
    var DynamicSegment = _emberHtmlbarsHelper.default.extend({
      init: function () {
        this._super.apply(this, arguments);
        helper = this;
      },
      compute: function () {
        return phrase;
      }
    });
    var JoinWords = _emberHtmlbarsHelper.default.extend({
      compute: function (params) {
        return params.join(' ');
      }
    });
    registry.register('component-lookup:main', _emberViewsComponent_lookup.default);
    registry.register('component:some-component', _emberMetalCore.default.Component.extend({
      layout: _emberTemplateCompilerSystemCompile.default('{{first}} {{second}} {{third}} {{fourth}} {{fifth}}')
    }));
    registry.register('helper:dynamic-segment', DynamicSegment);
    registry.register('helper:join-words', JoinWords);
    component = _emberViewsViewsComponent.default.extend({
      container: container,
      layout: _emberTemplateCompilerSystemCompile.default('{{some-component first="Who"\n                   second=(dynamic-segment)\n                   third="force"\n                   fourth=(join-words (join-words "hath overcome but" "half"))\n                   fifth=(join-words "his" (join-words "foe"))}}')
    }).create();

    _emberRuntimeTestsUtils.runAppend(component);

    equal(component.$().text(), 'Who overcomes by force hath overcome but half his foe');

    phrase = 'believes his';
    _emberMetalCore.default.run(function () {
      helper.recompute();
    });

    equal(component.$().text(), 'Who believes his force hath overcome but half his foe');
  });

  QUnit.test('dashed helper used in subexpression is destroyed', function () {
    var destroyCount = 0;
    var DynamicSegment = _emberHtmlbarsHelper.default.extend({
      phrase: 'overcomes by',
      compute: function () {
        return this.phrase;
      },
      destroy: function () {
        destroyCount++;
        this._super.apply(this, arguments);
      }
    });
    var JoinWords = _emberHtmlbarsHelper.helper(function (params) {
      return params.join(' ');
    });
    registry.register('helper:dynamic-segment', DynamicSegment);
    registry.register('helper:join-words', JoinWords);
    component = _emberViewsViewsComponent.default.extend({
      container: container,
      layout: _emberTemplateCompilerSystemCompile.default('{{join-words "Who"\n                   (dynamic-segment)\n                   "force"\n                   (join-words (join-words "hath overcome but" "half"))\n                   (join-words "his" (join-words "foe"))}}')
    }).create();

    _emberRuntimeTestsUtils.runAppend(component);
    _emberRuntimeTestsUtils.runDestroy(component);

    equal(destroyCount, 1, 'destroy is called after a view is destroyed');
  });
});
enifed('ember-htmlbars/tests/helpers/custom_helper_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/helpers');
  test('ember-htmlbars/tests/helpers/custom_helper_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/helpers/custom_helper_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/helpers/custom_helper_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/helpers');
  QUnit.test('ember-htmlbars/tests/helpers/custom_helper_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/helpers/custom_helper_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/helpers/debug_test', ['exports', 'ember-metal/core', 'ember-metal/logger', 'ember-views/views/view', 'ember-template-compiler/system/compile', 'ember-runtime/tests/utils'], function (exports, _emberMetalCore, _emberMetalLogger, _emberViewsViewsView, _emberTemplateCompilerSystemCompile, _emberRuntimeTestsUtils) {
  'use strict';

  var originalLookup = _emberMetalCore.default.lookup;
  var lookup;
  var originalLog, logCalls;
  var view;

  QUnit.module('Handlebars {{log}} helper', {
    setup: function () {
      _emberMetalCore.default.lookup = lookup = { Ember: _emberMetalCore.default };

      originalLog = _emberMetalLogger.default.log;
      logCalls = [];
      _emberMetalLogger.default.log = function () {
        logCalls.push.apply(logCalls, arguments);
      };
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(view);
      view = null;

      _emberMetalLogger.default.log = originalLog;
      _emberMetalCore.default.lookup = originalLookup;
    }
  });

  QUnit.test('should be able to log multiple properties', function () {
    var context = {
      value: 'one',
      valueTwo: 'two'
    };

    view = _emberViewsViewsView.default.create({
      context: context,
      template: _emberTemplateCompilerSystemCompile.default('{{log value valueTwo}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), '', 'shouldn\'t render any text');
    equal(logCalls[0], 'one');
    equal(logCalls[1], 'two');
  });

  QUnit.test('should be able to log primitives', function () {
    var context = {
      value: 'one',
      valueTwo: 'two'
    };

    view = _emberViewsViewsView.default.create({
      context: context,
      template: _emberTemplateCompilerSystemCompile.default('{{log value "foo" 0 valueTwo true}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), '', 'shouldn\'t render any text');
    strictEqual(logCalls[0], 'one');
    strictEqual(logCalls[1], 'foo');
    strictEqual(logCalls[2], 0);
    strictEqual(logCalls[3], 'two');
    strictEqual(logCalls[4], true);
  });
});
// Ember.lookup
enifed('ember-htmlbars/tests/helpers/debug_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/helpers');
  test('ember-htmlbars/tests/helpers/debug_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/helpers/debug_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/helpers/debug_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/helpers');
  QUnit.test('ember-htmlbars/tests/helpers/debug_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/helpers/debug_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/helpers/each_in_test', ['exports', 'ember-metal/features', 'ember-views/views/component', 'ember-template-compiler/system/compile', 'ember-metal/run_loop', 'ember-runtime/tests/utils'], function (exports, _emberMetalFeatures, _emberViewsViewsComponent, _emberTemplateCompilerSystemCompile, _emberMetalRun_loop, _emberRuntimeTestsUtils) {
  'use strict';

  var component;

  QUnit.module('ember-htmlbars: {{#each-in}} helper', {
    teardown: function () {
      if (component) {
        _emberRuntimeTestsUtils.runDestroy(component);
      }
    }
  });

  function renderTemplate(_template, props) {
    var template = _emberTemplateCompilerSystemCompile.default(_template);

    component = _emberViewsViewsComponent.default.create(props, {
      layout: template
    });

    _emberRuntimeTestsUtils.runAppend(component);
  }

  QUnit.test('it renders the template for each item in a hash', function (assert) {
    var categories = {
      'Smartphones': 8203,
      'JavaScript Frameworks': Infinity
    };

    renderTemplate('\n      <ul class="categories">\n      {{#each-in categories as |category count|}}\n        <li>{{category}}: {{count}}</li>\n      {{/each-in}}\n      </ul>\n    ', { categories: categories });

    assert.equal(component.$('li').length, 2, 'renders 2 lis');
    assert.equal(component.$('li').first().text(), 'Smartphones: 8203', 'renders first item correctly');
    assert.equal(component.$('li:eq(1)').text(), 'JavaScript Frameworks: Infinity', 'renders second item correctly');

    _emberMetalRun_loop.default(function () {
      component.rerender();
    });

    assert.equal(component.$('li').length, 2, 'renders 2 lis after rerender');
    assert.equal(component.$('li').first().text(), 'Smartphones: 8203', 'renders first item correctly after rerender');
    assert.equal(component.$('li:eq(1)').text(), 'JavaScript Frameworks: Infinity', 'renders second item correctly after rerender');

    _emberMetalRun_loop.default(function () {
      component.set('categories', {
        'Smartphones': 100
      });
    });

    assert.equal(component.$('li').length, 1, 'removes unused item after data changes');
    assert.equal(component.$('li').first().text(), 'Smartphones: 100', 'correctly updates item after data changes');

    _emberMetalRun_loop.default(function () {
      component.set('categories', {
        'Programming Languages': 199303,
        'Good Programming Languages': 123,
        'Bad Programming Languages': 456
      });
    });

    assert.equal(component.$('li').length, 3, 'renders 3 lis after updating data');
    assert.equal(component.$('li').first().text(), 'Programming Languages: 199303', 'renders first item correctly after rerender');
    assert.equal(component.$('li:eq(1)').text(), 'Good Programming Languages: 123', 'renders second item correctly after rerender');
    assert.equal(component.$('li:eq(2)').text(), 'Bad Programming Languages: 456', 'renders third item correctly after rerender');
  });

  QUnit.test('it only iterates over an object\'s own properties', function (assert) {
    var protoCategories = {
      'Smartphones': 8203,
      'JavaScript Frameworks': Infinity
    };

    var categories = Object.create(protoCategories);
    categories['Televisions'] = 183;
    categories['Alarm Clocks'] = 999;

    renderTemplate('\n      <ul class="categories">\n      {{#each-in categories as |category count|}}\n        <li>{{category}}: {{count}}</li>\n      {{/each-in}}\n      </ul>\n    ', { categories: categories });

    assert.equal(component.$('li').length, 2, 'renders 2 lis');
    assert.equal(component.$('li').first().text(), 'Televisions: 183', 'renders first item correctly');
    assert.equal(component.$('li:eq(1)').text(), 'Alarm Clocks: 999', 'renders second item correctly');

    _emberMetalRun_loop.default(function () {
      return component.rerender();
    });

    assert.equal(component.$('li').length, 2, 'renders 2 lis after rerender');
    assert.equal(component.$('li').first().text(), 'Televisions: 183', 'renders first item correctly after rerender');
    assert.equal(component.$('li:eq(1)').text(), 'Alarm Clocks: 999', 'renders second item correctly after rerender');
  });

  QUnit.test('it emits nothing if the passed argument is not an object', function (assert) {
    var categories = null;

    renderTemplate('\n      <ul class="categories">\n      {{#each-in categories as |category count|}}\n        <li>{{category}}: {{count}}</li>\n      {{/each-in}}\n      </ul>\n    ', { categories: categories });

    assert.equal(component.$('li').length, 0, 'nothing is rendered if the object is not passed');

    _emberMetalRun_loop.default(function () {
      return component.rerender();
    });
    assert.equal(component.$('li').length, 0, 'nothing is rendered if the object is not passed after rerender');
  });

  QUnit.test('it supports rendering an inverse', function (assert) {
    var categories = null;

    renderTemplate('\n      <ul class="categories">\n      {{#each-in categories as |category count|}}\n        <li>{{category}}: {{count}}</li>\n      {{else}}\n        <li>No categories.</li>\n      {{/each-in}}\n      </ul>\n    ', { categories: categories });

    assert.equal(component.$('li').length, 1, 'one li is rendered');
    assert.equal(component.$('li').text(), 'No categories.', 'the inverse is rendered');

    _emberMetalRun_loop.default(function () {
      return component.rerender();
    });
    assert.equal(component.$('li').length, 1, 'one li is rendered');
    assert.equal(component.$('li').text(), 'No categories.', 'the inverse is rendered');

    _emberMetalRun_loop.default(function () {
      component.set('categories', {
        'First Category': 123
      });
    });

    assert.equal(component.$('li').length, 1, 'one li is rendered');
    assert.equal(component.$('li').text(), 'First Category: 123', 'the list is rendered after being set');

    _emberMetalRun_loop.default(function () {
      component.set('categories', null);
    });

    assert.equal(component.$('li').length, 1, 'one li is rendered');
    assert.equal(component.$('li').text(), 'No categories.', 'the inverse is rendered when the value becomes falsey again');
  });
});
enifed('ember-htmlbars/tests/helpers/each_in_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/helpers');
  test('ember-htmlbars/tests/helpers/each_in_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/helpers/each_in_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/helpers/each_in_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/helpers');
  QUnit.test('ember-htmlbars/tests/helpers/each_in_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/helpers/each_in_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/helpers/each_test', ['exports', 'ember-metal/core', 'ember-runtime/system/object', 'ember-metal/run_loop', 'ember-views/views/view', 'ember-views/views/legacy_each_view', 'ember-runtime/system/native_array', 'ember-runtime/controllers/controller', 'ember-runtime/system/container', 'ember-metal/property_set', 'ember-runtime/tests/utils', 'ember-template-compiler/system/compile', 'ember-htmlbars/tests/utils', 'ember-template-compiler/plugins/transform-each-into-collection', 'ember-htmlbars/keywords/view'], function (exports, _emberMetalCore, _emberRuntimeSystemObject, _emberMetalRun_loop, _emberViewsViewsView, _emberViewsViewsLegacy_each_view, _emberRuntimeSystemNative_array, _emberRuntimeControllersController, _emberRuntimeSystemContainer, _emberMetalProperty_set, _emberRuntimeTestsUtils, _emberTemplateCompilerSystemCompile, _emberHtmlbarsTestsUtils, _emberTemplateCompilerPluginsTransformEachIntoCollection, _emberHtmlbarsKeywordsView) {
  /*jshint newcap:false*/
  'use strict';

  var people, view, registry, container;
  var template, templateMyView, MyView, MyEmptyView, templateMyEmptyView;
  var originalViewKeyword;

  var originalLookup = _emberMetalCore.default.lookup;
  var lookup;

  QUnit.module('the #each helper', {
    setup: function () {
      _emberMetalCore.default.lookup = lookup = { Ember: _emberMetalCore.default };

      originalViewKeyword = _emberHtmlbarsTestsUtils.registerKeyword('view', _emberHtmlbarsKeywordsView.default);

      _emberHtmlbarsTestsUtils.registerAstPlugin(_emberTemplateCompilerPluginsTransformEachIntoCollection.default);

      template = _emberTemplateCompilerSystemCompile.default('{{#each view.people as |person|}}{{person.name}}{{/each}}');
      people = _emberRuntimeSystemNative_array.A([{ name: 'Steve Holt' }, { name: 'Annabelle' }]);

      registry = new _emberRuntimeSystemContainer.Registry();
      container = registry.container();

      registry.register('view:toplevel', _emberViewsViewsView.default.extend());
      registry.register('view:-legacy-each', _emberViewsViewsLegacy_each_view.default);

      view = _emberViewsViewsView.default.create({
        container: container,
        template: template,
        people: people
      });

      templateMyView = _emberTemplateCompilerSystemCompile.default('{{name}}');
      lookup.MyView = MyView = _emberViewsViewsView.default.extend({ template: templateMyView });
      registry.register('view:my-view', MyView);

      templateMyEmptyView = _emberTemplateCompilerSystemCompile.default('I\'m empty');
      lookup.MyEmptyView = MyEmptyView = _emberViewsViewsView.default.extend({
        template: templateMyEmptyView
      });
      registry.register('view:my-empty-view', MyEmptyView);

      _emberRuntimeTestsUtils.runAppend(view);
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(container);
      _emberRuntimeTestsUtils.runDestroy(view);
      registry = container = view = null;

      _emberMetalCore.default.lookup = originalLookup;

      _emberHtmlbarsTestsUtils.removeAstPlugin(_emberTemplateCompilerPluginsTransformEachIntoCollection.default);

      _emberHtmlbarsTestsUtils.resetKeyword('view', originalViewKeyword);
    }
  });

  var assertHTML = function (view, expectedHTML) {
    var html = view.$().html();

    // IE 8 (and prior?) adds the \r\n
    html = html.replace(/<script[^>]*><\/script>/ig, '').replace(/[\r\n]/g, '');

    equal(html, expectedHTML);
  };

  var assertText = function (view, expectedText) {
    equal(view.$().text(), expectedText);
  };

  QUnit.test('it renders the template for each item in an array', function () {
    assertHTML(view, 'Steve HoltAnnabelle');
  });

  QUnit.test('it updates the view if an item is added', function () {
    _emberMetalRun_loop.default(function () {
      people.pushObject({ name: 'Tom Dale' });
    });

    assertHTML(view, 'Steve HoltAnnabelleTom Dale');
  });

  QUnit.test('it updates the view if an item is removed', function () {
    _emberMetalRun_loop.default(function () {
      people.removeAt(0);
    });

    assertHTML(view, 'Annabelle');
  });

  QUnit.test('it updates the view if an item is replaced', function () {
    _emberMetalRun_loop.default(function () {
      people.removeAt(0);
      people.insertAt(0, { name: 'Kazuki' });
    });

    assertHTML(view, 'KazukiAnnabelle');
  });

  QUnit.test('can add and replace in the same runloop', function () {
    _emberMetalRun_loop.default(function () {
      people.pushObject({ name: 'Tom Dale' });
      people.removeAt(0);
      people.insertAt(0, { name: 'Kazuki' });
    });

    assertHTML(view, 'KazukiAnnabelleTom Dale');
  });

  QUnit.test('can add and replace the object before the add in the same runloop', function () {
    _emberMetalRun_loop.default(function () {
      people.pushObject({ name: 'Tom Dale' });
      people.removeAt(1);
      people.insertAt(1, { name: 'Kazuki' });
    });

    assertHTML(view, 'Steve HoltKazukiTom Dale');
  });

  QUnit.test('can add and replace complicatedly', function () {
    _emberMetalRun_loop.default(function () {
      people.pushObject({ name: 'Tom Dale' });
      people.removeAt(1);
      people.insertAt(1, { name: 'Kazuki' });
      people.pushObject({ name: 'Firestone' });
      people.pushObject({ name: 'McMunch' });
      people.removeAt(3);
    });

    assertHTML(view, 'Steve HoltKazukiTom DaleMcMunch');
  });

  QUnit.test('can add and replace complicatedly harder', function () {
    _emberMetalRun_loop.default(function () {
      people.pushObject({ name: 'Tom Dale' });
      people.removeAt(1);
      people.insertAt(1, { name: 'Kazuki' });
      people.pushObject({ name: 'Firestone' });
      people.pushObject({ name: 'McMunch' });
      people.removeAt(2);
    });

    assertHTML(view, 'Steve HoltKazukiFirestoneMcMunch');
  });

  QUnit.test('it does not mark each option tag as selected', function () {
    var selectView = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('<select id="people-select"><option value="">Please select a name</option>{{#each view.people}}<option value={{name}}>{{name}}</option>{{/each}}</select>'),
      people: people
    });

    _emberRuntimeTestsUtils.runAppend(selectView);

    equal(selectView.$('option').length, 3, 'renders 3 <option> elements');

    equal(selectView.$().find(':selected').text(), 'Please select a name', 'first option is selected');

    _emberMetalRun_loop.default(function () {
      people.pushObject({ name: 'Black Francis' });
    });

    equal(selectView.$().find(':selected').text(), 'Please select a name', 'first option is selected');

    equal(selectView.$('option').length, 4, 'renders an additional <option> element when an object is added');

    _emberRuntimeTestsUtils.runDestroy(selectView);
  });

  QUnit.test('View should not use keyword incorrectly - Issue #1315', function () {
    _emberRuntimeTestsUtils.runDestroy(view);

    view = _emberViewsViewsView.default.create({
      container: container,
      template: _emberTemplateCompilerSystemCompile.default('{{#each view.content as |value|}}{{value}}-{{#each view.options as |option|}}{{option.value}}:{{option.label}} {{/each}}{{/each}}'),

      content: _emberRuntimeSystemNative_array.A(['X', 'Y']),
      options: _emberRuntimeSystemNative_array.A([{ label: 'One', value: 1 }, { label: 'Two', value: 2 }])
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'X-1:One 2:Two Y-1:One 2:Two ');
  });

  QUnit.test('it works inside a ul element', function () {
    var ulView = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('<ul>{{#each view.people}}<li>{{name}}</li>{{/each}}</ul>'),
      people: people
    });

    _emberRuntimeTestsUtils.runAppend(ulView);

    equal(ulView.$('li').length, 2, 'renders two <li> elements');

    _emberMetalRun_loop.default(function () {
      people.pushObject({ name: 'Black Francis' });
    });

    equal(ulView.$('li').length, 3, 'renders an additional <li> element when an object is added');

    _emberRuntimeTestsUtils.runDestroy(ulView);
  });

  QUnit.test('it works inside a table element', function () {
    var tableView = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('<table><tbody>{{#each view.people}}<tr><td>{{name}}</td></tr>{{/each}}</tbody></table>'),
      people: people
    });

    _emberRuntimeTestsUtils.runAppend(tableView);

    equal(tableView.$('td').length, 2, 'renders two <td> elements');

    _emberMetalRun_loop.default(function () {
      people.pushObject({ name: 'Black Francis' });
    });

    equal(tableView.$('td').length, 3, 'renders an additional <td> element when an object is added');

    _emberMetalRun_loop.default(function () {
      people.insertAt(0, { name: 'Kim Deal' });
    });

    equal(tableView.$('td').length, 4, 'renders an additional <td> when an object is inserted at the beginning of the array');

    _emberRuntimeTestsUtils.runDestroy(tableView);
  });

  QUnit.test('it supports {{itemView=}}', function () {
    _emberRuntimeTestsUtils.runDestroy(view);
    var itemView = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('itemView:{{name}}')
    });

    expectDeprecation(function () {
      view = _emberViewsViewsView.default.create({
        template: _emberTemplateCompilerSystemCompile.default('{{each view.people itemView="anItemView"}}'),
        people: people,
        container: container
      });
    }, /Using 'itemView' with '{{each}}'/);

    registry.register('view:anItemView', itemView);

    _emberRuntimeTestsUtils.runAppend(view);

    assertText(view, 'itemView:Steve HoltitemView:Annabelle');
  });

  QUnit.test('it defers all normalization of itemView names to the resolver', function () {
    _emberRuntimeTestsUtils.runDestroy(view);
    var itemView = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('itemView:{{name}}')
    });

    expectDeprecation(function () {
      view = _emberViewsViewsView.default.create({
        template: _emberTemplateCompilerSystemCompile.default('{{each view.people itemView="an-item-view"}}'),
        people: people,
        container: container
      });
    }, /Using 'itemView' with '{{each}}'/);

    registry.register('view:an-item-view', itemView);
    _emberRuntimeTestsUtils.runAppend(view);

    assertText(view, 'itemView:Steve HoltitemView:Annabelle');
  });

  QUnit.test('it supports {{itemViewClass=}} via container', function () {
    _emberRuntimeTestsUtils.runDestroy(view);
    expectDeprecation(function () {
      view = _emberViewsViewsView.default.create({
        container: container,
        template: _emberTemplateCompilerSystemCompile.default('{{each view.people itemViewClass="my-view"}}'),
        people: people
      });
    }, /Using 'itemViewClass' with '{{each}}'/);

    _emberRuntimeTestsUtils.runAppend(view);

    assertText(view, 'Steve HoltAnnabelle');
  });

  QUnit.test('it supports {{itemViewClass=}} with each view tagName (DEPRECATED)', function () {
    _emberRuntimeTestsUtils.runDestroy(view);
    expectDeprecation(function () {
      view = _emberViewsViewsView.default.create({
        template: _emberTemplateCompilerSystemCompile.default('{{each view.people itemViewClass="my-view" tagName="ul"}}'),
        people: people,
        container: container
      });
    }, /Using 'itemViewClass' with '{{each}}'/);

    _emberRuntimeTestsUtils.runAppend(view);
    equal(view.$('ul').length, 1, 'rendered ul tag');
    equal(view.$('ul li').length, 2, 'rendered 2 li tags');
    equal(view.$('ul li').text(), 'Steve HoltAnnabelle');
  });

  QUnit.test('it supports {{itemViewClass=}} with tagName in itemViewClass (DEPRECATED)', function () {
    _emberRuntimeTestsUtils.runDestroy(view);
    registry.register('view:li-view', _emberViewsViewsView.default.extend({
      tagName: 'li'
    }));

    expectDeprecation(function () {
      view = _emberViewsViewsView.default.create({
        template: _emberTemplateCompilerSystemCompile.default('<ul>{{#each view.people itemViewClass="li-view" as |item|}}{{item.name}}{{/each}}</ul>'),
        people: people,
        container: container
      });
    }, /Using 'itemViewClass' with '{{each}}'/);

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('ul').length, 1, 'rendered ul tag');
    equal(view.$('ul li').length, 2, 'rendered 2 li tags');
    equal(view.$('ul li').text(), 'Steve HoltAnnabelle');
  });

  QUnit.test('it supports {{itemViewClass=}} with {{else}} block (DEPRECATED)', function () {
    _emberRuntimeTestsUtils.runDestroy(view);
    expectDeprecation(function () {
      view = _emberViewsViewsView.default.create({
        template: _emberTemplateCompilerSystemCompile.default('\n        {{~#each view.people itemViewClass="my-view" as |item|~}}\n          {{item.name}}\n        {{~else~}}\n          No records!\n        {{~/each}}'),
        people: _emberRuntimeSystemNative_array.A(),
        container: container
      });
    }, /Using 'itemViewClass' with '{{each}}'/);

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'No records!');
  });

  QUnit.test('it supports {{emptyView=}}', function () {
    _emberRuntimeTestsUtils.runDestroy(view);
    var emptyView = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('emptyView:sad panda')
    });

    expectDeprecation(function () {
      view = _emberViewsViewsView.default.create({
        template: _emberTemplateCompilerSystemCompile.default('{{each view.people emptyView="anEmptyView"}}'),
        people: _emberRuntimeSystemNative_array.A(),
        container: container
      });
    }, /Using 'emptyView' with '{{each}}'/);

    registry.register('view:anEmptyView', emptyView);

    _emberRuntimeTestsUtils.runAppend(view);

    assertText(view, 'emptyView:sad panda');
  });

  QUnit.test('it defers all normalization of emptyView names to the resolver', function () {
    _emberRuntimeTestsUtils.runDestroy(view);
    var emptyView = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('emptyView:sad panda')
    });

    expectDeprecation(function () {
      view = _emberViewsViewsView.default.create({
        template: _emberTemplateCompilerSystemCompile.default('{{each view.people emptyView="an-empty-view"}}'),
        people: _emberRuntimeSystemNative_array.A(),
        container: container
      });
    }, /Using 'emptyView' with '{{each}}'/);

    registry.register('view:an-empty-view', emptyView);

    _emberRuntimeTestsUtils.runAppend(view);

    assertText(view, 'emptyView:sad panda');
  });

  QUnit.test('it supports {{emptyViewClass=}} via container', function () {
    _emberRuntimeTestsUtils.runDestroy(view);
    expectDeprecation(function () {
      view = _emberViewsViewsView.default.create({
        container: container,
        template: _emberTemplateCompilerSystemCompile.default('{{each view.people emptyViewClass="my-empty-view"}}'),
        people: _emberRuntimeSystemNative_array.A()
      });
    }, /Using 'emptyViewClass' with '{{each}}'/);

    _emberRuntimeTestsUtils.runAppend(view);

    assertText(view, 'I\'m empty');
  });

  QUnit.test('it supports {{emptyViewClass=}} with tagName (DEPRECATED)', function () {
    _emberRuntimeTestsUtils.runDestroy(view);
    expectDeprecation(function () {
      view = _emberViewsViewsView.default.create({
        template: _emberTemplateCompilerSystemCompile.default('{{each view.people emptyViewClass="my-empty-view" tagName="b"}}'),
        people: _emberRuntimeSystemNative_array.A(),
        container: container
      });
    }, /Using 'emptyViewClass' with '{{each}}'/);

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('b').length, 1, 'rendered b tag');
    equal(view.$('b').text(), 'I\'m empty');
  });

  QUnit.test('it supports {{emptyViewClass=}} with in format', function () {
    _emberRuntimeTestsUtils.runDestroy(view);
    expectDeprecation(function () {
      view = _emberViewsViewsView.default.create({
        container: container,
        template: _emberTemplateCompilerSystemCompile.default('{{each person in view.people emptyViewClass="my-empty-view"}}'),
        people: _emberRuntimeSystemNative_array.A()
      });
    }, /Using 'emptyViewClass' with '{{each}}'/);

    _emberRuntimeTestsUtils.runAppend(view);

    assertText(view, 'I\'m empty');
  });

  QUnit.test('it uses {{else}} when replacing model with an empty array', function () {
    _emberRuntimeTestsUtils.runDestroy(view);
    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('{{#each view.items as |item|}}{{item}}{{else}}Nothing{{/each}}'),
      items: _emberRuntimeSystemNative_array.A(['one', 'two'])
    });

    _emberRuntimeTestsUtils.runAppend(view);

    assertHTML(view, 'onetwo');

    _emberMetalRun_loop.default(function () {
      view.set('items', _emberRuntimeSystemNative_array.A());
    });

    assertHTML(view, 'Nothing');
  });

  QUnit.test('it uses {{else}} when removing all items in an array', function () {
    _emberRuntimeTestsUtils.runDestroy(view);
    var items = _emberRuntimeSystemNative_array.A(['one', 'two']);
    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('{{#each view.items as |item|}}{{item}}{{else}}Nothing{{/each}}'),
      items: items
    });

    _emberRuntimeTestsUtils.runAppend(view);

    assertHTML(view, 'onetwo');

    _emberMetalRun_loop.default(function () {
      items.shiftObject();
      items.shiftObject();
    });

    assertHTML(view, 'Nothing');
  });

  QUnit.test('it can move to and from {{else}} properly when the backing array gains and looses items (#11140)', function () {
    _emberRuntimeTestsUtils.runDestroy(view);
    var items = _emberRuntimeSystemNative_array.A(['one', 'two']);
    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('{{#each view.items as |item|}}{{item}}{{else}}Nothing{{/each}}'),
      items: items
    });

    _emberRuntimeTestsUtils.runAppend(view);

    assertHTML(view, 'onetwo');

    _emberMetalRun_loop.default(function () {
      items.shiftObject();
      items.shiftObject();
    });

    assertHTML(view, 'Nothing');

    _emberMetalRun_loop.default(function () {
      items.pushObject('three');
      items.pushObject('four');
    });

    assertHTML(view, 'threefour');

    _emberMetalRun_loop.default(function () {
      items.shiftObject();
      items.shiftObject();
    });

    assertHTML(view, 'Nothing');
  });

  QUnit.module('{{each bar as |foo|}}', {
    setup: function () {
      registry = new _emberRuntimeSystemContainer.Registry();
      container = registry.container();

      registry.register('view:toplevel', _emberViewsViewsView.default.extend());
      registry.register('view:-legacy-each', _emberViewsViewsLegacy_each_view.default);
    },
    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(container);
      _emberRuntimeTestsUtils.runDestroy(view);
      container = view = null;
    }
  });

  QUnit.test('#each accepts a name binding', function () {
    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('{{#each view.items as |item|}}{{view.title}} {{item}}{{/each}}'),
      title: 'My Cool Each Test',
      items: _emberRuntimeSystemNative_array.A([1, 2])
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'My Cool Each Test 1My Cool Each Test 2');
  });

  QUnit.test('#each accepts a name binding and does not change the context', function () {
    var controller = _emberRuntimeControllersController.default.create({
      name: 'bob the controller'
    });
    var obj = _emberRuntimeSystemObject.default.create({
      name: 'henry the item'
    });

    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('{{#each view.items as |item|}}{{name}}{{/each}}'),
      title: 'My Cool Each Test',
      items: _emberRuntimeSystemNative_array.A([obj]),
      controller: controller
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'bob the controller');
  });

  QUnit.test('#each accepts a name binding and can display child properties', function () {
    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('{{#each view.items as |item|}}{{view.title}} {{item.name}}{{/each}}'),
      title: 'My Cool Each Test',
      items: _emberRuntimeSystemNative_array.A([{ name: 1 }, { name: 2 }])
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'My Cool Each Test 1My Cool Each Test 2');
  });

  QUnit.test('#each accepts \'this\' as the right hand side', function () {
    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('{{#each this as |item|}}{{view.title}} {{item.name}}{{/each}}'),
      title: 'My Cool Each Test',
      controller: _emberRuntimeSystemNative_array.A([{ name: 1 }, { name: 2 }])
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'My Cool Each Test 1My Cool Each Test 2');
  });

  QUnit.test('it doesn\'t assert when the morph tags have the same parent', function () {
    view = _emberViewsViewsView.default.create({
      controller: _emberRuntimeSystemNative_array.A(['Cyril', 'David']),
      template: _emberTemplateCompilerSystemCompile.default('<table><tbody>{{#each this as |name|}}<tr><td>{{name}}</td></tr>{{/each}}</tbody></table>')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    ok(true, 'No assertion from valid template');
  });

  QUnit.test('locals in stable loops update when the list is updated', function () {
    expect(3);

    var list = [{ key: 'adam', name: 'Adam' }, { key: 'steve', name: 'Steve' }];
    view = _emberViewsViewsView.default.create({
      queries: list,
      template: _emberTemplateCompilerSystemCompile.default('{{#each view.queries key="key" as |query|}}{{query.name}}{{/each}}', true)
    });
    _emberRuntimeTestsUtils.runAppend(view);
    equal(view.$().text(), 'AdamSteve');

    _emberMetalRun_loop.default(function () {
      list.unshift({ key: 'bob', name: 'Bob' });
      view.set('queries', list);
      view.notifyPropertyChange('queries');
    });

    equal(view.$().text(), 'BobAdamSteve');

    _emberMetalRun_loop.default(function () {
      view.set('queries', [{ key: 'bob', name: 'Bob' }, { key: 'steve', name: 'Steve' }]);
      view.notifyPropertyChange('queries');
    });

    equal(view.$().text(), 'BobSteve');
  });

  QUnit.test('the index is passed as the second parameter to #each blocks', function () {
    expect(3);

    var adam = { name: 'Adam' };
    view = _emberViewsViewsView.default.create({
      controller: _emberRuntimeSystemNative_array.A([adam, { name: 'Steve' }]),
      template: _emberTemplateCompilerSystemCompile.default('{{#each this as |person index|}}{{index}}. {{person.name}}{{/each}}')
    });
    _emberRuntimeTestsUtils.runAppend(view);
    equal(view.$().text(), '0. Adam1. Steve');

    _emberMetalRun_loop.default(function () {
      view.get('controller').unshiftObject({ name: 'Bob' });
    });
    equal(view.$().text(), '0. Bob1. Adam2. Steve');

    _emberMetalRun_loop.default(function () {
      view.get('controller').removeObject(adam);
    });
    equal(view.$().text(), '0. Bob1. Steve');
  });

  QUnit.test('a string key can be used with {{each}}', function () {
    _emberRuntimeTestsUtils.runDestroy(view);
    view = _emberViewsViewsView.default.create({
      items: [{ id: 'foo' }, { id: 'bar' }, { id: 'baz' }],
      template: _emberTemplateCompilerSystemCompile.default('{{#each view.items key=\'id\' as |item|}}{{item.id}}{{/each}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'foobarbaz');
  });

  QUnit.test('a numeric key can be used with {{each}}', function () {
    _emberRuntimeTestsUtils.runDestroy(view);
    view = _emberViewsViewsView.default.create({
      items: [{ id: 1 }, { id: 2 }, { id: 3 }],
      template: _emberTemplateCompilerSystemCompile.default('{{#each view.items key=\'id\' as |item|}}{{item.id}}{{/each}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), '123');
  });

  QUnit.test('can specify `@index` to represent the items index in the array being iterated', function () {
    _emberRuntimeTestsUtils.runDestroy(view);
    view = _emberViewsViewsView.default.create({
      items: [{ id: 1 }, { id: 2 }, { id: 3 }],
      template: _emberTemplateCompilerSystemCompile.default('{{#each view.items key=\'@index\' as |item|}}{{item.id}}{{/each}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), '123');
  });

  QUnit.test('can specify `@identity` to represent primitive items', function () {
    _emberRuntimeTestsUtils.runDestroy(view);
    view = _emberViewsViewsView.default.create({
      items: [1, 2, 3],
      template: _emberTemplateCompilerSystemCompile.default('{{#each view.items key=\'@identity\' as |item|}}{{item}}{{/each}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), '123');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'items', ['foo', 'bar', 'baz']);
    });

    equal(view.$().text(), 'foobarbaz');
  });

  QUnit.test('can specify `@identity` to represent mixed object and primitive items', function () {
    _emberRuntimeTestsUtils.runDestroy(view);
    view = _emberViewsViewsView.default.create({
      items: [1, { id: 2 }, 3],
      template: _emberTemplateCompilerSystemCompile.default('{{#each view.items key=\'@identity\' as |item|}}{{#if item.id}}{{item.id}}{{else}}{{item}}{{/if}}{{/each}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), '123');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'items', ['foo', { id: 'bar' }, 'baz']);
    });

    equal(view.$().text(), 'foobarbaz');
  });

  QUnit.test('duplicate keys work properly with primitive items', function () {
    _emberRuntimeTestsUtils.runDestroy(view);
    view = _emberViewsViewsView.default.create({
      items: ['a', 'a', 'a'],
      template: _emberTemplateCompilerSystemCompile.default('{{#each view.items as |item|}}{{item}}{{/each}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'aaa');
  });

  QUnit.test('pushing a new duplicate key will render properly with primitive items', function () {
    _emberRuntimeTestsUtils.runDestroy(view);
    view = _emberViewsViewsView.default.create({
      items: _emberRuntimeSystemNative_array.A(['a', 'b', 'c']),
      template: _emberTemplateCompilerSystemCompile.default('{{#each view.items as |item|}}{{item}}{{/each}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    _emberMetalRun_loop.default(function () {
      view.get('items').pushObject('a');
    });

    equal(view.$().text(), 'abca');
  });

  QUnit.test('pushing primitive item twice will render properly', function () {
    _emberRuntimeTestsUtils.runDestroy(view);
    view = _emberViewsViewsView.default.create({
      items: _emberRuntimeSystemNative_array.A(),
      template: _emberTemplateCompilerSystemCompile.default('{{#each view.items as |item|}}{{item}}{{/each}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    _emberMetalRun_loop.default(function () {
      view.get('items').pushObject('a');
    });

    equal(view.$().text(), 'a');

    _emberMetalRun_loop.default(function () {
      view.get('items').pushObject('a');
    });

    equal(view.$().text(), 'aa');
  });

  QUnit.test('duplicate keys work properly with objects', function () {
    _emberRuntimeTestsUtils.runDestroy(view);
    var duplicateItem = { display: 'foo' };
    view = _emberViewsViewsView.default.create({
      items: [duplicateItem, duplicateItem, { display: 'bar' }, { display: 'qux' }],
      template: _emberTemplateCompilerSystemCompile.default('{{#each view.items as |item|}}{{item.display}}{{/each}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'foofoobarqux');
  });

  QUnit.test('pushing a new duplicate key will render properly with objects', function () {
    _emberRuntimeTestsUtils.runDestroy(view);

    var duplicateItem = { display: 'foo' };
    view = _emberViewsViewsView.default.create({
      items: _emberRuntimeSystemNative_array.A([duplicateItem, { display: 'bar' }, { display: 'qux' }]),
      template: _emberTemplateCompilerSystemCompile.default('{{#each view.items as |item|}}{{item.display}}{{/each}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    _emberMetalRun_loop.default(function () {
      view.get('items').pushObject(duplicateItem);
    });

    equal(view.$().text(), 'foobarquxfoo');
  });
});
// Ember.lookup;
enifed('ember-htmlbars/tests/helpers/each_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/helpers');
  test('ember-htmlbars/tests/helpers/each_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/helpers/each_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/helpers/each_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/helpers');
  QUnit.test('ember-htmlbars/tests/helpers/each_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/helpers/each_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/helpers/get_test', ['exports', 'ember-metal/core', 'ember-metal/features', 'ember-metal/run_loop', 'ember-runtime/system/container', 'ember-template-compiler/system/compile', 'ember-runtime/tests/utils', 'ember-views/views/view', 'ember-views/component_lookup', 'ember-views/views/text_field'], function (exports, _emberMetalCore, _emberMetalFeatures, _emberMetalRun_loop, _emberRuntimeSystemContainer, _emberTemplateCompilerSystemCompile, _emberRuntimeTestsUtils, _emberViewsViewsView, _emberViewsComponent_lookup, _emberViewsViewsText_field) {
  'use strict';

  var view, registry, container;

  QUnit.module('ember-htmlbars: {{get}} helper', {
    setup: function () {
      registry = new _emberRuntimeSystemContainer.Registry();
      registry.register('component:-text-field', _emberViewsViewsText_field.default);
      registry.register('component-lookup:main', _emberViewsComponent_lookup.default);

      container = registry.container();
      registry.optionsForType('template', { instantiate: false });
    },
    teardown: function () {
      _emberMetalRun_loop.default(function () {
        _emberMetalCore.default.TEMPLATES = {};
      });
      _emberRuntimeTestsUtils.runDestroy(view);
      _emberRuntimeTestsUtils.runDestroy(container);
      registry = container = view = null;
    }
  });

  QUnit.test('should be able to get an object value with a static key', function () {
    var context = {
      colors: { apple: 'red', banana: 'yellow' }
    };

    view = _emberViewsViewsView.default.create({
      context: context,
      template: _emberTemplateCompilerSystemCompile.default('[{{get colors \'apple\'}}] [{{if true (get colors \'apple\')}}]')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), '[red] [red]', 'should return \'red\' for {{get colors \'apple\'}}');

    _emberMetalRun_loop.default(function () {
      view.set('context.colors', { apple: 'green', banana: 'purple' });
    });

    equal(view.$().text(), '[green] [green]', 'should return \'green\' for {{get colors \'apple\'}}');

    _emberMetalRun_loop.default(function () {
      view.set('context.colors.apple', 'red');
    });

    equal(view.$().text(), '[red] [red]', 'should return \'red\' for {{get colors \'apple\'}}');
  });

  QUnit.test('should be able to get an object value with a bound/dynamic key', function () {
    var context = {
      colors: { apple: 'red', banana: 'yellow' },
      key: 'apple'
    };

    view = _emberViewsViewsView.default.create({
      context: context,
      template: _emberTemplateCompilerSystemCompile.default('[{{get colors key}}] [{{if true (get colors key)}}]')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), '[red] [red]', 'should return \'red\' for {{get colors key}}  (key = \'apple\')');

    _emberMetalRun_loop.default(function () {
      view.set('context.key', 'banana');
    });

    equal(view.$().text(), '[yellow] [yellow]', 'should return \'red\' for {{get colors key}} (key = \'banana\')');

    _emberMetalRun_loop.default(function () {
      view.set('context.colors', { apple: 'green', banana: 'purple' });
    });

    equal(view.$().text(), '[purple] [purple]', 'should return \'purple\' for {{get colors key}} (key = \'banana\')');

    _emberMetalRun_loop.default(function () {
      view.set('context.key', 'apple');
    });

    equal(view.$().text(), '[green] [green]', 'should return \'green\' for {{get colors key}} (key = \'apple\')');

    _emberMetalRun_loop.default(function () {
      view.set('context.colors.apple', 'red');
    });

    equal(view.$().text(), '[red] [red]', 'should return \'red\' for {{get colors key}}  (key = \'apple\')');
  });

  QUnit.test('should be able to get an object value with a GetStream key', function () {
    var context = {
      colors: { apple: 'red', banana: 'yellow' },
      key: 'key1',
      possibleKeys: { key1: 'apple', key2: 'banana' }
    };

    view = _emberViewsViewsView.default.create({
      context: context,
      template: _emberTemplateCompilerSystemCompile.default('[{{get colors (get possibleKeys key)}}] [{{if true (get colors (get possibleKeys key))}}]')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), '[red] [red]', 'should return \'red\'');

    _emberMetalRun_loop.default(function () {
      view.set('context.key', 'key2');
    });

    equal(view.$().text(), '[yellow] [yellow]', 'should return \'red\' for {{get colors key}} (key = \'banana\')');

    _emberMetalRun_loop.default(function () {
      view.set('context.colors', { apple: 'green', banana: 'purple' });
    });

    equal(view.$().text(), '[purple] [purple]', 'should return \'purple\'');

    _emberMetalRun_loop.default(function () {
      view.set('context.key', 'key1');
    });

    equal(view.$().text(), '[green] [green]', 'should return \'green\'');

    _emberMetalRun_loop.default(function () {
      view.set('context.colors.apple', 'red');
    });

    equal(view.$().text(), '[red] [red]', 'should return \'red\'');
  });

  QUnit.test('should be able to get an object value with a GetStream value and bound/dynamic key', function () {
    var context = {
      possibleValues: {
        colors1: { apple: 'red', banana: 'yellow' },
        colors2: { apple: 'green', banana: 'purple' }
      },
      objectKey: 'colors1',
      key: 'apple'
    };

    view = _emberViewsViewsView.default.create({
      context: context,
      template: _emberTemplateCompilerSystemCompile.default('[{{get (get possibleValues objectKey) key}}] [{{if true (get (get possibleValues objectKey) key)}}]')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), '[red] [red]', 'should return \'red\'');

    _emberMetalRun_loop.default(function () {
      view.set('context.objectKey', 'colors2');
    });

    equal(view.$().text(), '[green] [green]', 'should return \'green\'');

    _emberMetalRun_loop.default(function () {
      view.set('context.objectKey', 'colors1');
    });

    equal(view.$().text(), '[red] [red]', 'should return \'red\'');

    _emberMetalRun_loop.default(function () {
      view.set('context.key', 'banana');
    });

    equal(view.$().text(), '[yellow] [yellow]', 'should return \'yellow\'');

    _emberMetalRun_loop.default(function () {
      view.set('context.objectKey', 'colors2');
    });

    equal(view.$().text(), '[purple] [purple]', 'should return \'purple\'');

    _emberMetalRun_loop.default(function () {
      view.set('context.objectKey', 'colors1');
    });

    equal(view.$().text(), '[yellow] [yellow]', 'should return \'yellow\'');
  });

  QUnit.test('should be able to get an object value with a GetStream value and GetStream key', function () {
    var context = {
      possibleValues: {
        colors1: { apple: 'red', banana: 'yellow' },
        colors2: { apple: 'green', banana: 'purple' }
      },
      objectKey: 'colors1',
      possibleKeys: {
        key1: 'apple',
        key2: 'banana'
      },
      key: 'key1'
    };

    view = _emberViewsViewsView.default.create({
      context: context,
      template: _emberTemplateCompilerSystemCompile.default('[{{get (get possibleValues objectKey) (get possibleKeys key)}}] [{{if true (get (get possibleValues objectKey) (get possibleKeys key))}}]')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), '[red] [red]', 'should return \'red\'');

    _emberMetalRun_loop.default(function () {
      view.set('context.objectKey', 'colors2');
    });

    equal(view.$().text(), '[green] [green]', 'should return \'green\'');

    _emberMetalRun_loop.default(function () {
      view.set('context.objectKey', 'colors1');
    });

    equal(view.$().text(), '[red] [red]', 'should return \'red\'');

    _emberMetalRun_loop.default(function () {
      view.set('context.key', 'key2');
    });

    equal(view.$().text(), '[yellow] [yellow]', 'should return \'yellow\'');

    _emberMetalRun_loop.default(function () {
      view.set('context.objectKey', 'colors2');
    });

    equal(view.$().text(), '[purple] [purple]', 'should return \'purple\'');

    _emberMetalRun_loop.default(function () {
      view.set('context.objectKey', 'colors1');
    });

    equal(view.$().text(), '[yellow] [yellow]', 'should return \'yellow\'');
  });

  QUnit.test('should handle object values as nulls', function () {
    var context = {
      colors: null
    };

    view = _emberViewsViewsView.default.create({
      context: context,
      template: _emberTemplateCompilerSystemCompile.default('[{{get colors \'apple\'}}] [{{if true (get colors \'apple\')}}]')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), '[] []', 'should return \'\' for {{get colors \'apple\'}} (colors = null)');

    _emberMetalRun_loop.default(function () {
      view.set('context.colors', { apple: 'green', banana: 'purple' });
    });

    equal(view.$().text(), '[green] [green]', 'should return \'green\' for {{get colors \'apple\'}} (colors = { apple: \'green\', banana: \'purple\' })');

    _emberMetalRun_loop.default(function () {
      view.set('context.colors', null);
    });

    equal(view.$().text(), '[] []', 'should return \'\' for {{get colors \'apple\'}} (colors = null)');
  });

  QUnit.test('should handle object keys as nulls', function () {
    var context = {
      colors: { apple: 'red', banana: 'yellow' },
      key: null
    };

    view = _emberViewsViewsView.default.create({
      context: context,
      template: _emberTemplateCompilerSystemCompile.default('[{{get colors key}}] [{{if true (get colors key)}}]')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), '[] []', 'should return \'\' for {{get colors key}}  (key = null)');

    _emberMetalRun_loop.default(function () {
      view.set('context.key', 'banana');
    });

    equal(view.$().text(), '[yellow] [yellow]', 'should return \'yellow\' for {{get colors key}} (key = \'banana\')');

    _emberMetalRun_loop.default(function () {
      view.set('context.key', null);
    });

    equal(view.$().text(), '[] []', 'should return \'\' for {{get colors key}}  (key = null)');
  });

  QUnit.test('should handle object values and keys as nulls', function () {
    var context = {
      colors: null,
      key: null
    };

    view = _emberViewsViewsView.default.create({
      context: context,
      template: _emberTemplateCompilerSystemCompile.default('[{{get colors key}}] [{{if true (get colors key)}}]')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), '[] []', 'should return \'\' for {{get colors key}}  (colors=null, key = null)');
  });

  QUnit.test('get helper value should be updatable using {{input}} and (mut) - dynamic key', function () {
    var context = {
      source: _emberMetalCore.default.Object.create({
        banana: 'banana'
      }),
      key: 'banana'
    };

    view = _emberViewsViewsView.default.create({
      context: context,
      container: container,
      template: _emberTemplateCompilerSystemCompile.default('{{input type=\'text\' value=(mut (get source key)) id=\'get-input\'}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('#get-input').val(), 'banana');

    _emberMetalRun_loop.default(function () {
      view.set('context.source.banana', 'yellow');
    });

    equal(view.$('#get-input').val(), 'yellow');

    _emberMetalRun_loop.default(function () {
      view.$('#get-input').val('some value');
      view.childViews[0]._elementValueDidChange();
    });

    equal(view.$('#get-input').val(), 'some value');
    equal(view.get('context.source.banana'), 'some value');
  });

  QUnit.test('get helper value should be updatable using {{input}} and (mut) - static key', function () {
    var context = {
      source: _emberMetalCore.default.Object.create({
        banana: 'banana'
      }),
      key: 'banana'
    };

    view = _emberViewsViewsView.default.create({
      context: context,
      container: container,
      template: _emberTemplateCompilerSystemCompile.default('{{input type=\'text\' value=(mut (get source \'banana\')) id=\'get-input\'}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('#get-input').val(), 'banana');

    _emberMetalRun_loop.default(function () {
      view.set('context.source.banana', 'yellow');
    });

    equal(view.$('#get-input').val(), 'yellow');

    _emberMetalRun_loop.default(function () {
      view.$('#get-input').val('some value');
      view.childViews[0]._elementValueDidChange();
    });

    equal(view.$('#get-input').val(), 'some value');
    equal(view.get('context.source.banana'), 'some value');
  });
});
enifed('ember-htmlbars/tests/helpers/get_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/helpers');
  test('ember-htmlbars/tests/helpers/get_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/helpers/get_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/helpers/get_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/helpers');
  QUnit.test('ember-htmlbars/tests/helpers/get_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/helpers/get_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/helpers/if_unless_test', ['exports', 'ember-metal/core', 'ember-metal/features', 'ember-metal/run_loop', 'ember-runtime/system/namespace', 'ember-runtime/system/container', 'ember-views/views/view', 'ember-views/views/component', 'ember-runtime/system/object_proxy', 'ember-runtime/system/object', 'ember-template-compiler/system/compile', 'ember-runtime/system/array_proxy', 'ember-runtime/system/native_array', 'ember-metal/property_set', 'ember-runtime/utils', 'ember-runtime/tests/utils', 'ember-htmlbars/tests/utils', 'ember-htmlbars/keywords/view', 'ember-views/component_lookup'], function (exports, _emberMetalCore, _emberMetalFeatures, _emberMetalRun_loop, _emberRuntimeSystemNamespace, _emberRuntimeSystemContainer, _emberViewsViewsView, _emberViewsViewsComponent, _emberRuntimeSystemObject_proxy, _emberRuntimeSystemObject, _emberTemplateCompilerSystemCompile, _emberRuntimeSystemArray_proxy, _emberRuntimeSystemNative_array, _emberMetalProperty_set, _emberRuntimeUtils, _emberRuntimeTestsUtils, _emberHtmlbarsTestsUtils, _emberHtmlbarsKeywordsView, _emberViewsComponent_lookup) {
  'use strict';

  var originalLookup = _emberMetalCore.default.lookup;

  var view, lookup, registry, container, TemplateTests, originalViewKeyword;

  QUnit.module('ember-htmlbars: {{#if}} and {{#unless}} helpers', {
    setup: function () {
      originalViewKeyword = _emberHtmlbarsTestsUtils.registerKeyword('view', _emberHtmlbarsKeywordsView.default);

      _emberMetalCore.default.lookup = lookup = {};
      lookup.TemplateTests = TemplateTests = _emberRuntimeSystemNamespace.default.create();
      registry = new _emberRuntimeSystemContainer.Registry();
      container = registry.container();
      registry.optionsForType('template', { instantiate: false });
      registry.optionsForType('view', { singleton: false });
      registry.optionsForType('component', { singleton: false });
      registry.register('view:toplevel', _emberViewsViewsView.default.extend());
      registry.register('component-lookup:main', _emberViewsComponent_lookup.default);
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(container);
      _emberRuntimeTestsUtils.runDestroy(view);
      registry = container = view = null;

      _emberMetalCore.default.lookup = lookup = originalLookup;
      TemplateTests = null;

      _emberHtmlbarsTestsUtils.resetKeyword('view', originalViewKeyword);
    }
  });

  QUnit.test('The `if` helper tests for `isTruthy` if available', function () {
    view = _emberViewsViewsView.default.create({
      truthy: _emberRuntimeSystemObject.default.create({ isTruthy: true }),
      falsy: _emberRuntimeSystemObject.default.create({ isTruthy: false }),

      template: _emberTemplateCompilerSystemCompile.default('{{#if view.truthy}}Yep{{/if}}{{#if view.falsy}}Nope{{/if}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'Yep');
  });

  QUnit.test('The `if` helper does not error on undefined', function () {
    view = _emberViewsViewsView.default.create({
      undefinedValue: undefined,
      template: _emberTemplateCompilerSystemCompile.default('{{#if view.undefinedValue}}Yep{{/if}}{{#if (unbound view.undefinedValue)}}Yep{{/if}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), '');
  });

  QUnit.test('The `unless` helper does not error on undefined', function () {
    view = _emberViewsViewsView.default.create({
      undefinedValue: undefined,
      template: _emberTemplateCompilerSystemCompile.default('{{#unless view.undefinedValue}}YepBound{{/unless}}{{#unless (unbound view.undefinedValue)}}YepUnbound{{/unless}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'YepBoundYepUnbound');
  });

  QUnit.test('The `if` helper does not print the contents for an object proxy without content', function () {
    view = _emberViewsViewsView.default.create({
      truthy: _emberRuntimeSystemObject_proxy.default.create({ content: {} }),
      falsy: _emberRuntimeSystemObject_proxy.default.create({ content: null }),

      template: _emberTemplateCompilerSystemCompile.default('{{#if view.truthy}}Yep{{/if}}{{#if view.falsy}}Nope{{/if}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'Yep');
  });

  QUnit.test('The `if` helper updates if an object proxy gains or loses context', function () {
    view = _emberViewsViewsView.default.create({
      proxy: _emberRuntimeSystemObject_proxy.default.create({ content: null }),

      template: _emberTemplateCompilerSystemCompile.default('{{#if view.proxy}}Yep{{/if}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), '');

    _emberMetalRun_loop.default(function () {
      view.set('proxy.content', {});
    });

    equal(view.$().text(), 'Yep');

    _emberMetalRun_loop.default(function () {
      view.set('proxy.content', null);
    });

    equal(view.$().text(), '');
  });

  function testIfArray(array) {
    view = _emberViewsViewsView.default.create({
      array: array,

      template: _emberTemplateCompilerSystemCompile.default('{{#if view.array}}Yep{{/if}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), '');

    _emberMetalRun_loop.default(function () {
      view.get('array').pushObject(1);
    });

    equal(view.$().text(), 'Yep');

    _emberMetalRun_loop.default(function () {
      view.get('array').removeObject(1);
    });

    equal(view.$().text(), '');
  }

  QUnit.test('The `if` helper updates if an array is empty or not', function () {
    testIfArray(_emberMetalCore.default.A());
  });

  QUnit.test('The `if` helper updates if an array-like object is empty or not', function () {
    testIfArray(_emberRuntimeSystemArray_proxy.default.create({ content: _emberMetalCore.default.A([]) }));
  });

  QUnit.test('The `unless` helper updates if an array-like object is empty or not', function () {
    view = _emberViewsViewsView.default.create({
      array: _emberRuntimeSystemArray_proxy.default.create({ content: _emberMetalCore.default.A([]) }),

      template: _emberTemplateCompilerSystemCompile.default('{{#unless view.array}}Yep{{/unless}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'Yep');

    _emberMetalRun_loop.default(function () {
      view.get('array').pushObject(1);
    });

    equal(view.$().text(), '');

    _emberMetalRun_loop.default(function () {
      view.get('array').removeObject(1);
    });

    equal(view.$().text(), 'Yep');
  });

  QUnit.test('The `if` helper updates when the value changes', function () {
    view = _emberViewsViewsView.default.create({
      conditional: true,
      template: _emberTemplateCompilerSystemCompile.default('{{#if view.conditional}}Yep{{/if}}')
    });
    _emberRuntimeTestsUtils.runAppend(view);
    equal(view.$().text(), 'Yep');
    _emberMetalRun_loop.default(function () {
      view.set('conditional', false);
    });
    equal(view.$().text(), '');
  });

  QUnit.test('The `if (unbound` helper does not update when the value changes', function () {
    view = _emberViewsViewsView.default.create({
      conditional: true,
      template: _emberTemplateCompilerSystemCompile.default('{{#if (unbound view.conditional)}}Yep{{/if}}')
    });
    _emberRuntimeTestsUtils.runAppend(view);
    equal(view.$().text(), 'Yep');
    _emberMetalRun_loop.default(function () {
      view.set('conditional', false);
    });
    equal(view.$().text(), 'Yep');
  });

  QUnit.test('The `unless` helper updates when the value changes', function () {
    view = _emberViewsViewsView.default.create({
      conditional: false,
      template: _emberTemplateCompilerSystemCompile.default('{{#unless view.conditional}}Nope{{/unless}}')
    });
    _emberRuntimeTestsUtils.runAppend(view);
    equal(view.$().text(), 'Nope');
    _emberMetalRun_loop.default(function () {
      view.set('conditional', true);
    });
    equal(view.$().text(), '');
  });

  QUnit.test('The `if (unbound` helper does not update when the value changes', function () {
    view = _emberViewsViewsView.default.create({
      conditional: false,
      template: _emberTemplateCompilerSystemCompile.default('{{#unless (unbound view.conditional)}}Nope{{/unless}}')
    });
    _emberRuntimeTestsUtils.runAppend(view);
    equal(view.$().text(), 'Nope');
    _emberMetalRun_loop.default(function () {
      view.set('conditional', true);
    });
    equal(view.$().text(), 'Nope');
  });

  QUnit.test('The `if (unbound` helper should work when its inverse is not present', function () {
    view = _emberViewsViewsView.default.create({
      conditional: false,
      template: _emberTemplateCompilerSystemCompile.default('{{#if (unbound view.conditional)}}Yep{{/if}}')
    });
    _emberRuntimeTestsUtils.runAppend(view);
    equal(view.$().text(), '');
  });

  QUnit.test('should not rerender if truthiness does not change', function () {
    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('<h1 id="first">{{#if view.shouldDisplay}}{{view view.InnerViewClass}}{{/if}}</h1>'),

      shouldDisplay: true,

      InnerViewClass: _emberViewsViewsView.default.extend({
        template: _emberTemplateCompilerSystemCompile.default('bam')
      })
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('#first').text(), 'bam', 'renders block when condition is true');
    equal(view.$('#first div').text(), 'bam', 'inserts a div into the DOM');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'shouldDisplay', 1);
    });

    equal(view.$('#first').text(), 'bam', 'renders block when condition is true');
  });

  QUnit.test('should update the block when object passed to #unless helper changes', function () {
    registry.register('template:advice', _emberTemplateCompilerSystemCompile.default('<h1>{{#unless view.onDrugs}}{{view.doWellInSchool}}{{/unless}}</h1>'));

    view = _emberViewsViewsView.default.create({
      container: container,
      templateName: 'advice',

      onDrugs: true,
      doWellInSchool: 'Eat your vegetables'
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('h1').text(), '', 'hides block if true');

    var tests = [false, null, undefined, [], '', 0];

    tests.forEach(function (val) {
      _emberMetalRun_loop.default(function () {
        _emberMetalProperty_set.set(view, 'onDrugs', val);
      });

      equal(view.$('h1').text(), 'Eat your vegetables', 'renders block when conditional is "' + val + '"; ' + _emberRuntimeUtils.typeOf(val));
      _emberMetalRun_loop.default(function () {
        _emberMetalProperty_set.set(view, 'onDrugs', true);
      });

      equal(view.$('h1').text(), '', 'precond - hides block when conditional is true');
    });
  });

  QUnit.test('properties within an if statement should not fail on re-render', function () {
    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('{{#if view.value}}{{view.value}}{{/if}}'),
      value: null
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), '');

    _emberMetalRun_loop.default(function () {
      view.set('value', 'test');
    });

    equal(view.$().text(), 'test');

    _emberMetalRun_loop.default(function () {
      view.set('value', null);
    });

    equal(view.$().text(), '');
  });

  QUnit.test('should update the block when object passed to #if helper changes', function () {
    registry.register('template:menu', _emberTemplateCompilerSystemCompile.default('<h1>{{#if view.inception}}{{view.INCEPTION}}{{/if}}</h1>'));

    view = _emberViewsViewsView.default.create({
      container: container,
      templateName: 'menu',

      INCEPTION: 'BOOOOOOOONG doodoodoodoodooodoodoodoo',
      inception: 'OOOOoooooOOOOOOooooooo'
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('h1').text(), 'BOOOOOOOONG doodoodoodoodooodoodoodoo', 'renders block if a string');

    var tests = [false, null, undefined, [], '', 0];

    tests.forEach(function (val) {
      _emberMetalRun_loop.default(function () {
        _emberMetalProperty_set.set(view, 'inception', val);
      });

      equal(view.$('h1').text(), '', 'hides block when conditional is "' + val + '"');

      _emberMetalRun_loop.default(function () {
        _emberMetalProperty_set.set(view, 'inception', true);
      });

      equal(view.$('h1').text(), 'BOOOOOOOONG doodoodoodoodooodoodoodoo', 'precond - renders block when conditional is true');
    });
  });

  QUnit.test('should update the block when object passed to #if helper changes and an inverse is supplied', function () {
    registry.register('template:menu', _emberTemplateCompilerSystemCompile.default('<h1>{{#if view.inception}}{{view.INCEPTION}}{{else}}{{view.SAD}}{{/if}}</h1>'));

    view = _emberViewsViewsView.default.create({
      container: container,
      templateName: 'menu',

      INCEPTION: 'BOOOOOOOONG doodoodoodoodooodoodoodoo',
      inception: false,
      SAD: 'BOONG?'
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('h1').text(), 'BOONG?', 'renders alternate if false');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'inception', true);
    });

    var tests = [false, null, undefined, [], '', 0];

    tests.forEach(function (val) {
      _emberMetalRun_loop.default(function () {
        _emberMetalProperty_set.set(view, 'inception', val);
      });

      equal(view.$('h1').text(), 'BOONG?', 'renders alternate if ' + val);

      _emberMetalRun_loop.default(function () {
        _emberMetalProperty_set.set(view, 'inception', true);
      });

      equal(view.$('h1').text(), 'BOOOOOOOONG doodoodoodoodooodoodoodoo', 'precond - renders block when conditional is true');
    });
  });

  QUnit.test('views within an if statement should be sane on re-render', function () {
    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('{{#if view.display}}{{view view.MyView}}{{/if}}'),
      MyView: _emberViewsViewsView.default.extend({
        tagName: 'input'
      }),
      display: false
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('input').length, 0);

    _emberMetalRun_loop.default(function () {
      // Setting twice will trigger the observer twice, this is intentional
      view.set('display', true);
      view.set('display', 'yes');
    });

    var textfield = view.$('input');
    equal(textfield.length, 1);

    // Make sure the view is still registered in View.views
    ok(_emberViewsViewsView.default.views[textfield.attr('id')]);
  });

  QUnit.test('the {{this}} helper should not fail on removal', function () {
    view = _emberViewsViewsView.default.create({
      context: 'abc',
      template: _emberTemplateCompilerSystemCompile.default('{{#if view.show}}{{this}}{{/if}}'),
      show: true
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'abc', 'should start property - precond');

    _emberMetalRun_loop.default(function () {
      view.set('show', false);
    });

    equal(view.$().text(), '');
  });

  QUnit.test('should update the block when object passed to #unless helper changes', function () {
    registry.register('template:advice', _emberTemplateCompilerSystemCompile.default('<h1>{{#unless view.onDrugs}}{{view.doWellInSchool}}{{/unless}}</h1>'));

    view = _emberViewsViewsView.default.create({
      container: container,
      templateName: 'advice',

      onDrugs: true,
      doWellInSchool: 'Eat your vegetables'
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('h1').text(), '', 'hides block if true');

    var tests = [false, null, undefined, [], '', 0];

    tests.forEach(function (val) {
      _emberMetalRun_loop.default(function () {
        _emberMetalProperty_set.set(view, 'onDrugs', val);
      });

      equal(view.$('h1').text(), 'Eat your vegetables', 'renders block when conditional is "' + val + '"; ' + _emberRuntimeUtils.typeOf(val));

      _emberMetalRun_loop.default(function () {
        _emberMetalProperty_set.set(view, 'onDrugs', true);
      });

      equal(view.$('h1').text(), '', 'precond - hides block when conditional is true');
    });
  });

  QUnit.test('properties within an if statement should not fail on re-render', function () {
    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('{{#if view.value}}{{view.value}}{{/if}}'),
      value: null
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), '');

    _emberMetalRun_loop.default(function () {
      view.set('value', 'test');
    });

    equal(view.$().text(), 'test');

    _emberMetalRun_loop.default(function () {
      view.set('value', null);
    });

    equal(view.$().text(), '');
  });

  QUnit.test('should update the block when object passed to #if helper changes', function () {
    registry.register('template:menu', _emberTemplateCompilerSystemCompile.default('<h1>{{#if view.inception}}{{view.INCEPTION}}{{/if}}</h1>'));

    view = _emberViewsViewsView.default.create({
      container: container,
      templateName: 'menu',

      INCEPTION: 'BOOOOOOOONG doodoodoodoodooodoodoodoo',
      inception: 'OOOOoooooOOOOOOooooooo'
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('h1').text(), 'BOOOOOOOONG doodoodoodoodooodoodoodoo', 'renders block if a string');

    var tests = [false, null, undefined, [], '', 0];

    tests.forEach(function (val) {
      _emberMetalRun_loop.default(function () {
        _emberMetalProperty_set.set(view, 'inception', val);
      });

      equal(view.$('h1').text(), '', 'hides block when conditional is "' + val + '"');

      _emberMetalRun_loop.default(function () {
        _emberMetalProperty_set.set(view, 'inception', true);
      });

      equal(view.$('h1').text(), 'BOOOOOOOONG doodoodoodoodooodoodoodoo', 'precond - renders block when conditional is true');
    });
  });

  QUnit.test('should update the block when object passed to #if helper changes and an inverse is supplied', function () {
    registry.register('template:menu', _emberTemplateCompilerSystemCompile.default('<h1>{{#if view.inception}}{{view.INCEPTION}}{{else}}{{view.SAD}}{{/if}}</h1>'));

    view = _emberViewsViewsView.default.create({
      container: container,
      templateName: 'menu',

      INCEPTION: 'BOOOOOOOONG doodoodoodoodooodoodoodoo',
      inception: false,
      SAD: 'BOONG?'
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('h1').text(), 'BOONG?', 'renders alternate if false');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'inception', true);
    });

    var tests = [false, null, undefined, [], '', 0];

    tests.forEach(function (val) {
      _emberMetalRun_loop.default(function () {
        _emberMetalProperty_set.set(view, 'inception', val);
      });

      equal(view.$('h1').text(), 'BOONG?', 'renders alternate if ' + val);

      _emberMetalRun_loop.default(function () {
        _emberMetalProperty_set.set(view, 'inception', true);
      });

      equal(view.$('h1').text(), 'BOOOOOOOONG doodoodoodoodooodoodoodoo', 'precond - renders block when conditional is true');
    });
  });

  QUnit.test('the {{this}} helper should not fail on removal', function () {
    view = _emberViewsViewsView.default.create({
      context: 'abc',
      template: _emberTemplateCompilerSystemCompile.default('{{#if view.show}}{{this}}{{/if}}'),
      show: true
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'abc', 'should start property - precond');

    _emberMetalRun_loop.default(function () {
      view.set('show', false);
    });

    equal(view.$().text(), '');
  });

  QUnit.test('edge case: child conditional should not render children if parent conditional becomes false', function () {
    var childCreated = false;
    var child = null;

    view = _emberViewsViewsView.default.create({
      cond1: true,
      cond2: false,
      viewClass: _emberViewsViewsView.default.extend({
        init: function () {
          this._super.apply(this, arguments);
          childCreated = true;
          child = this;
        }
      }),
      template: _emberTemplateCompilerSystemCompile.default('{{#if view.cond1}}{{#if view.cond2}}{{#view view.viewClass}}test{{/view}}{{/if}}{{/if}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    ok(!childCreated, 'precondition');

    _emberMetalRun_loop.default(function () {
      // The order of these sets is important for the test
      view.set('cond2', true);
      view.set('cond1', false);
    });

    // TODO: Priority Queue, for now ensure correct result.
    ok(!childCreated, 'child should not be created');
    //ok(child.isDestroyed, 'child should be gone');
    equal(view.$().text(), '');
  });

  QUnit.test('edge case: rerender appearance of inner virtual view', function () {
    view = _emberViewsViewsView.default.create({
      tagName: '',
      cond2: false,
      template: _emberTemplateCompilerSystemCompile.default('{{#if view.cond2}}test{{/if}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);
    equal(_emberMetalCore.default.$('#qunit-fixture').text(), '');

    _emberMetalRun_loop.default(function () {
      view.set('cond2', true);
    });

    equal(_emberMetalCore.default.$('#qunit-fixture').text(), 'test');
  });

  QUnit.test('`if` helper with inline form: renders the second argument when conditional is truthy', function () {
    view = _emberViewsViewsView.default.create({
      conditional: true,
      template: _emberTemplateCompilerSystemCompile.default('{{if view.conditional "truthy" "falsy"}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'truthy');
  });

  QUnit.test('`if` helper with inline form: renders the third argument when conditional is falsy', function () {
    view = _emberViewsViewsView.default.create({
      conditional: false,
      template: _emberTemplateCompilerSystemCompile.default('{{if view.conditional "truthy" "falsy"}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'falsy');
  });

  QUnit.test('`if` helper with inline form: can omit the falsy argument', function () {
    view = _emberViewsViewsView.default.create({
      conditional: true,
      template: _emberTemplateCompilerSystemCompile.default('{{if view.conditional "truthy"}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'truthy');
  });

  QUnit.test('`if` helper with inline form: can omit the falsy argument and renders nothing when conditional is falsy', function () {
    view = _emberViewsViewsView.default.create({
      conditional: false,
      template: _emberTemplateCompilerSystemCompile.default('{{if view.conditional "truthy"}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), '');
  });

  QUnit.test('`if` helper with inline form: truthy and falsy arguments are changed if conditional changes', function () {
    view = _emberViewsViewsView.default.create({
      conditional: true,
      template: _emberTemplateCompilerSystemCompile.default('{{if view.conditional "truthy" "falsy"}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'truthy');

    _emberMetalRun_loop.default(function () {
      view.set('conditional', false);
    });

    equal(view.$().text(), 'falsy');
  });

  QUnit.test('`if` helper with inline form: can use truthy param as binding', function () {
    view = _emberViewsViewsView.default.create({
      truthy: 'ok',
      conditional: true,
      template: _emberTemplateCompilerSystemCompile.default('{{if view.conditional view.truthy}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'ok');

    _emberMetalRun_loop.default(function () {
      view.set('truthy', 'yes');
    });

    equal(view.$().text(), 'yes');
  });

  QUnit.test('`if` helper with inline form: can use falsy param as binding', function () {
    view = _emberViewsViewsView.default.create({
      truthy: 'ok',
      falsy: 'boom',
      conditional: false,
      template: _emberTemplateCompilerSystemCompile.default('{{if view.conditional view.truthy view.falsy}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'boom');

    _emberMetalRun_loop.default(function () {
      view.set('falsy', 'no');
    });

    equal(view.$().text(), 'no');
  });

  QUnit.test('`if` helper with inline form: raises when using more than three arguments', function () {
    view = _emberViewsViewsView.default.create({
      conditional: true,
      template: _emberTemplateCompilerSystemCompile.default('{{if one two three four}}')
    });

    expectAssertion(function () {
      _emberRuntimeTestsUtils.runAppend(view);
    }, /The inline form of the `if` and `unless` helpers expect two or three arguments/);
  });

  QUnit.test('`if` helper with inline form: raises when using less than two arguments', function () {
    view = _emberViewsViewsView.default.create({
      conditional: true,
      template: _emberTemplateCompilerSystemCompile.default('{{if one}}')
    });

    expectAssertion(function () {
      _emberRuntimeTestsUtils.runAppend(view);
    }, /The inline form of the `if` and `unless` helpers expect two or three arguments/);
  });

  QUnit.test('`if` helper with inline form: works when used in a sub expression', function () {
    view = _emberViewsViewsView.default.create({
      conditional: true,
      innerConditional: true,
      template: _emberTemplateCompilerSystemCompile.default('{{if view.conditional (if view.innerConditional "truthy" )}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'truthy');
  });

  QUnit.test('`if` helper with inline form: updates if condition changes in a sub expression', function () {
    view = _emberViewsViewsView.default.create({
      conditional: true,
      innerConditional: true,
      template: _emberTemplateCompilerSystemCompile.default('{{if view.conditional (if view.innerConditional "innerTruthy" "innerFalsy")}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'innerTruthy');

    _emberMetalRun_loop.default(function () {
      view.set('innerConditional', false);
    });

    equal(view.$().text(), 'innerFalsy');
  });

  QUnit.test('`if` helper with inline form: can use truthy param as binding in a sub expression', function () {
    view = _emberViewsViewsView.default.create({
      conditional: true,
      innerConditional: true,
      innerTruthy: 'innerTruthy',
      template: _emberTemplateCompilerSystemCompile.default('{{if view.conditional (if view.innerConditional view.innerTruthy)}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'innerTruthy');

    _emberMetalRun_loop.default(function () {
      view.set('innerTruthy', 'innerOk');
    });

    equal(view.$().text(), 'innerOk');
  });

  QUnit.test('`if` helper with inline form: respects isTruthy when object changes', function () {
    view = _emberViewsViewsView.default.create({
      conditional: _emberMetalCore.default.Object.create({ isTruthy: false }),
      template: _emberTemplateCompilerSystemCompile.default('{{if view.conditional "truthy" "falsy"}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'falsy');

    _emberMetalRun_loop.default(function () {
      view.set('conditional', _emberMetalCore.default.Object.create({ isTruthy: true }));
    });

    equal(view.$().text(), 'truthy');

    _emberMetalRun_loop.default(function () {
      view.set('conditional', _emberMetalCore.default.Object.create({ isTruthy: false }));
    });

    equal(view.$().text(), 'falsy');
  });

  QUnit.test('`if` helper with inline form: respects isTruthy when property changes', function () {
    var candidate = _emberMetalCore.default.Object.create({ isTruthy: false });

    view = _emberViewsViewsView.default.create({
      conditional: candidate,
      template: _emberTemplateCompilerSystemCompile.default('{{if view.conditional "truthy" "falsy"}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'falsy');

    _emberMetalRun_loop.default(function () {
      candidate.set('isTruthy', true);
    });

    equal(view.$().text(), 'truthy');

    _emberMetalRun_loop.default(function () {
      candidate.set('isTruthy', false);
    });

    equal(view.$().text(), 'falsy');
  });

  QUnit.test('`if` helper with inline form: respects length test when list content changes', function () {
    var list = _emberMetalCore.default.A();

    view = _emberViewsViewsView.default.create({
      conditional: list,
      template: _emberTemplateCompilerSystemCompile.default('{{if view.conditional "truthy" "falsy"}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'falsy');

    _emberMetalRun_loop.default(function () {
      list.pushObject(1);
    });

    equal(view.$().text(), 'truthy');

    _emberMetalRun_loop.default(function () {
      list.replace(0, 1);
    });

    equal(view.$().text(), 'falsy');
  });

  QUnit.test('`if` helper with inline form: respects length test when list itself', function () {
    view = _emberViewsViewsView.default.create({
      conditional: [],
      template: _emberTemplateCompilerSystemCompile.default('{{if view.conditional "truthy" "falsy"}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'falsy');

    _emberMetalRun_loop.default(function () {
      view.set('conditional', [1]);
    });

    equal(view.$().text(), 'truthy');

    _emberMetalRun_loop.default(function () {
      view.set('conditional', []);
    });

    equal(view.$().text(), 'falsy');
  });

  QUnit.test('`if` helper with inline form: updates when given a falsey second argument', function () {
    view = _emberViewsViewsView.default.create({
      conditional: false,
      template: _emberTemplateCompilerSystemCompile.default('{{if view.conditional "" "falsy"}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'falsy');

    _emberMetalRun_loop.default(function () {
      view.set('conditional', true);
    });

    equal(view.$().text(), '');

    _emberMetalRun_loop.default(function () {
      view.set('conditional', false);
    });

    equal(view.$().text(), 'falsy');
  });

  QUnit.test('using `if` with an `{{each}}` destroys components when transitioning to and from inverse (GH #12267)', function () {
    var destroyedChildrenCount = 0;

    registry.register('component:foo-bar', _emberViewsViewsComponent.default.extend({
      willDestroy: function () {
        destroyedChildrenCount++;
      }
    }));
    registry.register('template:components/foo-bar', _emberTemplateCompilerSystemCompile.default('{{number}}'));

    view = _emberViewsViewsView.default.create({
      container: container,
      test: true,
      list: _emberRuntimeSystemNative_array.A([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]),

      template: _emberTemplateCompilerSystemCompile.default('\n      {{~#if view.test~}}\n        {{~#each view.list as |number|~}}\n          {{~foo-bar number=number~}}\n        {{~/each~}}\n      {{~else~}}\n        Nothing Here!\n      {{~/if~}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), '12345678910');

    _emberMetalRun_loop.default(function () {
      view.set('test', false);
    });

    equal(view.$().text(), 'Nothing Here!');

    equal(destroyedChildrenCount, 10, 'the children were properly destroyed');
  });
});
enifed('ember-htmlbars/tests/helpers/if_unless_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/helpers');
  test('ember-htmlbars/tests/helpers/if_unless_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/helpers/if_unless_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/helpers/if_unless_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/helpers');
  QUnit.test('ember-htmlbars/tests/helpers/if_unless_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/helpers/if_unless_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/helpers/input_test', ['exports', 'ember-metal/run_loop', 'ember-metal/property_set', 'ember-views/views/view', 'ember-runtime/tests/utils', 'ember-template-compiler/system/compile', 'container/registry', 'ember-views/component_lookup', 'ember-views/views/text_field', 'ember-views/views/checkbox', 'ember-views/system/event_dispatcher'], function (exports, _emberMetalRun_loop, _emberMetalProperty_set, _emberViewsViewsView, _emberRuntimeTestsUtils, _emberTemplateCompilerSystemCompile, _containerRegistry, _emberViewsComponent_lookup, _emberViewsViewsText_field, _emberViewsViewsCheckbox, _emberViewsSystemEvent_dispatcher) {
  'use strict';

  var view;
  var controller, registry, container;

  function commonSetup() {
    registry = new _containerRegistry.default();
    registry.register('component:-text-field', _emberViewsViewsText_field.default);
    registry.register('component:-checkbox', _emberViewsViewsCheckbox.default);
    registry.register('component-lookup:main', _emberViewsComponent_lookup.default);
    registry.register('event_dispatcher:main', _emberViewsSystemEvent_dispatcher.default);
    container = registry.container();

    var dispatcher = container.lookup('event_dispatcher:main');
    dispatcher.setup({}, '#qunit-fixture');
  }

  QUnit.module('{{input type=\'text\'}}', {
    setup: function () {
      commonSetup();

      controller = {
        val: 'hello',
        place: 'Enter some text',
        name: 'some-name',
        max: 30,
        size: 30,
        tab: 5
      };

      view = _emberViewsViewsView.default.extend({
        container: container,
        controller: controller,
        template: _emberTemplateCompilerSystemCompile.default('{{input type="text" disabled=disabled value=val placeholder=place name=name maxlength=max size=size tabindex=tab}}')
      }).create();

      _emberRuntimeTestsUtils.runAppend(view);
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(view);
      _emberRuntimeTestsUtils.runDestroy(container);
    }
  });

  QUnit.test('should insert a text field into DOM', function () {
    equal(view.$('input').length, 1, 'A single text field was inserted');
  });

  QUnit.test('should become disabled if the disabled attribute is true', function () {
    ok(view.$('input').is(':not(:disabled)'), 'There are no disabled text fields');

    _emberMetalRun_loop.default(null, _emberMetalProperty_set.set, controller, 'disabled', true);
    ok(view.$('input').is(':disabled'), 'The text field is disabled');

    _emberMetalRun_loop.default(null, _emberMetalProperty_set.set, controller, 'disabled', false);
    ok(view.$('input').is(':not(:disabled)'), 'There are no disabled text fields');
  });

  QUnit.test('input value is updated when setting value property of view', function () {
    equal(view.$('input').val(), 'hello', 'renders text field with value');

    var id = view.$('input').prop('id');

    _emberMetalRun_loop.default(null, _emberMetalProperty_set.set, controller, 'val', 'bye!');
    equal(view.$('input').val(), 'bye!', 'updates text field after value changes');

    equal(view.$('input').prop('id'), id, 'the component hasn\'t changed');
  });

  QUnit.test('input placeholder is updated when setting placeholder property of view', function () {
    equal(view.$('input').attr('placeholder'), 'Enter some text', 'renders text field with placeholder');
    _emberMetalRun_loop.default(null, _emberMetalProperty_set.set, controller, 'place', 'Text, please enter it');
    equal(view.$('input').attr('placeholder'), 'Text, please enter it', 'updates text field after placeholder changes');
  });

  QUnit.test('input name is updated when setting name property of view', function () {
    equal(view.$('input').attr('name'), 'some-name', 'renders text field with name');
    _emberMetalRun_loop.default(null, _emberMetalProperty_set.set, controller, 'name', 'other-name');
    equal(view.$('input').attr('name'), 'other-name', 'updates text field after name changes');
  });

  QUnit.test('input maxlength is updated when setting maxlength property of view', function () {
    equal(view.$('input').attr('maxlength'), '30', 'renders text field with maxlength');
    _emberMetalRun_loop.default(null, _emberMetalProperty_set.set, controller, 'max', 40);
    equal(view.$('input').attr('maxlength'), '40', 'updates text field after maxlength changes');
  });

  QUnit.test('input size is updated when setting size property of view', function () {
    equal(view.$('input').attr('size'), '30', 'renders text field with size');
    _emberMetalRun_loop.default(null, _emberMetalProperty_set.set, controller, 'size', 40);
    equal(view.$('input').attr('size'), '40', 'updates text field after size changes');
  });

  QUnit.test('input tabindex is updated when setting tabindex property of view', function () {
    equal(view.$('input').attr('tabindex'), '5', 'renders text field with the tabindex');
    _emberMetalRun_loop.default(null, _emberMetalProperty_set.set, controller, 'tab', 3);
    equal(view.$('input').attr('tabindex'), '3', 'updates text field after tabindex changes');
  });

  QUnit.test('cursor position is not lost when updating content', function () {
    equal(view.$('input').val(), 'hello', 'precondition - renders text field with value');

    var $input = view.$('input');
    var input = $input[0];

    // set the cursor position to 3 (no selection)
    _emberMetalRun_loop.default(function () {
      input.value = 'derp';
      view.childViews[0]._elementValueDidChange();
      input.selectionStart = 3;
      input.selectionEnd = 3;
    });
    _emberMetalRun_loop.default(null, _emberMetalProperty_set.set, controller, 'val', 'derp');

    equal(view.$('input').val(), 'derp', 'updates text field after value changes');

    equal(input.selectionStart, 3, 'cursor position was not lost');
    equal(input.selectionEnd, 3, 'cursor position was not lost');
  });

  QUnit.test('input can be updated multiple times', function () {
    equal(view.$('input').val(), 'hello', 'precondition - renders text field with value');

    var $input = view.$('input');
    var input = $input[0];

    _emberMetalRun_loop.default(null, _emberMetalProperty_set.set, controller, 'val', '');
    equal(view.$('input').val(), '', 'updates first time');

    // Simulates setting the input to the same value as it already is which won't cause a rerender
    _emberMetalRun_loop.default(function () {
      input.value = 'derp';
    });
    _emberMetalRun_loop.default(null, _emberMetalProperty_set.set, controller, 'val', 'derp');
    equal(view.$('input').val(), 'derp', 'updates second time');

    _emberMetalRun_loop.default(null, _emberMetalProperty_set.set, controller, 'val', '');
    equal(view.$('input').val(), '', 'updates third time');
  });

  QUnit.module('{{input type=\'text\'}} - static values', {
    setup: function () {
      commonSetup();

      controller = {};

      view = _emberViewsViewsView.default.extend({
        container: container,
        controller: controller,
        template: _emberTemplateCompilerSystemCompile.default('{{input type="text" disabled=true value="hello" placeholder="Enter some text" name="some-name" maxlength=30 size=30 tabindex=5}}')
      }).create();

      _emberRuntimeTestsUtils.runAppend(view);
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(view);
      _emberRuntimeTestsUtils.runDestroy(container);
    }
  });

  QUnit.test('should insert a text field into DOM', function () {
    equal(view.$('input').length, 1, 'A single text field was inserted');
  });

  QUnit.test('should become disabled if the disabled attribute is true', function () {
    ok(view.$('input').is(':disabled'), 'The text field is disabled');
  });

  QUnit.test('input value is updated when setting value property of view', function () {
    equal(view.$('input').val(), 'hello', 'renders text field with value');
  });

  QUnit.test('input placeholder is updated when setting placeholder property of view', function () {
    equal(view.$('input').attr('placeholder'), 'Enter some text', 'renders text field with placeholder');
  });

  QUnit.test('input name is updated when setting name property of view', function () {
    equal(view.$('input').attr('name'), 'some-name', 'renders text field with name');
  });

  QUnit.test('input maxlength is updated when setting maxlength property of view', function () {
    equal(view.$('input').attr('maxlength'), '30', 'renders text field with maxlength');
  });

  QUnit.test('input size is updated when setting size property of view', function () {
    equal(view.$('input').attr('size'), '30', 'renders text field with size');
  });

  QUnit.test('input tabindex is updated when setting tabindex property of view', function () {
    equal(view.$('input').attr('tabindex'), '5', 'renders text field with the tabindex');
  });

  QUnit.test('specifying `on="someevent" action="foo"` triggers the action', function () {
    expect(2);
    _emberRuntimeTestsUtils.runDestroy(view);
    expectDeprecation('Using \'{{input on="focus-in" action="doFoo"}}\' (\'foo.hbs\' @ L1:C0) is deprecated. Please use \'{{input focus-in="doFoo"}}\' instead.');

    controller = {
      send: function (actionName, value, sender) {
        equal(actionName, 'doFoo', 'text field sent correct action name');
      }
    };

    view = _emberViewsViewsView.default.create({
      container: container,
      controller: controller,

      template: _emberTemplateCompilerSystemCompile.default('{{input type="text" on="focus-in" action="doFoo"}}', { moduleName: 'foo.hbs' })
    });

    _emberRuntimeTestsUtils.runAppend(view);

    _emberMetalRun_loop.default(function () {
      var textField = view.$('input');
      textField.trigger('focusin');
    });
  });

  QUnit.module('{{input type=\'text\'}} - dynamic type', {
    setup: function () {
      commonSetup();

      controller = {
        someProperty: 'password'
      };

      view = _emberViewsViewsView.default.extend({
        container: container,
        controller: controller,
        template: _emberTemplateCompilerSystemCompile.default('{{input type=someProperty}}')
      }).create();

      _emberRuntimeTestsUtils.runAppend(view);
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(view);
      _emberRuntimeTestsUtils.runDestroy(container);
    }
  });

  QUnit.test('should insert a text field into DOM', function () {
    equal(view.$('input').attr('type'), 'password', 'a bound property can be used to determine type.');
  });

  QUnit.test('should change if the type changes', function () {
    equal(view.$('input').attr('type'), 'password', 'a bound property can be used to determine type.');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(controller, 'someProperty', 'text');
    });

    equal(view.$('input').attr('type'), 'text', 'it changes after the type changes');
  });

  QUnit.module('{{input}} - default type', {
    setup: function () {
      commonSetup();

      controller = {};

      view = _emberViewsViewsView.default.extend({
        container: container,
        controller: controller,
        template: _emberTemplateCompilerSystemCompile.default('{{input}}')
      }).create();

      _emberRuntimeTestsUtils.runAppend(view);
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(view);
      _emberRuntimeTestsUtils.runDestroy(container);
    }
  });

  QUnit.test('should have the default type', function () {
    equal(view.$('input').attr('type'), 'text', 'Has a default text type');
  });

  QUnit.module('{{input type=\'checkbox\'}}', {
    setup: function () {
      commonSetup();

      controller = {
        tab: 6,
        name: 'hello',
        val: false
      };

      view = _emberViewsViewsView.default.extend({
        container: container,
        controller: controller,
        template: _emberTemplateCompilerSystemCompile.default('{{input type="checkbox" disabled=disabled tabindex=tab name=name checked=val}}')
      }).create();

      _emberRuntimeTestsUtils.runAppend(view);
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(view);
      _emberRuntimeTestsUtils.runDestroy(container);
    }
  });

  QUnit.test('should append a checkbox', function () {
    equal(view.$('input[type=checkbox]').length, 1, 'A single checkbox is added');
  });

  QUnit.test('should begin disabled if the disabled attribute is true', function () {
    ok(view.$('input').is(':not(:disabled)'), 'The checkbox isn\'t disabled');
    _emberMetalRun_loop.default(null, _emberMetalProperty_set.set, controller, 'disabled', true);
    ok(view.$('input').is(':disabled'), 'The checkbox is now disabled');
  });

  QUnit.test('should support the tabindex property', function () {
    equal(view.$('input').prop('tabindex'), '6', 'the initial checkbox tabindex is set in the DOM');
    _emberMetalRun_loop.default(null, _emberMetalProperty_set.set, controller, 'tab', 3);
    equal(view.$('input').prop('tabindex'), '3', 'the checkbox tabindex changes when it is changed in the view');
  });

  QUnit.test('checkbox name is updated', function () {
    equal(view.$('input').attr('name'), 'hello', 'renders checkbox with the name');
    _emberMetalRun_loop.default(null, _emberMetalProperty_set.set, controller, 'name', 'bye');
    equal(view.$('input').attr('name'), 'bye', 'updates checkbox after name changes');
  });

  QUnit.test('checkbox checked property is updated', function () {
    equal(view.$('input').prop('checked'), false, 'the checkbox isn\'t checked yet');
    _emberMetalRun_loop.default(null, _emberMetalProperty_set.set, controller, 'val', true);
    equal(view.$('input').prop('checked'), true, 'the checkbox is checked now');
  });

  QUnit.module('{{input type=\'checkbox\'}} - prevent value= usage', {
    setup: function () {
      commonSetup();

      view = _emberViewsViewsView.default.extend({
        container: container,
        controller: controller,
        template: _emberTemplateCompilerSystemCompile.default('{{input type="checkbox" disabled=disabled tabindex=tab name=name value=val}}')
      }).create();
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(view);
      _emberRuntimeTestsUtils.runDestroy(container);
    }
  });

  QUnit.test('It asserts the presence of checked=', function () {
    expectAssertion(function () {
      _emberRuntimeTestsUtils.runAppend(view);
    }, /you must use `checked=/);
  });

  QUnit.module('{{input type=boundType}}', {
    setup: function () {
      commonSetup();

      controller = {
        inputType: 'checkbox',
        isChecked: true
      };

      view = _emberViewsViewsView.default.extend({
        container: container,
        controller: controller,
        template: _emberTemplateCompilerSystemCompile.default('{{input type=inputType checked=isChecked}}')
      }).create();

      _emberRuntimeTestsUtils.runAppend(view);
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(view);
      _emberRuntimeTestsUtils.runDestroy(container);
    }
  });

  QUnit.test('should append a checkbox', function () {
    equal(view.$('input[type=checkbox]').length, 1, 'A single checkbox is added');
  });

  // Checking for the checked property is a good way to verify that the correct
  // view was used.
  QUnit.test('checkbox checked property is updated', function () {
    equal(view.$('input').prop('checked'), true, 'the checkbox is checked');
  });

  QUnit.module('{{input type=\'checkbox\'}} - static values', {
    setup: function () {
      commonSetup();

      controller = {
        tab: 6,
        name: 'hello',
        val: false
      };

      view = _emberViewsViewsView.default.extend({
        container: container,
        controller: controller,
        template: _emberTemplateCompilerSystemCompile.default('{{input type="checkbox" disabled=true tabindex=6 name="hello" checked=false}}')
      }).create();

      _emberRuntimeTestsUtils.runAppend(view);
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(view);
      _emberRuntimeTestsUtils.runDestroy(container);
    }
  });

  QUnit.test('should begin disabled if the disabled attribute is true', function () {
    ok(view.$().is(':not(:disabled)'), 'The checkbox isn\'t disabled');
  });

  QUnit.test('should support the tabindex property', function () {
    equal(view.$('input').prop('tabindex'), '6', 'the initial checkbox tabindex is set in the DOM');
  });

  QUnit.test('checkbox name is updated', function () {
    equal(view.$('input').attr('name'), 'hello', 'renders checkbox with the name');
  });

  QUnit.test('checkbox checked property is updated', function () {
    equal(view.$('input').prop('checked'), false, 'the checkbox isn\'t checked yet');
  });

  QUnit.module('{{input type=\'text\'}} - null/undefined values', {
    setup: function () {
      commonSetup();
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(view);
      _emberRuntimeTestsUtils.runDestroy(container);
    }
  });

  QUnit.test('placeholder attribute bound to undefined is not present', function () {
    view = _emberViewsViewsView.default.extend({
      container: container,
      controller: {},
      template: _emberTemplateCompilerSystemCompile.default('{{input placeholder=someThingNotThere}}')
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    ok(!view.element.childNodes[1].hasAttribute('placeholder'), 'attribute not present');

    _emberMetalRun_loop.default(null, _emberMetalProperty_set.set, view, 'controller.someThingNotThere', 'foo');

    equal(view.element.childNodes[1].getAttribute('placeholder'), 'foo', 'attribute is present');
  });

  QUnit.test('placeholder attribute bound to null is not present', function () {
    view = _emberViewsViewsView.default.extend({
      container: container,
      controller: {
        someNullProperty: null
      },
      template: _emberTemplateCompilerSystemCompile.default('{{input placeholder=someNullProperty}}')
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    ok(!view.element.childNodes[1].hasAttribute('placeholder'), 'attribute not present');

    _emberMetalRun_loop.default(null, _emberMetalProperty_set.set, view, 'controller.someNullProperty', 'foo');

    equal(view.element.childNodes[1].getAttribute('placeholder'), 'foo', 'attribute is present');
  });
});
enifed('ember-htmlbars/tests/helpers/input_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/helpers');
  test('ember-htmlbars/tests/helpers/input_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/helpers/input_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/helpers/input_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/helpers');
  QUnit.test('ember-htmlbars/tests/helpers/input_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/helpers/input_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/helpers/loc_test', ['exports', 'ember-metal/core', 'ember-views/views/view', 'ember-template-compiler/system/compile', 'ember-runtime/tests/utils'], function (exports, _emberMetalCore, _emberViewsViewsView, _emberTemplateCompilerSystemCompile, _emberRuntimeTestsUtils) {
  'use strict';

  function buildView(template, context) {
    return _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default(template),
      context: context || {}
    });
  }

  var oldString;

  QUnit.module('ember-htmlbars: {{#loc}} helper', {
    setup: function () {
      oldString = _emberMetalCore.default.STRINGS;
      _emberMetalCore.default.STRINGS = {
        '_Howdy Friend': 'Hallo Freund'
      };
    },

    teardown: function () {
      _emberMetalCore.default.STRINGS = oldString;
    }
  });

  QUnit.test('let the original value through by default', function () {
    var view = buildView('{{loc "Hiya buddy!"}}');
    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'Hiya buddy!');

    _emberRuntimeTestsUtils.runDestroy(view);
  });

  QUnit.test('localize a simple string', function () {
    var view = buildView('{{loc "_Howdy Friend"}}');
    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'Hallo Freund');

    _emberRuntimeTestsUtils.runDestroy(view);
  });

  QUnit.test('localize takes passed formats into an account', function () {
    var view = buildView('{{loc "%@, %@" "Hello" "Mr. Pitkin"}}');
    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'Hello, Mr. Pitkin', 'the value of localizationKey is correct');

    _emberRuntimeTestsUtils.runDestroy(view);
  });
});
enifed('ember-htmlbars/tests/helpers/loc_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/helpers');
  test('ember-htmlbars/tests/helpers/loc_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/helpers/loc_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/helpers/loc_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/helpers');
  QUnit.test('ember-htmlbars/tests/helpers/loc_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/helpers/loc_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/helpers/log_test', ['exports', 'ember-metal/core', 'ember-views/views/view', 'ember-template-compiler/system/compile', 'ember-runtime/tests/utils'], function (exports, _emberMetalCore, _emberViewsViewsView, _emberTemplateCompilerSystemCompile, _emberRuntimeTestsUtils) {
  'use strict';

  var originalLookup, originalLog, logCalls, lookup, view;

  QUnit.module('ember-htmlbars: {{#log}} helper', {
    setup: function () {
      _emberMetalCore.default.lookup = lookup = { Ember: _emberMetalCore.default };

      originalLog = _emberMetalCore.default.Logger.log;
      logCalls = [];
      _emberMetalCore.default.Logger.log = function (arg) {
        logCalls.push(arg);
      };
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(view);

      view = null;

      _emberMetalCore.default.Logger.log = originalLog;
      _emberMetalCore.default.lookup = originalLookup;
    }
  });

  QUnit.test('should be able to log a property', function () {
    var context = {
      value: 'one'
    };

    view = _emberViewsViewsView.default.create({
      context: context,
      template: _emberTemplateCompilerSystemCompile.default('{{log value}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), '', 'shouldn\'t render any text');
    equal(logCalls[0], 'one', 'should call log with value');
  });

  QUnit.test('should be able to log a view property', function () {
    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('{{log view.value}}'),
      value: 'one'
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), '', 'shouldn\'t render any text');
    equal(logCalls[0], 'one', 'should call log with value');
  });

  QUnit.test('should be able to log `this`', function () {
    view = _emberViewsViewsView.default.create({
      context: 'one',
      template: _emberTemplateCompilerSystemCompile.default('{{log this}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), '', 'shouldn\'t render any text');
    equal(logCalls[0], 'one', 'should call log with item one');
  });
});
enifed('ember-htmlbars/tests/helpers/log_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/helpers');
  test('ember-htmlbars/tests/helpers/log_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/helpers/log_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/helpers/log_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/helpers');
  QUnit.test('ember-htmlbars/tests/helpers/log_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/helpers/log_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/helpers/partial_test', ['exports', 'ember-metal/core', 'ember-runtime/system/object', 'ember-metal/run_loop', 'ember-views/views/view', 'ember-views/system/jquery', 'ember-runtime/system/container', 'ember-template-compiler/system/compile', 'ember-runtime/tests/utils'], function (exports, _emberMetalCore, _emberRuntimeSystemObject, _emberMetalRun_loop, _emberViewsViewsView, _emberViewsSystemJquery, _emberRuntimeSystemContainer, _emberTemplateCompilerSystemCompile, _emberRuntimeTestsUtils) {
  'use strict';

  var trim = _emberViewsSystemJquery.default.trim;

  var MyApp, lookup, view, registry, container;
  var originalLookup = _emberMetalCore.default.lookup;

  QUnit.module('Support for {{partial}} helper', {
    setup: function () {
      _emberMetalCore.default.lookup = lookup = { Ember: _emberMetalCore.default };
      MyApp = lookup.MyApp = _emberRuntimeSystemObject.default.create({});
      registry = new _emberRuntimeSystemContainer.Registry();
      container = registry.container();
      registry.optionsForType('template', { instantiate: false });
    },
    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(view);
      _emberMetalCore.default.lookup = originalLookup;
    }
  });

  QUnit.test('should render other templates registered with the container', function () {
    registry.register('template:_subTemplateFromContainer', _emberTemplateCompilerSystemCompile.default('sub-template'));

    view = _emberViewsViewsView.default.create({
      container: container,
      template: _emberTemplateCompilerSystemCompile.default('This {{partial "subTemplateFromContainer"}} is pretty great.')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(trim(view.$().text()), 'This sub-template is pretty great.');
  });

  QUnit.test('should render other slash-separated templates registered with the container', function () {
    registry.register('template:child/_subTemplateFromContainer', _emberTemplateCompilerSystemCompile.default('sub-template'));

    view = _emberViewsViewsView.default.create({
      container: container,
      template: _emberTemplateCompilerSystemCompile.default('This {{partial "child/subTemplateFromContainer"}} is pretty great.')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(trim(view.$().text()), 'This sub-template is pretty great.');
  });

  QUnit.test('should use the current view\'s context', function () {
    registry.register('template:_person_name', _emberTemplateCompilerSystemCompile.default('{{firstName}} {{lastName}}'));

    view = _emberViewsViewsView.default.create({
      container: container,
      template: _emberTemplateCompilerSystemCompile.default('Who is {{partial "person_name"}}?')
    });
    view.set('controller', _emberRuntimeSystemObject.default.create({
      firstName: 'Kris',
      lastName: 'Selden'
    }));

    _emberRuntimeTestsUtils.runAppend(view);

    equal(trim(view.$().text()), 'Who is Kris Selden?');
  });

  QUnit.test('Quoteless parameters passed to {{template}} perform a bound property lookup of the partial name', function () {
    registry.register('template:_subTemplate', _emberTemplateCompilerSystemCompile.default('sub-template'));
    registry.register('template:_otherTemplate', _emberTemplateCompilerSystemCompile.default('other-template'));

    view = _emberViewsViewsView.default.create({
      container: container,
      template: _emberTemplateCompilerSystemCompile.default('This {{partial view.partialName}} is pretty {{partial nonexistent}}great.'),
      partialName: 'subTemplate'
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(trim(view.$().text()), 'This sub-template is pretty great.');

    _emberMetalRun_loop.default(function () {
      view.set('partialName', 'otherTemplate');
    });

    equal(trim(view.$().text()), 'This other-template is pretty great.');

    _emberMetalRun_loop.default(function () {
      view.set('partialName', null);
    });

    equal(trim(view.$().text()), 'This  is pretty great.');
  });
});
enifed('ember-htmlbars/tests/helpers/partial_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/helpers');
  test('ember-htmlbars/tests/helpers/partial_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/helpers/partial_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/helpers/partial_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/helpers');
  QUnit.test('ember-htmlbars/tests/helpers/partial_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/helpers/partial_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/helpers/text_area_test', ['exports', 'ember-metal/run_loop', 'ember-views/views/view', 'ember-template-compiler/system/compile', 'ember-metal/property_set', 'ember-runtime/tests/utils', 'ember-views/views/text_area', 'container/registry', 'ember-views/component_lookup'], function (exports, _emberMetalRun_loop, _emberViewsViewsView, _emberTemplateCompilerSystemCompile, _emberMetalProperty_set, _emberRuntimeTestsUtils, _emberViewsViewsText_area, _containerRegistry, _emberViewsComponent_lookup) {
  'use strict';

  var textArea, controller;

  function set(object, key, value) {
    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(object, key, value);
    });
  }

  QUnit.module('{{textarea}}', {
    setup: function () {
      controller = {
        val: 'Lorem ipsum dolor'
      };

      var registry = new _containerRegistry.default();
      registry.register('component:-text-area', _emberViewsViewsText_area.default);
      registry.register('component-lookup:main', _emberViewsComponent_lookup.default);

      textArea = _emberViewsViewsView.default.extend({
        container: registry.container(),
        controller: controller,
        template: _emberTemplateCompilerSystemCompile.default('{{textarea disabled=disabled value=val}}')
      }).create();

      _emberRuntimeTestsUtils.runAppend(textArea);
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(textArea);
    }
  });

  QUnit.test('Should insert a textarea', function () {
    equal(textArea.$('textarea').length, 1, 'There is a single textarea');
  });

  QUnit.test('Should become disabled when the controller changes', function () {
    ok(textArea.$('textarea').is(':not(:disabled)'), 'Nothing is disabled yet');
    set(controller, 'disabled', true);
    ok(textArea.$('textarea').is(':disabled'), 'The disabled attribute is updated');
  });

  QUnit.test('Should bind its contents to the specified value', function () {
    equal(textArea.$('textarea').val(), 'Lorem ipsum dolor', 'The contents are included');
    set(controller, 'val', 'sit amet');
    equal(textArea.$('textarea').val(), 'sit amet', 'The new contents are included');
  });
});
enifed('ember-htmlbars/tests/helpers/text_area_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/helpers');
  test('ember-htmlbars/tests/helpers/text_area_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/helpers/text_area_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/helpers/text_area_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/helpers');
  QUnit.test('ember-htmlbars/tests/helpers/text_area_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/helpers/text_area_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/helpers/unbound_test', ['exports', 'ember-views/views/view', 'ember-views/views/component', 'ember-runtime/system/object', 'ember-runtime/system/native_array', 'ember-metal/core', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/run_loop', 'ember-template-compiler/system/compile', 'ember-htmlbars/helper', 'ember-runtime/system/container', 'ember-runtime/tests/utils'], function (exports, _emberViewsViewsView, _emberViewsViewsComponent, _emberRuntimeSystemObject, _emberRuntimeSystemNative_array, _emberMetalCore, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalRun_loop, _emberTemplateCompilerSystemCompile, _emberHtmlbarsHelper, _emberRuntimeSystemContainer, _emberRuntimeTestsUtils) {
  /*jshint newcap:false*/
  'use strict';

  var view, lookup, registry, container;
  var originalLookup = _emberMetalCore.default.lookup;

  QUnit.module('ember-htmlbars: {{#unbound}} helper', {
    setup: function () {
      _emberMetalCore.default.lookup = lookup = { Ember: _emberMetalCore.default };
      registry = new _emberRuntimeSystemContainer.Registry();
      container = registry.container();

      view = _emberViewsViewsView.default.create({
        container: container,
        template: _emberTemplateCompilerSystemCompile.default('{{unbound foo}} {{unbound bar}}'),
        context: _emberRuntimeSystemObject.default.create({
          foo: 'BORK',
          barBinding: 'foo'
        })
      });

      _emberRuntimeTestsUtils.runAppend(view);
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(view);
      _emberRuntimeTestsUtils.runDestroy(container);
      registry = container = view = null;
      _emberMetalCore.default.lookup = originalLookup;
    }
  });

  QUnit.test('it should render the current value of a property on the context', function () {
    equal(view.$().text(), 'BORK BORK', 'should render the current value of a property');
  });

  QUnit.test('it should not re-render if the property changes', function () {
    _emberMetalRun_loop.default(function () {
      view.set('context.foo', 'OOF');
    });
    equal(view.$().text(), 'BORK BORK', 'should not re-render if the property changes');
  });

  QUnit.test('it should not re-render if the parent view rerenders', function () {
    _emberMetalRun_loop.default(function () {
      view.set('context.foo', 'OOF');
      view.rerender();
    });
    equal(view.$().text(), 'OOF OOF', 'should re-render if the parent view rerenders');
  });

  QUnit.test('it should assert unbound cannot be called with multiple arguments', function () {
    expectAssertion(function () {
      _emberRuntimeTestsUtils.runAppend(_emberViewsViewsView.default.create({
        template: _emberTemplateCompilerSystemCompile.default('{{unbound foo bar}}'),
        context: _emberRuntimeSystemObject.default.create({
          foo: 'BORK',
          bar: 'foo'
        })
      }));
    }, /unbound helper cannot be called with multiple params or hash params/);
  });

  QUnit.test('should property escape unsafe hrefs', function () {
    /* jshint scripturl:true */

    expect(3);

    _emberRuntimeTestsUtils.runDestroy(view);

    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('<ul>{{#each view.people as |person|}}<a href="{{unbound person.url}}">{{person.name}}</a>{{/each}}</ul>'),
      people: _emberRuntimeSystemNative_array.A([{
        name: 'Bob',
        url: 'javascript:bob-is-cool'
      }, {
        name: 'James',
        url: 'vbscript:james-is-cool'
      }, {
        name: 'Richard',
        url: 'javascript:richard-is-cool'
      }])
    });

    _emberRuntimeTestsUtils.runAppend(view);

    var links = view.$('a');
    for (var i = 0, l = links.length; i < l; i++) {
      var link = links[i];
      equal(link.protocol, 'unsafe:', 'properly escaped');
    }
  });

  QUnit.test('should render on attributes', function (assert) {
    /* jshint scripturl:true */

    _emberRuntimeTestsUtils.runDestroy(view);

    view = _emberViewsViewsComponent.default.create({
      layout: _emberTemplateCompilerSystemCompile.default('<a href={{unbound name}}></a>'),
      name: 'bob'
    });

    _emberRuntimeTestsUtils.runAppend(view);

    _emberMetalRun_loop.default(function () {
      view.set('name', 'rick');
    });
    assert.equal(view.$().html(), '<a href="bob"></a>');
  });

  QUnit.module('ember-htmlbars: {{#unbound}} helper with container present', {
    setup: function () {
      _emberMetalCore.default.lookup = lookup = { Ember: _emberMetalCore.default };
      registry = new _emberRuntimeSystemContainer.Registry();
      container = registry.container();

      view = _emberViewsViewsView.default.create({
        container: container,
        template: _emberTemplateCompilerSystemCompile.default('{{unbound foo}}'),
        context: _emberRuntimeSystemObject.default.create({
          foo: 'bleep'
        })
      });
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(view);
      _emberRuntimeTestsUtils.runDestroy(container);
      container = registry = view = null;
      _emberMetalCore.default.lookup = originalLookup;
    }
  });

  QUnit.test('it should render the current value of a property path on the context', function () {
    _emberRuntimeTestsUtils.runAppend(view);
    equal(view.$().text(), 'bleep', 'should render the current value of a property path');
  });

  QUnit.module('ember-htmlbars: {{#unbound}} subexpression', {
    setup: function () {
      _emberMetalCore.default.lookup = lookup = { Ember: _emberMetalCore.default };
      registry = new _emberRuntimeSystemContainer.Registry();
      container = registry.container();

      registry.register('helper:-capitalize', _emberHtmlbarsHelper.helper(function (params) {
        return params[0].toUpperCase();
      }));

      view = _emberViewsViewsView.default.create({
        container: container,
        template: _emberTemplateCompilerSystemCompile.default('{{-capitalize (unbound foo)}}'),
        context: _emberRuntimeSystemObject.default.create({
          foo: 'bork'
        })
      });

      _emberRuntimeTestsUtils.runAppend(view);
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(view);
      _emberRuntimeTestsUtils.runDestroy(container);
      registry = container = view = null;
      _emberMetalCore.default.lookup = originalLookup;
    }
  });

  QUnit.test('it should render the current value of a property on the context', function () {
    equal(view.$().text(), 'BORK', 'should render the current value of a property');
  });

  QUnit.test('it should not re-render if the property changes', function () {
    _emberMetalRun_loop.default(function () {
      view.set('context.foo', 'oof');
    });
    equal(view.$().text(), 'BORK', 'should not re-render if the property changes');
  });

  QUnit.test('it should not re-render if the parent view rerenders', function () {
    _emberMetalRun_loop.default(function () {
      view.set('context.foo', 'oof');
      view.rerender();
    });
    equal(view.$().text(), 'BORK', 'should not re-render if the parent view rerenders');
  });

  QUnit.module('ember-htmlbars: {{#unbound}} subexpression - helper form', {
    setup: function () {
      _emberMetalCore.default.lookup = lookup = { Ember: _emberMetalCore.default };
      registry = new _emberRuntimeSystemContainer.Registry();
      container = registry.container();

      registry.register('helper:-capitalize', _emberHtmlbarsHelper.helper(function (params) {
        return params[0].toUpperCase();
      }));

      registry.register('helper:-doublize', _emberHtmlbarsHelper.helper(function (params) {
        return params[0] + ' ' + params[0];
      }));

      view = _emberViewsViewsView.default.create({
        container: container,
        template: _emberTemplateCompilerSystemCompile.default('{{-capitalize (unbound (-doublize foo))}}'),
        context: _emberRuntimeSystemObject.default.create({
          foo: 'bork'
        })
      });

      _emberRuntimeTestsUtils.runAppend(view);
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(view);
      _emberRuntimeTestsUtils.runDestroy(container);
      registry = container = view = null;
      _emberMetalCore.default.lookup = originalLookup;
    }
  });

  QUnit.test('it should render the current value of a property on the context', function () {
    equal(view.$().text(), 'BORK BORK', 'should render the current value of a property');
  });

  QUnit.test('it should not re-render if the property changes', function () {
    _emberMetalRun_loop.default(function () {
      view.set('context.foo', 'oof');
    });
    equal(view.$().text(), 'BORK BORK', 'should not re-render if the property changes');
  });

  QUnit.test('it should re-render if the parent view rerenders', function () {
    _emberMetalRun_loop.default(function () {
      view.set('context.foo', 'oof');
      view.rerender();
    });
    equal(view.$().text(), 'BORK BORK', 'should not re-render if the parent view rerenders');
  });

  QUnit.module('ember-htmlbars: {{#unbound boundHelper arg1 arg2... argN}} form: render unbound helper invocations', {
    setup: function () {
      _emberMetalCore.default.lookup = lookup = { Ember: _emberMetalCore.default };
      registry = new _emberRuntimeSystemContainer.Registry();
      container = registry.container();

      registry.register('helper:-surround', _emberHtmlbarsHelper.helper(function (_ref) {
        var prefix = _ref[0];
        var value = _ref[1];
        var suffix = _ref[2];

        return prefix + '-' + value + '-' + suffix;
      }));

      registry.register('helper:-capitalize', _emberHtmlbarsHelper.helper(function (_ref2) {
        var value = _ref2[0];

        return value.toUpperCase();
      }));

      registry.register('helper:-capitalizeName', _emberHtmlbarsHelper.default.extend({
        destroy: function () {
          this.removeObserver('value.firstName');
          this._super.apply(this, arguments);
        },
        compute: function (_ref3) {
          var value = _ref3[0];

          if (this.get('value')) {
            this.removeObserver('value.firstName');
          }
          this.set('value', value);
          this.addObserver('value.firstName', this, this.recompute);
          return value ? _emberMetalProperty_get.get(value, 'firstName').toUpperCase() : '';
        }
      }));

      registry.register('helper:-fauxconcat', _emberHtmlbarsHelper.helper(function (params) {
        return params.join('');
      }));

      registry.register('helper:-concatNames', _emberHtmlbarsHelper.default.extend({
        destroy: function () {
          this.teardown();
          this._super.apply(this, arguments);
        },
        teardown: function () {
          this.removeObserver('value.firstName');
          this.removeObserver('value.lastName');
        },
        compute: function (_ref4) {
          var value = _ref4[0];

          if (this.get('value')) {
            this.teardown();
          }
          this.set('value', value);
          this.addObserver('value.firstName', this, this.recompute);
          this.addObserver('value.lastName', this, this.recompute);
          return (value ? _emberMetalProperty_get.get(value, 'firstName') : '') + (value ? _emberMetalProperty_get.get(value, 'lastName') : '');
        }
      }));
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(view);
      _emberRuntimeTestsUtils.runDestroy(container);
      registry = container = view = null;
      _emberMetalCore.default.lookup = originalLookup;
    }
  });

  QUnit.test('should be able to render an unbound helper invocation', function () {
    registry.register('helper:-repeat', _emberHtmlbarsHelper.helper(function (_ref5, _ref6) {
      var value = _ref5[0];
      var count = _ref6.count;

      var a = [];
      while (a.length < count) {
        a.push(value);
      }
      return a.join('');
    }));

    view = _emberViewsViewsView.default.create({
      container: container,
      template: _emberTemplateCompilerSystemCompile.default('{{unbound (-repeat foo count=bar)}} {{-repeat foo count=bar}} {{unbound (-repeat foo count=2)}} {{-repeat foo count=4}}'),
      context: _emberRuntimeSystemObject.default.create({
        foo: 'X',
        numRepeatsBinding: 'bar',
        bar: 5
      })
    });
    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'XXXXX XXXXX XX XXXX', 'first render is correct');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'context.bar', 1);
    });

    equal(view.$().text(), 'XXXXX X XX XXXX', 'only unbound bound options changed');
  });

  QUnit.test('should be able to render an bound helper invocation mixed with static values', function () {
    view = _emberViewsViewsView.default.create({
      container: container,
      template: _emberTemplateCompilerSystemCompile.default('{{unbound (-surround prefix value "bar")}} {{-surround prefix value "bar"}} {{unbound (-surround "bar" value suffix)}} {{-surround "bar" value suffix}}'),
      context: _emberRuntimeSystemObject.default.create({
        prefix: 'before',
        value: 'core',
        suffix: 'after'
      })
    });
    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'before-core-bar before-core-bar bar-core-after bar-core-after', 'first render is correct');
    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'context.prefix', 'beforeChanged');
      _emberMetalProperty_set.set(view, 'context.value', 'coreChanged');
      _emberMetalProperty_set.set(view, 'context.suffix', 'afterChanged');
    });
    equal(view.$().text(), 'before-core-bar beforeChanged-coreChanged-bar bar-core-after bar-coreChanged-afterChanged', 'only bound values change');
  });

  QUnit.test('should be able to render unbound forms of multi-arg helpers', function () {
    view = _emberViewsViewsView.default.create({
      container: container,
      template: _emberTemplateCompilerSystemCompile.default('{{-fauxconcat foo bar bing}} {{unbound (-fauxconcat foo bar bing)}}'),
      context: _emberRuntimeSystemObject.default.create({
        foo: 'a',
        bar: 'b',
        bing: 'c'
      })
    });
    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'abc abc', 'first render is correct');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'context.bar', 'X');
    });

    equal(view.$().text(), 'aXc abc', 'unbound helpers/properties stayed the same');
  });

  QUnit.test('should be able to render an unbound helper invocation for helpers with dependent keys', function () {
    view = _emberViewsViewsView.default.create({
      container: container,
      template: _emberTemplateCompilerSystemCompile.default('{{-capitalizeName person}} {{unbound (-capitalizeName person)}} {{-concatNames person}} {{unbound (-concatNames person)}}'),
      context: _emberRuntimeSystemObject.default.create({
        person: _emberRuntimeSystemObject.default.create({
          firstName: 'shooby',
          lastName: 'taylor'
        })
      })
    });
    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'SHOOBY SHOOBY shoobytaylor shoobytaylor', 'first render is correct');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'context.person.firstName', 'sally');
    });

    equal(view.$().text(), 'SALLY SHOOBY sallytaylor shoobytaylor', 'only bound values change');
  });

  QUnit.test('should be able to render an unbound helper invocation in #each helper', function () {
    view = _emberViewsViewsView.default.create({
      container: container,
      template: _emberTemplateCompilerSystemCompile.default(['{{#each people as |person|}}', '{{-capitalize person.firstName}} {{unbound (-capitalize person.firstName)}}', '{{/each}}'].join('')),
      context: {
        people: _emberMetalCore.default.A([{
          firstName: 'shooby',
          lastName: 'taylor'
        }, {
          firstName: 'cindy',
          lastName: 'taylor'
        }])
      }
    });
    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'SHOOBY SHOOBYCINDY CINDY', 'unbound rendered correctly');
  });

  QUnit.test('should be able to render an unbound helper invocation with bound hash options', function () {
    registry.register('helper:-repeat', _emberHtmlbarsHelper.helper(function (_ref7) {
      var value = _ref7[0];

      return [].slice.call(arguments, 0, -1).join('');
    }));

    view = _emberViewsViewsView.default.create({
      container: container,
      template: _emberTemplateCompilerSystemCompile.default('{{-capitalizeName person}} {{unbound (-capitalizeName person)}} {{-concatNames person}} {{unbound (-concatNames person)}}'),
      context: _emberRuntimeSystemObject.default.create({
        person: _emberRuntimeSystemObject.default.create({
          firstName: 'shooby',
          lastName: 'taylor'
        })
      })
    });
    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'SHOOBY SHOOBY shoobytaylor shoobytaylor', 'first render is correct');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'context.person.firstName', 'sally');
    });

    equal(view.$().text(), 'SALLY SHOOBY sallytaylor shoobytaylor', 'only bound values change');
  });

  QUnit.test('should be able to render bound form of a helper inside unbound form of same helper', function () {
    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default(['{{#if (unbound foo)}}', '{{#if bar}}true{{/if}}', '{{#unless bar}}false{{/unless}}', '{{/if}}', '{{#unless (unbound notfoo)}}', '{{#if bar}}true{{/if}}', '{{#unless bar}}false{{/unless}}', '{{/unless}}'].join('')),
      context: _emberRuntimeSystemObject.default.create({
        foo: true,
        notfoo: false,
        bar: true
      })
    });
    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'truetrue', 'first render is correct');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'context.bar', false);
    });

    equal(view.$().text(), 'falsefalse', 'bound if and unless inside unbound if/unless are updated');
  });

  QUnit.module('ember-htmlbars: {{#unbound}} helper -- Container Lookup', {
    setup: function () {
      _emberMetalCore.default.lookup = lookup = { Ember: _emberMetalCore.default };
      registry = new _emberRuntimeSystemContainer.Registry();
      container = registry.container();
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(view);
      _emberRuntimeTestsUtils.runDestroy(container);
      registry = container = view = null;
      _emberMetalCore.default.lookup = originalLookup;
    }
  });

  QUnit.test('should lookup helpers in the container', function () {
    registry.register('helper:up-case', _emberHtmlbarsHelper.helper(function (_ref8) {
      var value = _ref8[0];

      return value.toUpperCase();
    }));

    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('{{unbound (up-case displayText)}}'),
      container: container,
      context: {
        displayText: 'such awesome'
      }
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'SUCH AWESOME', 'proper values were rendered');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'context.displayText', 'no changes');
    });

    equal(view.$().text(), 'SUCH AWESOME', 'only bound values change');
  });

  QUnit.test('should be able to output a property without binding', function () {
    var context = {
      content: _emberRuntimeSystemObject.default.create({
        anUnboundString: 'No spans here, son.'
      })
    };

    view = _emberViewsViewsView.default.create({
      context: context,
      template: _emberTemplateCompilerSystemCompile.default('<div id="first">{{unbound content.anUnboundString}}</div>')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('#first').html(), 'No spans here, son.');
  });

  QUnit.test('should be able to use unbound helper in #each helper', function () {
    view = _emberViewsViewsView.default.create({
      items: _emberRuntimeSystemNative_array.A(['a', 'b', 'c', 1, 2, 3]),
      template: _emberTemplateCompilerSystemCompile.default('<ul>{{#each view.items as |item|}}<li>{{unbound item}}</li>{{/each}}</ul>')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'abc123');
    equal(view.$('li').children().length, 0, 'No markers');
  });

  QUnit.test('should be able to use unbound helper in #each helper (with objects)', function () {
    view = _emberViewsViewsView.default.create({
      items: _emberRuntimeSystemNative_array.A([{ wham: 'bam' }, { wham: 1 }]),
      template: _emberTemplateCompilerSystemCompile.default('<ul>{{#each view.items as |item|}}<li>{{unbound item.wham}}</li>{{/each}}</ul>')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'bam1');
    equal(view.$('li').children().length, 0, 'No markers');
  });

  QUnit.test('should work properly with attributes', function () {
    expect(4);

    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('<ul>{{#each view.people as |person|}}<li class="{{unbound person.cool}}">{{person.name}}</li>{{/each}}</ul>'),
      people: _emberRuntimeSystemNative_array.A([{
        name: 'Bob',
        cool: 'not-cool'
      }, {
        name: 'James',
        cool: 'is-cool'
      }, {
        name: 'Richard',
        cool: 'is-cool'
      }])
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('li.not-cool').length, 1, 'correct number of not cool people');
    equal(view.$('li.is-cool').length, 2, 'correct number of cool people');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'people.firstObject.cool', 'is-cool');
    });

    equal(view.$('li.not-cool').length, 1, 'correct number of not cool people');
    equal(view.$('li.is-cool').length, 2, 'correct number of cool people');
  });
});
enifed('ember-htmlbars/tests/helpers/unbound_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/helpers');
  test('ember-htmlbars/tests/helpers/unbound_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/helpers/unbound_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/helpers/unbound_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/helpers');
  QUnit.test('ember-htmlbars/tests/helpers/unbound_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/helpers/unbound_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/helpers/view_test', ['exports', 'ember-metal/core', 'ember-views/views/view', 'ember-views/views/component', 'container/registry', 'ember-views/component_lookup', 'ember-metal/run_loop', 'ember-views/system/jquery', 'ember-views/views/text_field', 'ember-runtime/system/object', 'ember-views/views/container_view', 'htmlbars-util/safe-string', 'ember-template-compiler/compat/precompile', 'ember-template-compiler/system/compile', 'ember-template-compiler/system/template', 'ember-metal/observer', 'ember-runtime/controllers/controller', 'ember-htmlbars/helper', 'ember-runtime/tests/utils', 'ember-metal/property_set', 'ember-metal/property_get', 'ember-metal/computed', 'ember-htmlbars/tests/utils', 'ember-htmlbars/keywords/view'], function (exports, _emberMetalCore, _emberViewsViewsView, _emberViewsViewsComponent, _containerRegistry, _emberViewsComponent_lookup, _emberMetalRun_loop, _emberViewsSystemJquery, _emberViewsViewsText_field, _emberRuntimeSystemObject, _emberViewsViewsContainer_view, _htmlbarsUtilSafeString, _emberTemplateCompilerCompatPrecompile, _emberTemplateCompilerSystemCompile, _emberTemplateCompilerSystemTemplate, _emberMetalObserver, _emberRuntimeControllersController, _emberHtmlbarsHelper, _emberRuntimeTestsUtils, _emberMetalProperty_set, _emberMetalProperty_get, _emberMetalComputed, _emberHtmlbarsTestsUtils, _emberHtmlbarsKeywordsView) {
  /*globals EmberDev */
  'use strict';

  var view, originalLookup, registry, container, lookup, originalViewKeyword;

  var trim = _emberViewsSystemJquery.default.trim;

  function firstGrandchild(view) {
    return _emberMetalProperty_get.get(_emberMetalProperty_get.get(view, 'childViews').objectAt(0), 'childViews').objectAt(0);
  }

  function nthChild(view, nth) {
    return _emberMetalProperty_get.get(view, 'childViews').objectAt(nth || 0);
  }

  function viewClass(options) {
    options.container = options.container || container;
    return _emberViewsViewsView.default.extend(options);
  }

  var firstChild = nthChild;

  QUnit.module('ember-htmlbars: {{#view}} helper', {
    setup: function () {
      originalViewKeyword = _emberHtmlbarsTestsUtils.registerKeyword('view', _emberHtmlbarsKeywordsView.default);

      originalLookup = _emberMetalCore.default.lookup;
      _emberMetalCore.default.lookup = lookup = {};

      registry = new _containerRegistry.default();
      container = registry.container();
      registry.optionsForType('template', { instantiate: false });
      registry.register('view:toplevel', _emberViewsViewsView.default.extend());
      registry.register('component-lookup:main', _emberViewsComponent_lookup.default);
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(container);
      _emberRuntimeTestsUtils.runDestroy(view);
      registry = container = view = null;

      _emberMetalCore.default.lookup = lookup = originalLookup;

      _emberHtmlbarsTestsUtils.resetKeyword('view', originalViewKeyword);
    }
  });

  // https://github.com/emberjs/ember.js/issues/120
  QUnit.test('should not enter an infinite loop when binding an attribute in Handlebars', function () {
    var LinkView = _emberViewsViewsView.default.extend({
      classNames: ['app-link'],
      tagName: 'a',
      attributeBindings: ['href'],
      href: '#none',

      click: function () {
        return false;
      }
    });

    var parentView = _emberViewsViewsView.default.create({
      linkView: LinkView,
      test: _emberRuntimeSystemObject.default.create({ href: 'test' }),
      template: _emberTemplateCompilerSystemCompile.default('{{#view view.linkView href=view.test.href}} Test {{/view}}')
    });

    _emberRuntimeTestsUtils.runAppend(parentView);

    // Use match, since old IE appends the whole URL
    var href = parentView.$('a').attr('href');
    var classNames = parentView.$('a').attr('class');
    ok(href.match(/(^|\/)test$/), 'Expected href to be \'test\' but got "' + href + '"');
    equal(classNames, 'ember-view app-link');

    _emberRuntimeTestsUtils.runDestroy(parentView);
  });

  QUnit.test('By default view:toplevel is used', function () {
    var registry = new _containerRegistry.default();

    var DefaultView = viewClass({
      elementId: 'toplevel-view',
      template: _emberTemplateCompilerSystemCompile.default('hello world')
    });

    registry.register('view:toplevel', DefaultView);

    view = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('{{view}}'),
      container: registry.container()
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    equal(_emberViewsSystemJquery.default('#toplevel-view').text(), 'hello world');
  });

  QUnit.test('By default, without a container, EmberView is used', function () {
    view = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('{{view tagName="span"}}')
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    ok(_emberViewsSystemJquery.default('#qunit-fixture').html().toUpperCase().match(/<SPAN/), 'contains view with span');
  });

  QUnit.test('View lookup - \'fu\'', function () {
    var FuView = viewClass({
      elementId: 'fu',
      template: _emberTemplateCompilerSystemCompile.default('bro')
    });

    registry.register('view:fu', FuView);

    view = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('{{view \'fu\'}}'),
      container: container
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    equal(_emberViewsSystemJquery.default('#fu').text(), 'bro');
  });

  QUnit.test('View lookup - \'fu\' when fu is a property and a view name', function () {
    var FuView = viewClass({
      elementId: 'fu',
      template: _emberTemplateCompilerSystemCompile.default('bro')
    });

    registry.register('view:fu', FuView);

    view = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('{{view \'fu\'}}'),
      context: { fu: 'boom!' },
      container: container
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    equal(_emberViewsSystemJquery.default('#fu').text(), 'bro');
  });

  QUnit.test('View lookup - view.computed', function () {
    var FuView = viewClass({
      elementId: 'fu',
      template: _emberTemplateCompilerSystemCompile.default('bro')
    });

    registry.register('view:fu', FuView);

    view = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('{{view view.computed}}'),
      container: container,
      computed: 'fu'
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    equal(_emberViewsSystemJquery.default('#fu').text(), 'bro');
  });

  QUnit.test('id bindings downgrade to one-time property lookup', function () {
    view = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('{{#view id=view.meshuggah}}{{view.parentView.meshuggah}}{{/view}}'),
      meshuggah: 'stengah'
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    equal(_emberViewsSystemJquery.default('#stengah').text(), 'stengah', 'id binding performed property lookup');
    _emberMetalRun_loop.default(view, 'set', 'meshuggah', 'omg');
    equal(_emberViewsSystemJquery.default('#stengah').text(), 'omg', 'id didn\'t change');
  });

  QUnit.test('specifying `id` as a static value works properly', function () {
    view = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('{{#view id=\'blah\'}}{{view.parentView.meshuggah}}{{/view}}'),
      meshuggah: 'stengah'
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('#blah').text(), 'stengah', 'id binding performed property lookup');
  });

  QUnit.test('mixing old and new styles of property binding fires a warning, treats value as if it were quoted', function () {
    if (EmberDev && EmberDev.runningProdBuild) {
      ok(true, 'Logging does not occur in production builds');
      return;
    }

    expect(2);

    var oldWarn = _emberMetalCore.default.warn;

    _emberMetalCore.default.warn = function (msg, disableWarning) {
      if (!disableWarning) {
        ok(msg.match(/You're attempting to render a view by passing borfBinding.+, but this syntax is ambiguous./));
      }
    };

    var compiled = undefined;
    expectDeprecation(function () {
      compiled = _emberTemplateCompilerSystemCompile.default('{{#view borfBinding=view.snork}}<p id=\'lol\'>{{view.borf}}</p>{{/view}}');
    }, 'You\'re using legacy binding syntax: borfBinding=view.snork (L1:C8) . Please replace with borf=view.snork');

    view = _emberViewsViewsView.default.extend({
      template: compiled,
      snork: 'nerd'
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    equal(_emberViewsSystemJquery.default('#lol').text(), 'nerd', 'awkward mixed syntax treated like binding');

    _emberMetalCore.default.warn = oldWarn;
  });

  QUnit.test('"Binding"-suffixed bindings are runloop-synchronized [DEPRECATED]', function () {
    var subview;

    var Subview = _emberViewsViewsView.default.extend({
      init: function () {
        subview = this;
        return this._super.apply(this, arguments);
      },
      template: _emberTemplateCompilerSystemCompile.default('<div class="color">{{view.color}}</div>')
    });

    var compiled = undefined;
    expectDeprecation(function () {
      compiled = _emberTemplateCompilerSystemCompile.default('<h1>{{view view.Subview colorBinding="view.color"}}</h1>');
    }, 'You\'re using legacy binding syntax: colorBinding="view.color" (L1:C24) . Please replace with color=view.color');

    var View = _emberViewsViewsView.default.extend({
      color: 'mauve',
      Subview: Subview,
      template: compiled
    });

    view = View.create();

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('h1 .color').text(), 'mauve', 'renders bound value');

    _emberMetalRun_loop.default(function () {
      _emberMetalRun_loop.default.schedule('sync', function () {
        equal(_emberMetalProperty_get.get(subview, 'color'), 'mauve', 'bound property is correctly scheduled into the sync queue');
      });

      view.set('color', 'persian rose');

      _emberMetalRun_loop.default.schedule('sync', function () {
        equal(_emberMetalProperty_get.get(subview, 'color'), 'mauve', 'bound property is correctly scheduled into the sync queue');
      });

      _emberMetalRun_loop.default.schedule('afterRender', function () {
        equal(_emberMetalProperty_get.get(subview, 'color'), 'persian rose', 'bound property is correctly scheduled into the sync queue');
      });

      equal(_emberMetalProperty_get.get(subview, 'color'), 'mauve', 'bound property does not update immediately');
    });

    equal(_emberMetalProperty_get.get(subview, 'color'), 'persian rose', 'bound property is updated after runloop flush');
  });

  QUnit.test('Non-"Binding"-suffixed bindings are runloop-synchronized', function () {
    var subview;

    var Subview = _emberViewsViewsView.default.extend({
      init: function () {
        subview = this;
        return this._super.apply(this, arguments);
      },
      template: _emberTemplateCompilerSystemCompile.default('<div class="color">{{view.attrs.color}}</div>')
    });

    var View = _emberViewsViewsView.default.extend({
      color: 'mauve',
      Subview: Subview,
      template: _emberTemplateCompilerSystemCompile.default('<h1>{{view view.Subview color=view.color}}</h1>')
    });

    view = View.create();
    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('h1 .color').text(), 'mauve', 'renders bound value');

    _emberMetalRun_loop.default(function () {
      _emberMetalRun_loop.default.schedule('sync', function () {
        equal(_emberMetalProperty_get.get(subview, 'color'), 'mauve', 'bound property is correctly scheduled into the sync queue');
      });

      view.set('color', 'persian rose');

      _emberMetalRun_loop.default.schedule('sync', function () {
        equal(_emberMetalProperty_get.get(subview, 'color'), 'mauve', 'bound property is correctly scheduled into the sync queue');
      });

      _emberMetalRun_loop.default.schedule('afterRender', function () {
        equal(_emberMetalProperty_get.get(subview, 'color'), 'persian rose', 'bound property is correctly scheduled into the sync queue');
      });

      equal(_emberMetalProperty_get.get(subview, 'color'), 'mauve', 'bound property does not update immediately');
    });

    equal(_emberMetalProperty_get.get(subview, 'color'), 'persian rose', 'bound property is updated after runloop flush');
  });

  QUnit.test('allows you to pass attributes that will be assigned to the class instance, like class="foo"', function () {
    expect(4);

    registry = new _containerRegistry.default();
    container = registry.container();
    registry.register('view:toplevel', _emberViewsViewsView.default.extend());

    view = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('{{view id="foo" tagName="h1" class="foo"}}{{#view id="bar" class="bar"}}Bar{{/view}}'),
      container: container
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    ok(_emberViewsSystemJquery.default('#foo').hasClass('foo'));
    ok(_emberViewsSystemJquery.default('#foo').is('h1'));
    ok(_emberViewsSystemJquery.default('#bar').hasClass('bar'));
    equal(_emberViewsSystemJquery.default('#bar').text(), 'Bar');
  });

  QUnit.test('Should apply class without condition always', function () {
    view = _emberViewsViewsView.default.create({
      controller: _emberMetalCore.default.Object.create(),
      template: _emberTemplateCompilerSystemCompile.default('{{#view id="foo" classBinding=":foo"}} Foo{{/view}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    ok(_emberViewsSystemJquery.default('#foo').hasClass('foo'), 'Always applies classbinding without condition');
  });

  QUnit.test('Should apply classes when bound controller.* property specified', function () {
    view = _emberViewsViewsView.default.create({
      controller: {
        someProp: 'foo'
      },
      template: _emberTemplateCompilerSystemCompile.default('{{#view id="foo" class=controller.someProp}} Foo{{/view}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    ok(_emberViewsSystemJquery.default('#foo').hasClass('foo'), 'Always applies classbinding without condition');
  });

  QUnit.test('Should apply classes when bound property specified', function () {
    view = _emberViewsViewsView.default.create({
      controller: {
        someProp: 'foo'
      },
      template: _emberTemplateCompilerSystemCompile.default('{{#view id="foo" class=someProp}} Foo{{/view}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    ok(_emberViewsSystemJquery.default('#foo').hasClass('foo'), 'Always applies classbinding without condition');
  });

  QUnit.test('Should apply a class from a sub expression', function () {
    registry.register('helper:string-concat', _emberHtmlbarsHelper.helper(function (params) {
      return params.join('');
    }));

    view = _emberViewsViewsView.default.create({
      container: container,
      controller: {
        type: 'btn',
        size: 'large'
      },
      template: _emberTemplateCompilerSystemCompile.default('{{#view id="foo" class=(string-concat type "-" size)}} Foo{{/view}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    ok(_emberViewsSystemJquery.default('#foo').hasClass('btn-large'), 'applies classname from subexpression');

    _emberMetalRun_loop.default(view, view.set, 'controller.size', 'medium');

    ok(!_emberViewsSystemJquery.default('#foo').hasClass('btn-large'), 'removes classname from subexpression update');
    ok(_emberViewsSystemJquery.default('#foo').hasClass('btn-medium'), 'adds classname from subexpression update');
  });

  QUnit.test('Should not apply classes when bound property specified is false', function () {
    view = _emberViewsViewsView.default.create({
      controller: {
        someProp: false
      },
      template: _emberTemplateCompilerSystemCompile.default('{{#view id="foo" class=someProp}} Foo{{/view}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    ok(!_emberViewsSystemJquery.default('#foo').hasClass('some-prop'), 'does not add class when value is falsey');
  });

  QUnit.test('Should apply classes of the dasherized property name when bound property specified is true', function () {
    view = _emberViewsViewsView.default.create({
      controller: {
        someProp: true
      },
      template: _emberTemplateCompilerSystemCompile.default('{{#view id="foo" class=someProp}} Foo{{/view}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    ok(_emberViewsSystemJquery.default('#foo').hasClass('some-prop'), 'adds dasherized class when value is true');
  });

  QUnit.test('Should update classes from a bound property', function () {
    var controller = {
      someProp: true
    };

    view = _emberViewsViewsView.default.create({
      controller: controller,
      template: _emberTemplateCompilerSystemCompile.default('{{#view id="foo" class=someProp}} Foo{{/view}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    ok(_emberViewsSystemJquery.default('#foo').hasClass('some-prop'), 'adds dasherized class when value is true');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(controller, 'someProp', false);
    });

    ok(!_emberViewsSystemJquery.default('#foo').hasClass('some-prop'), 'does not add class when value is falsey');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(controller, 'someProp', 'fooBar');
    });

    ok(_emberViewsSystemJquery.default('#foo').hasClass('fooBar'), 'changes property to string value (but does not dasherize)');
  });

  QUnit.test('bound properties should be available in the view', function () {
    var FuView = viewClass({
      elementId: 'fu',
      template: _emberTemplateCompilerSystemCompile.default('{{view.attrs.foo}}')
    });

    registry.register('view:fu', FuView);

    view = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('{{view \'fu\' foo=view.someProp}}'),
      container: container,
      someProp: 'initial value'
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('#fu').text(), 'initial value');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'someProp', 'second value');
    });

    equal(view.$('#fu').text(), 'second value');
  });

  QUnit.test('should escape HTML in normal mustaches', function () {
    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('{{view.output}}'),
      output: 'you need to be more <b>bold</b>'
    });

    _emberRuntimeTestsUtils.runAppend(view);
    equal(view.$('b').length, 0, 'does not create an element');
    equal(view.$().text(), 'you need to be more <b>bold</b>', 'inserts entities, not elements');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'output', 'you are so <i>super</i>');
    });

    equal(view.$().text(), 'you are so <i>super</i>', 'updates with entities, not elements');
    equal(view.$('i').length, 0, 'does not create an element when value is updated');
  });

  QUnit.test('should not escape HTML in triple mustaches', function () {
    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('{{{view.output}}}'),
      output: 'you need to be more <b>bold</b>'
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('b').length, 1, 'creates an element');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'output', 'you are so <i>super</i>');
    });

    equal(view.$('i').length, 1, 'creates an element when value is updated');
  });

  QUnit.test('should not escape HTML if string is a Handlebars.SafeString', function () {
    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('{{view.output}}'),
      output: new _htmlbarsUtilSafeString.default('you need to be more <b>bold</b>')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('b').length, 1, 'creates an element');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'output', new _htmlbarsUtilSafeString.default('you are so <i>super</i>'));
    });

    equal(view.$('i').length, 1, 'creates an element when value is updated');
  });

  QUnit.test('should teardown observers from bound properties on rerender', function () {
    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('{{view.foo}}'),
      foo: 'bar'
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(_emberMetalObserver.observersFor(view, 'foo').length, 1);

    _emberMetalRun_loop.default(function () {
      view.rerender();
    });

    equal(_emberMetalObserver.observersFor(view, 'foo').length, 1);
  });

  QUnit.test('should update bound values after the view is removed and then re-appended', function () {
    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('{{#if view.showStuff}}{{view.boundValue}}{{else}}Not true.{{/if}}'),
      showStuff: true,
      boundValue: 'foo'
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(trim(view.$().text()), 'foo');
    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'showStuff', false);
    });
    equal(trim(view.$().text()), 'Not true.');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'showStuff', true);
    });
    equal(trim(view.$().text()), 'foo');

    _emberMetalRun_loop.default(function () {
      view.remove();
      _emberMetalProperty_set.set(view, 'showStuff', false);
    });
    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'showStuff', true);
    });
    _emberRuntimeTestsUtils.runAppend(view);

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'boundValue', 'bar');
    });
    equal(trim(view.$().text()), 'bar');
  });

  QUnit.test('views set the template of their children to a passed block', function () {
    registry.register('template:parent', _emberTemplateCompilerSystemCompile.default('<h1>{{#view}}<span>It worked!</span>{{/view}}</h1>'));

    view = _emberViewsViewsView.default.create({
      container: container,
      templateName: 'parent'
    });

    _emberRuntimeTestsUtils.runAppend(view);
    ok(view.$('h1:has(span)').length === 1, 'renders the passed template inside the parent template');
  });

  QUnit.test('{{view}} should not override class bindings defined on a child view', function () {
    var LabelView = _emberViewsViewsView.default.extend({
      container: container,
      classNameBindings: ['something'],
      something: 'visible'
    });

    registry.register('controller:label', _emberRuntimeControllersController.default, { instantiate: true });
    registry.register('view:label', LabelView);
    registry.register('template:label', _emberTemplateCompilerSystemCompile.default('<div id="child-view"></div>'));
    registry.register('template:nester', _emberTemplateCompilerSystemCompile.default('{{render "label"}}'));

    view = _emberViewsViewsView.default.create({
      container: container,
      templateName: 'nester',
      controller: _emberRuntimeControllersController.default.create({
        container: container
      })
    });

    _emberRuntimeTestsUtils.runAppend(view);

    ok(view.$('.visible').length > 0, 'class bindings are not overriden');
  });

  QUnit.test('child views can be inserted using the {{view}} helper', function () {
    registry.register('template:nester', _emberTemplateCompilerSystemCompile.default('<h1 id="hello-world">Hello {{world}}</h1>{{view view.labelView}}'));
    registry.register('template:nested', _emberTemplateCompilerSystemCompile.default('<div id="child-view">Goodbye {{cruel}} {{world}}</div>'));

    var context = {
      world: 'world!'
    };

    var LabelView = _emberViewsViewsView.default.extend({
      container: container,
      tagName: 'aside',
      templateName: 'nested'
    });

    view = _emberViewsViewsView.default.create({
      labelView: LabelView,
      container: container,
      templateName: 'nester',
      context: context
    });

    _emberMetalProperty_set.set(context, 'cruel', 'cruel');

    _emberRuntimeTestsUtils.runAppend(view);

    ok(view.$('#hello-world:contains("Hello world!")').length, 'The parent view renders its contents');
    ok(view.$('#child-view:contains("Goodbye cruel world!")').length === 1, 'The child view renders its content once');
    ok(view.$().text().match(/Hello world!.*Goodbye cruel world\!/), 'parent view should appear before the child view');
  });

  QUnit.test('should be able to explicitly set a view\'s context', function () {
    var context = _emberRuntimeSystemObject.default.create({
      test: 'test'
    });

    var CustomContextView = _emberViewsViewsView.default.extend({
      context: context,
      template: _emberTemplateCompilerSystemCompile.default('{{test}}')
    });

    view = _emberViewsViewsView.default.create({
      customContextView: CustomContextView,
      template: _emberTemplateCompilerSystemCompile.default('{{view view.customContextView}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'test');
  });

  QUnit.test('Template views add an elementId to child views created using the view helper', function () {
    registry.register('template:parent', _emberTemplateCompilerSystemCompile.default('<div>{{view view.childView}}</div>'));
    registry.register('template:child', _emberTemplateCompilerSystemCompile.default('I can\'t believe it\'s not butter.'));

    var ChildView = _emberViewsViewsView.default.extend({
      container: container,
      templateName: 'child'
    });

    view = _emberViewsViewsView.default.create({
      container: container,
      childView: ChildView,
      templateName: 'parent'
    });

    _emberRuntimeTestsUtils.runAppend(view);

    var childView = _emberMetalProperty_get.get(view, 'childViews.firstObject');
    equal(view.$().children().first().children().first().attr('id'), _emberMetalProperty_get.get(childView, 'elementId'));
  });

  QUnit.test('Child views created using the view helper should have their parent view set properly', function () {
    var template = '{{#view}}{{#view}}{{view}}{{/view}}{{/view}}';

    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default(template)
    });

    _emberRuntimeTestsUtils.runAppend(view);

    var childView = firstGrandchild(view);
    equal(childView, _emberMetalProperty_get.get(firstChild(childView), 'parentView'), 'parent view is correct');
  });

  QUnit.test('Child views created using the view helper should have their IDs registered for events', function () {
    var template = '{{view}}{{view id="templateViewTest"}}';

    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default(template)
    });

    _emberRuntimeTestsUtils.runAppend(view);

    var childView = firstChild(view);
    var id = childView.$()[0].id;
    equal(_emberViewsViewsView.default.views[id], childView, 'childView without passed ID is registered with View.views so that it can properly receive events from EventDispatcher');

    childView = nthChild(view, 1);
    id = childView.$()[0].id;
    equal(id, 'templateViewTest', 'precond -- id of childView should be set correctly');
    equal(_emberViewsViewsView.default.views[id], childView, 'childView with passed ID is registered with View.views so that it can properly receive events from EventDispatcher');
  });

  QUnit.test('Child views created using the view helper and that have a viewName should be registered as properties on their parentView', function () {
    var template = '{{#view}}{{view viewName="ohai"}}{{/view}}';

    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default(template)
    });

    _emberRuntimeTestsUtils.runAppend(view);

    var parentView = firstChild(view);
    var childView = firstGrandchild(view);

    equal(_emberMetalProperty_get.get(parentView, 'ohai'), childView);
  });

  QUnit.test('{{view}} id attribute should set id on layer', function () {
    registry.register('template:foo', _emberTemplateCompilerSystemCompile.default('{{#view view.idView id="bar"}}baz{{/view}}'));

    var IdView = _emberViewsViewsView.default;

    view = _emberViewsViewsView.default.create({
      idView: IdView,
      container: container,
      templateName: 'foo'
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('#bar').length, 1, 'adds id attribute to layer');
    equal(view.$('#bar').text(), 'baz', 'emits content');
  });

  QUnit.test('{{view}} tag attribute should set tagName of the view', function () {
    registry.register('template:foo', _emberTemplateCompilerSystemCompile.default('{{#view view.tagView tag="span"}}baz{{/view}}'));

    var TagView = _emberViewsViewsView.default;

    view = _emberViewsViewsView.default.create({
      tagView: TagView,
      container: container,
      templateName: 'foo'
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('span').length, 1, 'renders with tag name');
    equal(view.$('span').text(), 'baz', 'emits content');
  });

  QUnit.test('{{view}} class attribute should set class on layer', function () {
    registry.register('template:foo', _emberTemplateCompilerSystemCompile.default('{{#view view.idView class="bar"}}baz{{/view}}'));

    var IdView = _emberViewsViewsView.default;

    view = _emberViewsViewsView.default.create({
      idView: IdView,
      container: container,
      templateName: 'foo'
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('.bar').length, 1, 'adds class attribute to layer');
    equal(view.$('.bar').text(), 'baz', 'emits content');
  });

  QUnit.test('{{view}} should not allow attributeBindings to be set', function () {
    expectAssertion(function () {
      view = _emberViewsViewsView.default.create({
        template: _emberTemplateCompilerSystemCompile.default('{{view attributeBindings="one two"}}')
      });
      _emberRuntimeTestsUtils.runAppend(view);
    }, /Setting 'attributeBindings' via template helpers is not allowed/);
  });

  QUnit.test('{{view}} should be able to point to a local view', function () {
    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('{{view view.common}}'),

      common: _emberViewsViewsView.default.extend({
        template: _emberTemplateCompilerSystemCompile.default('common')
      })
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'common', 'tries to look up view name locally');
  });

  QUnit.test('{{view}} should evaluate class bindings set in the current context', function () {
    view = _emberViewsViewsView.default.create({
      isView: true,
      isEditable: true,
      directClass: 'view-direct',
      isEnabled: true,
      textField: _emberViewsViewsText_field.default,
      template: _emberTemplateCompilerSystemCompile.default('{{view view.textField class="unbound" classBinding="view.isEditable:editable view.directClass view.isView view.isEnabled:enabled:disabled"}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    ok(view.$('input').hasClass('unbound'), 'sets unbound classes directly');
    ok(view.$('input').hasClass('editable'), 'evaluates classes bound in the current context');
    ok(view.$('input').hasClass('view-direct'), 'evaluates classes bound directly in the current context');
    ok(view.$('input').hasClass('is-view'), 'evaluates classes bound directly to booleans in the current context - dasherizes and sets class when true');
    ok(view.$('input').hasClass('enabled'), 'evaluates ternary operator in classBindings');
    ok(!view.$('input').hasClass('disabled'), 'evaluates ternary operator in classBindings');

    _emberMetalRun_loop.default(function () {
      view.set('isView', false);
      view.set('isEnabled', false);
    });

    ok(!view.$('input').hasClass('is-view'), 'evaluates classes bound directly to booleans in the current context - removes class when false');
    ok(!view.$('input').hasClass('enabled'), 'evaluates ternary operator in classBindings');
    ok(view.$('input').hasClass('disabled'), 'evaluates ternary operator in classBindings');
  });

  QUnit.test('{{view}} should evaluate other attributes bindings set in the current context', function () {
    view = _emberViewsViewsView.default.create({
      name: 'myView',
      textField: _emberViewsViewsText_field.default,
      template: _emberTemplateCompilerSystemCompile.default('{{view view.textField value=view.name}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('input').val(), 'myView', 'evaluates attributes bound in the current context');
  });

  QUnit.test('{{view}} should be able to bind class names to truthy properties', function () {
    registry.register('template:template', _emberTemplateCompilerSystemCompile.default('{{#view view.classBindingView classBinding="view.number:is-truthy"}}foo{{/view}}'));

    var ClassBindingView = _emberViewsViewsView.default.extend();

    view = _emberViewsViewsView.default.create({
      classBindingView: ClassBindingView,
      container: container,
      number: 5,
      templateName: 'template'
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('.is-truthy').length, 1, 'sets class name');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'number', 0);
    });

    equal(view.$('.is-truthy').length, 0, 'removes class name if bound property is set to falsey');
  });

  QUnit.test('{{view}} should be able to bind class names to truthy or falsy properties', function () {
    registry.register('template:template', _emberTemplateCompilerSystemCompile.default('{{#view view.classBindingView classBinding="view.number:is-truthy:is-falsy"}}foo{{/view}}'));

    var ClassBindingView = _emberViewsViewsView.default.extend();

    view = _emberViewsViewsView.default.create({
      classBindingView: ClassBindingView,
      container: container,
      number: 5,
      templateName: 'template'
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('.is-truthy').length, 1, 'sets class name to truthy value');
    equal(view.$('.is-falsy').length, 0, 'doesn\'t set class name to falsy value');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'number', 0);
    });

    equal(view.$('.is-truthy').length, 0, 'doesn\'t set class name to truthy value');
    equal(view.$('.is-falsy').length, 1, 'sets class name to falsy value');
  });

  QUnit.test('a view helper\'s bindings are to the parent context', function () {
    var Subview = _emberViewsViewsView.default.extend({
      classNameBindings: ['attrs.color'],
      controller: _emberRuntimeSystemObject.default.create({
        color: 'green',
        name: 'bar'
      }),
      template: _emberTemplateCompilerSystemCompile.default('{{attrs.someController.name}} {{name}}')
    });

    var View = _emberViewsViewsView.default.extend({
      controller: _emberRuntimeSystemObject.default.create({
        color: 'mauve',
        name: 'foo'
      }),
      Subview: Subview,
      template: _emberTemplateCompilerSystemCompile.default('<h1>{{view view.Subview color=color someController=this}}</h1>')
    });

    view = View.create();
    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('h1 .mauve').length, 1, 'renders property on helper declaration from parent context');
    equal(view.$('h1 .mauve').text(), 'foo bar', 'renders property bound in template from subview context');
  });

  QUnit.test('should expose a controller keyword when present on the view', function () {
    var templateString = '{{controller.foo}}{{#view}}{{controller.baz}}{{/view}}';
    view = _emberViewsViewsView.default.create({
      container: container,
      controller: _emberRuntimeSystemObject.default.create({
        foo: 'bar',
        baz: 'bang'
      }),

      template: _emberTemplateCompilerSystemCompile.default(templateString)
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'barbang', 'renders values from controller and parent controller');

    var controller = _emberMetalProperty_get.get(view, 'controller');

    _emberMetalRun_loop.default(function () {
      controller.set('foo', 'BAR');
      controller.set('baz', 'BLARGH');
    });

    equal(view.$().text(), 'BARBLARGH', 'updates the DOM when a bound value is updated');

    _emberRuntimeTestsUtils.runDestroy(view);

    view = _emberViewsViewsView.default.create({
      controller: 'aString',
      template: _emberTemplateCompilerSystemCompile.default('{{controller}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'aString', 'renders the controller itself if no additional path is specified');
  });

  QUnit.test('should expose a controller keyword that can be used in conditionals', function () {
    var templateString = '{{#view}}{{#if controller}}{{controller.foo}}{{/if}}{{/view}}';
    view = _emberViewsViewsView.default.create({
      container: container,
      controller: _emberRuntimeSystemObject.default.create({
        foo: 'bar'
      }),

      template: _emberTemplateCompilerSystemCompile.default(templateString)
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'bar', 'renders values from controller and parent controller');

    _emberMetalRun_loop.default(function () {
      view.set('controller', null);
    });

    equal(view.$().text(), '', 'updates the DOM when the controller is changed');
  });

  QUnit.test('should expose a controller that can be used in the view instance', function () {
    var templateString = '{{#view view.childThing tagName="div"}}Stuff{{/view}}';
    var controller = {
      foo: 'bar'
    };
    var childThingController;
    view = _emberViewsViewsView.default.create({
      container: container,
      controller: controller,

      childThing: _emberViewsViewsView.default.extend({
        didInsertElement: function () {
          childThingController = _emberMetalProperty_get.get(this, 'controller');
        }
      }),

      template: _emberTemplateCompilerSystemCompile.default(templateString)
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(controller, childThingController, 'childThing should get the same controller as the outer scope');
  });

  QUnit.test('should expose a controller keyword that persists through Ember.ContainerView', function () {
    var templateString = '{{view view.containerView}}';
    view = _emberViewsViewsView.default.create({
      containerView: _emberViewsViewsContainer_view.default,
      container: container,
      controller: _emberRuntimeSystemObject.default.create({
        foo: 'bar'
      }),

      template: _emberTemplateCompilerSystemCompile.default(templateString)
    });

    _emberRuntimeTestsUtils.runAppend(view);

    var containerView = _emberMetalProperty_get.get(view, 'childViews.firstObject');
    var viewInstanceToBeInserted = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('{{controller.foo}}')
    });

    _emberMetalRun_loop.default(function () {
      containerView.pushObject(viewInstanceToBeInserted);
    });

    equal(trim(viewInstanceToBeInserted.$().text()), 'bar', 'renders value from parent\'s controller');
  });

  QUnit.test('should work with precompiled templates', function () {
    var templateString = _emberTemplateCompilerCompatPrecompile.default('{{view.value}}');
    var compiledTemplate = _emberTemplateCompilerSystemTemplate.default(eval(templateString));

    view = _emberViewsViewsView.default.create({
      value: 'rendered',
      template: compiledTemplate
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'rendered', 'the precompiled template was rendered');

    _emberMetalRun_loop.default(function () {
      view.set('value', 'updated');
    });

    equal(view.$().text(), 'updated', 'the precompiled template was updated');
  });

  QUnit.test('bindings should be relative to the current context [DEPRECATED]', function () {
    view = _emberViewsViewsView.default.create({
      museumOpen: true,

      museumDetails: _emberRuntimeSystemObject.default.create({
        name: 'SFMoMA',
        price: 20
      }),

      museumView: _emberViewsViewsView.default.extend({
        template: _emberTemplateCompilerSystemCompile.default('Name: {{view.attrs.name}} Price: ${{view.attrs.dollars}}')
      }),

      template: _emberTemplateCompilerSystemCompile.default('{{#if view.museumOpen}} {{view view.museumView name=view.museumDetails.name dollars=view.museumDetails.price}} {{/if}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(trim(view.$().text()), 'Name: SFMoMA Price: $20', 'should print baz twice');
  });

  QUnit.test('bindings should respect keywords [DEPRECATED]', function () {
    view = _emberViewsViewsView.default.create({
      museumOpen: true,

      controller: {
        museumOpen: true,
        museumDetails: _emberRuntimeSystemObject.default.create({
          name: 'SFMoMA',
          price: 20
        })
      },

      museumView: _emberViewsViewsView.default.extend({
        template: _emberTemplateCompilerSystemCompile.default('Name: {{view.attrs.name}} Price: ${{view.attrs.dollars}}')
      }),

      template: _emberTemplateCompilerSystemCompile.default('{{#if view.museumOpen}}{{view view.museumView name=controller.museumDetails.name dollars=controller.museumDetails.price}}{{/if}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(trim(view.$().text()), 'Name: SFMoMA Price: $20', 'should print baz twice');
  });

  QUnit.test('should respect keywords', function () {
    view = _emberViewsViewsView.default.create({
      museumOpen: true,

      controller: {
        museumOpen: true,
        museumDetails: _emberRuntimeSystemObject.default.create({
          name: 'SFMoMA',
          price: 20
        })
      },

      museumView: _emberViewsViewsView.default.extend({
        template: _emberTemplateCompilerSystemCompile.default('Name: {{view.attrs.name}} Price: ${{view.attrs.dollars}}')
      }),

      template: _emberTemplateCompilerSystemCompile.default('{{#if view.museumOpen}}{{view view.museumView name=controller.museumDetails.name dollars=controller.museumDetails.price}}{{/if}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(trim(view.$().text()), 'Name: SFMoMA Price: $20', 'should print baz twice');
  });

  QUnit.test('should bind to the property if no registered helper found for a mustache without parameters', function () {
    view = _emberViewsViewsView.default.extend({
      foobarProperty: _emberMetalComputed.computed(function () {
        return 'foobarProperty';
      })
    }).create({
      template: _emberTemplateCompilerSystemCompile.default('{{view.foobarProperty}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    ok(view.$().text() === 'foobarProperty', 'Property was bound to correctly');
  });

  QUnit.test('{{view}} should be able to point to a local instance of view', function () {
    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('{{view view.common}}'),

      common: _emberViewsViewsView.default.create({
        template: _emberTemplateCompilerSystemCompile.default('common')
      })
    });

    _emberRuntimeTestsUtils.runAppend(view);
    equal(view.$().text(), 'common', 'tries to look up view name locally');
  });

  QUnit.test('{{view}} should be able to point to a local instance of subclass of view', function () {
    var MyView = _emberViewsViewsView.default.extend();
    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('{{view view.subclassed}}'),
      subclassed: MyView.create({
        template: _emberTemplateCompilerSystemCompile.default('subclassed')
      })
    });

    _emberRuntimeTestsUtils.runAppend(view);
    equal(view.$().text(), 'subclassed', 'tries to look up view name locally');
  });

  QUnit.test('{{view}} asserts that a view class is present', function () {
    var MyView = _emberRuntimeSystemObject.default.extend();
    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('{{view view.notView}}'),
      notView: MyView.extend({
        template: _emberTemplateCompilerSystemCompile.default('notView')
      })
    });

    expectAssertion(function () {
      _emberRuntimeTestsUtils.runAppend(view);
    }, /must be a subclass or an instance of Ember.View/);
  });

  QUnit.test('{{view}} asserts that a view class is present off controller', function () {
    var MyView = _emberRuntimeSystemObject.default.extend();
    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('{{view notView}}'),
      controller: _emberRuntimeSystemObject.default.create({
        notView: MyView.extend({
          template: _emberTemplateCompilerSystemCompile.default('notView')
        })
      })
    });

    expectAssertion(function () {
      _emberRuntimeTestsUtils.runAppend(view);
    }, /must be a subclass or an instance of Ember.View/);
  });

  QUnit.test('{{view}} asserts that a view instance is present', function () {
    var MyView = _emberRuntimeSystemObject.default.extend();
    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('{{view view.notView}}'),
      notView: MyView.create({
        template: _emberTemplateCompilerSystemCompile.default('notView')
      })
    });

    expectAssertion(function () {
      _emberRuntimeTestsUtils.runAppend(view);
    }, /must be a subclass or an instance of Ember.View/);
  });

  QUnit.test('{{view}} asserts that a view subclass instance is present off controller', function () {
    var MyView = _emberRuntimeSystemObject.default.extend();
    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('{{view notView}}'),
      controller: _emberRuntimeSystemObject.default.create({
        notView: MyView.create({
          template: _emberTemplateCompilerSystemCompile.default('notView')
        })
      })
    });

    expectAssertion(function () {
      _emberRuntimeTestsUtils.runAppend(view);
    }, /must be a subclass or an instance of Ember.View/);
  });

  QUnit.test('Specifying `id` to {{view}} is set on the view.', function () {
    registry.register('view:derp', _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('<div id="view-id">{{view.id}}</div><div id="view-elementId">{{view.elementId}}</div>')
    }));

    view = _emberViewsViewsView.default.create({
      container: container,
      foo: 'bar',
      template: _emberTemplateCompilerSystemCompile.default('{{view "derp" id=view.foo}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('#bar').length, 1, 'it uses the provided id for the views elementId');
    equal(view.$('#view-id').text(), 'bar', 'the views id property is set');
    equal(view.$('#view-elementId').text(), 'bar', 'the views elementId property is set');
  });

  QUnit.test('Specifying `id` to {{view}} does not allow bound id changes.', function () {
    registry.register('view:derp', _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('<div id="view-id">{{view.id}}</div><div id="view-elementId">{{view.elementId}}</div>')
    }));

    view = _emberViewsViewsView.default.create({
      container: container,
      foo: 'bar',
      template: _emberTemplateCompilerSystemCompile.default('{{view "derp" id=view.foo}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('#bar #view-id').text(), 'bar', 'the views id property is set');

    _emberMetalRun_loop.default(view, _emberMetalProperty_set.set, view, 'foo', 'baz');

    equal(view.$('#bar #view-id').text(), 'baz', 'the views id property is not changed');
  });

  QUnit.test('using a bound view name does not change on view name property changes', function () {
    registry.register('view:foo', viewClass({
      elementId: 'foo'
    }));

    registry.register('view:bar', viewClass({
      elementId: 'bar'
    }));

    view = _emberViewsViewsView.default.extend({
      container: container,
      elementId: 'parent',
      viewName: 'foo',
      template: _emberTemplateCompilerSystemCompile.default('{{view view.viewName}}')
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('#foo').length, 1, 'moving from falsey to truthy causes the viewName to be looked up and rendered');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'viewName', 'bar');
    });

    equal(view.$('#bar').length, 0, 'changing the viewName string after it was initially rendered does not render the new viewName');
    equal(view.$('#foo').length, 1, 'the originally rendered view is still present');
  });

  QUnit.test('should have the correct action target', function () {
    registry.register('component:x-outer', _emberViewsViewsComponent.default.extend({
      container: container,
      layout: _emberTemplateCompilerSystemCompile.default('{{#x-middle}}{{view innerView dismiss="dismiss"}}{{/x-middle}}'),
      actions: {
        dismiss: function () {
          ok(true, 'We handled the action in the right place');
        }
      },
      innerView: _emberViewsViewsComponent.default.extend({
        container: container,
        elementId: 'x-inner'
      })
    }));

    registry.register('component:x-middle', _emberViewsViewsComponent.default.extend({
      container: container,
      actions: {
        dismiss: function () {
          throw new Error('action was not supposed to go here');
        }
      }
    }));

    view = _emberViewsViewsView.default.extend({
      container: container,
      template: _emberTemplateCompilerSystemCompile.default('{{x-outer}}')
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    _emberMetalRun_loop.default(function () {
      _emberViewsViewsView.default.views['x-inner'].sendAction('dismiss');
    });
  });
});
enifed('ember-htmlbars/tests/helpers/view_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/helpers');
  test('ember-htmlbars/tests/helpers/view_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/helpers/view_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/helpers/view_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/helpers');
  QUnit.test('ember-htmlbars/tests/helpers/view_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/helpers/view_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/helpers/with_test', ['exports', 'ember-metal/core', 'ember-views/views/view', 'ember-metal/run_loop', 'ember-runtime/system/object', 'ember-metal/property_set', 'ember-template-compiler/system/compile', 'ember-runtime/tests/utils'], function (exports, _emberMetalCore, _emberViewsViewsView, _emberMetalRun_loop, _emberRuntimeSystemObject, _emberMetalProperty_set, _emberTemplateCompilerSystemCompile, _emberRuntimeTestsUtils) {
  /*jshint newcap:false*/
  'use strict';

  var view, lookup;
  var originalLookup = _emberMetalCore.default.lookup;

  function testWithAs(moduleName, templateString, deprecated) {
    QUnit.module(moduleName, {
      setup: function () {
        _emberMetalCore.default.lookup = lookup = { Ember: _emberMetalCore.default };

        var template;
        if (deprecated) {
          expectDeprecation(function () {
            template = _emberTemplateCompilerSystemCompile.default(templateString);
          }, 'Using {{with}} without block syntax (L1:C0) is deprecated. Please use standard block form (`{{#with foo as |bar|}}`) instead.');
        } else {
          template = _emberTemplateCompilerSystemCompile.default(templateString);
        }

        view = _emberViewsViewsView.default.create({
          template: template,
          context: {
            title: 'Señor Engineer',
            person: { name: 'Tom Dale' }
          }
        });

        _emberRuntimeTestsUtils.runAppend(view);
      },

      teardown: function () {
        _emberRuntimeTestsUtils.runDestroy(view);
        _emberMetalCore.default.lookup = originalLookup;
      }
    });

    QUnit.test('it should support #with-as syntax', function () {
      equal(view.$().text(), 'Señor Engineer: Tom Dale', 'should be properly scoped');
    });

    QUnit.test('updating the context should update the alias', function () {
      _emberMetalRun_loop.default(function () {
        view.set('context.person', {
          name: 'Yehuda Katz'
        });
      });

      equal(view.$().text(), 'Señor Engineer: Yehuda Katz', 'should be properly scoped after updating');
    });

    QUnit.test('updating a property on the context should update the HTML', function () {
      equal(view.$().text(), 'Señor Engineer: Tom Dale', 'precond - should be properly scoped after updating');

      _emberMetalRun_loop.default(function () {
        _emberMetalProperty_set.set(view, 'context.person.name', 'Yehuda Katz');
      });

      equal(view.$().text(), 'Señor Engineer: Yehuda Katz', 'should be properly scoped after updating');
    });

    QUnit.test('updating a property on the view should update the HTML', function () {
      _emberMetalRun_loop.default(function () {
        view.set('context.title', 'Señorette Engineer');
      });

      equal(view.$().text(), 'Señorette Engineer: Tom Dale', 'should be properly scoped after updating');
    });
  }

  QUnit.module('Multiple Handlebars {{with foo as |bar|}} helpers', {
    setup: function () {
      _emberMetalCore.default.lookup = lookup = { Ember: _emberMetalCore.default };
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(view);

      _emberMetalCore.default.lookup = originalLookup;
    }
  });

  QUnit.test('re-using the same variable with different #with blocks does not override each other', function () {
    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('Admin: {{#with admin as |person|}}{{person.name}}{{/with}} User: {{#with user as |person|}}{{person.name}}{{/with}}'),
      context: {
        admin: { name: 'Tom Dale' },
        user: { name: 'Yehuda Katz' }
      }
    });

    _emberRuntimeTestsUtils.runAppend(view);
    equal(view.$().text(), 'Admin: Tom Dale User: Yehuda Katz', 'should be properly scoped');
  });

  QUnit.test('the scoped variable is not available outside the {{with}} block.', function () {
    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('{{name}}-{{#with other as |name|}}{{name}}{{/with}}-{{name}}'),
      context: {
        name: 'Stef',
        other: 'Yehuda'
      }
    });

    _emberRuntimeTestsUtils.runAppend(view);
    equal(view.$().text(), 'Stef-Yehuda-Stef', 'should be properly scoped after updating');
  });

  QUnit.test('nested {{with}} blocks shadow the outer scoped variable properly.', function () {
    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('{{#with first as |ring|}}{{ring}}-{{#with fifth as |ring|}}{{ring}}-{{#with ninth as |ring|}}{{ring}}-{{/with}}{{ring}}-{{/with}}{{ring}}{{/with}}'),
      context: {
        first: 'Limbo',
        fifth: 'Wrath',
        ninth: 'Treachery'
      }
    });

    _emberRuntimeTestsUtils.runAppend(view);
    equal(view.$().text(), 'Limbo-Wrath-Treachery-Wrath-Limbo', 'should be properly scoped after updating');
  });

  QUnit.module('Handlebars {{#with keyword as |foo|}}');

  QUnit.test('it should support #with view as |foo|', function () {
    var view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('{{#with view as |myView|}}{{myView.name}}{{/with}}'),
      name: 'Sonics'
    });

    _emberRuntimeTestsUtils.runAppend(view);
    equal(view.$().text(), 'Sonics', 'should be properly scoped');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'name', 'Thunder');
    });

    equal(view.$().text(), 'Thunder', 'should update');

    _emberRuntimeTestsUtils.runDestroy(view);
  });

  QUnit.test('it should support #with name as |foo|, then #with foo as |bar|', function () {
    var view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('{{#with name as |foo|}}{{#with foo as |bar|}}{{bar}}{{/with}}{{/with}}'),
      context: { name: 'caterpillar' }
    });

    _emberRuntimeTestsUtils.runAppend(view);
    equal(view.$().text(), 'caterpillar', 'should be properly scoped');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'context.name', 'butterfly');
    });

    equal(view.$().text(), 'butterfly', 'should update');

    _emberRuntimeTestsUtils.runDestroy(view);
  });

  QUnit.module('Handlebars {{#with this as |foo|}}');

  QUnit.test('it should support #with this as |qux|', function () {
    var view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('{{#with this as |person|}}{{person.name}}{{/with}}'),
      controller: _emberRuntimeSystemObject.default.create({ name: 'Los Pivots' })
    });

    _emberRuntimeTestsUtils.runAppend(view);
    equal(view.$().text(), 'Los Pivots', 'should be properly scoped');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'controller.name', 'l\'Pivots');
    });

    equal(view.$().text(), 'l\'Pivots', 'should update');

    _emberRuntimeTestsUtils.runDestroy(view);
  });

  QUnit.module('{{#with}} helper binding to view keyword', {
    setup: function () {
      _emberMetalCore.default.lookup = lookup = { Ember: _emberMetalCore.default };

      view = _emberViewsViewsView.default.create({
        template: _emberTemplateCompilerSystemCompile.default('We have: {{#with view.thing as |fromView|}}{{fromView.name}} and {{fromContext.name}}{{/with}}'),
        thing: { name: 'this is from the view' },
        context: {
          fromContext: { name: 'this is from the context' }
        }
      });

      _emberRuntimeTestsUtils.runAppend(view);
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(view);
      _emberMetalCore.default.lookup = originalLookup;
    }
  });

  QUnit.test('{{with}} helper can bind to keywords with \'as\'', function () {
    equal(view.$().text(), 'We have: this is from the view and this is from the context', 'should render');
  });

  testWithAs('ember-htmlbars: {{#with x as |y|}}', '{{#with person as |tom|}}{{title}}: {{tom.name}}{{/with}}');

  QUnit.module('Multiple Handlebars {{with foo as |bar|}} helpers', {
    setup: function () {
      _emberMetalCore.default.lookup = lookup = { Ember: _emberMetalCore.default };
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(view);
      _emberMetalCore.default.lookup = originalLookup;
    }
  });

  QUnit.test('re-using the same variable with different #with blocks does not override each other', function () {
    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('Admin: {{#with admin as |person|}}{{person.name}}{{/with}} User: {{#with user as |person|}}{{person.name}}{{/with}}'),
      context: {
        admin: { name: 'Tom Dale' },
        user: { name: 'Yehuda Katz' }
      }
    });

    _emberRuntimeTestsUtils.runAppend(view);
    equal(view.$().text(), 'Admin: Tom Dale User: Yehuda Katz', 'should be properly scoped');
  });

  QUnit.test('the scoped variable is not available outside the {{with}} block.', function () {
    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('{{name}}-{{#with other as |name|}}{{name}}{{/with}}-{{name}}'),
      context: {
        name: 'Stef',
        other: 'Yehuda'
      }
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'Stef-Yehuda-Stef', 'should be properly scoped after updating');
  });

  QUnit.test('nested {{with}} blocks shadow the outer scoped variable properly.', function () {
    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('{{#with first as |ring|}}{{ring}}-{{#with fifth as |ring|}}{{ring}}-{{#with ninth as |ring|}}{{ring}}-{{/with}}{{ring}}-{{/with}}{{ring}}{{/with}}'),
      context: {
        first: 'Limbo',
        fifth: 'Wrath',
        ninth: 'Treachery'
      }
    });

    _emberRuntimeTestsUtils.runAppend(view);
    equal(view.$().text(), 'Limbo-Wrath-Treachery-Wrath-Limbo', 'should be properly scoped after updating');
  });

  QUnit.test('{{with}} block should not render if passed variable is falsey', function () {
    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('{{#with foo as |bar|}}Don\'t render me{{/with}}'),
      context: {
        foo: null
      }
    });
    _emberRuntimeTestsUtils.runAppend(view);
    equal(view.$().text(), '', 'should not render the inner template');
  });

  QUnit.module('{{#with}} inverse template', {
    setup: function () {
      _emberMetalCore.default.lookup = lookup = { Ember: _emberMetalCore.default };

      view = _emberViewsViewsView.default.create({
        template: _emberTemplateCompilerSystemCompile.default('{{#with view.falsyThing as |thing|}}Has Thing{{else}}No Thing{{/with}}'),
        falsyThing: null
      });

      _emberRuntimeTestsUtils.runAppend(view);
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(view);
      _emberMetalCore.default.lookup = originalLookup;
    }
  });

  QUnit.test('inverse template is displayed', function () {
    equal(view.$().text(), 'No Thing', 'should render inverse template');
  });

  QUnit.test('changing the property to truthy causes standard template to be displayed', function () {
    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'falsyThing', true);
    });
    equal(view.$().text(), 'Has Thing', 'should render standard template');
  });

  QUnit.module('{{#with}} inverse template preserves context', {
    setup: function () {
      _emberMetalCore.default.lookup = lookup = { Ember: _emberMetalCore.default };

      view = _emberViewsViewsView.default.create({
        template: _emberTemplateCompilerSystemCompile.default('{{#with falsyThing as |thing|}}Has Thing{{else}}No Thing {{otherThing}}{{/with}}'),
        context: {
          falsyThing: null,
          otherThing: 'bar'
        }
      });

      _emberRuntimeTestsUtils.runAppend(view);
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(view);
      _emberMetalCore.default.lookup = originalLookup;
    }
  });

  QUnit.test('inverse template is displayed with context', function () {
    equal(view.$().text(), 'No Thing bar', 'should render inverse template with context preserved');
  });
});
enifed('ember-htmlbars/tests/helpers/with_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/helpers');
  test('ember-htmlbars/tests/helpers/with_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/helpers/with_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/helpers/with_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/helpers');
  QUnit.test('ember-htmlbars/tests/helpers/with_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/helpers/with_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/helpers/yield_test', ['exports', 'ember-metal/core', 'ember-metal/run_loop', 'ember-views/views/view', 'ember-metal/computed', 'ember-runtime/system/container', 'ember-runtime/system/native_array', 'ember-views/views/component', 'ember-htmlbars/helpers', 'ember-views/component_lookup', 'ember-template-compiler/system/compile', 'ember-runtime/tests/utils', 'ember-htmlbars/tests/utils', 'ember-htmlbars/keywords/view'], function (exports, _emberMetalCore, _emberMetalRun_loop, _emberViewsViewsView, _emberMetalComputed, _emberRuntimeSystemContainer, _emberRuntimeSystemNative_array, _emberViewsViewsComponent, _emberHtmlbarsHelpers, _emberViewsComponent_lookup, _emberTemplateCompilerSystemCompile, _emberRuntimeTestsUtils, _emberHtmlbarsTestsUtils, _emberHtmlbarsKeywordsView) {
  /*jshint newcap:false*/
  'use strict';

  var view, registry, container, originalViewKeyword;

  function setupContainer() {
    registry = new _emberRuntimeSystemContainer.Registry();
    container = registry.container();
    registry.optionsForType('template', { instantiate: false });
    registry.register('component-lookup:main', _emberViewsComponent_lookup.default);
  }

  function teardownContainer() {
    _emberRuntimeTestsUtils.runDestroy(container);
    registry = container = view = null;
  }

  QUnit.module('ember-htmlbars: Support for {{yield}} helper', {
    setup: function () {
      setupContainer();
      originalViewKeyword = _emberHtmlbarsTestsUtils.registerKeyword('view', _emberHtmlbarsKeywordsView.default);
    },
    teardown: function () {
      _emberMetalRun_loop.default(function () {
        _emberMetalCore.default.TEMPLATES = {};
      });
      _emberRuntimeTestsUtils.runDestroy(view);
      teardownContainer();
      _emberHtmlbarsTestsUtils.resetKeyword('view', originalViewKeyword);
    }
  });

  QUnit.test('a view with a layout set renders its template where the {{yield}} helper appears', function () {
    var ViewWithLayout = _emberViewsViewsView.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('<div class="wrapper"><h1>{{attrs.title}}</h1>{{yield}}</div>')
    });

    view = _emberViewsViewsView.default.create({
      withLayout: ViewWithLayout,
      template: _emberTemplateCompilerSystemCompile.default('{{#view view.withLayout title="My Fancy Page"}}<div class="page-body">Show something interesting here</div>{{/view}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('div.wrapper div.page-body').length, 1, 'page-body is embedded within wrapping my-page');
  });

  QUnit.test('block should work properly even when templates are not hard-coded', function () {
    registry.register('template:nester', _emberTemplateCompilerSystemCompile.default('<div class="wrapper"><h1>{{attrs.title}}</h1>{{yield}}</div>'));
    registry.register('template:nested', _emberTemplateCompilerSystemCompile.default('{{#view "with-layout" title="My Fancy Page"}}<div class="page-body">Show something interesting here</div>{{/view}}'));

    registry.register('view:with-layout', _emberViewsViewsView.default.extend({
      container: container,
      layoutName: 'nester'
    }));

    view = _emberViewsViewsView.default.create({
      container: container,
      templateName: 'nested'
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('div.wrapper div.page-body').length, 1, 'page-body is embedded within wrapping my-page');
  });

  QUnit.test('templates should yield to block, when the yield is embedded in a hierarchy of virtual views', function () {
    var TimesView = _emberViewsViewsView.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('<div class="times">{{#each view.index as |item|}}{{yield}}{{/each}}</div>'),
      n: null,
      index: _emberMetalComputed.computed(function () {
        var n = this.attrs.n;
        var indexArray = _emberRuntimeSystemNative_array.A();
        for (var i = 0; i < n; i++) {
          indexArray[i] = i;
        }
        return indexArray;
      })
    });

    view = _emberViewsViewsView.default.create({
      timesView: TimesView,
      template: _emberTemplateCompilerSystemCompile.default('<div id="container"><div class="title">Counting to 5</div>{{#view view.timesView n=5}}<div class="times-item">Hello</div>{{/view}}</div>')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('div#container div.times-item').length, 5, 'times-item is embedded within wrapping container 5 times, as expected');
  });

  QUnit.test('templates should yield to block, when the yield is embedded in a hierarchy of non-virtual views', function () {
    var NestingView = _emberViewsViewsView.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('{{#view tagName="div" classNames="nesting"}}{{yield}}{{/view}}')
    });

    view = _emberViewsViewsView.default.create({
      nestingView: NestingView,
      template: _emberTemplateCompilerSystemCompile.default('<div id="container">{{#view view.nestingView}}<div id="block">Hello</div>{{/view}}</div>')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('div#container div.nesting div#block').length, 1, 'nesting view yields correctly even within a view hierarchy in the nesting view');
  });

  QUnit.test('block should not be required', function () {
    var YieldingView = _emberViewsViewsView.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('{{#view tagName="div" classNames="yielding"}}{{yield}}{{/view}}')
    });

    view = _emberViewsViewsView.default.create({
      yieldingView: YieldingView,
      template: _emberTemplateCompilerSystemCompile.default('<div id="container">{{view view.yieldingView}}</div>')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('div#container div.yielding').length, 1, 'yielding view is rendered as expected');
  });

  QUnit.test('yield uses the outer context', function () {
    var component = _emberViewsViewsComponent.default.extend({
      boundText: 'inner',
      layout: _emberTemplateCompilerSystemCompile.default('<p>{{boundText}}</p><p>{{yield}}</p>')
    });

    view = _emberViewsViewsView.default.create({
      controller: { boundText: 'outer', component: component },
      template: _emberTemplateCompilerSystemCompile.default('{{#view component}}{{boundText}}{{/view}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('div p:contains(inner) + p:contains(outer)').length, 1, 'Yield points at the right context');
  });

  QUnit.test('outer keyword doesn\'t mask inner component property', function () {
    var component = _emberViewsViewsComponent.default.extend({
      item: 'inner',
      layout: _emberTemplateCompilerSystemCompile.default('<p>{{item}}</p><p>{{yield}}</p>')
    });

    view = _emberViewsViewsView.default.create({
      controller: { boundText: 'outer', component: component },
      template: _emberTemplateCompilerSystemCompile.default('{{#with boundText as |item|}}{{#view component}}{{item}}{{/view}}{{/with}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('div p:contains(inner) + p:contains(outer)').length, 1, 'inner component property isn\'t masked by outer keyword');
  });

  QUnit.test('inner keyword doesn\'t mask yield property', function () {
    var component = _emberViewsViewsComponent.default.extend({
      boundText: 'inner',
      layout: _emberTemplateCompilerSystemCompile.default('{{#with boundText as |item|}}<p>{{item}}</p><p>{{yield}}</p>{{/with}}')
    });

    view = _emberViewsViewsView.default.create({
      controller: { item: 'outer', component: component },
      template: _emberTemplateCompilerSystemCompile.default('{{#view component}}{{item}}{{/view}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('div p:contains(inner) + p:contains(outer)').length, 1, 'outer property isn\'t masked by inner keyword');
  });

  QUnit.test('can bind a keyword to a component and use it in yield', function () {
    var component = _emberViewsViewsComponent.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('<p>{{attrs.content}}</p><p>{{yield}}</p>')
    });

    view = _emberViewsViewsView.default.create({
      controller: { boundText: 'outer', component: component },
      template: _emberTemplateCompilerSystemCompile.default('{{#with boundText as |item|}}{{#view component content=item}}{{item}}{{/view}}{{/with}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('div p:contains(outer) + p:contains(outer)').length, 1, 'component and yield have keyword');

    _emberMetalRun_loop.default(function () {
      view.set('controller.boundText', 'update');
    });

    equal(view.$('div p:contains(update) + p:contains(update)').length, 1, 'keyword has correctly propagated update');
  });

  QUnit.test('yield view should be a virtual view', function () {
    var component = _emberViewsViewsComponent.default.extend({
      isParentComponent: true,

      layout: _emberTemplateCompilerSystemCompile.default('{{yield}}')
    });

    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('{{#view component}}{{view includedComponent}}{{/view}}'),
      controller: {
        component: component,
        includedComponent: _emberViewsViewsComponent.default.extend({
          didInsertElement: function () {
            var parentView = this.get('parentView');

            ok(parentView.get('isParentComponent'), 'parent view is the parent component');
          }
        })
      }
    });

    _emberRuntimeTestsUtils.runAppend(view);
  });

  QUnit.test('yield should work for views even if parentView is null', function () {
    view = _emberViewsViewsView.default.create({
      layout: _emberTemplateCompilerSystemCompile.default('Layout: {{yield}}'),
      template: _emberTemplateCompilerSystemCompile.default('View Content')
    });

    _emberMetalRun_loop.default(function () {
      view.createElement();
    });

    equal(view.$().text(), 'Layout: View Content');
  });

  QUnit.test('simple bindings inside of a yielded template should work properly when the yield is nested inside of another view', function () {
    view = _emberViewsViewsView.default.create({
      layout: _emberTemplateCompilerSystemCompile.default('{{#if view.falsy}}{{else}}{{yield}}{{/if}}'),
      template: _emberTemplateCompilerSystemCompile.default('{{view.text}}'),
      text: 'ohai'
    });

    _emberMetalRun_loop.default(function () {
      view.createElement();
    });

    equal(view.$().text(), 'ohai');
  });

  QUnit.test('nested simple bindings inside of a yielded template should work properly when the yield is nested inside of another view', function () {
    view = _emberViewsViewsView.default.create({
      layout: _emberTemplateCompilerSystemCompile.default('{{#if view.falsy}}{{else}}{{yield}}{{/if}}'),
      template: _emberTemplateCompilerSystemCompile.default('{{#if view.falsy}}{{else}}{{view.text}}{{/if}}'),
      text: 'ohai'
    });

    _emberMetalRun_loop.default(function () {
      view.createElement();
    });

    equal(view.$().text(), 'ohai');
  });

  QUnit.module('ember-htmlbars: Component {{yield}}', {
    setup: function () {
      setupContainer();
      originalViewKeyword = _emberHtmlbarsTestsUtils.registerKeyword('view', _emberHtmlbarsKeywordsView.default);
    },
    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(view);
      delete _emberHtmlbarsHelpers.default['inner-component'];
      delete _emberHtmlbarsHelpers.default['outer-component'];
      _emberHtmlbarsTestsUtils.resetKeyword('view', originalViewKeyword);
    }
  });

  QUnit.test('yield with nested components (#3220)', function () {
    var InnerComponent = _emberViewsViewsComponent.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('{{yield}}')
    });

    registry.register('component:inner-component', InnerComponent);

    var OuterComponent = _emberViewsViewsComponent.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('{{#inner-component}}<span>{{yield}}</span>{{/inner-component}}')
    });

    registry.register('component:outer-component', OuterComponent);

    view = _emberViewsViewsView.default.extend({
      container: container,

      template: _emberTemplateCompilerSystemCompile.default('{{#outer-component}}Hello world{{/outer-component}}')
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('div > span').text(), 'Hello world');
  });

  QUnit.test('view keyword works inside component yield', function () {
    var component = _emberViewsViewsComponent.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('<p>{{yield}}</p>')
    });

    view = _emberViewsViewsView.default.create({
      dummyText: 'hello',
      component: component,
      template: _emberTemplateCompilerSystemCompile.default('{{#view view.component}}{{view.dummyText}}{{/view}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('div > p').text(), 'hello', 'view keyword inside component yield block should refer to the correct view');
  });
});

//import { set } from "ember-metal/property_set";
enifed('ember-htmlbars/tests/helpers/yield_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/helpers');
  test('ember-htmlbars/tests/helpers/yield_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/helpers/yield_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/helpers/yield_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/helpers');
  QUnit.test('ember-htmlbars/tests/helpers/yield_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/helpers/yield_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/hooks/component_test', ['exports', 'ember-metal/features', 'ember-views/component_lookup', 'container/registry', 'ember-views/views/view', 'ember-template-compiler/system/compile', 'ember-runtime/tests/utils'], function (exports, _emberMetalFeatures, _emberViewsComponent_lookup, _containerRegistry, _emberViewsViewsView, _emberTemplateCompilerSystemCompile, _emberRuntimeTestsUtils) {
  'use strict';

  var view, registry, container;
});
enifed('ember-htmlbars/tests/hooks/component_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/hooks');
  test('ember-htmlbars/tests/hooks/component_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/hooks/component_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/hooks/component_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/hooks');
  QUnit.test('ember-htmlbars/tests/hooks/component_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/hooks/component_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/hooks/text_node_test', ['exports', 'ember-views/views/view', 'ember-metal/run_loop', 'ember-runtime/system/object', 'ember-template-compiler/system/compile', 'htmlbars-test-helpers', 'ember-runtime/tests/utils'], function (exports, _emberViewsViewsView, _emberMetalRun_loop, _emberRuntimeSystemObject, _emberTemplateCompilerSystemCompile, _htmlbarsTestHelpers, _emberRuntimeTestsUtils) {
  'use strict';

  var view;

  QUnit.module('ember-htmlbars: hooks/text_node_test', {
    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(view);
    }
  });

  QUnit.test('property is output', function () {
    view = _emberViewsViewsView.default.create({
      context: { name: 'erik' },
      template: _emberTemplateCompilerSystemCompile.default('ohai {{name}}')
    });
    _emberRuntimeTestsUtils.runAppend(view);

    _htmlbarsTestHelpers.equalInnerHTML(view.element, 'ohai erik', 'property is output');
  });

  QUnit.test('path is output', function () {
    view = _emberViewsViewsView.default.create({
      context: { name: { firstName: 'erik' } },
      template: _emberTemplateCompilerSystemCompile.default('ohai {{name.firstName}}')
    });
    _emberRuntimeTestsUtils.runAppend(view);

    _htmlbarsTestHelpers.equalInnerHTML(view.element, 'ohai erik', 'path is output');
  });

  QUnit.test('changed property updates', function () {
    var context = _emberRuntimeSystemObject.default.create({ name: 'erik' });
    view = _emberViewsViewsView.default.create({
      context: context,
      template: _emberTemplateCompilerSystemCompile.default('ohai {{name}}')
    });
    _emberRuntimeTestsUtils.runAppend(view);

    _htmlbarsTestHelpers.equalInnerHTML(view.element, 'ohai erik', 'precond - original property is output');

    _emberMetalRun_loop.default(context, context.set, 'name', 'mmun');

    _htmlbarsTestHelpers.equalInnerHTML(view.element, 'ohai mmun', 'new property is output');
  });
});
enifed('ember-htmlbars/tests/hooks/text_node_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/hooks');
  test('ember-htmlbars/tests/hooks/text_node_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/hooks/text_node_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/hooks/text_node_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/hooks');
  QUnit.test('ember-htmlbars/tests/hooks/text_node_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/hooks/text_node_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/htmlbars_test', ['exports', 'ember-template-compiler/system/compile', 'ember-htmlbars/env', 'htmlbars-test-helpers', 'ember-metal/merge'], function (exports, _emberTemplateCompilerSystemCompile, _emberHtmlbarsEnv, _htmlbarsTestHelpers, _emberMetalMerge) {
  'use strict';

  QUnit.module('ember-htmlbars: main');

  QUnit.test('HTMLBars is present and can be executed', function () {
    var template = _emberTemplateCompilerSystemCompile.default('ohai');

    var env = _emberMetalMerge.default({ dom: _emberHtmlbarsEnv.domHelper }, _emberHtmlbarsEnv.default);

    var output = template.render({}, env, { contextualElement: document.body }).fragment;
    _htmlbarsTestHelpers.equalHTML(output, 'ohai');
  });
});
enifed('ember-htmlbars/tests/htmlbars_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests');
  test('ember-htmlbars/tests/htmlbars_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/htmlbars_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/htmlbars_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests');
  QUnit.test('ember-htmlbars/tests/htmlbars_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/htmlbars_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/integration/attribute_bindings_test', ['exports', 'ember-metal/run_loop', 'ember-views/views/view', 'ember-template-compiler/system/compile', 'ember-runtime/tests/utils', 'ember-metal/property_set'], function (exports, _emberMetalRun_loop, _emberViewsViewsView, _emberTemplateCompilerSystemCompile, _emberRuntimeTestsUtils, _emberMetalProperty_set) {
  'use strict';

  var view;

  QUnit.module('ember-htmlbars: custom morph integration tests', {
    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(view);
    }
  });

  QUnit.test('can properly re-render an if/else with attribute morphs', function () {
    view = _emberViewsViewsView.default.create({
      trueClass: 'truthy',
      falseClass: 'falsey',
      switch: true,

      template: _emberTemplateCompilerSystemCompile.default('{{#if view.switch}}<div class={{view.trueClass}}>Truthy</div>{{else}}<div class={{view.falseClass}}>Falsey</div>{{/if}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('.truthy').length, 1, 'template block rendered properly');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'switch', false);
    });

    equal(view.$('.falsey').length, 1, 'inverse block rendered properly');
  });

  QUnit.test('can properly re-render an if/else with element morphs', function () {
    view = _emberViewsViewsView.default.create({
      trueClass: 'truthy',
      falseClass: 'falsey',
      switch: true,

      template: _emberTemplateCompilerSystemCompile.default('{{#if view.switch}}<div class="truthy" {{action view.trueClass}}>Truthy</div>{{else}}<div class="falsey" {{action view.falseClass}}>Falsey</div>{{/if}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('.truthy').length, 1, 'template block rendered properly');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'switch', false);
    });

    equal(view.$('.falsey').length, 1, 'inverse block rendered properly');
  });
});
enifed('ember-htmlbars/tests/integration/attribute_bindings_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/integration');
  test('ember-htmlbars/tests/integration/attribute_bindings_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/integration/attribute_bindings_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/integration/attribute_bindings_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/integration');
  QUnit.test('ember-htmlbars/tests/integration/attribute_bindings_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/integration/attribute_bindings_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/integration/attrs_lookup_test', ['exports', 'container/registry', 'ember-template-compiler/system/compile', 'ember-views/component_lookup', 'ember-views/views/component', 'ember-runtime/tests/utils', 'ember-views/views/view', 'ember-metal/run_loop'], function (exports, _containerRegistry, _emberTemplateCompilerSystemCompile, _emberViewsComponent_lookup, _emberViewsViewsComponent, _emberRuntimeTestsUtils, _emberViewsViewsView, _emberMetalRun_loop) {
  'use strict';

  var registry, container, view;

  QUnit.module('component - attrs lookup', {
    setup: function () {
      registry = new _containerRegistry.default();
      container = registry.container();
      registry.optionsForType('component', { singleton: false });
      registry.optionsForType('view', { singleton: false });
      registry.optionsForType('template', { instantiate: false });
      registry.register('component-lookup:main', _emberViewsComponent_lookup.default);
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(container);
      _emberRuntimeTestsUtils.runDestroy(view);
      registry = container = view = null;
    }
  });

  QUnit.test('should be able to lookup attrs without `attrs.` - template access', function () {
    registry.register('template:components/foo-bar', _emberTemplateCompilerSystemCompile.default('{{first}}'));

    view = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('{{foo-bar first="first attr"}}'),
      container: container
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'first attr');
  });

  QUnit.test('should be able to lookup attrs without `attrs.` - component access', function () {
    var component;

    registry.register('component:foo-bar', _emberViewsViewsComponent.default.extend({
      init: function () {
        this._super.apply(this, arguments);
        component = this;
      }
    }));

    view = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('{{foo-bar first="first attr"}}'),
      container: container
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    equal(component.get('first'), 'first attr');
  });

  QUnit.test('should be able to modify a provided attr into local state #11571 / #11559', function () {
    var component;

    registry.register('component:foo-bar', _emberViewsViewsComponent.default.extend({
      init: function () {
        this._super.apply(this, arguments);
        component = this;
      },

      didReceiveAttrs: function () {
        this.set('first', this.getAttr('first').toUpperCase());
      }
    }));
    registry.register('template:components/foo-bar', _emberTemplateCompilerSystemCompile.default('{{first}}'));

    view = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('{{foo-bar first="first attr"}}'),
      container: container
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'FIRST ATTR', 'template lookup uses local state');
    equal(component.get('first'), 'FIRST ATTR', 'component lookup uses local state');
  });

  QUnit.test('should be able to access unspecified attr #12035', function () {
    var component;

    registry.register('component:foo-bar', _emberViewsViewsComponent.default.extend({
      init: function () {
        this._super.apply(this, arguments);
        component = this;
      },

      didReceiveAttrs: function () {
        equal(this.get('woot'), 'yes', 'found attr in didReceiveAttrs');
      }
    }));
    // registry.register('template:components/foo-bar', compile('{{first}}'));

    view = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('{{foo-bar woot="yes"}}'),
      container: container
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    // equal(view.$().text(), 'FIRST ATTR', 'template lookup uses local state');
    equal(component.get('woot'), 'yes', 'component found attr');
  });

  QUnit.test('should not need to call _super in `didReceiveAttrs` (GH #11992)', function () {
    expect(12);
    var firstValue = 'first';
    var secondValue = 'second';

    registry.register('component:foo-bar', _emberViewsViewsComponent.default.extend({
      didReceiveAttrs: function () {
        var rootFirst = this.get('first');
        var rootSecond = this.get('second');
        var attrFirst = this.getAttr('first');
        var attrSecond = this.getAttr('second');

        equal(rootFirst, attrFirst, 'root property matches attrs value');
        equal(rootSecond, attrSecond, 'root property matches attrs value');

        equal(rootFirst, firstValue, 'matches known value');
        equal(rootSecond, secondValue, 'matches known value');
      }
    }));

    view = _emberViewsViewsView.default.extend({
      first: firstValue,
      second: secondValue,
      template: _emberTemplateCompilerSystemCompile.default('{{foo-bar first=view.first second=view.second}}'),
      container: container
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    firstValue = 'asdf';
    _emberMetalRun_loop.default(view, 'set', 'first', firstValue);

    secondValue = 'jkl;';
    _emberMetalRun_loop.default(view, 'set', 'second', secondValue);
  });
});
enifed('ember-htmlbars/tests/integration/attrs_lookup_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/integration');
  test('ember-htmlbars/tests/integration/attrs_lookup_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/integration/attrs_lookup_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/integration/attrs_lookup_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/integration');
  QUnit.test('ember-htmlbars/tests/integration/attrs_lookup_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/integration/attrs_lookup_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/integration/binding_integration_test', ['exports', 'ember-metal/core', 'ember-metal/run_loop', 'ember-views/system/jquery', 'ember-views/views/view', 'ember-metal/binding', 'ember-runtime/system/object', 'ember-metal/computed', 'ember-views/views/container_view', 'ember-template-compiler/system/compile', 'ember-runtime/tests/utils', 'ember-htmlbars/helpers', 'ember-metal/property_set', 'ember-htmlbars/tests/utils', 'ember-htmlbars/keywords/view'], function (exports, _emberMetalCore, _emberMetalRun_loop, _emberViewsSystemJquery, _emberViewsViewsView, _emberMetalBinding, _emberRuntimeSystemObject, _emberMetalComputed, _emberViewsViewsContainer_view, _emberTemplateCompilerSystemCompile, _emberRuntimeTestsUtils, _emberHtmlbarsHelpers, _emberMetalProperty_set, _emberHtmlbarsTestsUtils, _emberHtmlbarsKeywordsView) {
  'use strict';

  var view, MyApp, originalLookup, lookup, originalViewKeyword;

  var trim = _emberViewsSystemJquery.default.trim;

  QUnit.module('ember-htmlbars: binding integration', {
    setup: function () {
      originalViewKeyword = _emberHtmlbarsTestsUtils.registerKeyword('view', _emberHtmlbarsKeywordsView.default);
      originalLookup = _emberMetalCore.default.lookup;
      _emberMetalCore.default.lookup = lookup = {};

      MyApp = lookup.MyApp = _emberRuntimeSystemObject.default.create({});
    },

    teardown: function () {
      _emberMetalCore.default.lookup = originalLookup;

      _emberRuntimeTestsUtils.runDestroy(view);
      _emberHtmlbarsTestsUtils.resetKeyword('view', originalViewKeyword);
      view = null;

      MyApp = null;
    }
  });

  QUnit.test('should call a registered helper for mustache without parameters', function () {
    _emberHtmlbarsHelpers.registerHelper('foobar', function () {
      return 'foobar';
    });

    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('{{foobar}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    ok(view.$().text() === 'foobar', 'Regular helper was invoked correctly');
  });

  QUnit.test('should bind to the property if no registered helper found for a mustache without parameters', function () {
    view = _emberViewsViewsView.default.extend({
      foobarProperty: _emberMetalComputed.computed(function () {
        return 'foobarProperty';
      })
    }).create({
      template: _emberTemplateCompilerSystemCompile.default('{{view.foobarProperty}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    ok(view.$().text() === 'foobarProperty', 'Property was bound to correctly');
  });

  QUnit.test('should be able to update when bound property updates', function () {
    MyApp.set('controller', _emberRuntimeSystemObject.default.create({ name: 'first' }));

    var View = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('<i>{{view.value.name}}, {{view.computed}}</i>'),
      valueBinding: 'MyApp.controller',
      computed: _emberMetalComputed.computed(function () {
        return this.get('value.name') + ' - computed';
      }).property('value')
    });

    _emberMetalRun_loop.default(function () {
      view = View.create();
    });

    _emberRuntimeTestsUtils.runAppend(view);

    _emberMetalRun_loop.default(function () {
      MyApp.set('controller', _emberRuntimeSystemObject.default.create({
        name: 'second'
      }));
    });

    equal(view.get('computed'), 'second - computed', 'view computed properties correctly update');
    equal(view.$('i').text(), 'second, second - computed', 'view rerenders when bound properties change');
  });

  QUnit.test('should allow rendering of undefined props', function () {
    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('{{name}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), '', 'rendered undefined binding');
  });

  QUnit.test('should cleanup bound properties on rerender', function () {
    view = _emberViewsViewsView.default.create({
      controller: _emberRuntimeSystemObject.default.create({ name: 'wycats' }),
      template: _emberTemplateCompilerSystemCompile.default('{{name}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'wycats', 'rendered binding');

    _emberMetalRun_loop.default(view, 'rerender');

    equal(view.$().text(), 'wycats', 'rendered binding');
  });

  QUnit.test('should update bound values after view\'s parent is removed and then re-appended', function () {
    expectDeprecation('Setting `childViews` on a Container is deprecated.');

    var controller = _emberRuntimeSystemObject.default.create();

    var parentView = _emberViewsViewsContainer_view.default.create({
      childViews: ['testView'],

      controller: controller,

      testView: _emberViewsViewsView.default.create({
        template: _emberTemplateCompilerSystemCompile.default('{{#if showStuff}}{{boundValue}}{{else}}Not true.{{/if}}')
      })
    });

    controller.setProperties({
      showStuff: true,
      boundValue: 'foo'
    });

    _emberRuntimeTestsUtils.runAppend(parentView);
    view = parentView.get('testView');

    equal(trim(view.$().text()), 'foo');
    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(controller, 'showStuff', false);
    });
    equal(trim(view.$().text()), 'Not true.');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(controller, 'showStuff', true);
    });
    equal(trim(view.$().text()), 'foo');

    _emberMetalRun_loop.default(function () {
      parentView.remove();
      _emberMetalProperty_set.set(controller, 'showStuff', false);
    });
    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(controller, 'showStuff', true);
    });
    _emberRuntimeTestsUtils.runAppend(parentView);

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(controller, 'boundValue', 'bar');
    });
    equal(trim(view.$().text()), 'bar');

    _emberRuntimeTestsUtils.runDestroy(parentView);
  });

  QUnit.test('should accept bindings as a string or an Ember.Binding', function () {
    var ViewWithBindings = _emberViewsViewsView.default.extend({
      twoWayBindingTestBinding: _emberMetalBinding.Binding.from('context.direction'),
      stringBindingTestBinding: 'context.direction',
      template: _emberTemplateCompilerSystemCompile.default('two way: {{view.twoWayBindingTest}}, ' + 'string: {{view.stringBindingTest}}')
    });

    view = _emberViewsViewsView.default.create({
      viewWithBindingsClass: ViewWithBindings,
      context: _emberRuntimeSystemObject.default.create({
        direction: 'down'
      }),
      template: _emberTemplateCompilerSystemCompile.default('{{view view.viewWithBindingsClass}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(trim(view.$().text()), 'two way: down, string: down');
  });
});
enifed('ember-htmlbars/tests/integration/binding_integration_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/integration');
  test('ember-htmlbars/tests/integration/binding_integration_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/integration/binding_integration_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/integration/binding_integration_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/integration');
  QUnit.test('ember-htmlbars/tests/integration/binding_integration_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/integration/binding_integration_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/integration/block_params_test', ['exports', 'container/registry', 'ember-metal/run_loop', 'ember-views/component_lookup', 'ember-views/views/view', 'ember-views/views/component', 'ember-template-compiler/system/compile', 'ember-runtime/tests/utils'], function (exports, _containerRegistry, _emberMetalRun_loop, _emberViewsComponent_lookup, _emberViewsViewsView, _emberViewsViewsComponent, _emberTemplateCompilerSystemCompile, _emberRuntimeTestsUtils) {
  'use strict';

  var registry, container, view;

  QUnit.module('ember-htmlbars: block params', {
    setup: function () {
      registry = new _containerRegistry.default();
      container = registry.container();
      registry.optionsForType('component', { singleton: false });
      registry.optionsForType('view', { singleton: false });
      registry.optionsForType('template', { instantiate: false });
      registry.register('component-lookup:main', _emberViewsComponent_lookup.default);
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(view);
      _emberRuntimeTestsUtils.runDestroy(container);
      registry = container = view = null;
    }
  });

  QUnit.test('should raise error if helper not available', function () {
    view = _emberViewsViewsView.default.create({
      container: container,
      template: _emberTemplateCompilerSystemCompile.default('{{#shouldfail}}{{/shouldfail}}')
    });

    expectAssertion(function () {
      _emberRuntimeTestsUtils.runAppend(view);
    }, 'A helper named \'shouldfail\' could not be found');
  });

  QUnit.test('basic block params usage', function () {
    view = _emberViewsViewsView.default.create({
      committer: { name: 'rwjblue' },
      template: _emberTemplateCompilerSystemCompile.default('{{#with view.committer.name as |name|}}name: {{name}}, length: {{name.length}}{{/with}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'name: rwjblue, length: 7');

    _emberMetalRun_loop.default(function () {
      view.set('committer.name', 'krisselden');
    });

    equal(view.$().text(), 'name: krisselden, length: 10');
  });

  QUnit.test('nested block params shadow correctly', function () {
    view = _emberViewsViewsView.default.create({
      context: { name: 'ebryn' },
      committer1: { name: 'trek' },
      committer2: { name: 'machty' },
      template: _emberTemplateCompilerSystemCompile.default('{{name}}' + '{{#with view.committer1.name as |name|}}' + '[{{name}}' + '{{#with view.committer2.name as |name|}}' + '[{{name}}]' + '{{/with}}' + '{{name}}]' + '{{/with}}' + '{{name}}' + '{{#with view.committer2.name as |name|}}' + '[{{name}}' + '{{#with view.committer1.name as |name|}}' + '[{{name}}]' + '{{/with}}' + '{{name}}]' + '{{/with}}' + '{{name}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'ebryn[trek[machty]trek]ebryn[machty[trek]machty]ebryn');
  });

  QUnit.test('components can yield values', function () {
    registry.register('template:components/x-alias', _emberTemplateCompilerSystemCompile.default('{{yield attrs.param.name}}'));

    view = _emberViewsViewsView.default.create({
      container: container,
      context: { name: 'ebryn' },
      committer1: { name: 'trek' },
      committer2: { name: 'machty' },
      template: _emberTemplateCompilerSystemCompile.default('{{name}}' + '{{#x-alias param=view.committer1 as |name|}}' + '[{{name}}' + '{{#x-alias param=view.committer2 as |name|}}' + '[{{name}}]' + '{{/x-alias}}' + '{{name}}]' + '{{/x-alias}}' + '{{name}}' + '{{#x-alias param=view.committer2 as |name|}}' + '[{{name}}' + '{{#x-alias param=view.committer1 as |name|}}' + '[{{name}}]' + '{{/x-alias}}' + '{{name}}]' + '{{/x-alias}}' + '{{name}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'ebryn[trek[machty]trek]ebryn[machty[trek]machty]ebryn');

    _emberMetalRun_loop.default(function () {
      view.set('committer1', { name: 'wycats' });
    });

    equal(view.$().text(), 'ebryn[wycats[machty]wycats]ebryn[machty[wycats]machty]ebryn');
  });

  QUnit.test('#11519 - block param infinite loop', function (assert) {
    // To trigger this case, a component must 1) consume a KeyStream and then yield that KeyStream
    // into a parent light scope.
    registry.register('template:components/block-with-yield', _emberTemplateCompilerSystemCompile.default('{{danger}} {{yield danger}}'));

    var component;
    registry.register('component:block-with-yield', _emberViewsViewsComponent.default.extend({
      init: function () {
        component = this;
        return this._super.apply(this, arguments);
      },

      danger: 0
    }));

    view = _emberViewsViewsView.default.create({
      container: container,
      template: _emberTemplateCompilerSystemCompile.default('{{#block-with-yield as |dangerBlockParam|}} {{/block-with-yield}}')
    });

    // On initial render, create streams. The bug will not have manifested yet, but at this point
    // we have created streams that create a circular invalidation.
    _emberRuntimeTestsUtils.runAppend(view);

    // Trigger a revalidation, which will cause an infinite loop without the fix
    // in place.  Note that we do not see the infinite loop is in testing mode,
    // because a deprecation warning about re-renders is issued, which Ember
    // treats as an exception.
    _emberMetalRun_loop.default(function () {
      component.set('danger', 1);
    });

    assert.equal(view.$().text().trim(), '1');
  });
});
enifed('ember-htmlbars/tests/integration/block_params_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/integration');
  test('ember-htmlbars/tests/integration/block_params_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/integration/block_params_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/integration/block_params_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/integration');
  QUnit.test('ember-htmlbars/tests/integration/block_params_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/integration/block_params_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/integration/component_element_id_test', ['exports', 'ember-views/views/view', 'ember-runtime/system/container', 'ember-template-compiler/system/compile', 'ember-runtime/tests/utils', 'ember-views/component_lookup', 'ember-views/views/component'], function (exports, _emberViewsViewsView, _emberRuntimeSystemContainer, _emberTemplateCompilerSystemCompile, _emberRuntimeTestsUtils, _emberViewsComponent_lookup, _emberViewsViewsComponent) {
  'use strict';

  var registry, container, view;

  QUnit.module('ember-htmlbars: component elementId', {
    setup: function () {
      registry = new _emberRuntimeSystemContainer.Registry();
      container = registry.container();
      registry.optionsForType('component', { singleton: false });
      registry.optionsForType('view', { singleton: false });
      registry.optionsForType('template', { instantiate: false });
      registry.register('component-lookup:main', _emberViewsComponent_lookup.default);
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(container);
      _emberRuntimeTestsUtils.runDestroy(view);
      registry = container = view = null;
    }
  });

  QUnit.test('passing undefined elementId results in a default elementId', function () {
    registry.register('component:x-foo', _emberViewsViewsComponent.default.extend({
      tagName: 'h1'
    }));

    view = _emberViewsViewsView.default.create({
      container: container,
      template: _emberTemplateCompilerSystemCompile.default('{{x-foo id=somethingUndefined}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);
    var foundId = view.$('h1').attr('id');
    ok(/^ember/.test(foundId), 'Has a reasonable id attribute (found id=' + foundId + ').');
  });
});
enifed('ember-htmlbars/tests/integration/component_element_id_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/integration');
  test('ember-htmlbars/tests/integration/component_element_id_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/integration/component_element_id_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/integration/component_element_id_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/integration');
  QUnit.test('ember-htmlbars/tests/integration/component_element_id_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/integration/component_element_id_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/integration/component_invocation_test', ['exports', 'ember-metal/core', 'ember-metal/features', 'ember-views/views/view', 'container/registry', 'ember-views/system/jquery', 'ember-template-compiler/system/compile', 'ember-views/component_lookup', 'ember-views/views/component', 'ember-runtime/tests/utils', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/run_loop'], function (exports, _emberMetalCore, _emberMetalFeatures, _emberViewsViewsView, _containerRegistry, _emberViewsSystemJquery, _emberTemplateCompilerSystemCompile, _emberViewsComponent_lookup, _emberViewsViewsComponent, _emberRuntimeTestsUtils, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalRun_loop) {
  'use strict';

  var registry, container, view;

  function commonSetup() {
    registry = new _containerRegistry.default();
    container = registry.container();
    registry.optionsForType('component', { singleton: false });
    registry.optionsForType('view', { singleton: false });
    registry.optionsForType('template', { instantiate: false });
    registry.register('component-lookup:main', _emberViewsComponent_lookup.default);
  }

  function commonTeardown() {
    _emberRuntimeTestsUtils.runDestroy(container);
    _emberRuntimeTestsUtils.runDestroy(view);
    registry = container = view = null;
  }

  function appendViewFor(template) {
    var hash = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];

    var view = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default(template),
      container: container
    }).create(hash);

    _emberRuntimeTestsUtils.runAppend(view);

    return view;
  }

  QUnit.module('component - invocation', {
    setup: function () {
      commonSetup();
    },

    teardown: function () {
      commonTeardown();
    }
  });

  QUnit.test('non-block without properties', function () {
    expect(1);

    registry.register('template:components/non-block', _emberTemplateCompilerSystemCompile.default('In layout'));

    view = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('{{non-block}}'),
      container: container
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    equal(_emberViewsSystemJquery.default('#qunit-fixture').text(), 'In layout');
  });

  QUnit.test('block without properties', function () {
    expect(1);

    registry.register('template:components/with-block', _emberTemplateCompilerSystemCompile.default('In layout - {{yield}}'));

    view = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('{{#with-block}}In template{{/with-block}}'),
      container: container
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    equal(_emberViewsSystemJquery.default('#qunit-fixture').text(), 'In layout - In template');
  });

  QUnit.test('non-block with properties on attrs', function () {
    expect(1);

    registry.register('template:components/non-block', _emberTemplateCompilerSystemCompile.default('In layout - someProp: {{attrs.someProp}}'));

    view = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('{{non-block someProp="something here"}}'),
      container: container
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    equal(_emberViewsSystemJquery.default('#qunit-fixture').text(), 'In layout - someProp: something here');
  });

  QUnit.test('non-block with properties on attrs and component class', function () {
    registry.register('component:non-block', _emberViewsViewsComponent.default.extend());
    registry.register('template:components/non-block', _emberTemplateCompilerSystemCompile.default('In layout - someProp: {{attrs.someProp}}'));

    view = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('{{non-block someProp="something here"}}'),
      container: container
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    equal(_emberViewsSystemJquery.default('#qunit-fixture').text(), 'In layout - someProp: something here');
  });

  QUnit.test('lookup of component takes priority over property', function () {
    expect(1);

    registry.register('template:components/some-component', _emberTemplateCompilerSystemCompile.default('some-component'));

    view = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('{{some-prop}} {{some-component}}'),
      container: container,
      context: {
        'some-component': 'not-some-component',
        'some-prop': 'some-prop'
      }
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    equal(_emberViewsSystemJquery.default('#qunit-fixture').text(), 'some-prop some-component');
  });

  QUnit.test('component without dash is not looked up', function () {
    expect(1);

    registry.register('template:components/somecomponent', _emberTemplateCompilerSystemCompile.default('somecomponent'));

    view = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('{{somecomponent}}'),
      container: container,
      context: {
        'somecomponent': 'notsomecomponent'
      }
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    equal(_emberViewsSystemJquery.default('#qunit-fixture').text(), 'notsomecomponent');
  });

  QUnit.test('rerendering component with attrs from parent', function () {
    var willUpdate = 0;
    var didReceiveAttrs = 0;

    registry.register('component:non-block', _emberViewsViewsComponent.default.extend({
      didReceiveAttrs: function () {
        didReceiveAttrs++;
      },

      willUpdate: function () {
        willUpdate++;
      }
    }));
    registry.register('template:components/non-block', _emberTemplateCompilerSystemCompile.default('In layout - someProp: {{attrs.someProp}}'));

    view = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('{{non-block someProp=view.someProp}}'),
      container: container,
      someProp: 'wycats'
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    equal(didReceiveAttrs, 1, 'The didReceiveAttrs hook fired');

    equal(_emberViewsSystemJquery.default('#qunit-fixture').text(), 'In layout - someProp: wycats');

    _emberMetalRun_loop.default(function () {
      view.set('someProp', 'tomdale');
    });

    equal(_emberViewsSystemJquery.default('#qunit-fixture').text(), 'In layout - someProp: tomdale');
    equal(didReceiveAttrs, 2, 'The didReceiveAttrs hook fired again');
    equal(willUpdate, 1, 'The willUpdate hook fired once');

    _emberMetalCore.default.run(view, 'rerender');

    equal(_emberViewsSystemJquery.default('#qunit-fixture').text(), 'In layout - someProp: tomdale');
    equal(didReceiveAttrs, 3, 'The didReceiveAttrs hook fired again');
    equal(willUpdate, 2, 'The willUpdate hook fired again');
  });

  QUnit.test('[DEPRECATED] non-block with properties on self', function () {
    // TODO: attrs
    // expectDeprecation("You accessed the `someProp` attribute directly. Please use `attrs.someProp` instead.");

    registry.register('template:components/non-block', _emberTemplateCompilerSystemCompile.default('In layout - someProp: {{someProp}}'));

    view = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('{{non-block someProp="something here"}}'),
      container: container
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    equal(_emberViewsSystemJquery.default('#qunit-fixture').text(), 'In layout - someProp: something here');
  });

  QUnit.test('block with properties on attrs', function () {
    expect(1);

    registry.register('template:components/with-block', _emberTemplateCompilerSystemCompile.default('In layout - someProp: {{attrs.someProp}} - {{yield}}'));

    view = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('{{#with-block someProp="something here"}}In template{{/with-block}}'),
      container: container
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    equal(_emberViewsSystemJquery.default('#qunit-fixture').text(), 'In layout - someProp: something here - In template');
  });

  QUnit.test('[DEPRECATED] block with properties on self', function () {
    // TODO: attrs
    // expectDeprecation("You accessed the `someProp` attribute directly. Please use `attrs.someProp` instead.");

    registry.register('template:components/with-block', _emberTemplateCompilerSystemCompile.default('In layout - someProp: {{someProp}} - {{yield}}'));

    view = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('{{#with-block someProp="something here"}}In template{{/with-block}}'),
      container: container
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    equal(_emberViewsSystemJquery.default('#qunit-fixture').text(), 'In layout - someProp: something here - In template');
  });

  QUnit.test('with ariaRole specified', function () {
    expect(1);

    registry.register('template:components/aria-test', _emberTemplateCompilerSystemCompile.default('Here!'));

    view = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('{{aria-test id="aria-test" ariaRole="main"}}'),
      container: container
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('#aria-test').attr('role'), 'main', 'role attribute is applied');
  });

  QUnit.test('`template` specified in a component is overridden by block', function () {
    expect(1);

    registry.register('component:with-block', _emberViewsViewsComponent.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('{{yield}}'),
      template: _emberTemplateCompilerSystemCompile.default('Oh, noes!')
    }));

    view = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('{{#with-block}}Whoop, whoop!{{/with-block}}'),
      container: container
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'Whoop, whoop!', 'block provided always overrides template property');
  });

  QUnit.test('hasBlock is true when block supplied', function () {
    expect(1);

    registry.register('template:components/with-block', _emberTemplateCompilerSystemCompile.default('{{#if hasBlock}}{{yield}}{{else}}No Block!{{/if}}'));

    view = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('{{#with-block}}In template{{/with-block}}'),
      container: container
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    equal(_emberViewsSystemJquery.default('#qunit-fixture').text(), 'In template');
  });

  QUnit.test('hasBlock is false when no block supplied', function () {
    expect(1);

    registry.register('template:components/with-block', _emberTemplateCompilerSystemCompile.default('{{#if hasBlock}}{{yield}}{{else}}No Block!{{/if}}'));

    view = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('{{with-block}}'),
      container: container
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    equal(_emberViewsSystemJquery.default('#qunit-fixture').text(), 'No Block!');
  });

  QUnit.test('hasBlockParams is true when block param supplied', function () {
    expect(1);

    registry.register('template:components/with-block', _emberTemplateCompilerSystemCompile.default('{{#if hasBlockParams}}{{yield this}} - In Component{{else}}{{yield}} No Block!{{/if}}'));

    view = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('{{#with-block as |something|}}In template{{/with-block}}'),
      container: container
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    equal(_emberViewsSystemJquery.default('#qunit-fixture').text(), 'In template - In Component');
  });

  QUnit.test('hasBlockParams is false when no block param supplied', function () {
    expect(1);

    registry.register('template:components/with-block', _emberTemplateCompilerSystemCompile.default('{{#if hasBlockParams}}{{yield this}}{{else}}{{yield}} No Block Param!{{/if}}'));

    view = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('{{#with-block}}In block{{/with-block}}'),
      container: container
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    equal(_emberViewsSystemJquery.default('#qunit-fixture').text(), 'In block No Block Param!');
  });

  QUnit.test('static named positional parameters', function () {
    var SampleComponent = _emberViewsViewsComponent.default.extend();
    SampleComponent.reopenClass({
      positionalParams: ['name', 'age']
    });
    registry.register('template:components/sample-component', _emberTemplateCompilerSystemCompile.default('{{attrs.name}}{{attrs.age}}'));
    registry.register('component:sample-component', SampleComponent);

    view = _emberViewsViewsView.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('{{sample-component "Quint" 4}}'),
      container: container
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    equal(_emberViewsSystemJquery.default('#qunit-fixture').text(), 'Quint4');
  });

  QUnit.test('dynamic named positional parameters', function () {
    var SampleComponent = _emberViewsViewsComponent.default.extend();
    SampleComponent.reopenClass({
      positionalParams: ['name', 'age']
    });

    registry.register('template:components/sample-component', _emberTemplateCompilerSystemCompile.default('{{attrs.name}}{{attrs.age}}'));
    registry.register('component:sample-component', SampleComponent);

    view = _emberViewsViewsView.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('{{sample-component myName myAge}}'),
      container: container,
      context: {
        myName: 'Quint',
        myAge: 4
      }
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    equal(_emberViewsSystemJquery.default('#qunit-fixture').text(), 'Quint4');
    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view.context, 'myName', 'Edward');
      _emberMetalProperty_set.set(view.context, 'myAge', '5');
    });

    equal(_emberViewsSystemJquery.default('#qunit-fixture').text(), 'Edward5');
  });

  QUnit.test('static arbitrary number of positional parameters', function () {
    var SampleComponent = _emberViewsViewsComponent.default.extend();
    SampleComponent.reopenClass({
      positionalParams: 'names'
    });

    registry.register('template:components/sample-component', _emberTemplateCompilerSystemCompile.default('{{#each attrs.names as |name|}}{{name}}{{/each}}'));
    registry.register('component:sample-component', SampleComponent);

    view = _emberViewsViewsView.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('{{sample-component "Foo" 4 "Bar" id="args-3"}}{{sample-component "Foo" 4 "Bar" 5 "Baz" id="args-5"}}{{component "sample-component" "Foo" 4 "Bar" 5 "Baz" id="helper"}}'),
      container: container
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('#args-3').text(), 'Foo4Bar');
    equal(view.$('#args-5').text(), 'Foo4Bar5Baz');
    equal(view.$('#helper').text(), 'Foo4Bar5Baz');
  });

  QUnit.test('dynamic arbitrary number of positional parameters', function () {
    var SampleComponent = _emberViewsViewsComponent.default.extend();
    SampleComponent.reopenClass({
      positionalParams: 'n'
    });
    registry.register('template:components/sample-component', _emberTemplateCompilerSystemCompile.default('{{#each attrs.n as |name|}}{{name}}{{/each}}'));
    registry.register('component:sample-component', SampleComponent);

    view = _emberViewsViewsView.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('{{sample-component user1 user2 id="direct"}}{{component "sample-component" user1 user2 id="helper"}}'),
      container: container,
      context: {
        user1: 'Foo',
        user2: 4
      }
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('#direct').text(), 'Foo4');
    equal(view.$('#helper').text(), 'Foo4');
    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view.context, 'user1', 'Bar');
      _emberMetalProperty_set.set(view.context, 'user2', '5');
    });

    equal(view.$('#direct').text(), 'Bar5');
    equal(view.$('#helper').text(), 'Bar5');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view.context, 'user2', '6');
    });

    equal(view.$('#direct').text(), 'Bar6');
    equal(view.$('#helper').text(), 'Bar6');
  });

  QUnit.test('moduleName is available on _renderNode when a layout is present', function () {
    expect(1);

    var layoutModuleName = 'my-app-name/templates/components/sample-component';
    var sampleComponentLayout = _emberTemplateCompilerSystemCompile.default('Sample Component - {{yield}}', {
      moduleName: layoutModuleName
    });
    registry.register('template:components/sample-component', sampleComponentLayout);
    registry.register('component:sample-component', _emberViewsViewsComponent.default.extend({
      didInsertElement: function () {
        equal(this._renderNode.lastResult.template.meta.moduleName, layoutModuleName);
      }
    }));

    view = _emberViewsViewsView.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('{{sample-component}}'),
      container: container
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);
  });

  QUnit.test('moduleName is available on _renderNode when no layout is present', function () {
    expect(1);

    var templateModuleName = 'my-app-name/templates/application';
    registry.register('component:sample-component', _emberViewsViewsComponent.default.extend({
      didInsertElement: function () {
        equal(this._renderNode.lastResult.template.meta.moduleName, templateModuleName);
      }
    }));

    view = _emberViewsViewsView.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('{{#sample-component}}Derp{{/sample-component}}', {
        moduleName: templateModuleName
      }),
      container: container
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);
  });

  QUnit.test('{{component}} helper works with positional params', function () {
    var SampleComponent = _emberViewsViewsComponent.default.extend();
    SampleComponent.reopenClass({
      positionalParams: ['name', 'age']
    });

    registry.register('template:components/sample-component', _emberTemplateCompilerSystemCompile.default('{{attrs.name}}{{attrs.age}}'));
    registry.register('component:sample-component', SampleComponent);

    view = _emberViewsViewsView.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('{{component "sample-component" myName myAge}}'),
      container: container,
      context: {
        myName: 'Quint',
        myAge: 4
      }
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);
    equal(_emberViewsSystemJquery.default('#qunit-fixture').text(), 'Quint4');
    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view.context, 'myName', 'Edward');
      _emberMetalProperty_set.set(view.context, 'myAge', '5');
    });

    equal(_emberViewsSystemJquery.default('#qunit-fixture').text(), 'Edward5');
  });

  QUnit.test('yield to inverse', function () {
    registry.register('template:components/my-if', _emberTemplateCompilerSystemCompile.default('{{#if predicate}}Yes:{{yield someValue}}{{else}}No:{{yield to="inverse"}}{{/if}}'));

    view = _emberViewsViewsView.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('{{#my-if predicate=activated someValue=42 as |result|}}Hello{{result}}{{else}}Goodbye{{/my-if}}'),
      container: container,
      context: {
        activated: true
      }
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);
    equal(_emberViewsSystemJquery.default('#qunit-fixture').text(), 'Yes:Hello42');
    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view.context, 'activated', false);
    });

    equal(_emberViewsSystemJquery.default('#qunit-fixture').text(), 'No:Goodbye');
  });

  QUnit.test('parameterized hasBlock inverse', function () {
    registry.register('template:components/check-inverse', _emberTemplateCompilerSystemCompile.default('{{#if (hasBlock "inverse")}}Yes{{else}}No{{/if}}'));

    view = _emberViewsViewsView.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('{{#check-inverse id="expect-no"}}{{/check-inverse}}  {{#check-inverse id="expect-yes"}}{{else}}{{/check-inverse}}'),
      container: container
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);
    equal(_emberViewsSystemJquery.default('#qunit-fixture #expect-no').text(), 'No');
    equal(_emberViewsSystemJquery.default('#qunit-fixture #expect-yes').text(), 'Yes');
  });

  QUnit.test('parameterized hasBlock default', function () {
    registry.register('template:components/check-block', _emberTemplateCompilerSystemCompile.default('{{#if (hasBlock)}}Yes{{else}}No{{/if}}'));

    view = _emberViewsViewsView.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('{{check-block id="expect-no"}}  {{#check-block id="expect-yes"}}{{/check-block}}'),
      container: container
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);
    equal(_emberViewsSystemJquery.default('#qunit-fixture #expect-no').text(), 'No');
    equal(_emberViewsSystemJquery.default('#qunit-fixture #expect-yes').text(), 'Yes');
  });

  QUnit.test('non-expression hasBlock ', function () {
    registry.register('template:components/check-block', _emberTemplateCompilerSystemCompile.default('{{#if hasBlock}}Yes{{else}}No{{/if}}'));

    view = _emberViewsViewsView.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('{{check-block id="expect-no"}}  {{#check-block id="expect-yes"}}{{/check-block}}'),
      container: container
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);
    equal(_emberViewsSystemJquery.default('#qunit-fixture #expect-no').text(), 'No');
    equal(_emberViewsSystemJquery.default('#qunit-fixture #expect-yes').text(), 'Yes');
  });

  QUnit.test('parameterized hasBlockParams', function () {
    registry.register('template:components/check-params', _emberTemplateCompilerSystemCompile.default('{{#if (hasBlockParams)}}Yes{{else}}No{{/if}}'));

    view = _emberViewsViewsView.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('{{#check-params id="expect-no"}}{{/check-params}}  {{#check-params id="expect-yes" as |foo|}}{{/check-params}}'),
      container: container
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);
    equal(_emberViewsSystemJquery.default('#qunit-fixture #expect-no').text(), 'No');
    equal(_emberViewsSystemJquery.default('#qunit-fixture #expect-yes').text(), 'Yes');
  });

  QUnit.test('non-expression hasBlockParams', function () {
    registry.register('template:components/check-params', _emberTemplateCompilerSystemCompile.default('{{#if hasBlockParams}}Yes{{else}}No{{/if}}'));

    view = _emberViewsViewsView.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('{{#check-params id="expect-no"}}{{/check-params}}  {{#check-params id="expect-yes" as |foo|}}{{/check-params}}'),
      container: container
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);
    equal(_emberViewsSystemJquery.default('#qunit-fixture #expect-no').text(), 'No');
    equal(_emberViewsSystemJquery.default('#qunit-fixture #expect-yes').text(), 'Yes');
  });

  QUnit.test('components in template of a yielding component should have the proper parentView', function () {
    var outer, innerTemplate, innerLayout;

    registry.register('component:x-outer', _emberViewsViewsComponent.default.extend({
      init: function () {
        this._super.apply(this, arguments);
        outer = this;
      }
    }));

    registry.register('component:x-inner-in-template', _emberViewsViewsComponent.default.extend({
      init: function () {
        this._super.apply(this, arguments);
        innerTemplate = this;
      }
    }));

    registry.register('component:x-inner-in-layout', _emberViewsViewsComponent.default.extend({
      init: function () {
        this._super.apply(this, arguments);
        innerLayout = this;
      }
    }));

    registry.register('template:components/x-outer', _emberTemplateCompilerSystemCompile.default('{{x-inner-in-layout}}{{yield}}'));

    view = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('{{#x-outer}}{{x-inner-in-template}}{{/x-outer}}'),
      container: container
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    equal(innerTemplate.parentView, outer, 'receives the wrapping component as its parentView in template blocks');
    equal(innerLayout.parentView, outer, 'receives the wrapping component as its parentView in layout');
    equal(outer.parentView, view, 'x-outer receives the ambient scope as its parentView');
  });

  QUnit.test('newly-added sub-components get correct parentView', function () {
    var outer, inner;

    registry.register('component:x-outer', _emberViewsViewsComponent.default.extend({
      init: function () {
        this._super.apply(this, arguments);
        outer = this;
      }
    }));

    registry.register('component:x-inner', _emberViewsViewsComponent.default.extend({
      init: function () {
        this._super.apply(this, arguments);
        inner = this;
      }
    }));

    view = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('{{#x-outer}}{{#if view.showInner}}{{x-inner}}{{/if}}{{/x-outer}}'),
      container: container,
      showInner: false
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    _emberMetalRun_loop.default(function () {
      view.set('showInner', true);
    });

    equal(inner.parentView, outer, 'receives the wrapping component as its parentView in template blocks');
    equal(outer.parentView, view, 'x-outer receives the ambient scope as its parentView');
  });

  QUnit.test('components should receive the viewRegistry from the parent view', function () {
    var outer, innerTemplate, innerLayout;

    var viewRegistry = {};

    registry.register('component:x-outer', _emberViewsViewsComponent.default.extend({
      init: function () {
        this._super.apply(this, arguments);
        outer = this;
      }
    }));

    registry.register('component:x-inner-in-template', _emberViewsViewsComponent.default.extend({
      init: function () {
        this._super.apply(this, arguments);
        innerTemplate = this;
      }
    }));

    registry.register('component:x-inner-in-layout', _emberViewsViewsComponent.default.extend({
      init: function () {
        this._super.apply(this, arguments);
        innerLayout = this;
      }
    }));

    registry.register('template:components/x-outer', _emberTemplateCompilerSystemCompile.default('{{x-inner-in-layout}}{{yield}}'));

    view = _emberViewsViewsView.default.extend({
      _viewRegistry: viewRegistry,
      template: _emberTemplateCompilerSystemCompile.default('{{#x-outer}}{{x-inner-in-template}}{{/x-outer}}'),
      container: container
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    equal(innerTemplate._viewRegistry, viewRegistry);
    equal(innerLayout._viewRegistry, viewRegistry);
    equal(outer._viewRegistry, viewRegistry);
  });

  QUnit.test('comopnent should rerender when a property is changed during children\'s rendering', function () {
    expectDeprecation(/modified value twice in a single render/);

    var outer, middle;

    registry.register('component:x-outer', _emberViewsViewsComponent.default.extend({
      value: 1,
      grabReference: _emberMetalCore.default.on('init', function () {
        outer = this;
      })
    }));

    registry.register('component:x-middle', _emberViewsViewsComponent.default.extend({
      value: null,
      grabReference: _emberMetalCore.default.on('init', function () {
        middle = this;
      })
    }));

    registry.register('component:x-inner', _emberViewsViewsComponent.default.extend({
      value: null,
      pushDataUp: _emberMetalCore.default.observer('value', function () {
        middle.set('value', this.get('value'));
      })
    }));

    registry.register('template:components/x-outer', _emberTemplateCompilerSystemCompile.default('{{#x-middle}}{{x-inner value=value}}{{/x-middle}}'));
    registry.register('template:components/x-middle', _emberTemplateCompilerSystemCompile.default('<div id="middle-value">{{value}}</div>{{yield}}'));
    registry.register('template:components/x-inner', _emberTemplateCompilerSystemCompile.default('<div id="inner-value">{{value}}</div>'));

    view = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('{{x-outer}}'),
      container: container
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('#inner-value').text(), '1', 'initial render of inner');
    equal(view.$('#middle-value').text(), '', 'initial render of middle (observers do not run during init)');

    _emberMetalRun_loop.default(function () {
      return outer.set('value', 2);
    });

    equal(view.$('#inner-value').text(), '2', 'second render of inner');
    equal(view.$('#middle-value').text(), '2', 'second render of middle');

    _emberMetalRun_loop.default(function () {
      return outer.set('value', 3);
    });

    equal(view.$('#inner-value').text(), '3', 'third render of inner');
    equal(view.$('#middle-value').text(), '3', 'third render of middle');
  });

  QUnit.test('non-block with each rendering child components', function () {
    expect(2);

    registry.register('template:components/non-block', _emberTemplateCompilerSystemCompile.default('In layout. {{#each attrs.items as |item|}}[{{child-non-block item=item}}]{{/each}}'));
    registry.register('template:components/child-non-block', _emberTemplateCompilerSystemCompile.default('Child: {{attrs.item}}.'));

    var items = _emberMetalCore.default.A(['Tom', 'Dick', 'Harry']);

    view = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('{{non-block items=view.items}}'),
      container: container,
      items: items
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    equal(_emberViewsSystemJquery.default('#qunit-fixture').text(), 'In layout. [Child: Tom.][Child: Dick.][Child: Harry.]');

    _emberMetalRun_loop.default(function () {
      items.pushObject('James');
    });

    equal(_emberViewsSystemJquery.default('#qunit-fixture').text(), 'In layout. [Child: Tom.][Child: Dick.][Child: Harry.][Child: James.]');
  });

  QUnit.test('specifying classNames results in correct class', function (assert) {
    expect(1);

    registry.register('component:some-clicky-thing', _emberViewsViewsComponent.default.extend({
      tagName: 'button',
      classNames: ['foo', 'bar'],
      click: function () {
        assert.ok(true, 'click was fired!');
      }
    }));

    view = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('{{#some-clicky-thing classNames="baz"}}Click Me{{/some-clicky-thing}}'),
      container: container
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    var button = view.$('button');
    ok(button.is('.foo.bar.baz.ember-view'), 'the element has the correct classes: ' + button.attr('class'));
  });

  QUnit.test('specifying custom concatenatedProperties avoids clobbering', function (assert) {
    expect(1);

    var clickyThing = undefined;
    registry.register('component:some-clicky-thing', _emberViewsViewsComponent.default.extend({
      concatenatedProperties: ['blahzz'],
      blahzz: ['blark', 'pory'],
      init: function () {
        this._super.apply(this, arguments);
        clickyThing = this;
      }
    }));

    view = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('{{#some-clicky-thing blahzz="baz"}}Click Me{{/some-clicky-thing}}'),
      container: container
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    assert.deepEqual(clickyThing.get('blahzz'), ['blark', 'pory', 'baz'], 'property is properly combined');
  });

  // jscs:disable validateIndentation
});

//equal(jQuery('#qunit-fixture').text(), 'In layout - someProp: something here');
enifed('ember-htmlbars/tests/integration/component_invocation_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/integration');
  test('ember-htmlbars/tests/integration/component_invocation_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/integration/component_invocation_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/integration/component_invocation_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/integration');
  QUnit.test('ember-htmlbars/tests/integration/component_invocation_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/integration/component_invocation_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/integration/component_lifecycle_test', ['exports', 'container/registry', 'ember-views/system/jquery', 'ember-template-compiler/system/compile', 'ember-views/component_lookup', 'ember-views/views/component', 'ember-runtime/tests/utils', 'ember-metal/run_loop', 'ember-views/views/view'], function (exports, _containerRegistry, _emberViewsSystemJquery, _emberTemplateCompilerSystemCompile, _emberViewsComponent_lookup, _emberViewsViewsComponent, _emberRuntimeTestsUtils, _emberMetalRun_loop, _emberViewsViewsView) {
  'use strict';

  var registry, container, view;
  var hooks;

  QUnit.module('component - lifecycle hooks', {
    setup: function () {
      registry = new _containerRegistry.default();
      container = registry.container();
      registry.optionsForType('component', { singleton: false });
      registry.optionsForType('view', { singleton: false });
      registry.optionsForType('template', { instantiate: false });
      registry.register('component-lookup:main', _emberViewsComponent_lookup.default);

      hooks = [];
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(container);
      _emberRuntimeTestsUtils.runDestroy(view);
      registry = container = view = null;
    }
  });

  function pushHook(view, type, arg) {
    hooks.push(hook(view, type, arg));
  }

  function hook(view, type, arg) {
    return { type: type, view: view, arg: arg };
  }

  QUnit.test('lifecycle hooks are invoked in a predictable order', function () {
    var components = {};

    function component(label) {
      return _emberViewsViewsComponent.default.extend({
        init: function () {
          this.label = label;
          components[label] = this;
          this._super.apply(this, arguments);
        },

        didInitAttrs: function (options) {
          pushHook(label, 'didInitAttrs', options);
        },

        didUpdateAttrs: function (options) {
          pushHook(label, 'didUpdateAttrs', options);
        },

        willUpdate: function (options) {
          pushHook(label, 'willUpdate', options);
        },

        didReceiveAttrs: function (options) {
          pushHook(label, 'didReceiveAttrs', options);
        },

        willRender: function () {
          pushHook(label, 'willRender');
        },

        didRender: function () {
          pushHook(label, 'didRender');
        },

        didInsertElement: function () {
          pushHook(label, 'didInsertElement');
        },

        didUpdate: function (options) {
          pushHook(label, 'didUpdate', options);
        }
      });
    }

    registry.register('component:the-top', component('top'));
    registry.register('component:the-middle', component('middle'));
    registry.register('component:the-bottom', component('bottom'));

    registry.register('template:components/the-top', _emberTemplateCompilerSystemCompile.default('Twitter: {{attrs.twitter}} {{the-middle name="Tom Dale"}}'));
    registry.register('template:components/the-middle', _emberTemplateCompilerSystemCompile.default('Name: {{attrs.name}} {{the-bottom website="tomdale.net"}}'));
    registry.register('template:components/the-bottom', _emberTemplateCompilerSystemCompile.default('Website: {{attrs.website}}'));

    view = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('{{the-top twitter=(readonly view.twitter)}}'),
      twitter: '@tomdale',
      container: container
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    ok(component, 'The component was inserted');
    equal(_emberViewsSystemJquery.default('#qunit-fixture').text(), 'Twitter: @tomdale Name: Tom Dale Website: tomdale.net');

    var topAttrs = { twitter: '@tomdale' };
    var middleAttrs = { name: 'Tom Dale' };
    var bottomAttrs = { website: 'tomdale.net' };

    deepEqual(hooks, [hook('top', 'didInitAttrs', { attrs: topAttrs }), hook('top', 'didReceiveAttrs', { newAttrs: topAttrs }), hook('top', 'willRender'), hook('middle', 'didInitAttrs', { attrs: middleAttrs }), hook('middle', 'didReceiveAttrs', { newAttrs: middleAttrs }), hook('middle', 'willRender'), hook('bottom', 'didInitAttrs', { attrs: bottomAttrs }), hook('bottom', 'didReceiveAttrs', { newAttrs: bottomAttrs }), hook('bottom', 'willRender'), hook('bottom', 'didInsertElement'), hook('bottom', 'didRender'), hook('middle', 'didInsertElement'), hook('middle', 'didRender'), hook('top', 'didInsertElement'), hook('top', 'didRender')]);

    hooks = [];

    _emberMetalRun_loop.default(function () {
      components.bottom.rerender();
    });

    deepEqual(hooks, [hook('bottom', 'willUpdate'), hook('bottom', 'willRender'), hook('bottom', 'didUpdate'), hook('bottom', 'didRender')]);

    hooks = [];

    _emberMetalRun_loop.default(function () {
      components.middle.rerender();
    });

    bottomAttrs = { oldAttrs: { website: 'tomdale.net' }, newAttrs: { website: 'tomdale.net' } };

    deepEqual(hooks, [hook('middle', 'willUpdate'), hook('middle', 'willRender'), hook('bottom', 'didUpdateAttrs', bottomAttrs), hook('bottom', 'didReceiveAttrs', bottomAttrs), hook('bottom', 'willUpdate'), hook('bottom', 'willRender'), hook('bottom', 'didUpdate'), hook('bottom', 'didRender'), hook('middle', 'didUpdate'), hook('middle', 'didRender')]);

    hooks = [];

    _emberMetalRun_loop.default(function () {
      components.top.rerender();
    });

    middleAttrs = { oldAttrs: { name: 'Tom Dale' }, newAttrs: { name: 'Tom Dale' } };

    deepEqual(hooks, [hook('top', 'willUpdate'), hook('top', 'willRender'), hook('middle', 'didUpdateAttrs', middleAttrs), hook('middle', 'didReceiveAttrs', middleAttrs), hook('middle', 'willUpdate'), hook('middle', 'willRender'), hook('bottom', 'didUpdateAttrs', bottomAttrs), hook('bottom', 'didReceiveAttrs', bottomAttrs), hook('bottom', 'willUpdate'), hook('bottom', 'willRender'), hook('bottom', 'didUpdate'), hook('bottom', 'didRender'), hook('middle', 'didUpdate'), hook('middle', 'didRender'), hook('top', 'didUpdate'), hook('top', 'didRender')]);

    hooks = [];

    _emberMetalRun_loop.default(function () {
      view.set('twitter', '@hipstertomdale');
    });

    // Because the `twitter` attr is only used by the topmost component,
    // and not passed down, we do not expect to see lifecycle hooks
    // called for child components. If the `didReceiveAttrs` hook used
    // the new attribute to rerender itself imperatively, that would result
    // in lifecycle hooks being invoked for the child.

    deepEqual(hooks, [hook('top', 'didUpdateAttrs', { oldAttrs: { twitter: '@tomdale' }, newAttrs: { twitter: '@hipstertomdale' } }), hook('top', 'didReceiveAttrs', { oldAttrs: { twitter: '@tomdale' }, newAttrs: { twitter: '@hipstertomdale' } }), hook('top', 'willUpdate'), hook('top', 'willRender'), hook('top', 'didUpdate'), hook('top', 'didRender')]);
  });

  QUnit.test('passing values through attrs causes lifecycle hooks to fire if the attribute values have changed', function () {
    var components = {};

    function component(label) {
      return _emberViewsViewsComponent.default.extend({
        init: function () {
          this.label = label;
          components[label] = this;
          this._super.apply(this, arguments);
        },

        didInitAttrs: function (options) {
          pushHook(label, 'didInitAttrs', options);
        },

        didUpdateAttrs: function (options) {
          pushHook(label, 'didUpdateAttrs', options);
        },

        willUpdate: function (options) {
          pushHook(label, 'willUpdate', options);
        },

        didReceiveAttrs: function (options) {
          pushHook(label, 'didReceiveAttrs', options);
        },

        willRender: function () {
          pushHook(label, 'willRender');
        },

        didRender: function () {
          pushHook(label, 'didRender');
        },

        didInsertElement: function () {
          pushHook(label, 'didInsertElement');
        },

        didUpdate: function (options) {
          pushHook(label, 'didUpdate', options);
        }
      });
    }

    registry.register('component:the-top', component('top'));
    registry.register('component:the-middle', component('middle'));
    registry.register('component:the-bottom', component('bottom'));

    registry.register('template:components/the-top', _emberTemplateCompilerSystemCompile.default('Top: {{the-middle twitterTop=(readonly attrs.twitter)}}'));
    registry.register('template:components/the-middle', _emberTemplateCompilerSystemCompile.default('Middle: {{the-bottom twitterMiddle=(readonly attrs.twitterTop)}}'));
    registry.register('template:components/the-bottom', _emberTemplateCompilerSystemCompile.default('Bottom: {{attrs.twitterMiddle}}'));

    view = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('{{the-top twitter=(readonly view.twitter)}}'),
      twitter: '@tomdale',
      container: container
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    ok(component, 'The component was inserted');
    equal(_emberViewsSystemJquery.default('#qunit-fixture').text(), 'Top: Middle: Bottom: @tomdale');

    var topAttrs = { twitter: '@tomdale' };
    var middleAttrs = { twitterTop: '@tomdale' };
    var bottomAttrs = { twitterMiddle: '@tomdale' };

    deepEqual(hooks, [hook('top', 'didInitAttrs', { attrs: topAttrs }), hook('top', 'didReceiveAttrs', { newAttrs: topAttrs }), hook('top', 'willRender'), hook('middle', 'didInitAttrs', { attrs: middleAttrs }), hook('middle', 'didReceiveAttrs', { newAttrs: middleAttrs }), hook('middle', 'willRender'), hook('bottom', 'didInitAttrs', { attrs: bottomAttrs }), hook('bottom', 'didReceiveAttrs', { newAttrs: bottomAttrs }), hook('bottom', 'willRender'), hook('bottom', 'didInsertElement'), hook('bottom', 'didRender'), hook('middle', 'didInsertElement'), hook('middle', 'didRender'), hook('top', 'didInsertElement'), hook('top', 'didRender')]);

    hooks = [];

    _emberMetalRun_loop.default(function () {
      view.set('twitter', '@hipstertomdale');
    });

    // Because the `twitter` attr is used by the all of the components,
    // the lifecycle hooks are invoked for all components.

    topAttrs = { oldAttrs: { twitter: '@tomdale' }, newAttrs: { twitter: '@hipstertomdale' } };
    middleAttrs = { oldAttrs: { twitterTop: '@tomdale' }, newAttrs: { twitterTop: '@hipstertomdale' } };
    bottomAttrs = { oldAttrs: { twitterMiddle: '@tomdale' }, newAttrs: { twitterMiddle: '@hipstertomdale' } };

    deepEqual(hooks, [hook('top', 'didUpdateAttrs', topAttrs), hook('top', 'didReceiveAttrs', topAttrs), hook('top', 'willUpdate'), hook('top', 'willRender'), hook('middle', 'didUpdateAttrs', middleAttrs), hook('middle', 'didReceiveAttrs', middleAttrs), hook('middle', 'willUpdate'), hook('middle', 'willRender'), hook('bottom', 'didUpdateAttrs', bottomAttrs), hook('bottom', 'didReceiveAttrs', bottomAttrs), hook('bottom', 'willUpdate'), hook('bottom', 'willRender'), hook('bottom', 'didUpdate'), hook('bottom', 'didRender'), hook('middle', 'didUpdate'), hook('middle', 'didRender'), hook('top', 'didUpdate'), hook('top', 'didRender')]);

    hooks = [];

    // In this case, because the attrs are passed down, all child components are invoked.

    _emberMetalRun_loop.default(function () {
      view.rerender();
    });

    topAttrs = { oldAttrs: { twitter: '@hipstertomdale' }, newAttrs: { twitter: '@hipstertomdale' } };
    middleAttrs = { oldAttrs: { twitterTop: '@hipstertomdale' }, newAttrs: { twitterTop: '@hipstertomdale' } };
    bottomAttrs = { oldAttrs: { twitterMiddle: '@hipstertomdale' }, newAttrs: { twitterMiddle: '@hipstertomdale' } };

    deepEqual(hooks, [hook('top', 'didUpdateAttrs', topAttrs), hook('top', 'didReceiveAttrs', topAttrs), hook('top', 'willUpdate'), hook('top', 'willRender'), hook('middle', 'didUpdateAttrs', middleAttrs), hook('middle', 'didReceiveAttrs', middleAttrs), hook('middle', 'willUpdate'), hook('middle', 'willRender'), hook('bottom', 'didUpdateAttrs', bottomAttrs), hook('bottom', 'didReceiveAttrs', bottomAttrs), hook('bottom', 'willUpdate'), hook('bottom', 'willRender'), hook('bottom', 'didUpdate'), hook('bottom', 'didRender'), hook('middle', 'didUpdate'), hook('middle', 'didRender'), hook('top', 'didUpdate'), hook('top', 'didRender')]);
  });

  QUnit.test('changing a component\'s displayed properties inside didInsertElement() is deprecated', function (assert) {
    var component = _emberViewsViewsComponent.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('{{handle}}'),
      handle: '@wycats',
      container: container,

      didInsertElement: function () {
        this.set('handle', '@tomdale');
      }
    }).create();

    expectDeprecation(function () {
      _emberRuntimeTestsUtils.runAppend(component);
    }, /modified inside the didInsertElement hook/);

    assert.strictEqual(component.$().text(), '@tomdale');

    _emberMetalRun_loop.default(function () {
      component.destroy();
    });
  });

  // TODO: Write a test that involves deep mutability: the component plucks something
  // from inside the attrs hash out into state and passes it as attrs into a child
  // component. The hooks should run correctly.
});
enifed('ember-htmlbars/tests/integration/component_lifecycle_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/integration');
  test('ember-htmlbars/tests/integration/component_lifecycle_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/integration/component_lifecycle_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/integration/component_lifecycle_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/integration');
  QUnit.test('ember-htmlbars/tests/integration/component_lifecycle_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/integration/component_lifecycle_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/integration/escape_integration_test', ['exports', 'ember-metal/run_loop', 'ember-views/views/view', 'ember-template-compiler/system/compile', 'ember-metal/property_set', 'ember-runtime/tests/utils'], function (exports, _emberMetalRun_loop, _emberViewsViewsView, _emberTemplateCompilerSystemCompile, _emberMetalProperty_set, _emberRuntimeTestsUtils) {
  'use strict';

  var view;

  QUnit.module('ember-htmlbars: Escaped Integration', {
    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(view);

      view = null;
    }
  });

  QUnit.test('should read from a global-ish simple local path without deprecation', function () {
    view = _emberViewsViewsView.default.create({
      context: { NotGlobal: 'Gwar' },
      template: _emberTemplateCompilerSystemCompile.default('{{NotGlobal}}')
    });

    expectNoDeprecation();
    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'Gwar');
  });

  QUnit.test('should read a number value', function () {
    var context = { aNumber: 1 };
    view = _emberViewsViewsView.default.create({
      context: context,
      template: _emberTemplateCompilerSystemCompile.default('{{aNumber}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);
    equal(view.$().text(), '1');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(context, 'aNumber', 2);
    });

    equal(view.$().text(), '2');
  });

  QUnit.test('should read an escaped number value', function () {
    var context = { aNumber: 1 };
    view = _emberViewsViewsView.default.create({
      context: context,
      template: _emberTemplateCompilerSystemCompile.default('{{{aNumber}}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);
    equal(view.$().text(), '1');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(context, 'aNumber', 2);
    });

    equal(view.$().text(), '2');
  });

  QUnit.test('should read from an Object.create(null)', function () {
    // Use ember's polyfill for Object.create
    var nullObject = Object.create(null);
    nullObject['foo'] = 'bar';
    view = _emberViewsViewsView.default.create({
      context: { nullObject: nullObject },
      template: _emberTemplateCompilerSystemCompile.default('{{nullObject.foo}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);
    equal(view.$().text(), 'bar');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(nullObject, 'foo', 'baz');
    });

    equal(view.$().text(), 'baz');
  });

  QUnit.test('should escape HTML in primitive value contexts when using normal mustaches', function () {
    view = _emberViewsViewsView.default.create({
      context: '<b>Max</b><b>James</b>',
      template: _emberTemplateCompilerSystemCompile.default('{{this}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('b').length, 0, 'does not create an element');
    equal(view.$().text(), '<b>Max</b><b>James</b>', 'inserts entities, not elements');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'context', '<i>Max</i><i>James</i>');
    });

    equal(view.$().text(), '<i>Max</i><i>James</i>', 'updates with entities, not elements');
    equal(view.$('i').length, 0, 'does not create an element when value is updated');
  });

  QUnit.test('should not escape HTML in primitive value contexts when using triple mustaches', function () {
    view = _emberViewsViewsView.default.create({
      context: '<b>Max</b><b>James</b>',
      template: _emberTemplateCompilerSystemCompile.default('{{{this}}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('b').length, 2, 'creates an element');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'context', '<i>Max</i><i>James</i>');
    });

    equal(view.$('i').length, 2, 'creates an element when value is updated');
  });
});
enifed('ember-htmlbars/tests/integration/escape_integration_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/integration');
  test('ember-htmlbars/tests/integration/escape_integration_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/integration/escape_integration_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/integration/escape_integration_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/integration');
  QUnit.test('ember-htmlbars/tests/integration/escape_integration_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/integration/escape_integration_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/integration/helper-lookup-test', ['exports', 'ember-metal/features', 'container/registry', 'ember-template-compiler/system/compile', 'ember-views/component_lookup', 'ember-views/views/component', 'ember-htmlbars/helper', 'ember-runtime/tests/utils'], function (exports, _emberMetalFeatures, _containerRegistry, _emberTemplateCompilerSystemCompile, _emberViewsComponent_lookup, _emberViewsViewsComponent, _emberHtmlbarsHelper, _emberRuntimeTestsUtils) {
  'use strict';

  var registry, container, component;

  QUnit.module('component - invocation', {
    setup: function () {
      registry = new _containerRegistry.default();
      container = registry.container();
      registry.optionsForType('component', { singleton: false });
      registry.optionsForType('view', { singleton: false });
      registry.optionsForType('template', { instantiate: false });
      registry.optionsForType('helper', { instantiate: false });
      registry.register('component-lookup:main', _emberViewsComponent_lookup.default);
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(container);
      _emberRuntimeTestsUtils.runDestroy(component);
      registry = container = component = null;
    }
  });

  QUnit.test('non-dashed helpers are found', function () {
    expect(1);

    registry.register('helper:fullname', _emberHtmlbarsHelper.helper(function (_ref) {
      var first = _ref[0];
      var last = _ref[1];

      return first + ' ' + last;
    }));

    component = _emberViewsViewsComponent.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('{{fullname "Robert" "Jackson"}}'),
      container: container
    }).create();

    _emberRuntimeTestsUtils.runAppend(component);

    equal(component.$().text(), 'Robert Jackson');
  });
});
enifed('ember-htmlbars/tests/integration/helper-lookup-test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/integration');
  test('ember-htmlbars/tests/integration/helper-lookup-test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/integration/helper-lookup-test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/integration/helper-lookup-test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/integration');
  QUnit.test('ember-htmlbars/tests/integration/helper-lookup-test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/integration/helper-lookup-test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/integration/mutable_binding_test', ['exports', 'ember-metal/features', 'ember-views/views/view', 'container/registry', 'ember-template-compiler/system/compile', 'ember-views/component_lookup', 'ember-views/views/component', 'ember-runtime/tests/utils', 'ember-metal/run_loop', 'ember-metal/computed'], function (exports, _emberMetalFeatures, _emberViewsViewsView, _containerRegistry, _emberTemplateCompilerSystemCompile, _emberViewsComponent_lookup, _emberViewsViewsComponent, _emberRuntimeTestsUtils, _emberMetalRun_loop, _emberMetalComputed) {
  'use strict';

  var registry, container, view;

  QUnit.module('component - mutable bindings', {
    setup: function () {
      registry = new _containerRegistry.default();
      container = registry.container();
      registry.optionsForType('component', { singleton: false });
      registry.optionsForType('view', { singleton: false });
      registry.optionsForType('template', { instantiate: false });
      registry.register('component-lookup:main', _emberViewsComponent_lookup.default);
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(container);
      _emberRuntimeTestsUtils.runDestroy(view);
      registry = container = view = null;
    }
  });

  QUnit.test('a simple mutable binding propagates properly [DEPRECATED]', function (assert) {
    // TODO: attrs
    // expectDeprecation();

    var bottom;

    registry.register('component:middle-mut', _emberViewsViewsComponent.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('{{bottom-mut setMe=value}}')
    }));

    registry.register('component:bottom-mut', _emberViewsViewsComponent.default.extend({
      didInsertElement: function () {
        bottom = this;
      }
    }));

    view = _emberViewsViewsView.default.create({
      container: container,
      template: _emberTemplateCompilerSystemCompile.default('{{middle-mut value=view.val}}'),
      val: 12
    });

    _emberRuntimeTestsUtils.runAppend(view);

    assert.strictEqual(bottom.get('setMe'), 12, 'precond - the data propagated');

    _emberMetalRun_loop.default(function () {
      return bottom.set('setMe', 13);
    });

    assert.strictEqual(bottom.get('setMe'), 13, 'precond - the set took effect');
    assert.strictEqual(view.get('val'), 13, 'the set propagated back up');
  });

  QUnit.test('a simple mutable binding using `mut` propagates properly', function (assert) {
    var bottom;

    registry.register('component:middle-mut', _emberViewsViewsComponent.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('{{bottom-mut setMe=(mut attrs.value)}}')
    }));

    registry.register('component:bottom-mut', _emberViewsViewsComponent.default.extend({
      didInsertElement: function () {
        bottom = this;
      }
    }));

    view = _emberViewsViewsView.default.create({
      container: container,
      template: _emberTemplateCompilerSystemCompile.default('{{middle-mut value=(mut view.val)}}'),
      val: 12
    });

    _emberRuntimeTestsUtils.runAppend(view);

    assert.strictEqual(bottom.attrs.setMe.value, 12, 'precond - the data propagated');

    _emberMetalRun_loop.default(function () {
      return bottom.attrs.setMe.update(13);
    });

    assert.strictEqual(bottom.attrs.setMe.value, 13, 'precond - the set took effect');
    assert.strictEqual(view.get('val'), 13, 'the set propagated back up');
  });

  QUnit.test('using a string value through middle tier does not trigger assertion', function (assert) {
    var bottom;

    registry.register('component:middle-mut', _emberViewsViewsComponent.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('{{bottom-mut stuff=attrs.value}}')
    }));

    registry.register('component:bottom-mut', _emberViewsViewsComponent.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('<p class="bottom">{{attrs.stuff}}</p>'),
      didInsertElement: function () {
        bottom = this;
      }
    }));

    view = _emberViewsViewsView.default.create({
      container: container,
      template: _emberTemplateCompilerSystemCompile.default('{{middle-mut value="foo"}}'),
      val: 12
    });

    _emberRuntimeTestsUtils.runAppend(view);

    assert.strictEqual(bottom.attrs.stuff.value, 'foo', 'precond - the data propagated');
    assert.strictEqual(view.$('p.bottom').text(), 'foo');
  });

  QUnit.test('a simple mutable binding using `mut` inserts into the DOM', function (assert) {
    var bottom;

    registry.register('component:middle-mut', _emberViewsViewsComponent.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('{{bottom-mut setMe=(mut attrs.value)}}')
    }));

    registry.register('component:bottom-mut', _emberViewsViewsComponent.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('<p class="bottom">{{attrs.setMe}}</p>'),
      didInsertElement: function () {
        bottom = this;
      }
    }));

    view = _emberViewsViewsView.default.create({
      container: container,
      template: _emberTemplateCompilerSystemCompile.default('{{middle-mut value=(mut view.val)}}'),
      val: 12
    });

    _emberRuntimeTestsUtils.runAppend(view);

    assert.strictEqual(view.$('p.bottom').text(), '12');
    assert.strictEqual(bottom.attrs.setMe.value, 12, 'precond - the data propagated');

    _emberMetalRun_loop.default(function () {
      return bottom.attrs.setMe.update(13);
    });

    assert.strictEqual(bottom.attrs.setMe.value, 13, 'precond - the set took effect');
    assert.strictEqual(view.get('val'), 13, 'the set propagated back up');
  });

  QUnit.test('a simple mutable binding using `mut` can be converted into an immutable binding', function (assert) {
    var middle, bottom;

    registry.register('component:middle-mut', _emberViewsViewsComponent.default.extend({
      // no longer mutable
      layout: _emberTemplateCompilerSystemCompile.default('{{bottom-mut setMe=(readonly attrs.value)}}'),

      didInsertElement: function () {
        middle = this;
      }
    }));

    registry.register('component:bottom-mut', _emberViewsViewsComponent.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('<p class="bottom">{{attrs.setMe}}</p>'),

      didInsertElement: function () {
        bottom = this;
      }
    }));

    view = _emberViewsViewsView.default.create({
      container: container,
      template: _emberTemplateCompilerSystemCompile.default('{{middle-mut value=(mut view.val)}}'),
      val: 12
    });

    _emberRuntimeTestsUtils.runAppend(view);

    assert.strictEqual(view.$('p.bottom').text(), '12');

    _emberMetalRun_loop.default(function () {
      return middle.attrs.value.update(13);
    });

    assert.strictEqual(middle.attrs.value.value, 13, 'precond - the set took effect');
    assert.strictEqual(bottom.attrs.setMe, 13, 'the mutable binding has been converted to an immutable cell');
    assert.strictEqual(view.$('p.bottom').text(), '13');
    assert.strictEqual(view.get('val'), 13, 'the set propagated back up');
  });

  QUnit.test('mutable bindings work inside of yielded content', function (assert) {
    registry.register('component:middle-mut', _emberViewsViewsComponent.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('{{#bottom-mut}}{{attrs.model.name}}{{/bottom-mut}}')
    }));

    registry.register('component:bottom-mut', _emberViewsViewsComponent.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('<p class="bottom">{{yield}}</p>')
    }));

    view = _emberViewsViewsView.default.create({
      container: container,
      template: _emberTemplateCompilerSystemCompile.default('{{middle-mut model=(mut view.model)}}'),
      model: { name: 'Matthew Beale' }
    });

    _emberRuntimeTestsUtils.runAppend(view);

    assert.strictEqual(view.$('p.bottom').text(), 'Matthew Beale');
  });

  QUnit.test('a simple mutable binding using `mut` is available in hooks', function (assert) {
    var bottom;
    var willRender = [];
    var didInsert = [];

    registry.register('component:middle-mut', _emberViewsViewsComponent.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('{{bottom-mut setMe=(mut attrs.value)}}')
    }));

    registry.register('component:bottom-mut', _emberViewsViewsComponent.default.extend({
      willRender: function () {
        willRender.push(this.attrs.setMe.value);
      },
      didInsertElement: function () {
        didInsert.push(this.attrs.setMe.value);
        bottom = this;
      }
    }));

    view = _emberViewsViewsView.default.create({
      container: container,
      template: _emberTemplateCompilerSystemCompile.default('{{middle-mut value=(mut view.val)}}'),
      val: 12
    });

    _emberRuntimeTestsUtils.runAppend(view);

    assert.deepEqual(willRender, [12], 'willReceive is [12]');
    assert.deepEqual(didInsert, [12], 'didInsert is [12]');

    assert.strictEqual(bottom.attrs.setMe.value, 12, 'precond - the data propagated');

    _emberMetalRun_loop.default(function () {
      return bottom.attrs.setMe.update(13);
    });

    assert.strictEqual(bottom.attrs.setMe.value, 13, 'precond - the set took effect');
    assert.strictEqual(view.get('val'), 13, 'the set propagated back up');
  });

  QUnit.test('a mutable binding with a backing computed property and attribute present in the root of the component is updated when the upstream property invalidates #11023', function (assert) {
    var bottom;

    registry.register('component:bottom-mut', _emberViewsViewsComponent.default.extend({
      thingy: null,

      didInsertElement: function () {
        bottom = this;
      }
    }));

    view = _emberViewsViewsView.default.extend({
      container: container,
      template: _emberTemplateCompilerSystemCompile.default('{{bottom-mut thingy=(mut view.val)}}'),
      baseValue: 12,
      val: _emberMetalComputed.computed('baseValue', function () {
        return this.get('baseValue');
      })
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    assert.strictEqual(bottom.attrs.thingy.value, 12, 'data propagated');

    _emberMetalRun_loop.default(function () {
      return view.set('baseValue', 13);
    });
    assert.strictEqual(bottom.attrs.thingy.value, 13, 'the set took effect');

    _emberMetalRun_loop.default(function () {
      return view.set('baseValue', 14);
    });
    assert.strictEqual(bottom.attrs.thingy.value, 14, 'the set took effect');
  });

  QUnit.test('automatic mutable bindings tolerate undefined non-stream inputs', function (assert) {
    registry.register('template:components/x-outer', _emberTemplateCompilerSystemCompile.default('{{x-inner model=attrs.nonexistent}}'));
    registry.register('template:components/x-inner', _emberTemplateCompilerSystemCompile.default('hello'));

    view = _emberViewsViewsView.default.create({
      container: container,
      template: _emberTemplateCompilerSystemCompile.default('{{x-outer}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);
    assert.strictEqual(view.$().text(), 'hello');
  });

  QUnit.test('automatic mutable bindings tolerate constant non-stream inputs', function (assert) {
    registry.register('template:components/x-outer', _emberTemplateCompilerSystemCompile.default('{{x-inner model="foo"}}'));
    registry.register('template:components/x-inner', _emberTemplateCompilerSystemCompile.default('hello{{attrs.model}}'));

    view = _emberViewsViewsView.default.create({
      container: container,
      template: _emberTemplateCompilerSystemCompile.default('{{x-outer}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);
    assert.strictEqual(view.$().text(), 'hellofoo');
  });

  QUnit.test('automatic mutable bindings to undefined non-streams tolerate attempts to set them', function (assert) {
    var inner;

    registry.register('template:components/x-outer', _emberTemplateCompilerSystemCompile.default('{{x-inner model=attrs.nonexistent}}'));
    registry.register('component:x-inner', _emberViewsViewsComponent.default.extend({
      didInsertElement: function () {
        inner = this;
      }
    }));

    view = _emberViewsViewsView.default.create({
      container: container,
      template: _emberTemplateCompilerSystemCompile.default('{{x-outer}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);
    _emberMetalRun_loop.default(function () {
      return inner.attrs.model.update(42);
    });
    assert.equal(inner.attrs.model.value, 42);
  });

  // jscs:enable validateIndentation
  QUnit.test('automatic mutable bindings to constant non-streams tolerate attempts to set them', function (assert) {
    var inner;

    registry.register('template:components/x-outer', _emberTemplateCompilerSystemCompile.default('{{x-inner model=attrs.x}}'));
    registry.register('component:x-inner', _emberViewsViewsComponent.default.extend({
      didInsertElement: function () {
        inner = this;
      }
    }));

    view = _emberViewsViewsView.default.create({
      container: container,
      template: _emberTemplateCompilerSystemCompile.default('{{x-outer x="foo"}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);
    _emberMetalRun_loop.default(function () {
      return inner.attrs.model.update(42);
    });
    assert.equal(inner.attrs.model.value, 42);
  });

  // jscs:disable validateIndentation
});

//import jQuery from "ember-views/system/jquery";

// no longer mutable

// no longer mutable
enifed('ember-htmlbars/tests/integration/mutable_binding_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/integration');
  test('ember-htmlbars/tests/integration/mutable_binding_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/integration/mutable_binding_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/integration/mutable_binding_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/integration');
  QUnit.test('ember-htmlbars/tests/integration/mutable_binding_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/integration/mutable_binding_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/integration/select_in_template_test', ['exports', 'ember-metal/core', 'ember-runtime/system/object', 'ember-metal/run_loop', 'ember-views/views/view', 'ember-views/system/event_dispatcher', 'ember-metal/computed', 'ember-runtime/system/namespace', 'ember-runtime/system/array_proxy', 'ember-views/views/select', 'ember-template-compiler/system/compile', 'ember-runtime/controllers/controller', 'ember-runtime/tests/utils', 'ember-htmlbars/tests/utils', 'ember-htmlbars/keywords/view'], function (exports, _emberMetalCore, _emberRuntimeSystemObject, _emberMetalRun_loop, _emberViewsViewsView, _emberViewsSystemEvent_dispatcher, _emberMetalComputed, _emberRuntimeSystemNamespace, _emberRuntimeSystemArray_proxy, _emberViewsViewsSelect, _emberTemplateCompilerSystemCompile, _emberRuntimeControllersController, _emberRuntimeTestsUtils, _emberHtmlbarsTestsUtils, _emberHtmlbarsKeywordsView) {
  'use strict';

  var dispatcher, view, originalViewKeyword;

  QUnit.module('ember-htmlbars: Ember.Select - usage inside templates', {
    setup: function () {
      originalViewKeyword = _emberHtmlbarsTestsUtils.registerKeyword('view', _emberHtmlbarsKeywordsView.default);
      dispatcher = _emberViewsSystemEvent_dispatcher.default.create();
      dispatcher.setup();
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(dispatcher);
      _emberRuntimeTestsUtils.runDestroy(view);
      _emberHtmlbarsTestsUtils.resetKeyword('view', originalViewKeyword);
    }
  });

  QUnit.test('works from a template with bindings [DEPRECATED]', function () {
    var Person = _emberRuntimeSystemObject.default.extend({
      id: null,
      firstName: null,
      lastName: null,

      fullName: _emberMetalComputed.computed(function () {
        return this.get('firstName') + ' ' + this.get('lastName');
      }).property('firstName', 'lastName')
    });

    var erik = Person.create({ id: 4, firstName: 'Erik', lastName: 'Bryn' });

    var application = _emberRuntimeSystemNamespace.default.create();

    application.peopleController = _emberRuntimeControllersController.default.create({
      content: _emberMetalCore.default.A([Person.create({ id: 1, firstName: 'Yehuda', lastName: 'Katz' }), Person.create({ id: 2, firstName: 'Tom', lastName: 'Dale' }), Person.create({ id: 3, firstName: 'Peter', lastName: 'Wagenet' }), erik])
    });

    application.selectedPersonController = _emberRuntimeSystemObject.default.create({
      person: null
    });

    view = _emberViewsViewsView.default.create({
      app: application,
      selectView: _emberViewsViewsSelect.default,
      template: _emberTemplateCompilerSystemCompile.default('{{view view.selectView viewName="select"' + '    content=view.app.peopleController.content' + '    optionLabelPath="content.fullName"' + '    optionValuePath="content.id"' + '    prompt="Pick a person:"' + '    selection=view.app.selectedPersonController.person}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    var select = view.get('select');
    ok(select.$().length, 'Select was rendered');
    equal(select.$('option').length, 5, 'Options were rendered');
    equal(select.$().text(), 'Pick a person:Yehuda KatzTom DalePeter WagenetErik Bryn\n', 'Option values were rendered');
    equal(select.get('selection'), null, 'Nothing has been selected');

    _emberMetalRun_loop.default(function () {
      application.selectedPersonController.set('person', erik);
    });

    equal(select.get('selection'), erik, 'Selection was updated through binding');
    _emberMetalRun_loop.default(function () {
      application.peopleController.get('content').pushObject(Person.create({ id: 5, firstName: 'James', lastName: 'Rosen' }));
    });

    equal(select.$('option').length, 6, 'New option was added');
    equal(select.get('selection'), erik, 'Selection was maintained after new option was added');
  });

  QUnit.test('works from a template', function () {
    var Person = _emberRuntimeSystemObject.default.extend({
      id: null,
      firstName: null,
      lastName: null,

      fullName: _emberMetalComputed.computed(function () {
        return this.get('firstName') + ' ' + this.get('lastName');
      }).property('firstName', 'lastName')
    });

    var erik = Person.create({ id: 4, firstName: 'Erik', lastName: 'Bryn' });

    var application = _emberRuntimeSystemNamespace.default.create();

    application.peopleController = _emberRuntimeControllersController.default.create({
      content: _emberMetalCore.default.A([Person.create({ id: 1, firstName: 'Yehuda', lastName: 'Katz' }), Person.create({ id: 2, firstName: 'Tom', lastName: 'Dale' }), Person.create({ id: 3, firstName: 'Peter', lastName: 'Wagenet' }), erik])
    });

    application.selectedPersonController = _emberRuntimeSystemObject.default.create({
      person: null
    });

    view = _emberViewsViewsView.default.create({
      app: application,
      selectView: _emberViewsViewsSelect.default,
      template: _emberTemplateCompilerSystemCompile.default('{{view view.selectView viewName="select"' + '    content=view.app.peopleController.content' + '    optionLabelPath="content.fullName"' + '    optionValuePath="content.id"' + '    prompt="Pick a person:"' + '    selection=view.app.selectedPersonController.person}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    var select = view.get('select');
    ok(select.$().length, 'Select was rendered');
    equal(select.$('option').length, 5, 'Options were rendered');
    equal(select.$().text(), 'Pick a person:Yehuda KatzTom DalePeter WagenetErik Bryn\n', 'Option values were rendered');
    equal(select.get('selection'), null, 'Nothing has been selected');

    _emberMetalRun_loop.default(function () {
      application.selectedPersonController.set('person', erik);
    });

    equal(select.get('selection'), erik, 'Selection was updated through binding');
    _emberMetalRun_loop.default(function () {
      application.peopleController.get('content').pushObject(Person.create({ id: 5, firstName: 'James', lastName: 'Rosen' }));
    });

    equal(select.$('option').length, 6, 'New option was added');
    equal(select.get('selection'), erik, 'Selection was maintained after new option was added');
  });

  QUnit.test('upon content change, the DOM should reflect the selection (#481)', function () {
    var userOne = { name: 'Mike', options: _emberMetalCore.default.A(['a', 'b']), selectedOption: 'a' };
    var userTwo = { name: 'John', options: _emberMetalCore.default.A(['c', 'd']), selectedOption: 'd' };

    view = _emberViewsViewsView.default.create({
      user: userOne,
      selectView: _emberViewsViewsSelect.default,
      template: _emberTemplateCompilerSystemCompile.default('{{view view.selectView viewName="select"' + '    content=view.user.options' + '    selection=view.user.selectedOption}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    var select = view.get('select');
    var selectEl = select.$()[0];

    equal(select.get('selection'), 'a', 'Precond: Initial selection is correct');
    equal(selectEl.selectedIndex, 0, 'Precond: The DOM reflects the correct selection');

    _emberMetalRun_loop.default(function () {
      view.set('user', userTwo);
    });

    equal(select.get('selection'), 'd', 'Selection was properly set after content change');
    equal(selectEl.selectedIndex, 1, 'The DOM reflects the correct selection');
  });

  QUnit.test('upon content change with Array-like content, the DOM should reflect the selection', function () {
    var tom = { id: 4, name: 'Tom' };
    var sylvain = { id: 5, name: 'Sylvain' };

    var proxy = _emberRuntimeSystemArray_proxy.default.create({
      content: _emberMetalCore.default.A(),
      selectedOption: sylvain
    });

    view = _emberViewsViewsView.default.create({
      proxy: proxy,
      selectView: _emberViewsViewsSelect.default,
      template: _emberTemplateCompilerSystemCompile.default('{{view view.selectView viewName="select"' + '    content=view.proxy' + '    selection=view.proxy.selectedOption}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    var select = view.get('select');
    var selectEl = select.$()[0];

    equal(selectEl.selectedIndex, -1, 'Precond: The DOM reflects the lack of selection');

    _emberMetalRun_loop.default(function () {
      proxy.set('content', _emberMetalCore.default.A([tom, sylvain]));
    });

    equal(select.get('selection'), sylvain, 'Selection was properly set after content change');
    equal(selectEl.selectedIndex, 1, 'The DOM reflects the correct selection');
  });

  function testValueBinding(templateString) {
    view = _emberViewsViewsView.default.create({
      collection: _emberMetalCore.default.A([{ name: 'Wes', value: 'w' }, { name: 'Gordon', value: 'g' }]),
      val: 'g',
      selectView: _emberViewsViewsSelect.default,
      template: _emberTemplateCompilerSystemCompile.default(templateString)
    });

    _emberRuntimeTestsUtils.runAppend(view);

    var select = view.get('select');
    var selectEl = select.$()[0];

    equal(view.get('val'), 'g', 'Precond: Initial bound property is correct');
    equal(select.get('value'), 'g', 'Precond: Initial selection is correct');
    equal(selectEl.selectedIndex, 2, 'Precond: The DOM reflects the correct selection');

    select.$('option:eq(2)').removeAttr('selected');
    select.$('option:eq(1)').prop('selected', true);
    select.$().trigger('change');

    equal(view.get('val'), 'w', 'Updated bound property is correct');
    equal(select.get('value'), 'w', 'Updated selection is correct');
    equal(selectEl.selectedIndex, 1, 'The DOM is updated to reflect the new selection');
  }

  QUnit.test('select element should correctly initialize and update selectedIndex and bound properties when using valueBinding [DEPRECATED]', function () {
    expectDeprecation('You\'re using legacy binding syntax: valueBinding="view.val" (L1:C176) . Please replace with value=view.val');

    testValueBinding('{{view view.selectView viewName="select"' + '    contentBinding="view.collection"' + '    optionLabelPath="content.name"' + '    optionValuePath="content.value"' + '    prompt="Please wait..."' + '    valueBinding="view.val"}}');
  });

  QUnit.test('select element should correctly initialize and update selectedIndex and bound properties when using valueBinding', function () {
    testValueBinding('{{view view.selectView viewName="select"' + '    content=view.collection' + '    optionLabelPath="content.name"' + '    optionValuePath="content.value"' + '    prompt="Please wait..."' + '    value=view.val}}');
  });

  function testSelectionBinding(templateString) {
    view = _emberViewsViewsView.default.create({
      collection: _emberMetalCore.default.A([{ name: 'Wes', value: 'w' }, { name: 'Gordon', value: 'g' }]),
      selection: { name: 'Gordon', value: 'g' },
      selectView: _emberViewsViewsSelect.default,
      template: _emberTemplateCompilerSystemCompile.default(templateString)
    });

    _emberRuntimeTestsUtils.runAppend(view);

    var select = view.get('select');
    var selectEl = select.$()[0];

    equal(view.get('selection.value'), 'g', 'Precond: Initial bound property is correct');
    equal(select.get('selection.value'), 'g', 'Precond: Initial selection is correct');
    equal(selectEl.selectedIndex, 2, 'Precond: The DOM reflects the correct selection');
    equal(select.$('option:eq(2)').prop('selected'), true, 'Precond: selected property is set to proper option');

    select.$('option:eq(2)').removeAttr('selected');
    select.$('option:eq(1)').prop('selected', true);
    select.$().trigger('change');

    equal(view.get('selection.value'), 'w', 'Updated bound property is correct');
    equal(select.get('selection.value'), 'w', 'Updated selection is correct');
    equal(selectEl.selectedIndex, 1, 'The DOM is updated to reflect the new selection');
    equal(select.$('option:eq(1)').prop('selected'), true, 'Selected property is set to proper option');
  }

  QUnit.test('select element should correctly initialize and update selectedIndex and bound properties when using selectionBinding [DEPRECATED]', function () {
    expectDeprecation('You\'re using legacy binding syntax: contentBinding="view.collection" (L1:C44) . Please replace with content=view.collection');

    testSelectionBinding('{{view view.selectView viewName="select"' + '    contentBinding="view.collection"' + '    optionLabelPath="content.name"' + '    optionValuePath="content.value"' + '    prompt="Please wait..."' + '    selectionBinding="view.selection"}}');
  });

  QUnit.test('select element should correctly initialize and update selectedIndex and bound properties when using a bound selection', function () {
    testSelectionBinding('{{view view.selectView viewName="select"' + '    content=view.collection' + '    optionLabelPath="content.name"' + '    optionValuePath="content.value"' + '    prompt="Please wait..."' + '    selection=view.selection}}');
  });

  QUnit.test('select element should correctly initialize and update selectedIndex and bound properties when using selectionBinding and optionValuePath with custom path', function () {
    var templateString = '{{view view.selectView viewName="select"' + '    content=view.collection' + '    optionLabelPath="content.name"' + '    optionValuePath="content.val"' + '    prompt="Please wait..."' + '    selection=view.selection}}';

    view = _emberViewsViewsView.default.create({
      collection: _emberMetalCore.default.A([{ name: 'Wes', val: 'w' }, { name: 'Gordon', val: 'g' }]),
      selection: { name: 'Gordon', val: 'g' },
      selectView: _emberViewsViewsSelect.default,
      template: _emberTemplateCompilerSystemCompile.default(templateString)
    });

    _emberMetalRun_loop.default(function () {
      view.appendTo('#qunit-fixture');
    });

    var select = view.get('select');
    var selectEl = select.$()[0];

    equal(view.get('selection.val'), 'g', 'Precond: Initial bound property is correct');
    equal(select.get('selection.val'), 'g', 'Precond: Initial selection is correct');
    equal(selectEl.selectedIndex, 2, 'Precond: The DOM reflects the correct selection');
    equal(select.$('option:eq(1)').prop('selected'), false, 'Precond: selected property is set to proper option');

    select.$('option:eq(2)').removeAttr('selected');
    select.$('option:eq(1)').prop('selected', true);
    select.$().trigger('change');

    equal(view.get('selection.val'), 'w', 'Updated bound property is correct');
    equal(select.get('selection.val'), 'w', 'Updated selection is correct');
    equal(selectEl.selectedIndex, 1, 'The DOM is updated to reflect the new selection');
    equal(select.$('option:eq(1)').prop('selected'), true, 'selected property is set to proper option');
  });
});
enifed('ember-htmlbars/tests/integration/select_in_template_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/integration');
  test('ember-htmlbars/tests/integration/select_in_template_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/integration/select_in_template_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/integration/select_in_template_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/integration');
  QUnit.test('ember-htmlbars/tests/integration/select_in_template_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/integration/select_in_template_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/integration/tagless_views_rerender_test', ['exports', 'ember-metal/core', 'ember-metal/run_loop', 'ember-views/views/view', 'ember-template-compiler', 'ember-runtime/tests/utils'], function (exports, _emberMetalCore, _emberMetalRun_loop, _emberViewsViewsView, _emberTemplateCompiler, _emberRuntimeTestsUtils) {
  'use strict';

  var view;

  QUnit.module('ember-htmlbars: tagless views should be able to add/remove child views', {
    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(view);
    }
  });

  QUnit.test('can insert new child views after initial tagless view rendering', function () {
    view = _emberViewsViewsView.default.create({
      shouldShow: false,
      array: _emberMetalCore.default.A([1]),

      template: _emberTemplateCompiler.compile('{{#if view.shouldShow}}{{#each view.array as |item|}}{{item}}{{/each}}{{/if}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), '');

    _emberMetalRun_loop.default(function () {
      view.set('shouldShow', true);
    });

    equal(view.$().text(), '1');

    _emberMetalRun_loop.default(function () {
      view.get('array').pushObject(2);
    });

    equal(view.$().text(), '12');
  });

  QUnit.test('can remove child views after initial tagless view rendering', function () {
    view = _emberViewsViewsView.default.create({
      shouldShow: false,
      array: _emberMetalCore.default.A([]),

      template: _emberTemplateCompiler.compile('{{#if view.shouldShow}}{{#each view.array as |item|}}{{item}}{{/each}}{{/if}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), '');

    _emberMetalRun_loop.default(function () {
      view.set('shouldShow', true);
      view.get('array').pushObject(1);
    });

    equal(view.$().text(), '1');

    _emberMetalRun_loop.default(function () {
      view.get('array').removeObject(1);
    });

    equal(view.$().text(), '');
  });
});
enifed('ember-htmlbars/tests/integration/tagless_views_rerender_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/integration');
  test('ember-htmlbars/tests/integration/tagless_views_rerender_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/integration/tagless_views_rerender_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/integration/tagless_views_rerender_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/integration');
  QUnit.test('ember-htmlbars/tests/integration/tagless_views_rerender_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/integration/tagless_views_rerender_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/integration/void-element-component-test', ['exports', 'ember-views/views/view', 'ember-runtime/system/container', 'ember-template-compiler/system/compile', 'ember-runtime/tests/utils', 'ember-views/component_lookup', 'ember-views/views/component'], function (exports, _emberViewsViewsView, _emberRuntimeSystemContainer, _emberTemplateCompilerSystemCompile, _emberRuntimeTestsUtils, _emberViewsComponent_lookup, _emberViewsViewsComponent) {
  'use strict';

  var registry, container, view;

  QUnit.module('ember-htmlbars: components for void elements', {
    setup: function () {
      registry = new _emberRuntimeSystemContainer.Registry();
      container = registry.container();
      registry.optionsForType('component', { singleton: false });
      registry.optionsForType('view', { singleton: false });
      registry.optionsForType('template', { instantiate: false });
      registry.register('component-lookup:main', _emberViewsComponent_lookup.default);
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(container);
      _emberRuntimeTestsUtils.runDestroy(view);
      registry = container = view = null;
    }
  });

  QUnit.test('a void element does not have childNodes', function () {
    var component;
    registry.register('component:x-foo', _emberViewsViewsComponent.default.extend({
      tagName: 'input',

      init: function () {
        this._super.apply(this, arguments);
        component = this;
      }
    }));

    view = _emberViewsViewsView.default.create({
      container: container,
      template: _emberTemplateCompilerSystemCompile.default('{{x-foo}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    deepEqual(component.element.childNodes.length, 0, 'no childNodes are added for `<input>`');
  });
});
enifed('ember-htmlbars/tests/integration/void-element-component-test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/integration');
  test('ember-htmlbars/tests/integration/void-element-component-test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/integration/void-element-component-test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/integration/void-element-component-test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/integration');
  QUnit.test('ember-htmlbars/tests/integration/void-element-component-test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/integration/void-element-component-test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/integration/will-destroy-element-hook-test', ['exports', 'ember-metal/run_loop', 'ember-views/views/component', 'ember-template-compiler/system/compile', 'ember-runtime/tests/utils', 'ember-metal/property_set', 'ember-htmlbars/tests/utils', 'ember-htmlbars/keywords/view'], function (exports, _emberMetalRun_loop, _emberViewsViewsComponent, _emberTemplateCompilerSystemCompile, _emberRuntimeTestsUtils, _emberMetalProperty_set, _emberHtmlbarsTestsUtils, _emberHtmlbarsKeywordsView) {
  'use strict';

  var component, originalViewKeyword;

  QUnit.module('ember-htmlbars: destroy-element-hook tests', {
    setup: function () {
      originalViewKeyword = _emberHtmlbarsTestsUtils.registerKeyword('view', _emberHtmlbarsKeywordsView.default);
    },
    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(component);
      _emberHtmlbarsTestsUtils.resetKeyword('view', originalViewKeyword);
    }
  });

  QUnit.test('willDestroyElement is only called once when a component leaves scope', function (assert) {
    var innerChild, innerChildDestroyed;

    component = _emberViewsViewsComponent.default.create({
      switch: true,

      layout: _emberTemplateCompilerSystemCompile.default('\n     {{~#if switch~}}\n       {{~#view innerChild}}Truthy{{/view~}}\n     {{~/if~}}\n    '),

      innerChild: _emberViewsViewsComponent.default.extend({
        init: function () {
          this._super.apply(this, arguments);
          innerChild = this;
        },

        willDestroyElement: function () {
          if (innerChildDestroyed) {
            throw new Error('willDestroyElement has already been called!!');
          } else {
            innerChildDestroyed = true;
          }
        }
      })
    });

    _emberRuntimeTestsUtils.runAppend(component);

    assert.equal(component.$().text(), 'Truthy', 'precond - truthy template is displayed');
    assert.equal(component.get('childViews.length'), 1);

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(component, 'switch', false);
    });

    _emberMetalRun_loop.default(function () {
      assert.equal(innerChild.get('isDestroyed'), true, 'the innerChild has been destroyed');
      assert.equal(component.$().text(), '', 'truthy template is removed');
    });
  });
});
enifed('ember-htmlbars/tests/integration/will-destroy-element-hook-test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/integration');
  test('ember-htmlbars/tests/integration/will-destroy-element-hook-test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/integration/will-destroy-element-hook-test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/integration/will-destroy-element-hook-test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/integration');
  QUnit.test('ember-htmlbars/tests/integration/will-destroy-element-hook-test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/integration/will-destroy-element-hook-test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/integration/with_view_test', ['exports', 'ember-views/views/view', 'ember-runtime/system/container', 'ember-runtime/system/object', 'ember-template-compiler/system/compile', 'ember-runtime/tests/utils', 'ember-metal/property_set', 'ember-htmlbars/tests/utils', 'ember-htmlbars/keywords/view'], function (exports, _emberViewsViewsView, _emberRuntimeSystemContainer, _emberRuntimeSystemObject, _emberTemplateCompilerSystemCompile, _emberRuntimeTestsUtils, _emberMetalProperty_set, _emberHtmlbarsTestsUtils, _emberHtmlbarsKeywordsView) {
  'use strict';

  var view, registry, container, originalViewKeyword;

  QUnit.module('ember-htmlbars: {{#with}} and {{#view}} integration', {
    setup: function () {
      originalViewKeyword = _emberHtmlbarsTestsUtils.registerKeyword('view', _emberHtmlbarsKeywordsView.default);
      registry = new _emberRuntimeSystemContainer.Registry();
      container = registry.container();
      registry.optionsForType('template', { instantiate: false });
      registry.register('view:toplevel', _emberViewsViewsView.default.extend());
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(container);
      _emberRuntimeTestsUtils.runDestroy(view);
      _emberHtmlbarsTestsUtils.resetKeyword('view', originalViewKeyword);
      registry = container = view = null;
    }
  });

  QUnit.test('child views can be inserted inside a bind block', function () {
    registry.register('template:nester', _emberTemplateCompilerSystemCompile.default('<h1 id="hello-world">Hello {{world}}</h1>{{view view.bqView}}'));
    registry.register('template:nested', _emberTemplateCompilerSystemCompile.default('<div id="child-view">Goodbye {{#with content as |thing|}}{{thing.blah}} {{view view.otherView}}{{/with}} {{world}}</div>'));
    registry.register('template:other', _emberTemplateCompilerSystemCompile.default('cruel'));

    var context = {
      world: 'world!'
    };

    var OtherView = _emberViewsViewsView.default.extend({
      container: container,
      templateName: 'other'
    });

    var BQView = _emberViewsViewsView.default.extend({
      container: container,
      otherView: OtherView,
      tagName: 'blockquote',
      templateName: 'nested'
    });

    view = _emberViewsViewsView.default.create({
      container: container,
      bqView: BQView,
      context: context,
      templateName: 'nester'
    });

    _emberMetalProperty_set.set(context, 'content', _emberRuntimeSystemObject.default.create({
      blah: 'wot'
    }));

    _emberRuntimeTestsUtils.runAppend(view);

    ok(view.$('#hello-world:contains("Hello world!")').length, 'The parent view renders its contents');

    ok(view.$('blockquote').text().match(/Goodbye.*wot.*cruel.*world\!/), 'The child view renders its content once');
    ok(view.$().text().match(/Hello world!.*Goodbye.*wot.*cruel.*world\!/), 'parent view should appear before the child view');
  });

  QUnit.test('views render their template in the context of the parent view\'s context', function () {
    registry.register('template:parent', _emberTemplateCompilerSystemCompile.default('<h1>{{#with content as |person|}}{{#view}}{{person.firstName}} {{person.lastName}}{{/view}}{{/with}}</h1>'));

    var context = {
      content: {
        firstName: 'Lana',
        lastName: 'del Heeeyyyyyy'
      }
    };

    view = _emberViewsViewsView.default.create({
      container: container,
      templateName: 'parent',
      context: context
    });

    _emberRuntimeTestsUtils.runAppend(view);
    equal(view.$('h1').text(), 'Lana del Heeeyyyyyy', 'renders properties from parent context');
  });

  QUnit.test('views make a view keyword available that allows template to reference view context', function () {
    registry.register('template:parent', _emberTemplateCompilerSystemCompile.default('<h1>{{#with view.content as |person|}}{{#view person.subview}}{{view.firstName}} {{person.lastName}}{{/view}}{{/with}}</h1>'));

    view = _emberViewsViewsView.default.create({
      container: container,
      templateName: 'parent',

      content: {
        subview: _emberViewsViewsView.default.extend({
          firstName: 'Brodele'
        }),
        firstName: 'Lana',
        lastName: 'del Heeeyyyyyy'
      }
    });

    _emberRuntimeTestsUtils.runAppend(view);
    equal(view.$('h1').text(), 'Brodele del Heeeyyyyyy', 'renders properties from parent context');
  });
});
enifed('ember-htmlbars/tests/integration/with_view_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/integration');
  test('ember-htmlbars/tests/integration/with_view_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/integration/with_view_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/integration/with_view_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/integration');
  QUnit.test('ember-htmlbars/tests/integration/with_view_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/integration/with_view_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/system/append-templated-view-test', ['exports', 'ember-runtime/tests/utils', 'ember-views/views/view', 'ember-views/views/component', 'ember-template-compiler/system/compile', 'ember-htmlbars/tests/utils', 'ember-htmlbars/keywords/view'], function (exports, _emberRuntimeTestsUtils, _emberViewsViewsView, _emberViewsViewsComponent, _emberTemplateCompilerSystemCompile, _emberHtmlbarsTestsUtils, _emberHtmlbarsKeywordsView) {
  'use strict';

  var view, originalViewKeyword;
  QUnit.module('ember-htmlbars: appendTemplatedView', {
    setup: function () {
      originalViewKeyword = _emberHtmlbarsTestsUtils.registerKeyword('view', _emberHtmlbarsKeywordsView.default);
    },
    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(view);
      _emberHtmlbarsTestsUtils.resetKeyword('view', originalViewKeyword);
    }
  });

  QUnit.test('can accept a view instance', function () {
    var controller = {
      someProp: 'controller context',
      someView: _emberViewsViewsView.default.create({
        template: _emberTemplateCompilerSystemCompile.default('{{someProp}}')
      })
    };

    view = _emberViewsViewsView.default.create({
      controller: controller,
      template: _emberTemplateCompilerSystemCompile.default('{{someProp}} - {{view someView}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'controller context - controller context');
  });

  QUnit.test('can accept a view factory', function () {
    var controller = {
      someProp: 'controller context',
      someView: _emberViewsViewsView.default.extend({
        template: _emberTemplateCompilerSystemCompile.default('{{someProp}}')
      })
    };

    view = _emberViewsViewsView.default.create({
      controller: controller,
      template: _emberTemplateCompilerSystemCompile.default('{{someProp}} - {{view someView}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'controller context - controller context');
  });

  QUnit.test('does change the context if the view factory has a controller specified', function () {
    var controller = {
      someProp: 'controller context',
      someView: _emberViewsViewsView.default.extend({
        controller: {
          someProp: 'view local controller context'
        },
        template: _emberTemplateCompilerSystemCompile.default('{{someProp}}')
      })
    };

    view = _emberViewsViewsView.default.create({
      controller: controller,
      template: _emberTemplateCompilerSystemCompile.default('{{someProp}} - {{view someView}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'controller context - view local controller context');
  });

  QUnit.test('does change the context if a component factory is used', function () {
    var controller = {
      someProp: 'controller context',
      someView: _emberViewsViewsComponent.default.extend({
        someProp: 'view local controller context',
        layout: _emberTemplateCompilerSystemCompile.default('{{someProp}}')
      })
    };

    view = _emberViewsViewsView.default.create({
      controller: controller,
      template: _emberTemplateCompilerSystemCompile.default('{{someProp}} - {{view someView}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'controller context - view local controller context');
  });

  QUnit.test('does change the context if a component instance is used', function () {
    var controller = {
      someProp: 'controller context',
      someView: _emberViewsViewsComponent.default.create({
        someProp: 'view local controller context',
        layout: _emberTemplateCompilerSystemCompile.default('{{someProp}}')
      })
    };

    view = _emberViewsViewsView.default.create({
      controller: controller,
      template: _emberTemplateCompilerSystemCompile.default('{{someProp}} - {{view someView}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'controller context - view local controller context');
  });
});
enifed('ember-htmlbars/tests/system/append-templated-view-test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/system');
  test('ember-htmlbars/tests/system/append-templated-view-test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/system/append-templated-view-test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/system/append-templated-view-test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/system');
  QUnit.test('ember-htmlbars/tests/system/append-templated-view-test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/system/append-templated-view-test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/system/bootstrap_test', ['exports', 'ember-metal/core', 'ember-views/system/jquery', 'ember-metal/run_loop', 'ember-views/views/view', 'ember-runtime/tests/utils', 'ember-htmlbars/system/bootstrap'], function (exports, _emberMetalCore, _emberViewsSystemJquery, _emberMetalRun_loop, _emberViewsViewsView, _emberRuntimeTestsUtils, _emberHtmlbarsSystemBootstrap) {
  'use strict';

  var trim = _emberViewsSystemJquery.default.trim;

  var originalLookup = _emberMetalCore.default.lookup;
  var lookup, App, view;

  QUnit.module('ember-htmlbars: bootstrap', {
    setup: function () {
      _emberMetalCore.default.lookup = lookup = { Ember: _emberMetalCore.default };
    },
    teardown: function () {
      _emberMetalCore.default.TEMPLATES = {};
      _emberMetalCore.default.lookup = originalLookup;
      _emberRuntimeTestsUtils.runDestroy(App);
      _emberRuntimeTestsUtils.runDestroy(view);
    }
  });

  function checkTemplate(templateName) {
    _emberMetalRun_loop.default(function () {
      _emberHtmlbarsSystemBootstrap.default(_emberViewsSystemJquery.default('#qunit-fixture'));
    });
    var template = _emberMetalCore.default.TEMPLATES[templateName];
    ok(template, 'template is available on Ember.TEMPLATES');
    equal(_emberViewsSystemJquery.default('#qunit-fixture script').length, 0, 'script removed');
    var view = _emberViewsViewsView.default.create({
      template: template,
      context: {
        firstName: 'Tobias',
        drug: 'teamocil'
      }
    });
    _emberMetalRun_loop.default(function () {
      view.createElement();
    });
    equal(trim(view.$().text()), 'Tobias takes teamocil', 'template works');
    _emberRuntimeTestsUtils.runDestroy(view);
  }

  QUnit.test('template with data-template-name should add a new template to Ember.TEMPLATES', function () {
    _emberViewsSystemJquery.default('#qunit-fixture').html('<script type="text/x-handlebars" data-template-name="funkyTemplate">{{firstName}} takes {{drug}}</script>');

    checkTemplate('funkyTemplate');
  });

  QUnit.test('template with id instead of data-template-name should add a new template to Ember.TEMPLATES', function () {
    _emberViewsSystemJquery.default('#qunit-fixture').html('<script type="text/x-handlebars" id="funkyTemplate" >{{firstName}} takes {{drug}}</script>');

    checkTemplate('funkyTemplate');
  });

  QUnit.test('template without data-template-name or id should default to application', function () {
    _emberViewsSystemJquery.default('#qunit-fixture').html('<script type="text/x-handlebars">{{firstName}} takes {{drug}}</script>');

    checkTemplate('application');
  });

  if (typeof Handlebars === 'object') {
    QUnit.test('template with type text/x-raw-handlebars should be parsed', function () {
      _emberViewsSystemJquery.default('#qunit-fixture').html('<script type="text/x-raw-handlebars" data-template-name="funkyTemplate">{{name}}</script>');

      _emberMetalRun_loop.default(function () {
        _emberHtmlbarsSystemBootstrap.default(_emberViewsSystemJquery.default('#qunit-fixture'));
      });

      ok(_emberMetalCore.default.TEMPLATES['funkyTemplate'], 'template with name funkyTemplate available');

      // This won't even work with Ember templates
      equal(trim(_emberMetalCore.default.TEMPLATES['funkyTemplate']({ name: 'Tobias' })), 'Tobias');
    });
  }

  QUnit.test('duplicated default application templates should throw exception', function () {
    _emberViewsSystemJquery.default('#qunit-fixture').html('<script type="text/x-handlebars">first</script><script type="text/x-handlebars">second</script>');

    throws(function () {
      _emberHtmlbarsSystemBootstrap.default(_emberViewsSystemJquery.default('#qunit-fixture'));
    }, /Template named "[^"]+" already exists\./, 'duplicate templates should not be allowed');
  });

  QUnit.test('default application template and id application template present should throw exception', function () {
    _emberViewsSystemJquery.default('#qunit-fixture').html('<script type="text/x-handlebars">first</script><script type="text/x-handlebars" id="application">second</script>');

    throws(function () {
      _emberHtmlbarsSystemBootstrap.default(_emberViewsSystemJquery.default('#qunit-fixture'));
    }, /Template named "[^"]+" already exists\./, 'duplicate templates should not be allowed');
  });

  QUnit.test('default application template and data-template-name application template present should throw exception', function () {
    _emberViewsSystemJquery.default('#qunit-fixture').html('<script type="text/x-handlebars">first</script><script type="text/x-handlebars" data-template-name="application">second</script>');

    throws(function () {
      _emberHtmlbarsSystemBootstrap.default(_emberViewsSystemJquery.default('#qunit-fixture'));
    }, /Template named "[^"]+" already exists\./, 'duplicate templates should not be allowed');
  });

  QUnit.test('duplicated template id should throw exception', function () {
    _emberViewsSystemJquery.default('#qunit-fixture').html('<script type="text/x-handlebars" id="funkyTemplate">first</script><script type="text/x-handlebars" id="funkyTemplate">second</script>');

    throws(function () {
      _emberHtmlbarsSystemBootstrap.default(_emberViewsSystemJquery.default('#qunit-fixture'));
    }, /Template named "[^"]+" already exists\./, 'duplicate templates should not be allowed');
  });

  QUnit.test('duplicated template data-template-name should throw exception', function () {
    _emberViewsSystemJquery.default('#qunit-fixture').html('<script type="text/x-handlebars" data-template-name="funkyTemplate">first</script><script type="text/x-handlebars" data-template-name="funkyTemplate">second</script>');

    throws(function () {
      _emberHtmlbarsSystemBootstrap.default(_emberViewsSystemJquery.default('#qunit-fixture'));
    }, /Template named "[^"]+" already exists\./, 'duplicate templates should not be allowed');
  });

  if (_emberMetalCore.default.component) {
    QUnit.test('registerComponents initializer', function () {
      _emberMetalCore.default.TEMPLATES['components/x-apple'] = 'asdf';

      App = _emberMetalRun_loop.default(_emberMetalCore.default.Application, 'create');

      ok(_emberMetalCore.default.Handlebars.helpers['x-apple'], 'x-apple helper is present');
      ok(App.__container__.has('component:x-apple'), 'the container is aware of x-apple');
    });

    QUnit.test('registerComponents and generated components', function () {
      _emberMetalCore.default.TEMPLATES['components/x-apple'] = 'asdf';

      App = _emberMetalRun_loop.default(_emberMetalCore.default.Application, 'create');
      view = App.__container__.lookup('component:x-apple');
      equal(view.get('layoutName'), 'components/x-apple', 'has correct layout name');
    });

    QUnit.test('registerComponents and non-generated components', function () {
      _emberMetalCore.default.TEMPLATES['components/x-apple'] = 'asdf';

      _emberMetalRun_loop.default(function () {
        App = _emberMetalCore.default.Application.create();

        // currently Component code must be loaded before initializers
        // this is mostly due to how they are bootstrapped. We will hopefully
        // sort this out soon.
        App.XAppleComponent = _emberMetalCore.default.Component.extend({
          isCorrect: true
        });
      });

      view = App.__container__.lookup('component:x-apple');
      equal(view.get('layoutName'), 'components/x-apple', 'has correct layout name');
      ok(view.get('isCorrect'), 'ensure a non-generated component');
    });
  }
});
enifed('ember-htmlbars/tests/system/bootstrap_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/system');
  test('ember-htmlbars/tests/system/bootstrap_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/system/bootstrap_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/system/bootstrap_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/system');
  QUnit.test('ember-htmlbars/tests/system/bootstrap_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/system/bootstrap_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/system/discover-known-helpers-test', ['exports', 'ember-metal/features', 'container/registry', 'ember-htmlbars/helper', 'ember-runtime/tests/utils', 'ember-htmlbars/system/discover-known-helpers'], function (exports, _emberMetalFeatures, _containerRegistry, _emberHtmlbarsHelper, _emberRuntimeTestsUtils, _emberHtmlbarsSystemDiscoverKnownHelpers) {
  'use strict';

  var resolver, registry, container;

  QUnit.module('ember-htmlbars: discover-known-helpers', {
    setup: function () {
      resolver = function () {};

      registry = new _containerRegistry.default({ resolver: resolver });
      container = registry.container();
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(container);
      registry = container = null;
    }
  });

  QUnit.test('returns an empty hash when no helpers are known', function () {
    var result = _emberHtmlbarsSystemDiscoverKnownHelpers.default(container);

    deepEqual(result, {}, 'no helpers were known');
  });

  QUnit.test('includes helpers in the registry', function () {
    registry.register('helper:t', _emberHtmlbarsHelper.default);
    var result = _emberHtmlbarsSystemDiscoverKnownHelpers.default(container);
    var helpers = Object.keys(result);

    deepEqual(helpers, ['t'], 'helpers from the registry were known');
  });

  QUnit.test('includes resolved helpers', function () {
    resolver.knownForType = function () {
      return {
        'helper:f': true
      };
    };

    registry.register('helper:t', _emberHtmlbarsHelper.default);
    var result = _emberHtmlbarsSystemDiscoverKnownHelpers.default(container);
    var helpers = Object.keys(result);

    deepEqual(helpers, ['t', 'f'], 'helpers from the registry were known');
  });
});
enifed('ember-htmlbars/tests/system/discover-known-helpers-test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/system');
  test('ember-htmlbars/tests/system/discover-known-helpers-test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/system/discover-known-helpers-test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/system/discover-known-helpers-test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/system');
  QUnit.test('ember-htmlbars/tests/system/discover-known-helpers-test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/system/discover-known-helpers-test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/system/lookup-helper_test', ['exports', 'ember-htmlbars/system/lookup-helper', 'ember-views/component_lookup', 'container/registry', 'ember-htmlbars/helper'], function (exports, _emberHtmlbarsSystemLookupHelper, _emberViewsComponent_lookup, _containerRegistry, _emberHtmlbarsHelper) {
  'use strict';

  function generateEnv(helpers, container) {
    return {
      container: container,
      helpers: helpers ? helpers : {},
      hooks: { keywords: {} },
      knownHelpers: {}
    };
  }

  function generateContainer() {
    var registry = new _containerRegistry.default();
    var container = registry.container();

    registry.register('component-lookup:main', _emberViewsComponent_lookup.default);

    return container;
  }

  QUnit.module('ember-htmlbars: lookupHelper hook');

  QUnit.test('looks for helpers in the provided `env.helpers`', function () {
    var env = generateEnv({
      'flubarb': function () {}
    });

    var actual = _emberHtmlbarsSystemLookupHelper.default('flubarb', null, env);

    equal(actual, env.helpers.flubarb, 'helpers are looked up on env');
  });

  QUnit.test('returns undefined if no container exists (and helper is not found in env)', function () {
    var env = generateEnv();
    var view = {};

    var actual = _emberHtmlbarsSystemLookupHelper.findHelper('flubarb', view, env);

    equal(actual, undefined, 'does not blow up if view does not have a container');
  });

  QUnit.test('does not lookup in the container if the name does not contain a dash (and helper is not found in env)', function () {
    var env = generateEnv();
    var view = {
      container: {
        lookup: function () {
          ok(false, 'should not lookup in the container');
        }
      }
    };

    var actual = _emberHtmlbarsSystemLookupHelper.findHelper('flubarb', view, env);

    equal(actual, undefined, 'does not blow up if view does not have a container');
  });

  QUnit.test('does a lookup in the container if the name contains a dash (and helper is not found in env)', function () {
    var container = generateContainer();
    var env = generateEnv(null, container);
    var view = {
      container: container
    };

    var someName = _emberHtmlbarsHelper.default.extend();
    view.container._registry.register('helper:some-name', someName);

    var actual = _emberHtmlbarsSystemLookupHelper.default('some-name', view, env);

    ok(someName.detect(actual), 'helper is an instance of the helper class');
  });

  QUnit.test('does a lookup in the container if the name is found in knownHelpers', function () {
    var container = generateContainer();
    var env = generateEnv(null, container);
    var view = {
      container: container
    };

    env.knownHelpers['t'] = true;
    var t = _emberHtmlbarsHelper.default.extend();
    view.container._registry.register('helper:t', t);

    var actual = _emberHtmlbarsSystemLookupHelper.default('t', view, env);

    ok(t.detect(actual), 'helper is an instance of the helper class');
  });

  QUnit.test('looks up a shorthand helper in the container', function () {
    expect(2);
    var container = generateContainer();
    var env = generateEnv(null, container);
    var view = {
      container: container
    };
    var called;

    function someName() {
      called = true;
    }
    view.container._registry.register('helper:some-name', _emberHtmlbarsHelper.helper(someName));

    var actual = _emberHtmlbarsSystemLookupHelper.default('some-name', view, env);

    ok(actual.isHelperInstance, 'is a helper');

    actual.compute([], {});

    ok(called, 'HTMLBars compatible wrapper is wraping the provided function');
  });

  QUnit.test('fails with a useful error when resolving a function', function () {
    expect(1);
    var container = generateContainer();
    var env = generateEnv(null, container);
    var view = {
      container: container
    };

    function someName() {}
    view.container._registry.register('helper:some-name', someName);

    var actual;
    expectAssertion(function () {
      actual = _emberHtmlbarsSystemLookupHelper.default('some-name', view, env);
    }, 'Expected to find an Ember.Helper with the name helper:some-name, but found an object of type function instead.');
  });
});
enifed('ember-htmlbars/tests/system/lookup-helper_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/system');
  test('ember-htmlbars/tests/system/lookup-helper_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/system/lookup-helper_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/system/lookup-helper_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/system');
  QUnit.test('ember-htmlbars/tests/system/lookup-helper_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/system/lookup-helper_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/system/render_env_test', ['exports', 'ember-views/views/view', 'container/registry', 'ember-template-compiler/system/compile', 'ember-views/component_lookup', 'ember-views/views/component', 'ember-htmlbars/system/render-env', 'ember-runtime/tests/utils', 'ember-metal/run_loop'], function (exports, _emberViewsViewsView, _containerRegistry, _emberTemplateCompilerSystemCompile, _emberViewsComponent_lookup, _emberViewsViewsComponent, _emberHtmlbarsSystemRenderEnv, _emberRuntimeTestsUtils, _emberMetalRun_loop) {
  'use strict';

  var registry, container, view, components;

  function commonSetup() {
    registry = new _containerRegistry.default();
    container = registry.container();
    registry.optionsForType('component', { singleton: false });
    registry.optionsForType('view', { singleton: false });
    registry.optionsForType('template', { instantiate: false });
    registry.optionsForType('helper', { instantiate: false });
    registry.register('component-lookup:main', _emberViewsComponent_lookup.default);
  }

  function commonTeardown() {
    _emberRuntimeTestsUtils.runDestroy(container);
    _emberRuntimeTestsUtils.runDestroy(view);
    registry = container = view = null;
  }

  function appendViewFor(template) {
    var hash = arguments.length <= 1 || arguments[1] === undefined ? {} : arguments[1];

    var view = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default(template),
      container: container
    }).create(hash);

    _emberRuntimeTestsUtils.runAppend(view);

    return view;
  }

  function constructComponent(label) {
    return _emberViewsViewsComponent.default.extend({
      init: function () {
        this.label = label;
        components[label] = this;
        this._super.apply(this, arguments);
      }
    });
  }

  function extractEnv(component) {
    return component._renderNode.lastResult.env;
  }

  QUnit.module('ember-htmlbars: RenderEnv', {
    setup: function () {
      commonSetup();
    },

    teardown: function () {
      commonTeardown();
    }
  });

  QUnit.test('non-block component test', function () {
    components = {};

    registry.register('component:non-block', constructComponent('nonblock'));
    registry.register('template:components/non-block', _emberTemplateCompilerSystemCompile.default('In layout'));

    view = appendViewFor('{{non-block}}');

    ok(view.env instanceof _emberHtmlbarsSystemRenderEnv.default, 'initial render: View environment should be an instance of RenderEnv');
    ok(extractEnv(components.nonblock) instanceof _emberHtmlbarsSystemRenderEnv.default, 'initial render: {{#non-block}} environment should be an instance of RenderEnv');

    _emberMetalRun_loop.default(components.nonblock, 'rerender');

    ok(view.env instanceof _emberHtmlbarsSystemRenderEnv.default, 'rerender: View environment should be an instance of RenderEnv');
    ok(extractEnv(components.nonblock) instanceof _emberHtmlbarsSystemRenderEnv.default, 'rerender: {{#non-block}} environment should be an instance of RenderEnv');
  });

  QUnit.test('block component test', function () {
    components = {};

    registry.register('component:block-component', constructComponent('block'));
    registry.register('template:components/block-component', _emberTemplateCompilerSystemCompile.default('In layout {{yield}}'));

    view = appendViewFor('{{#block-component}}content{{/block-component}}');

    ok(view.env instanceof _emberHtmlbarsSystemRenderEnv.default, 'initial render: View environment should be an instance of RenderEnv');
    ok(extractEnv(components.block) instanceof _emberHtmlbarsSystemRenderEnv.default, 'initial render: {{#block-component}} environment should be an instance of RenderEnv');

    _emberMetalRun_loop.default(components.block, 'rerender');

    ok(view.env instanceof _emberHtmlbarsSystemRenderEnv.default, 'rerender: View environment should be an instance of RenderEnv');
    ok(extractEnv(components.block) instanceof _emberHtmlbarsSystemRenderEnv.default, 'rerender: {{#block-component}} environment should be an instance of RenderEnv');
  });

  QUnit.test('block component with child component test', function () {
    components = {};

    registry.register('component:block-component', constructComponent('block'));
    registry.register('component:child-component', constructComponent('child'));

    registry.register('template:components/block-component', _emberTemplateCompilerSystemCompile.default('In layout {{yield}}'));
    registry.register('template:components/child-component', _emberTemplateCompilerSystemCompile.default('Child Component'));

    view = appendViewFor('{{#block-component}}{{child-component}}{{/block-component}}');

    ok(view.env instanceof _emberHtmlbarsSystemRenderEnv.default, 'initial render: View environment should be an instance of RenderEnv');
    ok(extractEnv(components.block) instanceof _emberHtmlbarsSystemRenderEnv.default, 'initial render: {{#block-component}} environment should be an instance of RenderEnv');
    ok(extractEnv(components.child) instanceof _emberHtmlbarsSystemRenderEnv.default, 'initial render: {{child-component}} environment should be an instance of RenderEnv');

    _emberMetalRun_loop.default(components.block, 'rerender');

    ok(view.env instanceof _emberHtmlbarsSystemRenderEnv.default, 'rerender: View environment should be an instance of RenderEnv');
    ok(extractEnv(components.block) instanceof _emberHtmlbarsSystemRenderEnv.default, 'rerender: {{#block-component}} environment should be an instance of RenderEnv');
    ok(extractEnv(components.child) instanceof _emberHtmlbarsSystemRenderEnv.default, 'rerender: {{child-component}} environment should be an instance of RenderEnv');
  });
});
enifed('ember-htmlbars/tests/system/render_env_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/system');
  test('ember-htmlbars/tests/system/render_env_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/system/render_env_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/system/render_env_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/system');
  QUnit.test('ember-htmlbars/tests/system/render_env_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/system/render_env_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/utils', ['exports', 'ember-htmlbars/keywords', 'ember-template-compiler/plugins'], function (exports, _emberHtmlbarsKeywords, _emberTemplateCompilerPlugins) {
  'use strict';

  function registerAstPlugin(plugin) {
    _emberTemplateCompilerPlugins.registerPlugin('ast', plugin);
  }

  function removeAstPlugin(plugin) {
    var index = _emberTemplateCompilerPlugins.default['ast'].indexOf(plugin);
    _emberTemplateCompilerPlugins.default['ast'].splice(index, 1);
  }

  function registerKeyword(name, keyword) {
    return _emberHtmlbarsKeywords.registerKeyword(name, keyword);
  }

  function resetKeyword(name, original) {
    if (original) {
      _emberHtmlbarsKeywords.default[name] = original;
    } else {
      delete _emberHtmlbarsKeywords.default[name];
    }
  }

  exports.registerAstPlugin = registerAstPlugin;
  exports.removeAstPlugin = removeAstPlugin;
  exports.registerKeyword = registerKeyword;
  exports.resetKeyword = resetKeyword;
});
enifed('ember-htmlbars/tests/utils.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests');
  test('ember-htmlbars/tests/utils.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/utils.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/utils.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests');
  QUnit.test('ember-htmlbars/tests/utils.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/utils.js should pass jshint.');
  });
});
enifed('ember-htmlbars/tests/utils/string_test', ['exports', 'htmlbars-util/safe-string', 'ember-htmlbars/utils/string'], function (exports, _htmlbarsUtilSafeString, _emberHtmlbarsUtilsString) {
  'use strict';

  QUnit.module('ember-htmlbars: SafeString');

  QUnit.test('htmlSafe should return an instance of SafeString', function () {
    var safeString = _emberHtmlbarsUtilsString.htmlSafe('you need to be more <b>bold</b>');

    ok(safeString instanceof _htmlbarsUtilSafeString.default, 'should return SafeString');
  });

  QUnit.test('htmlSafe should return an empty string for null', function () {
    equal(_emberHtmlbarsUtilsString.htmlSafe(null).toString(), '', 'should return an empty string');
  });

  QUnit.test('htmlSafe should return an empty string for undefined', function () {
    equal(_emberHtmlbarsUtilsString.htmlSafe().toString(), '', 'should return an empty string');
  });
});
enifed('ember-htmlbars/tests/utils/string_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/tests/utils');
  test('ember-htmlbars/tests/utils/string_test.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/tests/utils/string_test.js should pass jscs.');
  });
});
enifed('ember-htmlbars/tests/utils/string_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/tests/utils');
  QUnit.test('ember-htmlbars/tests/utils/string_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/tests/utils/string_test.js should pass jshint.');
  });
});
enifed('ember-htmlbars/utils/decode-each-key.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/utils');
  test('ember-htmlbars/utils/decode-each-key.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/utils/decode-each-key.js should pass jscs.');
  });
});
enifed('ember-htmlbars/utils/decode-each-key.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/utils');
  QUnit.test('ember-htmlbars/utils/decode-each-key.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/utils/decode-each-key.js should pass jshint.');
  });
});
enifed('ember-htmlbars/utils/is-component.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/utils');
  test('ember-htmlbars/utils/is-component.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/utils/is-component.js should pass jscs.');
  });
});
enifed('ember-htmlbars/utils/is-component.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/utils');
  QUnit.test('ember-htmlbars/utils/is-component.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/utils/is-component.js should pass jshint.');
  });
});
enifed('ember-htmlbars/utils/lookup-component.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/utils');
  test('ember-htmlbars/utils/lookup-component.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/utils/lookup-component.js should pass jscs.');
  });
});
enifed('ember-htmlbars/utils/lookup-component.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/utils');
  QUnit.test('ember-htmlbars/utils/lookup-component.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/utils/lookup-component.js should pass jshint.');
  });
});
enifed('ember-htmlbars/utils/normalize-self.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/utils');
  test('ember-htmlbars/utils/normalize-self.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/utils/normalize-self.js should pass jscs.');
  });
});
enifed('ember-htmlbars/utils/normalize-self.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/utils');
  QUnit.test('ember-htmlbars/utils/normalize-self.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/utils/normalize-self.js should pass jshint.');
  });
});
enifed('ember-htmlbars/utils/string.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/utils');
  test('ember-htmlbars/utils/string.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/utils/string.js should pass jscs.');
  });
});
enifed('ember-htmlbars/utils/string.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/utils');
  QUnit.test('ember-htmlbars/utils/string.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/utils/string.js should pass jshint.');
  });
});
enifed('ember-htmlbars/utils/subscribe.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/utils');
  test('ember-htmlbars/utils/subscribe.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/utils/subscribe.js should pass jscs.');
  });
});
enifed('ember-htmlbars/utils/subscribe.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/utils');
  QUnit.test('ember-htmlbars/utils/subscribe.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/utils/subscribe.js should pass jshint.');
  });
});
enifed('ember-htmlbars/utils/update-scope.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-htmlbars/utils');
  test('ember-htmlbars/utils/update-scope.js should pass jscs', function () {
    ok(true, 'ember-htmlbars/utils/update-scope.js should pass jscs.');
  });
});
enifed('ember-htmlbars/utils/update-scope.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-htmlbars/utils');
  QUnit.test('ember-htmlbars/utils/update-scope.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-htmlbars/utils/update-scope.js should pass jshint.');
  });
});
enifed('ember-metal-views.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - .');
  test('ember-metal-views.js should pass jscs', function () {
    ok(true, 'ember-metal-views.js should pass jscs.');
  });
});
enifed('ember-metal-views.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - .');
  QUnit.test('ember-metal-views.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal-views.js should pass jshint.');
  });
});
enifed('ember-metal-views/renderer.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal-views');
  test('ember-metal-views/renderer.js should pass jscs', function () {
    ok(true, 'ember-metal-views/renderer.js should pass jscs.');
  });
});
enifed('ember-metal-views/renderer.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal-views');
  QUnit.test('ember-metal-views/renderer.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal-views/renderer.js should pass jshint.');
  });
});
enifed('ember-metal.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - .');
  test('ember-metal.js should pass jscs', function () {
    ok(true, 'ember-metal.js should pass jscs.');
  });
});
enifed('ember-metal.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - .');
  QUnit.test('ember-metal.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal.js should pass jshint.');
  });
});
enifed('ember-metal/alias.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal');
  test('ember-metal/alias.js should pass jscs', function () {
    ok(true, 'ember-metal/alias.js should pass jscs.');
  });
});
enifed('ember-metal/alias.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal');
  QUnit.test('ember-metal/alias.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/alias.js should pass jshint.');
  });
});
enifed('ember-metal/binding.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal');
  test('ember-metal/binding.js should pass jscs', function () {
    ok(true, 'ember-metal/binding.js should pass jscs.');
  });
});
enifed('ember-metal/binding.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal');
  QUnit.test('ember-metal/binding.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/binding.js should pass jshint.');
  });
});
enifed('ember-metal/cache.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal');
  test('ember-metal/cache.js should pass jscs', function () {
    ok(true, 'ember-metal/cache.js should pass jscs.');
  });
});
enifed('ember-metal/cache.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal');
  QUnit.test('ember-metal/cache.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/cache.js should pass jshint.');
  });
});
enifed('ember-metal/chains.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal');
  test('ember-metal/chains.js should pass jscs', function () {
    ok(true, 'ember-metal/chains.js should pass jscs.');
  });
});
enifed('ember-metal/chains.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal');
  QUnit.test('ember-metal/chains.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/chains.js should pass jshint.');
  });
});
enifed('ember-metal/computed.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal');
  test('ember-metal/computed.js should pass jscs', function () {
    ok(true, 'ember-metal/computed.js should pass jscs.');
  });
});
enifed('ember-metal/computed.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal');
  QUnit.test('ember-metal/computed.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/computed.js should pass jshint.');
  });
});
enifed('ember-metal/computed_macros.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal');
  test('ember-metal/computed_macros.js should pass jscs', function () {
    ok(true, 'ember-metal/computed_macros.js should pass jscs.');
  });
});
enifed('ember-metal/computed_macros.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal');
  QUnit.test('ember-metal/computed_macros.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/computed_macros.js should pass jshint.');
  });
});
enifed('ember-metal/core.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal');
  test('ember-metal/core.js should pass jscs', function () {
    ok(true, 'ember-metal/core.js should pass jscs.');
  });
});
enifed('ember-metal/core.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal');
  QUnit.test('ember-metal/core.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/core.js should pass jshint.');
  });
});
enifed('ember-metal/dependent_keys.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal');
  test('ember-metal/dependent_keys.js should pass jscs', function () {
    ok(true, 'ember-metal/dependent_keys.js should pass jscs.');
  });
});
enifed('ember-metal/dependent_keys.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal');
  QUnit.test('ember-metal/dependent_keys.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/dependent_keys.js should pass jshint.');
  });
});
enifed('ember-metal/deprecate_property.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal');
  test('ember-metal/deprecate_property.js should pass jscs', function () {
    ok(true, 'ember-metal/deprecate_property.js should pass jscs.');
  });
});
enifed('ember-metal/deprecate_property.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal');
  QUnit.test('ember-metal/deprecate_property.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/deprecate_property.js should pass jshint.');
  });
});
enifed('ember-metal/dictionary.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal');
  test('ember-metal/dictionary.js should pass jscs', function () {
    ok(true, 'ember-metal/dictionary.js should pass jscs.');
  });
});
enifed('ember-metal/dictionary.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal');
  QUnit.test('ember-metal/dictionary.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/dictionary.js should pass jshint.');
  });
});
enifed('ember-metal/empty_object.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal');
  test('ember-metal/empty_object.js should pass jscs', function () {
    ok(true, 'ember-metal/empty_object.js should pass jscs.');
  });
});
enifed('ember-metal/empty_object.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal');
  QUnit.test('ember-metal/empty_object.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/empty_object.js should pass jshint.');
  });
});
enifed('ember-metal/environment.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal');
  test('ember-metal/environment.js should pass jscs', function () {
    ok(true, 'ember-metal/environment.js should pass jscs.');
  });
});
enifed('ember-metal/environment.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal');
  QUnit.test('ember-metal/environment.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/environment.js should pass jshint.');
  });
});
enifed('ember-metal/error.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal');
  test('ember-metal/error.js should pass jscs', function () {
    ok(true, 'ember-metal/error.js should pass jscs.');
  });
});
enifed('ember-metal/error.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal');
  QUnit.test('ember-metal/error.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/error.js should pass jshint.');
  });
});
enifed('ember-metal/events.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal');
  test('ember-metal/events.js should pass jscs', function () {
    ok(true, 'ember-metal/events.js should pass jscs.');
  });
});
enifed('ember-metal/events.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal');
  QUnit.test('ember-metal/events.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/events.js should pass jshint.');
  });
});
enifed('ember-metal/expand_properties.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal');
  test('ember-metal/expand_properties.js should pass jscs', function () {
    ok(true, 'ember-metal/expand_properties.js should pass jscs.');
  });
});
enifed('ember-metal/expand_properties.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal');
  QUnit.test('ember-metal/expand_properties.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/expand_properties.js should pass jshint.');
  });
});
enifed('ember-metal/features.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal');
  test('ember-metal/features.js should pass jscs', function () {
    ok(true, 'ember-metal/features.js should pass jscs.');
  });
});
enifed('ember-metal/features.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal');
  QUnit.test('ember-metal/features.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/features.js should pass jshint.');
  });
});
enifed('ember-metal/get_properties.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal');
  test('ember-metal/get_properties.js should pass jscs', function () {
    ok(true, 'ember-metal/get_properties.js should pass jscs.');
  });
});
enifed('ember-metal/get_properties.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal');
  QUnit.test('ember-metal/get_properties.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/get_properties.js should pass jshint.');
  });
});
enifed('ember-metal/injected_property.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal');
  test('ember-metal/injected_property.js should pass jscs', function () {
    ok(true, 'ember-metal/injected_property.js should pass jscs.');
  });
});
enifed('ember-metal/injected_property.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal');
  QUnit.test('ember-metal/injected_property.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/injected_property.js should pass jshint.');
  });
});
enifed('ember-metal/instrumentation.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal');
  test('ember-metal/instrumentation.js should pass jscs', function () {
    ok(true, 'ember-metal/instrumentation.js should pass jscs.');
  });
});
enifed('ember-metal/instrumentation.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal');
  QUnit.test('ember-metal/instrumentation.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/instrumentation.js should pass jshint.');
  });
});
enifed('ember-metal/is_blank.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal');
  test('ember-metal/is_blank.js should pass jscs', function () {
    ok(true, 'ember-metal/is_blank.js should pass jscs.');
  });
});
enifed('ember-metal/is_blank.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal');
  QUnit.test('ember-metal/is_blank.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/is_blank.js should pass jshint.');
  });
});
enifed('ember-metal/is_empty.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal');
  test('ember-metal/is_empty.js should pass jscs', function () {
    ok(true, 'ember-metal/is_empty.js should pass jscs.');
  });
});
enifed('ember-metal/is_empty.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal');
  QUnit.test('ember-metal/is_empty.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/is_empty.js should pass jshint.');
  });
});
enifed('ember-metal/is_none.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal');
  test('ember-metal/is_none.js should pass jscs', function () {
    ok(true, 'ember-metal/is_none.js should pass jscs.');
  });
});
enifed('ember-metal/is_none.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal');
  QUnit.test('ember-metal/is_none.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/is_none.js should pass jshint.');
  });
});
enifed('ember-metal/is_present.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal');
  test('ember-metal/is_present.js should pass jscs', function () {
    ok(true, 'ember-metal/is_present.js should pass jscs.');
  });
});
enifed('ember-metal/is_present.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal');
  QUnit.test('ember-metal/is_present.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/is_present.js should pass jshint.');
  });
});
enifed('ember-metal/keys.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal');
  test('ember-metal/keys.js should pass jscs', function () {
    ok(true, 'ember-metal/keys.js should pass jscs.');
  });
});
enifed('ember-metal/keys.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal');
  QUnit.test('ember-metal/keys.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/keys.js should pass jshint.');
  });
});
enifed('ember-metal/libraries.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal');
  test('ember-metal/libraries.js should pass jscs', function () {
    ok(true, 'ember-metal/libraries.js should pass jscs.');
  });
});
enifed('ember-metal/libraries.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal');
  QUnit.test('ember-metal/libraries.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/libraries.js should pass jshint.');
  });
});
enifed('ember-metal/logger.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal');
  test('ember-metal/logger.js should pass jscs', function () {
    ok(true, 'ember-metal/logger.js should pass jscs.');
  });
});
enifed('ember-metal/logger.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal');
  QUnit.test('ember-metal/logger.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/logger.js should pass jshint.');
  });
});
enifed('ember-metal/map.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal');
  test('ember-metal/map.js should pass jscs', function () {
    ok(true, 'ember-metal/map.js should pass jscs.');
  });
});
enifed('ember-metal/map.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal');
  QUnit.test('ember-metal/map.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/map.js should pass jshint.');
  });
});
enifed('ember-metal/merge.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal');
  test('ember-metal/merge.js should pass jscs', function () {
    ok(true, 'ember-metal/merge.js should pass jscs.');
  });
});
enifed('ember-metal/merge.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal');
  QUnit.test('ember-metal/merge.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/merge.js should pass jshint.');
  });
});
enifed('ember-metal/mixin.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal');
  test('ember-metal/mixin.js should pass jscs', function () {
    ok(true, 'ember-metal/mixin.js should pass jscs.');
  });
});
enifed('ember-metal/mixin.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal');
  QUnit.test('ember-metal/mixin.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/mixin.js should pass jshint.');
  });
});
enifed('ember-metal/observer.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal');
  test('ember-metal/observer.js should pass jscs', function () {
    ok(true, 'ember-metal/observer.js should pass jscs.');
  });
});
enifed('ember-metal/observer.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal');
  QUnit.test('ember-metal/observer.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/observer.js should pass jshint.');
  });
});
enifed('ember-metal/observer_set.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal');
  test('ember-metal/observer_set.js should pass jscs', function () {
    ok(true, 'ember-metal/observer_set.js should pass jscs.');
  });
});
enifed('ember-metal/observer_set.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal');
  QUnit.test('ember-metal/observer_set.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/observer_set.js should pass jshint.');
  });
});
enifed('ember-metal/path_cache.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal');
  test('ember-metal/path_cache.js should pass jscs', function () {
    ok(true, 'ember-metal/path_cache.js should pass jscs.');
  });
});
enifed('ember-metal/path_cache.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal');
  QUnit.test('ember-metal/path_cache.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/path_cache.js should pass jshint.');
  });
});
enifed('ember-metal/properties.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal');
  test('ember-metal/properties.js should pass jscs', function () {
    ok(true, 'ember-metal/properties.js should pass jscs.');
  });
});
enifed('ember-metal/properties.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal');
  QUnit.test('ember-metal/properties.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/properties.js should pass jshint.');
  });
});
enifed('ember-metal/property_events.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal');
  test('ember-metal/property_events.js should pass jscs', function () {
    ok(true, 'ember-metal/property_events.js should pass jscs.');
  });
});
enifed('ember-metal/property_events.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal');
  QUnit.test('ember-metal/property_events.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/property_events.js should pass jshint.');
  });
});
enifed('ember-metal/property_get.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal');
  test('ember-metal/property_get.js should pass jscs', function () {
    ok(true, 'ember-metal/property_get.js should pass jscs.');
  });
});
enifed('ember-metal/property_get.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal');
  QUnit.test('ember-metal/property_get.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/property_get.js should pass jshint.');
  });
});
enifed('ember-metal/property_set.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal');
  test('ember-metal/property_set.js should pass jscs', function () {
    ok(true, 'ember-metal/property_set.js should pass jscs.');
  });
});
enifed('ember-metal/property_set.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal');
  QUnit.test('ember-metal/property_set.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/property_set.js should pass jshint.');
  });
});
enifed('ember-metal/replace.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal');
  test('ember-metal/replace.js should pass jscs', function () {
    ok(true, 'ember-metal/replace.js should pass jscs.');
  });
});
enifed('ember-metal/replace.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal');
  QUnit.test('ember-metal/replace.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/replace.js should pass jshint.');
  });
});
enifed('ember-metal/run_loop.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal');
  test('ember-metal/run_loop.js should pass jscs', function () {
    ok(true, 'ember-metal/run_loop.js should pass jscs.');
  });
});
enifed('ember-metal/run_loop.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal');
  QUnit.test('ember-metal/run_loop.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/run_loop.js should pass jshint.');
  });
});
enifed('ember-metal/set_properties.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal');
  test('ember-metal/set_properties.js should pass jscs', function () {
    ok(true, 'ember-metal/set_properties.js should pass jscs.');
  });
});
enifed('ember-metal/set_properties.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal');
  QUnit.test('ember-metal/set_properties.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/set_properties.js should pass jshint.');
  });
});
enifed('ember-metal/streams/conditional.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/streams');
  test('ember-metal/streams/conditional.js should pass jscs', function () {
    ok(true, 'ember-metal/streams/conditional.js should pass jscs.');
  });
});
enifed('ember-metal/streams/conditional.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/streams');
  QUnit.test('ember-metal/streams/conditional.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/streams/conditional.js should pass jshint.');
  });
});
enifed('ember-metal/streams/dependency.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/streams');
  test('ember-metal/streams/dependency.js should pass jscs', function () {
    ok(true, 'ember-metal/streams/dependency.js should pass jscs.');
  });
});
enifed('ember-metal/streams/dependency.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/streams');
  QUnit.test('ember-metal/streams/dependency.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/streams/dependency.js should pass jshint.');
  });
});
enifed('ember-metal/streams/key-stream.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/streams');
  test('ember-metal/streams/key-stream.js should pass jscs', function () {
    ok(true, 'ember-metal/streams/key-stream.js should pass jscs.');
  });
});
enifed('ember-metal/streams/key-stream.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/streams');
  QUnit.test('ember-metal/streams/key-stream.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/streams/key-stream.js should pass jshint.');
  });
});
enifed('ember-metal/streams/proxy-stream.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/streams');
  test('ember-metal/streams/proxy-stream.js should pass jscs', function () {
    ok(true, 'ember-metal/streams/proxy-stream.js should pass jscs.');
  });
});
enifed('ember-metal/streams/proxy-stream.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/streams');
  QUnit.test('ember-metal/streams/proxy-stream.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/streams/proxy-stream.js should pass jshint.');
  });
});
enifed('ember-metal/streams/stream.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/streams');
  test('ember-metal/streams/stream.js should pass jscs', function () {
    ok(true, 'ember-metal/streams/stream.js should pass jscs.');
  });
});
enifed('ember-metal/streams/stream.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/streams');
  QUnit.test('ember-metal/streams/stream.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/streams/stream.js should pass jshint.');
  });
});
enifed('ember-metal/streams/subscriber.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/streams');
  test('ember-metal/streams/subscriber.js should pass jscs', function () {
    ok(true, 'ember-metal/streams/subscriber.js should pass jscs.');
  });
});
enifed('ember-metal/streams/subscriber.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/streams');
  QUnit.test('ember-metal/streams/subscriber.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/streams/subscriber.js should pass jshint.');
  });
});
enifed('ember-metal/streams/utils.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/streams');
  test('ember-metal/streams/utils.js should pass jscs', function () {
    ok(true, 'ember-metal/streams/utils.js should pass jscs.');
  });
});
enifed('ember-metal/streams/utils.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/streams');
  QUnit.test('ember-metal/streams/utils.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/streams/utils.js should pass jshint.');
  });
});
enifed('ember-metal/symbol.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal');
  test('ember-metal/symbol.js should pass jscs', function () {
    ok(true, 'ember-metal/symbol.js should pass jscs.');
  });
});
enifed('ember-metal/symbol.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal');
  QUnit.test('ember-metal/symbol.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/symbol.js should pass jshint.');
  });
});
enifed('ember-metal/tests/accessors/get_path_test', ['exports', 'ember-metal/property_get'], function (exports, _emberMetalProperty_get) {
  'use strict';

  var obj;
  var moduleOpts = {
    setup: function () {
      obj = {
        foo: {
          bar: {
            baz: { biff: 'BIFF' }
          }
        },
        foothis: {
          bar: {
            baz: { biff: 'BIFF' }
          }
        },
        falseValue: false,
        emptyString: '',
        Wuz: {
          nar: 'foo'
        }
      };
    },

    teardown: function () {
      obj = undefined;
    }
  };

  QUnit.module('Ember.get with path', moduleOpts);

  // ..........................................................
  // LOCAL PATHS
  //

  QUnit.test('[obj, foo] -> obj.foo', function () {
    deepEqual(_emberMetalProperty_get.get(obj, 'foo'), obj.foo);
  });

  QUnit.test('[obj, foo.bar] -> obj.foo.bar', function () {
    deepEqual(_emberMetalProperty_get.get(obj, 'foo.bar'), obj.foo.bar);
  });

  QUnit.test('[obj, foothis.bar] -> obj.foothis.bar', function () {
    deepEqual(_emberMetalProperty_get.get(obj, 'foothis.bar'), obj.foothis.bar);
  });

  QUnit.test('[obj, falseValue.notDefined] -> (undefined)', function () {
    equal(_emberMetalProperty_get.get(obj, 'falseValue.notDefined'), undefined);
  });

  QUnit.test('[obj, emptyString.length] -> 0', function () {
    equal(_emberMetalProperty_get.get(obj, 'emptyString.length'), 0);
  });

  // ..........................................................
  // GLOBAL PATHS TREATED LOCAL WITH GET
  //

  QUnit.test('[obj, Wuz] -> obj.Wuz', function () {
    deepEqual(_emberMetalProperty_get.get(obj, 'Wuz'), obj.Wuz);
  });

  QUnit.test('[obj, Wuz.nar] -> obj.Wuz.nar', function () {
    deepEqual(_emberMetalProperty_get.get(obj, 'Wuz.nar'), obj.Wuz.nar);
  });

  QUnit.test('[obj, Foo] -> (undefined)', function () {
    equal(_emberMetalProperty_get.get(obj, 'Foo'), undefined);
  });

  QUnit.test('[obj, Foo.bar] -> (undefined)', function () {
    equal(_emberMetalProperty_get.get(obj, 'Foo.bar'), undefined);
  });
});
enifed('ember-metal/tests/accessors/get_path_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests/accessors');
  test('ember-metal/tests/accessors/get_path_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/accessors/get_path_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/accessors/get_path_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests/accessors');
  QUnit.test('ember-metal/tests/accessors/get_path_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/accessors/get_path_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/accessors/get_properties_test', ['exports', 'ember-metal/get_properties'], function (exports, _emberMetalGet_properties) {
  'use strict';

  QUnit.module('Ember.getProperties');

  QUnit.test('can retrieve a hash of properties from an object via an argument list or array of property names', function () {
    var obj = {
      firstName: 'Steve',
      lastName: 'Jobs',
      companyName: 'Apple, Inc.'
    };

    deepEqual(_emberMetalGet_properties.default(obj, 'firstName', 'lastName'), { firstName: 'Steve', lastName: 'Jobs' });
    deepEqual(_emberMetalGet_properties.default(obj, 'firstName', 'lastName'), { firstName: 'Steve', lastName: 'Jobs' });
    deepEqual(_emberMetalGet_properties.default(obj, 'lastName'), { lastName: 'Jobs' });
    deepEqual(_emberMetalGet_properties.default(obj), {});
    deepEqual(_emberMetalGet_properties.default(obj, ['firstName', 'lastName']), { firstName: 'Steve', lastName: 'Jobs' });
    deepEqual(_emberMetalGet_properties.default(obj, ['firstName']), { firstName: 'Steve' });
    deepEqual(_emberMetalGet_properties.default(obj, []), {});
  });
});
enifed('ember-metal/tests/accessors/get_properties_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests/accessors');
  test('ember-metal/tests/accessors/get_properties_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/accessors/get_properties_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/accessors/get_properties_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests/accessors');
  QUnit.test('ember-metal/tests/accessors/get_properties_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/accessors/get_properties_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/accessors/get_test', ['exports', 'ember-metal/tests/props_helper', 'ember-metal/property_get', 'ember-metal/mixin', 'ember-metal/observer'], function (exports, _emberMetalTestsProps_helper, _emberMetalProperty_get, _emberMetalMixin, _emberMetalObserver) {
  'use strict';

  QUnit.module('Ember.get');

  QUnit.test('should get arbitrary properties on an object', function () {
    var obj = {
      string: 'string',
      number: 23,
      boolTrue: true,
      boolFalse: false,
      nullValue: null
    };

    for (var key in obj) {
      if (!obj.hasOwnProperty(key)) {
        continue;
      }
      equal(_emberMetalProperty_get.get(obj, key), obj[key], key);
    }
  });

  _emberMetalTestsProps_helper.testBoth('should call unknownProperty on watched values if the value is undefined', function (get, set) {
    var obj = {
      count: 0,
      unknownProperty: function (key) {
        equal(key, 'foo', 'should pass key');
        this.count++;
        return 'FOO';
      }
    };

    var count = 0;
    _emberMetalObserver.addObserver(obj, 'foo', function () {
      count++;
    });

    equal(get(obj, 'foo'), 'FOO', 'should return value from unknown');
  });

  QUnit.test('warn on attemps to call get with no arguments', function () {
    expectAssertion(function () {
      _emberMetalProperty_get.get('aProperty');
    }, /Get must be called with two arguments;/i);
  });

  QUnit.test('warn on attemps to call get with only one argument', function () {
    expectAssertion(function () {
      _emberMetalProperty_get.get('aProperty');
    }, /Get must be called with two arguments;/i);
  });

  QUnit.test('warn on attemps to call get with more then two arguments', function () {
    expectAssertion(function () {
      _emberMetalProperty_get.get({}, 'aProperty', true);
    }, /Get must be called with two arguments;/i);
  });

  QUnit.test('warn on attempts to get a property of undefined', function () {
    expectAssertion(function () {
      _emberMetalProperty_get.get(undefined, 'aProperty');
    }, /Cannot call get with 'aProperty' on an undefined object/i);
  });

  QUnit.test('warn on attempts to get a property path of undefined', function () {
    expectAssertion(function () {
      _emberMetalProperty_get.get(undefined, 'aProperty.on.aPath');
    }, /Cannot call get with 'aProperty.on.aPath' on an undefined object/);
  });

  QUnit.test('warn on attempts to get a property of null', function () {
    expectAssertion(function () {
      _emberMetalProperty_get.get(null, 'aProperty');
    }, /Cannot call get with 'aProperty' on an undefined object/);
  });

  QUnit.test('warn on attempts to get a property path of null', function () {
    expectAssertion(function () {
      _emberMetalProperty_get.get(null, 'aProperty.on.aPath');
    }, /Cannot call get with 'aProperty.on.aPath' on an undefined object/);
  });

  QUnit.test('warn on attempts to use get with an unsupported property path', function () {
    var obj = {};
    expectAssertion(function () {
      _emberMetalProperty_get.get(obj, null);
    }, /The key provided to get must be a string, you passed null/);
    expectAssertion(function () {
      _emberMetalProperty_get.get(obj, NaN);
    }, /The key provided to get must be a string, you passed NaN/);
    expectAssertion(function () {
      _emberMetalProperty_get.get(obj, undefined);
    }, /The key provided to get must be a string, you passed undefined/);
    expectAssertion(function () {
      _emberMetalProperty_get.get(obj, false);
    }, /The key provided to get must be a string, you passed false/);
    expectAssertion(function () {
      _emberMetalProperty_get.get(obj, 42);
    }, /The key provided to get must be a string, you passed 42/);
  });

  // ..........................................................
  // BUGS
  //

  QUnit.test('(regression) watched properties on unmodified inherited objects should still return their original value', function () {

    var MyMixin = _emberMetalMixin.Mixin.create({
      someProperty: 'foo',
      propertyDidChange: _emberMetalMixin.observer('someProperty', function () {
        // NOTHING TO DO
      })
    });

    var baseObject = MyMixin.apply({});
    var theRealObject = Object.create(baseObject);

    equal(_emberMetalProperty_get.get(theRealObject, 'someProperty'), 'foo', 'should return the set value, not false');
  });

  QUnit.module('Ember.getWithDefault');

  QUnit.test('should get arbitrary properties on an object', function () {
    var obj = {
      string: 'string',
      number: 23,
      boolTrue: true,
      boolFalse: false,
      nullValue: null
    };

    for (var key in obj) {
      if (!obj.hasOwnProperty(key)) {
        continue;
      }
      equal(_emberMetalProperty_get.getWithDefault(obj, key, 'fail'), obj[key], key);
    }

    obj = {
      undef: undefined
    };

    equal(_emberMetalProperty_get.getWithDefault(obj, 'undef', 'default'), 'default', 'explicit undefined retrieves the default');
    equal(_emberMetalProperty_get.getWithDefault(obj, 'not-present', 'default'), 'default', 'non-present key retrieves the default');
  });

  QUnit.test('should call unknownProperty if defined and value is undefined', function () {

    var obj = {
      count: 0,
      unknownProperty: function (key) {
        equal(key, 'foo', 'should pass key');
        this.count++;
        return 'FOO';
      }
    };

    equal(_emberMetalProperty_get.get(obj, 'foo'), 'FOO', 'should return value from unknown');
    equal(obj.count, 1, 'should have invoked');
  });

  _emberMetalTestsProps_helper.testBoth('if unknownProperty is present, it is called', function (get, set) {
    var obj = {
      count: 0,
      unknownProperty: function (key) {
        if (key === 'foo') {
          equal(key, 'foo', 'should pass key');
          this.count++;
          return 'FOO';
        }
      }
    };

    var count = 0;
    _emberMetalObserver.addObserver(obj, 'foo', function () {
      count++;
    });

    equal(_emberMetalProperty_get.getWithDefault(obj, 'foo', 'fail'), 'FOO', 'should return value from unknownProperty');
    equal(_emberMetalProperty_get.getWithDefault(obj, 'bar', 'default'), 'default', 'should convert undefined from unknownProperty into default');
  });

  // ..........................................................
  // BUGS
  //

  QUnit.test('(regression) watched properties on unmodified inherited objects should still return their original value', function () {

    var MyMixin = _emberMetalMixin.Mixin.create({
      someProperty: 'foo',
      propertyDidChange: _emberMetalMixin.observer('someProperty', function () {
        // NOTHING TO DO
      })
    });

    var baseObject = MyMixin.apply({});
    var theRealObject = Object.create(baseObject);

    equal(_emberMetalProperty_get.getWithDefault(theRealObject, 'someProperty', 'fail'), 'foo', 'should return the set value, not false');
  });
});
enifed('ember-metal/tests/accessors/get_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests/accessors');
  test('ember-metal/tests/accessors/get_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/accessors/get_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/accessors/get_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests/accessors');
  QUnit.test('ember-metal/tests/accessors/get_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/accessors/get_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/accessors/is_global_path_test', ['exports', 'ember-metal/binding'], function (exports, _emberMetalBinding) {
  'use strict';

  QUnit.module('Ember.isGlobalPath');

  QUnit.test('global path\'s are recognized', function () {
    ok(_emberMetalBinding.isGlobalPath('App.myProperty'));
    ok(_emberMetalBinding.isGlobalPath('App.myProperty.subProperty'));
  });

  QUnit.test('if there is a \'this\' in the path, it\'s not a global path', function () {
    ok(!_emberMetalBinding.isGlobalPath('this.myProperty'));
    ok(!_emberMetalBinding.isGlobalPath('this'));
  });

  QUnit.test('if the path starts with a lowercase character, it is not a global path', function () {
    ok(!_emberMetalBinding.isGlobalPath('myObj'));
    ok(!_emberMetalBinding.isGlobalPath('myObj.SecondProperty'));
  });
});
enifed('ember-metal/tests/accessors/is_global_path_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests/accessors');
  test('ember-metal/tests/accessors/is_global_path_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/accessors/is_global_path_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/accessors/is_global_path_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests/accessors');
  QUnit.test('ember-metal/tests/accessors/is_global_path_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/accessors/is_global_path_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/accessors/mandatory_setters_test', ['exports', 'ember-metal/features', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/watching', 'ember-metal/utils'], function (exports, _emberMetalFeatures, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalWatching, _emberMetalUtils) {
  'use strict';

  QUnit.module('mandatory-setters');

  function hasMandatorySetter(object, property) {
    var meta = _emberMetalUtils.meta(object);

    return property in meta.values;
  }

  QUnit.test('does not assert if property is not being watched', function () {
    var obj = {
      someProp: null,
      toString: function () {
        return 'custom-object';
      }
    };

    obj.someProp = 'blastix';
    equal(_emberMetalProperty_get.get(obj, 'someProp'), 'blastix');
  });

  QUnit.test('should not setup mandatory-setter if property is not writable', function () {
    expect(6);

    var obj = {};

    Object.defineProperty(obj, 'a', { value: true });
    Object.defineProperty(obj, 'b', { value: false });
    Object.defineProperty(obj, 'c', { value: undefined });
    Object.defineProperty(obj, 'd', { value: undefined, writable: false });
    Object.defineProperty(obj, 'e', { value: undefined, configurable: false });
    Object.defineProperty(obj, 'f', { value: undefined, configurable: true });

    _emberMetalWatching.watch(obj, 'a');
    _emberMetalWatching.watch(obj, 'b');
    _emberMetalWatching.watch(obj, 'c');
    _emberMetalWatching.watch(obj, 'd');
    _emberMetalWatching.watch(obj, 'e');
    _emberMetalWatching.watch(obj, 'f');

    ok(!hasMandatorySetter(obj, 'a'), 'mandatory-setter should not be installed');
    ok(!hasMandatorySetter(obj, 'b'), 'mandatory-setter should not be installed');
    ok(!hasMandatorySetter(obj, 'c'), 'mandatory-setter should not be installed');
    ok(!hasMandatorySetter(obj, 'd'), 'mandatory-setter should not be installed');
    ok(!hasMandatorySetter(obj, 'e'), 'mandatory-setter should not be installed');
    ok(!hasMandatorySetter(obj, 'f'), 'mandatory-setter should not be installed');
  });

  QUnit.test('should not setup mandatory-setter if setter is already setup on property', function () {
    expect(2);

    var obj = { someProp: null };

    Object.defineProperty(obj, 'someProp', {
      set: function (value) {
        equal(value, 'foo-bar', 'custom setter was called');
      }
    });

    _emberMetalWatching.watch(obj, 'someProp');
    ok(!hasMandatorySetter(obj, 'someProp'), 'mandatory-setter should not be installed');

    obj.someProp = 'foo-bar';
  });

  QUnit.test('should assert if set without Ember.set when property is being watched', function () {
    var obj = {
      someProp: null,
      toString: function () {
        return 'custom-object';
      }
    };

    _emberMetalWatching.watch(obj, 'someProp');

    expectAssertion(function () {
      obj.someProp = 'foo-bar';
    }, 'You must use Ember.set() to set the `someProp` property (of custom-object) to `foo-bar`.');
  });

  QUnit.test('should not assert if set with Ember.set when property is being watched', function () {
    var obj = {
      someProp: null,
      toString: function () {
        return 'custom-object';
      }
    };

    _emberMetalWatching.watch(obj, 'someProp');
    _emberMetalProperty_set.set(obj, 'someProp', 'foo-bar');

    equal(_emberMetalProperty_get.get(obj, 'someProp'), 'foo-bar');
  });

  QUnit.test('does not setup mandatory-setter if non-configurable', function () {
    var obj = {
      someProp: null,
      toString: function () {
        return 'custom-object';
      }
    };
    var meta = _emberMetalUtils.meta(obj);

    Object.defineProperty(obj, 'someProp', {
      configurable: false,
      enumerable: true,
      value: 'blastix'
    });

    _emberMetalWatching.watch(obj, 'someProp');
    ok(!('someProp' in meta.values), 'blastix');
  });

  QUnit.test('sets up mandatory-setter if property comes from prototype', function () {
    expect(2);

    var obj = {
      someProp: null,
      toString: function () {
        return 'custom-object';
      }
    };
    var obj2 = Object.create(obj);

    _emberMetalWatching.watch(obj2, 'someProp');
    var meta = _emberMetalUtils.meta(obj2);

    ok('someProp' in meta.values, 'mandatory setter has been setup');

    expectAssertion(function () {
      obj2.someProp = 'foo-bar';
    }, 'You must use Ember.set() to set the `someProp` property (of custom-object) to `foo-bar`.');
  });
});
enifed('ember-metal/tests/accessors/mandatory_setters_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests/accessors');
  test('ember-metal/tests/accessors/mandatory_setters_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/accessors/mandatory_setters_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/accessors/mandatory_setters_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests/accessors');
  QUnit.test('ember-metal/tests/accessors/mandatory_setters_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/accessors/mandatory_setters_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/accessors/normalize_tuple_test', ['exports', 'ember-metal/core', 'ember-metal/property_get'], function (exports, _emberMetalCore, _emberMetalProperty_get) {
  /*globals Foo:true, $foo:true */
  'use strict';

  var obj;
  var moduleOpts = {
    setup: function () {
      obj = {
        foo: {
          bar: {
            baz: {}
          }
        }
      };

      window.Foo = {
        bar: {
          baz: {}
        }
      };

      window.$foo = {
        bar: {
          baz: {}
        }
      };
    },

    teardown: function () {
      obj = undefined;
      window.Foo = undefined;
      window.$foo = undefined;
    }
  };

  QUnit.module('normalizeTuple', moduleOpts);

  // ..........................................................
  // LOCAL PATHS
  //

  QUnit.test('[obj, foo] -> [obj, foo]', function () {
    deepEqual(_emberMetalProperty_get.normalizeTuple(obj, 'foo'), [obj, 'foo']);
  });

  QUnit.test('[obj, *] -> [obj, *]', function () {
    deepEqual(_emberMetalProperty_get.normalizeTuple(obj, '*'), [obj, '*']);
  });

  QUnit.test('[obj, foo.bar] -> [obj, foo.bar]', function () {
    deepEqual(_emberMetalProperty_get.normalizeTuple(obj, 'foo.bar'), [obj, 'foo.bar']);
  });

  QUnit.test('[obj, foo.*] -> [obj, foo.*]', function () {
    deepEqual(_emberMetalProperty_get.normalizeTuple(obj, 'foo.*'), [obj, 'foo.*']);
  });

  QUnit.test('[obj, foo.*.baz] -> [obj, foo.*.baz]', function () {
    deepEqual(_emberMetalProperty_get.normalizeTuple(obj, 'foo.*.baz'), [obj, 'foo.*.baz']);
  });

  QUnit.test('[obj, this.foo] -> [obj, foo]', function () {
    deepEqual(_emberMetalProperty_get.normalizeTuple(obj, 'this.foo'), [obj, 'foo']);
  });

  QUnit.test('[obj, this.foo.bar] -> [obj, foo.bar]', function () {
    deepEqual(_emberMetalProperty_get.normalizeTuple(obj, 'this.foo.bar'), [obj, 'foo.bar']);
  });

  QUnit.test('[obj, this.Foo.bar] -> [obj, Foo.bar]', function () {
    deepEqual(_emberMetalProperty_get.normalizeTuple(obj, 'this.Foo.bar'), [obj, 'Foo.bar']);
  });

  // ..........................................................
  // GLOBAL PATHS
  //

  QUnit.test('[obj, Foo] -> [Ember.lookup, Foo]', function () {
    deepEqual(_emberMetalProperty_get.normalizeTuple(obj, 'Foo'), [_emberMetalCore.default.lookup, 'Foo']);
  });

  QUnit.test('[obj, Foo.bar] -> [Foo, bar]', function () {
    deepEqual(_emberMetalProperty_get.normalizeTuple(obj, 'Foo.bar'), [Foo, 'bar']);
  });

  QUnit.test('[obj, $foo.bar.baz] -> [$foo, bar.baz]', function () {
    deepEqual(_emberMetalProperty_get.normalizeTuple(obj, '$foo.bar.baz'), [$foo, 'bar.baz']);
  });

  // ..........................................................
  // NO TARGET
  //

  QUnit.test('[null, Foo] -> [Ember.lookup, Foo]', function () {
    deepEqual(_emberMetalProperty_get.normalizeTuple(null, 'Foo'), [_emberMetalCore.default.lookup, 'Foo']);
  });

  QUnit.test('[null, Foo.bar] -> [Foo, bar]', function () {
    deepEqual(_emberMetalProperty_get.normalizeTuple(null, 'Foo.bar'), [Foo, 'bar']);
  });

  QUnit.test('[null, foo] -> [undefined, \'\']', function () {
    deepEqual(_emberMetalProperty_get.normalizeTuple(null, 'foo'), [undefined, '']);
  });

  QUnit.test('[null, foo.bar] -> [undefined, \'\']', function () {
    deepEqual(_emberMetalProperty_get.normalizeTuple(null, 'foo'), [undefined, '']);
  });

  QUnit.test('[null, $foo] -> [Ember.lookup, $foo]', function () {
    deepEqual(_emberMetalProperty_get.normalizeTuple(null, '$foo'), [_emberMetalCore.default.lookup, '$foo']);
  });

  QUnit.test('[null, $foo.bar] -> [$foo, bar]', function () {
    deepEqual(_emberMetalProperty_get.normalizeTuple(null, '$foo.bar'), [$foo, 'bar']);
  });
});
enifed('ember-metal/tests/accessors/normalize_tuple_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests/accessors');
  test('ember-metal/tests/accessors/normalize_tuple_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/accessors/normalize_tuple_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/accessors/normalize_tuple_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests/accessors');
  QUnit.test('ember-metal/tests/accessors/normalize_tuple_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/accessors/normalize_tuple_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/accessors/set_path_test', ['exports', 'ember-metal/core', 'ember-metal/property_set', 'ember-metal/property_get'], function (exports, _emberMetalCore, _emberMetalProperty_set, _emberMetalProperty_get) {
  'use strict';

  var obj;
  function commonSetup() {
    obj = {
      foo: {
        bar: {
          baz: { biff: 'BIFF' }
        }
      }
    };
  }

  function commonTeardown() {
    obj = null;
  }

  QUnit.module('set with path', {
    setup: commonSetup,
    teardown: commonTeardown
  });

  QUnit.test('[Foo, bar] -> Foo.bar', function () {
    _emberMetalCore.default.lookup.Foo = { toString: function () {
        return 'Foo';
      } }; // Behave like an Ember.Namespace

    _emberMetalProperty_set.set(_emberMetalCore.default.lookup.Foo, 'bar', 'baz');
    equal(_emberMetalProperty_get.get(_emberMetalCore.default.lookup.Foo, 'bar'), 'baz');
  });

  // ..........................................................
  //
  // LOCAL PATHS

  QUnit.test('[obj, foo] -> obj.foo', function () {
    _emberMetalProperty_set.set(obj, 'foo', 'BAM');
    equal(_emberMetalProperty_get.get(obj, 'foo'), 'BAM');
  });

  QUnit.test('[obj, foo.bar] -> obj.foo.bar', function () {
    _emberMetalProperty_set.set(obj, 'foo.bar', 'BAM');
    equal(_emberMetalProperty_get.get(obj, 'foo.bar'), 'BAM');
  });

  // ..........................................................
  // DEPRECATED
  //

  QUnit.module('set with path - deprecated', {
    setup: commonSetup,
    teardown: commonTeardown
  });

  QUnit.test('[obj, bla.bla] gives a proper exception message', function () {
    var exceptionMessage = 'Property set failed: object in path \"bla\" could not be found or was destroyed.';
    try {
      _emberMetalProperty_set.set(obj, 'bla.bla', 'BAM');
    } catch (ex) {
      equal(ex.message, exceptionMessage);
    }
  });

  QUnit.test('[obj, foo.baz.bat] -> EXCEPTION', function () {
    throws(function () {
      _emberMetalProperty_set.set(obj, 'foo.baz.bat', 'BAM');
    }, Error);
  });

  QUnit.test('[obj, foo.baz.bat] -> EXCEPTION', function () {
    _emberMetalProperty_set.trySet(obj, 'foo.baz.bat', 'BAM');
    ok(true, 'does not raise');
  });
});
enifed('ember-metal/tests/accessors/set_path_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests/accessors');
  test('ember-metal/tests/accessors/set_path_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/accessors/set_path_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/accessors/set_path_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests/accessors');
  QUnit.test('ember-metal/tests/accessors/set_path_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/accessors/set_path_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/accessors/set_test', ['exports', 'ember-metal/property_get', 'ember-metal/property_set'], function (exports, _emberMetalProperty_get, _emberMetalProperty_set) {
  'use strict';

  QUnit.module('set');

  QUnit.test('should set arbitrary properties on an object', function () {
    var obj = {
      string: 'string',
      number: 23,
      boolTrue: true,
      boolFalse: false,
      nullValue: null,
      undefinedValue: undefined
    };

    var newObj = {
      undefinedValue: 'emberjs'
    };

    for (var key in obj) {
      if (!obj.hasOwnProperty(key)) {
        continue;
      }

      equal(_emberMetalProperty_set.set(newObj, key, obj[key]), obj[key], 'should return value');
      equal(_emberMetalProperty_get.get(newObj, key), obj[key], 'should set value');
    }
  });

  QUnit.test('should call setUnknownProperty if defined and value is undefined', function () {

    var obj = {
      count: 0,

      unknownProperty: function (key, value) {
        ok(false, 'should not invoke unknownProperty if setUnknownProperty is defined');
      },

      setUnknownProperty: function (key, value) {
        equal(key, 'foo', 'should pass key');
        equal(value, 'BAR', 'should pass key');
        this.count++;
        return 'FOO';
      }
    };

    equal(_emberMetalProperty_set.set(obj, 'foo', 'BAR'), 'BAR', 'should return set value');
    equal(obj.count, 1, 'should have invoked');
  });

  QUnit.test('warn on attempts to call set with undefined as object', function () {
    expectAssertion(function () {
      _emberMetalProperty_set.set(undefined, 'aProperty', 'BAM');
    }, /Cannot call set with 'aProperty' on an undefined object./);
  });

  QUnit.test('warn on attempts to call set with null as object', function () {
    expectAssertion(function () {
      _emberMetalProperty_set.set(null, 'aProperty', 'BAM');
    }, /Cannot call set with 'aProperty' on an undefined object./);
  });

  QUnit.test('warn on attempts to use set with an unsupported property path', function () {
    var obj = {};
    expectAssertion(function () {
      _emberMetalProperty_set.set(obj, null, 42);
    }, /The key provided to set must be a string, you passed null/);
    expectAssertion(function () {
      _emberMetalProperty_set.set(obj, NaN, 42);
    }, /The key provided to set must be a string, you passed NaN/);
    expectAssertion(function () {
      _emberMetalProperty_set.set(obj, undefined, 42);
    }, /The key provided to set must be a string, you passed undefined/);
    expectAssertion(function () {
      _emberMetalProperty_set.set(obj, false, 42);
    }, /The key provided to set must be a string, you passed false/);
    expectAssertion(function () {
      _emberMetalProperty_set.set(obj, 42, 42);
    }, /The key provided to set must be a string, you passed 42/);
  });
});
enifed('ember-metal/tests/accessors/set_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests/accessors');
  test('ember-metal/tests/accessors/set_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/accessors/set_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/accessors/set_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests/accessors');
  QUnit.test('ember-metal/tests/accessors/set_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/accessors/set_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/alias_test', ['exports', 'ember-metal/alias', 'ember-metal/properties', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/utils', 'ember-metal/watching', 'ember-metal/observer'], function (exports, _emberMetalAlias, _emberMetalProperties, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalUtils, _emberMetalWatching, _emberMetalObserver) {
  'use strict';

  var obj, count;

  QUnit.module('ember-metal/alias', {
    setup: function () {
      obj = { foo: { faz: 'FOO' } };
      count = 0;
    },
    teardown: function () {
      obj = null;
    }
  });

  function incrementCount() {
    count++;
  }

  QUnit.test('should proxy get to alt key', function () {
    _emberMetalProperties.defineProperty(obj, 'bar', _emberMetalAlias.default('foo.faz'));
    equal(_emberMetalProperty_get.get(obj, 'bar'), 'FOO');
  });

  QUnit.test('should proxy set to alt key', function () {
    _emberMetalProperties.defineProperty(obj, 'bar', _emberMetalAlias.default('foo.faz'));
    _emberMetalProperty_set.set(obj, 'bar', 'BAR');
    equal(_emberMetalProperty_get.get(obj, 'foo.faz'), 'BAR');
  });

  QUnit.test('basic lifecycle', function () {
    _emberMetalProperties.defineProperty(obj, 'bar', _emberMetalAlias.default('foo.faz'));
    var m = _emberMetalUtils.meta(obj);
    _emberMetalObserver.addObserver(obj, 'bar', incrementCount);
    equal(m.deps['foo.faz'].bar, 1);
    _emberMetalObserver.removeObserver(obj, 'bar', incrementCount);
    equal(m.deps['foo.faz'].bar, 0);
  });

  QUnit.test('old dependent keys should not trigger property changes', function () {
    var obj1 = Object.create(null);
    _emberMetalProperties.defineProperty(obj1, 'foo', null, null);
    _emberMetalProperties.defineProperty(obj1, 'bar', _emberMetalAlias.default('foo'));
    _emberMetalProperties.defineProperty(obj1, 'baz', _emberMetalAlias.default('foo'));
    _emberMetalProperties.defineProperty(obj1, 'baz', _emberMetalAlias.default('bar')); // redefine baz
    _emberMetalObserver.addObserver(obj1, 'baz', incrementCount);

    _emberMetalProperty_set.set(obj1, 'foo', 'FOO');
    equal(count, 1);

    _emberMetalObserver.removeObserver(obj1, 'baz', incrementCount);

    _emberMetalProperty_set.set(obj1, 'foo', 'OOF');
    equal(count, 1);
  });

  QUnit.test('overridden dependent keys should not trigger property changes', function () {
    var obj1 = Object.create(null);
    _emberMetalProperties.defineProperty(obj1, 'foo', null, null);
    _emberMetalProperties.defineProperty(obj1, 'bar', _emberMetalAlias.default('foo'));
    _emberMetalProperties.defineProperty(obj1, 'baz', _emberMetalAlias.default('foo'));
    _emberMetalObserver.addObserver(obj1, 'baz', incrementCount);

    var obj2 = Object.create(obj1);
    _emberMetalProperties.defineProperty(obj2, 'baz', _emberMetalAlias.default('bar')); // override baz

    _emberMetalProperty_set.set(obj2, 'foo', 'FOO');
    equal(count, 1);

    _emberMetalObserver.removeObserver(obj2, 'baz', incrementCount);

    _emberMetalProperty_set.set(obj2, 'foo', 'OOF');
    equal(count, 1);
  });

  QUnit.test('begins watching alt key as soon as alias is watched', function () {
    _emberMetalProperties.defineProperty(obj, 'bar', _emberMetalAlias.default('foo.faz'));
    _emberMetalObserver.addObserver(obj, 'bar', incrementCount);
    ok(_emberMetalWatching.isWatching(obj, 'foo.faz'));
    _emberMetalProperty_set.set(obj, 'foo.faz', 'BAR');
    equal(count, 1);
  });

  QUnit.test('immediately sets up dependencies if already being watched', function () {
    _emberMetalObserver.addObserver(obj, 'bar', incrementCount);
    _emberMetalProperties.defineProperty(obj, 'bar', _emberMetalAlias.default('foo.faz'));
    ok(_emberMetalWatching.isWatching(obj, 'foo.faz'));
    _emberMetalProperty_set.set(obj, 'foo.faz', 'BAR');
    equal(count, 1);
  });

  QUnit.test('setting alias on self should fail assertion', function () {
    expectAssertion(function () {
      _emberMetalProperties.defineProperty(obj, 'bar', _emberMetalAlias.default('bar'));
    }, 'Setting alias \'bar\' on self');
  });
});
enifed('ember-metal/tests/alias_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests');
  test('ember-metal/tests/alias_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/alias_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/alias_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests');
  QUnit.test('ember-metal/tests/alias_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/alias_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/binding/connect_test', ['exports', 'ember-metal/core', 'ember-metal/tests/props_helper', 'ember-metal/binding', 'ember-metal/run_loop', 'ember-metal/property_set', 'ember-metal/property_get'], function (exports, _emberMetalCore, _emberMetalTestsProps_helper, _emberMetalBinding, _emberMetalRun_loop, _emberMetalProperty_set, _emberMetalProperty_get) {
  'use strict';

  function performTest(binding, a, b, get, set, connect) {
    if (connect === undefined) {
      connect = function () {
        binding.connect(a);
      };
    }

    ok(!_emberMetalRun_loop.default.currentRunLoop, 'performTest should not have a currentRunLoop');

    equal(get(a, 'foo'), 'FOO', 'a should not have changed');
    equal(get(b, 'bar'), 'BAR', 'b should not have changed');

    connect();

    equal(get(a, 'foo'), 'BAR', 'a should have changed');
    equal(get(b, 'bar'), 'BAR', 'b should have changed');
    //
    // make sure changes sync both ways
    _emberMetalRun_loop.default(function () {
      set(b, 'bar', 'BAZZ');
    });
    equal(get(a, 'foo'), 'BAZZ', 'a should have changed');

    _emberMetalRun_loop.default(function () {
      set(a, 'foo', 'BARF');
    });
    equal(get(b, 'bar'), 'BARF', 'a should have changed');
  }

  var originalLookup, lookup, GlobalB;

  QUnit.module('Ember.Binding', {
    setup: function () {
      originalLookup = _emberMetalCore.default.lookup;
      _emberMetalCore.default.lookup = lookup = {};
    },
    teardown: function () {
      lookup = null;
      _emberMetalCore.default.lookup = originalLookup;
    }
  });

  _emberMetalTestsProps_helper.testBoth('Connecting a binding between two properties', function (get, set) {
    var a = { foo: 'FOO', bar: 'BAR' };

    // a.bar -> a.foo
    var binding = new _emberMetalBinding.Binding('foo', 'bar');

    performTest(binding, a, a, get, set);
  });

  _emberMetalTestsProps_helper.testBoth('Connecting a binding between two objects', function (get, set) {
    var b = { bar: 'BAR' };
    var a = { foo: 'FOO', b: b };

    // b.bar -> a.foo
    var binding = new _emberMetalBinding.Binding('foo', 'b.bar');

    performTest(binding, a, b, get, set);
  });

  _emberMetalTestsProps_helper.testBoth('Connecting a binding to path', function (get, set) {
    var a = { foo: 'FOO' };
    lookup['GlobalB'] = GlobalB = {
      b: { bar: 'BAR' }
    };

    var b = get(GlobalB, 'b');

    // globalB.b.bar -> a.foo
    var binding = new _emberMetalBinding.Binding('foo', 'GlobalB.b.bar');

    performTest(binding, a, b, get, set);

    // make sure modifications update
    b = { bar: 'BIFF' };

    _emberMetalRun_loop.default(function () {
      set(GlobalB, 'b', b);
    });

    equal(get(a, 'foo'), 'BIFF', 'a should have changed');
  });

  _emberMetalTestsProps_helper.testBoth('Calling connect more than once', function (get, set) {
    var b = { bar: 'BAR' };
    var a = { foo: 'FOO', b: b };

    // b.bar -> a.foo
    var binding = new _emberMetalBinding.Binding('foo', 'b.bar');

    performTest(binding, a, b, get, set, function () {
      binding.connect(a);

      binding.connect(a);
    });
  });

  QUnit.test('inherited bindings should sync on create', function () {
    var a;
    _emberMetalRun_loop.default(function () {
      var A = function () {
        _emberMetalBinding.bind(this, 'foo', 'bar.baz');
      };

      a = new A();
      _emberMetalProperty_set.set(a, 'bar', { baz: 'BAZ' });
    });

    equal(_emberMetalProperty_get.get(a, 'foo'), 'BAZ', 'should have synced binding on new obj');
  });
});
enifed('ember-metal/tests/binding/connect_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests/binding');
  test('ember-metal/tests/binding/connect_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/binding/connect_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/binding/connect_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests/binding');
  QUnit.test('ember-metal/tests/binding/connect_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/binding/connect_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/binding/sync_test', ['exports', 'ember-metal/tests/props_helper', 'ember-metal/run_loop', 'ember-metal/observer', 'ember-metal/binding', 'ember-metal/computed', 'ember-metal/properties', 'ember-metal/property_events'], function (exports, _emberMetalTestsProps_helper, _emberMetalRun_loop, _emberMetalObserver, _emberMetalBinding, _emberMetalComputed, _emberMetalProperties, _emberMetalProperty_events) {
  'use strict';

  QUnit.module('system/binding/sync_test.js');

  _emberMetalTestsProps_helper.testBoth('bindings should not sync twice in a single run loop', function (get, set) {
    var a, b, setValue;
    var setCalled = 0;
    var getCalled = 0;

    _emberMetalRun_loop.default(function () {
      a = {};

      _emberMetalProperties.defineProperty(a, 'foo', _emberMetalComputed.computed({
        get: function (key) {
          getCalled++;
          return setValue;
        },
        set: function (key, value) {
          setCalled++;
          _emberMetalProperty_events.propertyWillChange(this, key);
          setValue = value;
          _emberMetalProperty_events.propertyDidChange(this, key);
          return value;
        }
      }).volatile());

      b = {
        a: a
      };
      _emberMetalBinding.bind(b, 'foo', 'a.foo');
    });

    // reset after initial binding synchronization
    getCalled = 0;

    _emberMetalRun_loop.default(function () {
      set(a, 'foo', 'trollface');
    });

    equal(get(b, 'foo'), 'trollface', 'the binding should sync');
    equal(setCalled, 1, 'Set should only be called once');
    equal(getCalled, 1, 'Get should only be called once');
  });

  _emberMetalTestsProps_helper.testBoth('bindings should not infinite loop if computed properties return objects', function (get, set) {
    var a, b;
    var getCalled = 0;

    _emberMetalRun_loop.default(function () {
      a = {};

      _emberMetalProperties.defineProperty(a, 'foo', _emberMetalComputed.computed(function () {
        getCalled++;
        if (getCalled > 1000) {
          throw 'infinite loop detected';
        }
        return ['foo', 'bar'];
      }));

      b = {
        a: a
      };
      _emberMetalBinding.bind(b, 'foo', 'a.foo');
    });

    deepEqual(get(b, 'foo'), ['foo', 'bar'], 'the binding should sync');
    equal(getCalled, 1, 'Get should only be called once');
  });

  _emberMetalTestsProps_helper.testBoth('bindings should do the right thing when observers trigger bindings in the opposite direction', function (get, set) {
    var a, b, c;

    _emberMetalRun_loop.default(function () {
      a = {
        foo: 'trololol'
      };

      b = {
        a: a
      };
      _emberMetalBinding.bind(b, 'foo', 'a.foo');

      c = {
        a: a
      };
      _emberMetalBinding.bind(c, 'foo', 'a.foo');
    });

    _emberMetalObserver.addObserver(b, 'foo', function () {
      set(c, 'foo', 'what is going on');
    });

    _emberMetalRun_loop.default(function () {
      set(a, 'foo', 'trollface');
    });

    equal(get(a, 'foo'), 'what is going on');
  });

  _emberMetalTestsProps_helper.testBoth('bindings should not try to sync destroyed objects', function (get, set) {
    var a, b;

    _emberMetalRun_loop.default(function () {
      a = {
        foo: 'trololol'
      };

      b = {
        a: a
      };
      _emberMetalBinding.bind(b, 'foo', 'a.foo');
    });

    _emberMetalRun_loop.default(function () {
      set(a, 'foo', 'trollface');
      set(b, 'isDestroyed', true);
      ok(true, 'should not raise');
    });

    _emberMetalRun_loop.default(function () {
      a = {
        foo: 'trololol'
      };

      b = {
        a: a
      };
      _emberMetalBinding.bind(b, 'foo', 'a.foo');
    });

    _emberMetalRun_loop.default(function () {
      set(b, 'foo', 'trollface');
      set(a, 'isDestroyed', true);
      ok(true, 'should not raise');
    });
  });
});
enifed('ember-metal/tests/binding/sync_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests/binding');
  test('ember-metal/tests/binding/sync_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/binding/sync_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/binding/sync_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests/binding');
  QUnit.test('ember-metal/tests/binding/sync_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/binding/sync_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/cache_test', ['exports', 'ember-metal/cache'], function (exports, _emberMetalCache) {
  'use strict';

  QUnit.module('Cache');

  QUnit.test('basic', function () {
    var cache = new _emberMetalCache.default(100, function (key) {
      return key.toUpperCase();
    });

    equal(cache.get('foo'), 'FOO');
    equal(cache.get('bar'), 'BAR');
    equal(cache.get('foo'), 'FOO');
  });

  QUnit.test('caches computation correctly', function () {
    var count = 0;
    var cache = new _emberMetalCache.default(100, function (key) {
      count++;
      return key.toUpperCase();
    });

    equal(count, 0);
    cache.get('foo');
    equal(count, 1);
    cache.get('bar');
    equal(count, 2);
    cache.get('bar');
    equal(count, 2);
    cache.get('foo');
    equal(count, 2);
  });

  QUnit.test('handles undefined value correctly', function () {
    var cache = new _emberMetalCache.default(100, function (key) {});

    equal(cache.get('foo'), undefined);
  });

  QUnit.test('continues working after reaching cache limit', function () {
    var cache = new _emberMetalCache.default(3, function (key) {
      return key.toUpperCase();
    });

    cache.get('a');
    cache.get('b');
    cache.get('c');

    equal(cache.get('d'), 'D');
    equal(cache.get('a'), 'A');
    equal(cache.get('b'), 'B');
    equal(cache.get('c'), 'C');
  });
});
enifed('ember-metal/tests/cache_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests');
  test('ember-metal/tests/cache_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/cache_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/cache_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests');
  QUnit.test('ember-metal/tests/cache_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/cache_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/chains_test', ['exports', 'ember-metal/observer', 'ember-metal/property_get', 'ember-metal/chains', 'ember-metal/properties', 'ember-metal/computed', 'ember-metal/property_events'], function (exports, _emberMetalObserver, _emberMetalProperty_get, _emberMetalChains, _emberMetalProperties, _emberMetalComputed, _emberMetalProperty_events) {
  'use strict';

  QUnit.module('Chains');

  QUnit.test('finishChains should properly copy chains from prototypes to instances', function () {
    function didChange() {}

    var obj = {};
    _emberMetalObserver.addObserver(obj, 'foo.bar', null, didChange);

    var childObj = Object.create(obj);
    _emberMetalChains.finishChains(childObj);

    ok(obj['__ember_meta__'].chains !== childObj['__ember_meta__'].chains, 'The chains object is copied');
  });

  QUnit.test('observer and CP chains', function () {
    var obj = {};

    _emberMetalProperties.defineProperty(obj, 'foo', _emberMetalComputed.default('qux.[]', function () {}));
    _emberMetalProperties.defineProperty(obj, 'qux', _emberMetalComputed.default(function () {}));

    // create DK chains
    _emberMetalProperty_get.get(obj, 'foo');

    // create observer chain
    _emberMetalObserver.addObserver(obj, 'qux.length', function () {});

    /*
               +-----+
               | qux |   root CP
               +-----+
                  ^
           +------+-----+
           |            |
       +--------+    +----+
       | length |    | [] |  chainWatchers
       +--------+    +----+
        observer       CP(foo, 'qux.[]')
    */

    // invalidate qux
    _emberMetalProperty_events.propertyDidChange(obj, 'qux');

    // CP chain is blown away

    /*
               +-----+
               | qux |   root CP
               +-----+
                  ^
           +------+xxxxxx
           |            x
       +--------+    xxxxxx
       | length |    x [] x  chainWatchers
       +--------+    xxxxxx
        observer       CP(foo, 'qux.[]')
    */

    _emberMetalProperty_get.get(obj, 'qux'); // CP chain re-recreated
    ok(true, 'no crash');
  });
});
enifed('ember-metal/tests/chains_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests');
  test('ember-metal/tests/chains_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/chains_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/chains_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests');
  QUnit.test('ember-metal/tests/chains_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/chains_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/computed_test', ['exports', 'ember-metal/core', 'ember-metal/tests/props_helper', 'ember-metal/computed', 'ember-metal/properties', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/watching', 'ember-metal/observer'], function (exports, _emberMetalCore, _emberMetalTestsProps_helper, _emberMetalComputed, _emberMetalProperties, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalWatching, _emberMetalObserver) {
  'use strict';

  var obj, count;

  QUnit.module('computed');

  QUnit.test('computed property should be an instance of descriptor', function () {
    ok(_emberMetalComputed.computed(function () {}) instanceof _emberMetalProperties.Descriptor);
  });

  QUnit.test('defining computed property should invoke property on get', function () {

    var obj = {};
    var count = 0;
    _emberMetalProperties.defineProperty(obj, 'foo', _emberMetalComputed.computed(function (key) {
      count++;
      return 'computed ' + key;
    }));

    equal(_emberMetalProperty_get.get(obj, 'foo'), 'computed foo', 'should return value');
    equal(count, 1, 'should have invoked computed property');
  });

  QUnit.test('defining computed property should invoke property on set', function () {
    var obj = {};
    var count = 0;
    _emberMetalProperties.defineProperty(obj, 'foo', _emberMetalComputed.computed({
      get: function (key) {
        return this['__' + key];
      },
      set: function (key, value) {
        count++;
        this['__' + key] = 'computed ' + value;
        return this['__' + key];
      }
    }));

    equal(_emberMetalProperty_set.set(obj, 'foo', 'bar'), 'bar', 'should return set value');
    equal(count, 1, 'should have invoked computed property');
    equal(_emberMetalProperty_get.get(obj, 'foo'), 'computed bar', 'should return new value');
  });

  QUnit.test('defining a computed property with a dependent key ending with @each is deprecated', function () {
    expectAssertion(function () {
      _emberMetalComputed.computed('blazo.@each', function () {});
    }, 'Depending on arrays using a dependent key ending with `@each` is no longer supported. Please refactor from `Ember.computed(\'blazo.@each\', function() {});` to `Ember.computed(\'blazo.[]\', function() {})`.');

    expectAssertion(function () {
      _emberMetalComputed.computed('qux', 'zoopa.@each', function () {});
    }, 'Depending on arrays using a dependent key ending with `@each` is no longer supported. Please refactor from `Ember.computed(\'zoopa.@each\', function() {});` to `Ember.computed(\'zoopa.[]\', function() {})`.');
  });

  var objA, objB;
  QUnit.module('computed should inherit through prototype', {
    setup: function () {
      objA = { __foo: 'FOO' };
      _emberMetalProperties.defineProperty(objA, 'foo', _emberMetalComputed.computed({
        get: function (key) {
          return this['__' + key];
        },
        set: function (key, value) {
          this['__' + key] = 'computed ' + value;
          return this['__' + key];
        }
      }));

      objB = Object.create(objA);
      objB.__foo = 'FOO'; // make a copy;
    },

    teardown: function () {
      objA = objB = null;
    }
  });

  _emberMetalTestsProps_helper.testBoth('using get() and set()', function (get, set) {
    equal(get(objA, 'foo'), 'FOO', 'should get FOO from A');
    equal(get(objB, 'foo'), 'FOO', 'should get FOO from B');

    set(objA, 'foo', 'BIFF');
    equal(get(objA, 'foo'), 'computed BIFF', 'should change A');
    equal(get(objB, 'foo'), 'FOO', 'should NOT change B');

    set(objB, 'foo', 'bar');
    equal(get(objB, 'foo'), 'computed bar', 'should change B');
    equal(get(objA, 'foo'), 'computed BIFF', 'should NOT change A');

    set(objA, 'foo', 'BAZ');
    equal(get(objA, 'foo'), 'computed BAZ', 'should change A');
    equal(get(objB, 'foo'), 'computed bar', 'should NOT change B');
  });

  QUnit.module('redefining computed property to normal', {
    setup: function () {
      objA = { __foo: 'FOO' };
      _emberMetalProperties.defineProperty(objA, 'foo', _emberMetalComputed.computed({
        get: function (key) {
          return this['__' + key];
        },
        set: function (key, value) {
          this['__' + key] = 'computed ' + value;
          return this['__' + key];
        }
      }));

      objB = Object.create(objA);
      _emberMetalProperties.defineProperty(objB, 'foo'); // make this just a normal property.
    },

    teardown: function () {
      objA = objB = null;
    }
  });

  _emberMetalTestsProps_helper.testBoth('using get() and set()', function (get, set) {
    equal(get(objA, 'foo'), 'FOO', 'should get FOO from A');
    equal(get(objB, 'foo'), undefined, 'should get undefined from B');

    set(objA, 'foo', 'BIFF');
    equal(get(objA, 'foo'), 'computed BIFF', 'should change A');
    equal(get(objB, 'foo'), undefined, 'should NOT change B');

    set(objB, 'foo', 'bar');
    equal(get(objB, 'foo'), 'bar', 'should change B');
    equal(get(objA, 'foo'), 'computed BIFF', 'should NOT change A');

    set(objA, 'foo', 'BAZ');
    equal(get(objA, 'foo'), 'computed BAZ', 'should change A');
    equal(get(objB, 'foo'), 'bar', 'should NOT change B');
  });

  QUnit.module('redefining computed property to another property', {
    setup: function () {
      objA = { __foo: 'FOO' };
      _emberMetalProperties.defineProperty(objA, 'foo', _emberMetalComputed.computed({
        get: function (key) {
          return this['__' + key];
        },
        set: function (key, value) {
          this['__' + key] = 'A ' + value;
          return this['__' + key];
        }
      }));

      objB = Object.create(objA);
      objB.__foo = 'FOO';
      _emberMetalProperties.defineProperty(objB, 'foo', _emberMetalComputed.computed({
        get: function (key) {
          return this['__' + key];
        },
        set: function (key, value) {
          this['__' + key] = 'B ' + value;
          return this['__' + key];
        }
      }));
    },

    teardown: function () {
      objA = objB = null;
    }
  });

  _emberMetalTestsProps_helper.testBoth('using get() and set()', function (get, set) {
    equal(get(objA, 'foo'), 'FOO', 'should get FOO from A');
    equal(get(objB, 'foo'), 'FOO', 'should get FOO from B');

    set(objA, 'foo', 'BIFF');
    equal(get(objA, 'foo'), 'A BIFF', 'should change A');
    equal(get(objB, 'foo'), 'FOO', 'should NOT change B');

    set(objB, 'foo', 'bar');
    equal(get(objB, 'foo'), 'B bar', 'should change B');
    equal(get(objA, 'foo'), 'A BIFF', 'should NOT change A');

    set(objA, 'foo', 'BAZ');
    equal(get(objA, 'foo'), 'A BAZ', 'should change A');
    equal(get(objB, 'foo'), 'B bar', 'should NOT change B');
  });

  QUnit.module('computed - metadata');

  QUnit.test('can set metadata on a computed property', function () {
    var computedProperty = _emberMetalComputed.computed(function () {});
    computedProperty.meta({ key: 'keyValue' });

    equal(computedProperty.meta().key, 'keyValue', 'saves passed meta hash to the _meta property');
  });

  QUnit.test('meta should return an empty hash if no meta is set', function () {
    var computedProperty = _emberMetalComputed.computed(function () {});
    deepEqual(computedProperty.meta(), {}, 'returned value is an empty hash');
  });

  // ..........................................................
  // CACHEABLE
  //

  QUnit.module('computed - cacheable', {
    setup: function () {
      obj = {};
      count = 0;
      var func = function (key, value) {
        count++;
        return 'bar ' + count;
      };
      _emberMetalProperties.defineProperty(obj, 'foo', _emberMetalComputed.computed({ get: func, set: func }));
    },

    teardown: function () {
      obj = count = null;
    }
  });

  _emberMetalTestsProps_helper.testBoth('cacheable should cache', function (get, set) {
    equal(get(obj, 'foo'), 'bar 1', 'first get');
    equal(get(obj, 'foo'), 'bar 1', 'second get');
    equal(count, 1, 'should only invoke once');
  });

  _emberMetalTestsProps_helper.testBoth('modifying a cacheable property should update cache', function (get, set) {
    equal(get(obj, 'foo'), 'bar 1', 'first get');
    equal(get(obj, 'foo'), 'bar 1', 'second get');

    equal(set(obj, 'foo', 'baz'), 'baz', 'setting');
    equal(get(obj, 'foo'), 'bar 2', 'third get');
    equal(count, 2, 'should not invoke again');
  });

  _emberMetalTestsProps_helper.testBoth('inherited property should not pick up cache', function (get, set) {
    var objB = Object.create(obj);

    equal(get(obj, 'foo'), 'bar 1', 'obj first get');
    equal(get(objB, 'foo'), 'bar 2', 'objB first get');

    equal(get(obj, 'foo'), 'bar 1', 'obj second get');
    equal(get(objB, 'foo'), 'bar 2', 'objB second get');

    set(obj, 'foo', 'baz'); // modify A
    equal(get(obj, 'foo'), 'bar 3', 'obj third get');
    equal(get(objB, 'foo'), 'bar 2', 'objB third get');
  });

  _emberMetalTestsProps_helper.testBoth('cacheFor should return the cached value', function (get, set) {
    equal(_emberMetalComputed.cacheFor(obj, 'foo'), undefined, 'should not yet be a cached value');

    get(obj, 'foo');

    equal(_emberMetalComputed.cacheFor(obj, 'foo'), 'bar 1', 'should retrieve cached value');
  });

  _emberMetalTestsProps_helper.testBoth('cacheFor should return falsy cached values', function (get, set) {

    _emberMetalProperties.defineProperty(obj, 'falsy', _emberMetalComputed.computed(function () {
      return false;
    }));

    equal(_emberMetalComputed.cacheFor(obj, 'falsy'), undefined, 'should not yet be a cached value');

    get(obj, 'falsy');

    equal(_emberMetalComputed.cacheFor(obj, 'falsy'), false, 'should retrieve cached value');
  });

  _emberMetalTestsProps_helper.testBoth('setting a cached computed property passes the old value as the third argument', function (get, set) {
    var obj = {
      foo: 0
    };

    var receivedOldValue;

    _emberMetalProperties.defineProperty(obj, 'plusOne', _emberMetalComputed.computed({
      get: function () {},
      set: function (key, value, oldValue) {
        receivedOldValue = oldValue;
        return value;
      } }).property('foo'));

    set(obj, 'plusOne', 1);
    strictEqual(receivedOldValue, undefined, 'oldValue should be undefined');

    set(obj, 'plusOne', 2);
    strictEqual(receivedOldValue, 1, 'oldValue should be 1');

    set(obj, 'plusOne', 3);
    strictEqual(receivedOldValue, 2, 'oldValue should be 2');
  });

  // ..........................................................
  // DEPENDENT KEYS
  //

  QUnit.module('computed - dependentkey', {
    setup: function () {
      obj = { bar: 'baz' };
      count = 0;
      var getterAndSetter = function (key, value) {
        count++;
        _emberMetalProperty_get.get(this, 'bar');
        return 'bar ' + count;
      };
      _emberMetalProperties.defineProperty(obj, 'foo', _emberMetalComputed.computed({
        get: getterAndSetter,
        set: getterAndSetter
      }).property('bar'));
    },

    teardown: function () {
      obj = count = null;
    }
  });

  _emberMetalTestsProps_helper.testBoth('should lazily watch dependent keys on set', function (get, set) {
    equal(_emberMetalWatching.isWatching(obj, 'bar'), false, 'precond not watching dependent key');
    set(obj, 'foo', 'bar');
    equal(_emberMetalWatching.isWatching(obj, 'bar'), true, 'lazily watching dependent key');
  });

  _emberMetalTestsProps_helper.testBoth('should lazily watch dependent keys on get', function (get, set) {
    equal(_emberMetalWatching.isWatching(obj, 'bar'), false, 'precond not watching dependent key');
    get(obj, 'foo');
    equal(_emberMetalWatching.isWatching(obj, 'bar'), true, 'lazily watching dependent key');
  });

  _emberMetalTestsProps_helper.testBoth('local dependent key should invalidate cache', function (get, set) {
    equal(_emberMetalWatching.isWatching(obj, 'bar'), false, 'precond not watching dependent key');
    equal(get(obj, 'foo'), 'bar 1', 'get once');
    equal(_emberMetalWatching.isWatching(obj, 'bar'), true, 'lazily setup watching dependent key');
    equal(get(obj, 'foo'), 'bar 1', 'cached retrieve');

    set(obj, 'bar', 'BIFF'); // should invalidate foo

    equal(get(obj, 'foo'), 'bar 2', 'should recache');
    equal(get(obj, 'foo'), 'bar 2', 'cached retrieve');
  });

  _emberMetalTestsProps_helper.testBoth('should invalidate multiple nested dependent keys', function (get, set) {
    var count = 0;
    _emberMetalProperties.defineProperty(obj, 'bar', _emberMetalComputed.computed(function () {
      count++;
      get(this, 'baz');
      return 'baz ' + count;
    }).property('baz'));

    equal(_emberMetalWatching.isWatching(obj, 'bar'), false, 'precond not watching dependent key');
    equal(_emberMetalWatching.isWatching(obj, 'baz'), false, 'precond not watching dependent key');
    equal(get(obj, 'foo'), 'bar 1', 'get once');
    equal(_emberMetalWatching.isWatching(obj, 'bar'), true, 'lazily setup watching dependent key');
    equal(_emberMetalWatching.isWatching(obj, 'baz'), true, 'lazily setup watching dependent key');
    equal(get(obj, 'foo'), 'bar 1', 'cached retrieve');

    set(obj, 'baz', 'BIFF'); // should invalidate bar -> foo
    equal(_emberMetalWatching.isWatching(obj, 'bar'), false, 'should not be watching dependent key after cache cleared');
    equal(_emberMetalWatching.isWatching(obj, 'baz'), false, 'should not be watching dependent key after cache cleared');

    equal(get(obj, 'foo'), 'bar 2', 'should recache');
    equal(get(obj, 'foo'), 'bar 2', 'cached retrieve');
    equal(_emberMetalWatching.isWatching(obj, 'bar'), true, 'lazily setup watching dependent key');
    equal(_emberMetalWatching.isWatching(obj, 'baz'), true, 'lazily setup watching dependent key');
  });

  _emberMetalTestsProps_helper.testBoth('circular keys should not blow up', function (get, set) {
    var func = function (key, value) {
      count++;
      return 'bar ' + count;
    };
    _emberMetalProperties.defineProperty(obj, 'bar', _emberMetalComputed.computed({ get: func, set: func }).property('foo'));

    _emberMetalProperties.defineProperty(obj, 'foo', _emberMetalComputed.computed(function (key) {
      count++;
      return 'foo ' + count;
    }).property('bar'));

    equal(get(obj, 'foo'), 'foo 1', 'get once');
    equal(get(obj, 'foo'), 'foo 1', 'cached retrieve');

    set(obj, 'bar', 'BIFF'); // should invalidate bar -> foo -> bar

    equal(get(obj, 'foo'), 'foo 3', 'should recache');
    equal(get(obj, 'foo'), 'foo 3', 'cached retrieve');
  });

  _emberMetalTestsProps_helper.testBoth('redefining a property should undo old dependent keys', function (get, set) {

    equal(_emberMetalWatching.isWatching(obj, 'bar'), false, 'precond not watching dependent key');
    equal(get(obj, 'foo'), 'bar 1');
    equal(_emberMetalWatching.isWatching(obj, 'bar'), true, 'lazily watching dependent key');

    _emberMetalProperties.defineProperty(obj, 'foo', _emberMetalComputed.computed(function () {
      count++;
      return 'baz ' + count;
    }).property('baz'));

    equal(_emberMetalWatching.isWatching(obj, 'bar'), false, 'after redefining should not be watching dependent key');

    equal(get(obj, 'foo'), 'baz 2');

    set(obj, 'bar', 'BIFF'); // should not kill cache
    equal(get(obj, 'foo'), 'baz 2');

    set(obj, 'baz', 'BOP');
    equal(get(obj, 'foo'), 'baz 3');
  });

  _emberMetalTestsProps_helper.testBoth('can watch multiple dependent keys specified declaratively via brace expansion', function (get, set) {
    _emberMetalProperties.defineProperty(obj, 'foo', _emberMetalComputed.computed(function (key) {
      count++;
      return 'foo ' + count;
    }).property('qux.{bar,baz}'));

    equal(get(obj, 'foo'), 'foo 1', 'get once');
    equal(get(obj, 'foo'), 'foo 1', 'cached retrieve');

    set(obj, 'qux', {});
    set(obj, 'qux.bar', 'bar'); // invalidate foo

    equal(get(obj, 'foo'), 'foo 2', 'foo invalidated from bar');

    set(obj, 'qux.baz', 'baz'); // invalidate foo

    equal(get(obj, 'foo'), 'foo 3', 'foo invalidated from baz');

    set(obj, 'qux.quux', 'quux'); // do not invalidate foo

    equal(get(obj, 'foo'), 'foo 3', 'foo not invalidated by quux');
  });

  _emberMetalTestsProps_helper.testBoth('throws assertion if brace expansion notation has spaces', function (get, set) {
    throws(function () {
      _emberMetalProperties.defineProperty(obj, 'roo', _emberMetalComputed.computed(function (key) {
        count++;
        return 'roo ' + count;
      }).property('fee.{bar, baz,bop , }'));
    }, /cannot contain spaces/);
  });

  // ..........................................................
  // CHAINED DEPENDENT KEYS
  //

  var func;
  var moduleOpts = {
    setup: function () {
      obj = {
        foo: {
          bar: {
            baz: {
              biff: 'BIFF'
            }
          }
        }
      };

      count = 0;
      func = function () {
        count++;
        return _emberMetalProperty_get.get(obj, 'foo.bar.baz.biff') + ' ' + count;
      };
    },

    teardown: function () {
      obj = count = func = null;
    }
  };

  QUnit.module('computed - dependentkey with chained properties', moduleOpts);

  _emberMetalTestsProps_helper.testBoth('depending on simple chain', function (get, set) {

    // assign computed property
    _emberMetalProperties.defineProperty(obj, 'prop', _emberMetalComputed.computed(func).property('foo.bar.baz.biff'));

    equal(get(obj, 'prop'), 'BIFF 1');

    set(get(obj, 'foo.bar.baz'), 'biff', 'BUZZ');
    equal(get(obj, 'prop'), 'BUZZ 2');
    equal(get(obj, 'prop'), 'BUZZ 2');

    set(get(obj, 'foo.bar'), 'baz', { biff: 'BLOB' });
    equal(get(obj, 'prop'), 'BLOB 3');
    equal(get(obj, 'prop'), 'BLOB 3');

    set(get(obj, 'foo.bar.baz'), 'biff', 'BUZZ');
    equal(get(obj, 'prop'), 'BUZZ 4');
    equal(get(obj, 'prop'), 'BUZZ 4');

    set(get(obj, 'foo'), 'bar', { baz: { biff: 'BOOM' } });
    equal(get(obj, 'prop'), 'BOOM 5');
    equal(get(obj, 'prop'), 'BOOM 5');

    set(get(obj, 'foo.bar.baz'), 'biff', 'BUZZ');
    equal(get(obj, 'prop'), 'BUZZ 6');
    equal(get(obj, 'prop'), 'BUZZ 6');

    set(obj, 'foo', { bar: { baz: { biff: 'BLARG' } } });
    equal(get(obj, 'prop'), 'BLARG 7');
    equal(get(obj, 'prop'), 'BLARG 7');

    set(get(obj, 'foo.bar.baz'), 'biff', 'BUZZ');
    equal(get(obj, 'prop'), 'BUZZ 8');
    equal(get(obj, 'prop'), 'BUZZ 8');

    _emberMetalProperties.defineProperty(obj, 'prop');
    set(obj, 'prop', 'NONE');
    equal(get(obj, 'prop'), 'NONE');

    set(obj, 'foo', { bar: { baz: { biff: 'BLARG' } } });
    equal(get(obj, 'prop'), 'NONE'); // should do nothing
    equal(count, 8, 'should be not have invoked computed again');
  });

  _emberMetalTestsProps_helper.testBoth('chained dependent keys should evaluate computed properties lazily', function (get, set) {
    _emberMetalProperties.defineProperty(obj.foo.bar, 'b', _emberMetalComputed.computed(func));
    _emberMetalProperties.defineProperty(obj.foo, 'c', _emberMetalComputed.computed(function () {}).property('bar.b'));
    equal(count, 0, 'b should not run');
  });

  // ..........................................................
  // improved-cp-syntax
  //

  QUnit.module('computed - improved cp syntax');

  QUnit.test('setter and getters are passed using an object', function () {
    var testObj = _emberMetalCore.default.Object.extend({
      a: '1',
      b: '2',
      aInt: _emberMetalComputed.computed('a', {
        get: function (keyName) {
          equal(keyName, 'aInt', 'getter receives the keyName');
          return parseInt(this.get('a'));
        },
        set: function (keyName, value, oldValue) {
          equal(keyName, 'aInt', 'setter receives the keyName');
          equal(value, 123, 'setter receives the new value');
          equal(oldValue, 1, 'setter receives the old value');
          this.set('a', '' + value); // side effect
          return parseInt(this.get('a'));
        }
      })
    }).create();

    ok(testObj.get('aInt') === 1, 'getter works');
    testObj.set('aInt', 123);
    ok(testObj.get('a') === '123', 'setter works');
    ok(testObj.get('aInt') === 123, 'cp has been updated too');
  });

  QUnit.test('setter can be omited', function () {
    var testObj = _emberMetalCore.default.Object.extend({
      a: '1',
      b: '2',
      aInt: _emberMetalComputed.computed('a', {
        get: function (keyName) {
          equal(keyName, 'aInt', 'getter receives the keyName');
          return parseInt(this.get('a'));
        }
      })
    }).create();

    ok(testObj.get('aInt') === 1, 'getter works');
    ok(testObj.get('a') === '1');
    testObj.set('aInt', '123');
    ok(testObj.get('aInt') === '123', 'cp has been updated too');
  });

  QUnit.test('the return value of the setter gets cached', function () {
    var testObj = _emberMetalCore.default.Object.extend({
      a: '1',
      sampleCP: _emberMetalComputed.computed('a', {
        get: function (keyName) {
          ok(false, 'The getter should not be invoked');
          return 'get-value';
        },
        set: function (keyName, value, oldValue) {
          return 'set-value';
        }
      })
    }).create();

    testObj.set('sampleCP', 'abcd');
    ok(testObj.get('sampleCP') === 'set-value', 'The return value of the CP was cached');
  });

  // ..........................................................
  // BUGS
  //

  QUnit.module('computed edge cases');

  QUnit.test('adding a computed property should show up in key iteration', function () {

    var obj = {};
    _emberMetalProperties.defineProperty(obj, 'foo', _emberMetalComputed.computed(function () {}));

    var found = [];
    for (var key in obj) {
      found.push(key);
    }
    ok(found.indexOf('foo') >= 0, 'should find computed property in iteration found=' + found);
    ok('foo' in obj, 'foo in obj should pass');
  });

  _emberMetalTestsProps_helper.testBoth('when setting a value after it had been retrieved empty don\'t pass function UNDEFINED as oldValue', function (get, set) {
    var obj = {};
    var oldValueIsNoFunction = true;

    _emberMetalProperties.defineProperty(obj, 'foo', _emberMetalComputed.computed({
      get: function () {},
      set: function (key, value, oldValue) {
        if (typeof oldValue === 'function') {
          oldValueIsNoFunction = false;
        }
        return undefined;
      }
    }));

    get(obj, 'foo');
    set(obj, 'foo', undefined);

    ok(oldValueIsNoFunction);
  });

  QUnit.module('computed - setter');

  _emberMetalTestsProps_helper.testBoth('setting a watched computed property', function (get, set) {
    var obj = {
      firstName: 'Yehuda',
      lastName: 'Katz'
    };
    _emberMetalProperties.defineProperty(obj, 'fullName', _emberMetalComputed.computed({
      get: function () {
        return get(this, 'firstName') + ' ' + get(this, 'lastName');
      },
      set: function (key, value) {
        var values = value.split(' ');
        set(this, 'firstName', values[0]);
        set(this, 'lastName', values[1]);
        return value;
      }
    }).property('firstName', 'lastName'));
    var fullNameWillChange = 0;
    var fullNameDidChange = 0;
    var firstNameWillChange = 0;
    var firstNameDidChange = 0;
    var lastNameWillChange = 0;
    var lastNameDidChange = 0;
    _emberMetalObserver._addBeforeObserver(obj, 'fullName', function () {
      fullNameWillChange++;
    });
    _emberMetalObserver.addObserver(obj, 'fullName', function () {
      fullNameDidChange++;
    });
    _emberMetalObserver._addBeforeObserver(obj, 'firstName', function () {
      firstNameWillChange++;
    });
    _emberMetalObserver.addObserver(obj, 'firstName', function () {
      firstNameDidChange++;
    });
    _emberMetalObserver._addBeforeObserver(obj, 'lastName', function () {
      lastNameWillChange++;
    });
    _emberMetalObserver.addObserver(obj, 'lastName', function () {
      lastNameDidChange++;
    });

    equal(get(obj, 'fullName'), 'Yehuda Katz');

    set(obj, 'fullName', 'Yehuda Katz');

    set(obj, 'fullName', 'Kris Selden');

    equal(get(obj, 'fullName'), 'Kris Selden');
    equal(get(obj, 'firstName'), 'Kris');
    equal(get(obj, 'lastName'), 'Selden');

    equal(fullNameWillChange, 1);
    equal(fullNameDidChange, 1);
    equal(firstNameWillChange, 1);
    equal(firstNameDidChange, 1);
    equal(lastNameWillChange, 1);
    equal(lastNameDidChange, 1);
  });

  _emberMetalTestsProps_helper.testBoth('setting a cached computed property that modifies the value you give it', function (get, set) {
    var obj = {
      foo: 0
    };
    _emberMetalProperties.defineProperty(obj, 'plusOne', _emberMetalComputed.computed({
      get: function (key) {
        return get(this, 'foo') + 1;
      },
      set: function (key, value) {
        set(this, 'foo', value);
        return value + 1;
      }
    }).property('foo'));
    var plusOneWillChange = 0;
    var plusOneDidChange = 0;
    _emberMetalObserver._addBeforeObserver(obj, 'plusOne', function () {
      plusOneWillChange++;
    });
    _emberMetalObserver.addObserver(obj, 'plusOne', function () {
      plusOneDidChange++;
    });

    equal(get(obj, 'plusOne'), 1);
    set(obj, 'plusOne', 1);
    equal(get(obj, 'plusOne'), 2);
    set(obj, 'plusOne', 1);
    equal(get(obj, 'plusOne'), 2);

    equal(plusOneWillChange, 1);
    equal(plusOneDidChange, 1);

    set(obj, 'foo', 5);
    equal(get(obj, 'plusOne'), 6);

    equal(plusOneWillChange, 2);
    equal(plusOneDidChange, 2);
  });

  QUnit.module('computed - default setter');

  _emberMetalTestsProps_helper.testBoth('when setting a value on a computed property that doesn\'t handle sets', function (get, set) {
    var obj = {};
    var observerFired = false;

    _emberMetalProperties.defineProperty(obj, 'foo', _emberMetalComputed.computed(function () {
      return 'foo';
    }));

    _emberMetalObserver.addObserver(obj, 'foo', null, function () {
      observerFired = true;
    });

    set(obj, 'foo', 'bar');

    equal(get(obj, 'foo'), 'bar', 'The set value is properly returned');
    ok(typeof obj.foo === 'string', 'The computed property was removed');
    ok(observerFired, 'The observer was still notified');
  });

  QUnit.module('computed - readOnly');

  QUnit.test('is chainable', function () {
    var cp = _emberMetalComputed.computed(function () {}).readOnly();

    ok(cp instanceof _emberMetalProperties.Descriptor);
    ok(cp instanceof _emberMetalComputed.ComputedProperty);
  });

  QUnit.test('throws assertion if called over a CP with a setter defined with the new syntax', function () {
    expectAssertion(function () {
      _emberMetalComputed.computed({
        get: function () {},
        set: function () {}
      }).readOnly();
    }, /Computed properties that define a setter using the new syntax cannot be read-only/);
  });

  _emberMetalTestsProps_helper.testBoth('protects against setting', function (get, set) {
    var obj = {};

    _emberMetalProperties.defineProperty(obj, 'bar', _emberMetalComputed.computed(function (key) {
      return 'barValue';
    }).readOnly());

    equal(get(obj, 'bar'), 'barValue');

    throws(function () {
      set(obj, 'bar', 'newBar');
    }, /Cannot set read\-only property "bar" on object:/);

    equal(get(obj, 'bar'), 'barValue');
  });
});
enifed('ember-metal/tests/computed_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests');
  test('ember-metal/tests/computed_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/computed_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/computed_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests');
  QUnit.test('ember-metal/tests/computed_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/computed_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/core/inspect_test', ['exports', 'ember-metal/utils'], function (exports, _emberMetalUtils) {
  'use strict';

  QUnit.module('Ember.inspect');

  QUnit.test('strings', function () {
    equal(_emberMetalUtils.inspect('foo'), 'foo');
  });

  QUnit.test('numbers', function () {
    equal(_emberMetalUtils.inspect(2.6), '2.6');
  });

  QUnit.test('null', function () {
    equal(_emberMetalUtils.inspect(null), 'null');
  });

  QUnit.test('undefined', function () {
    equal(_emberMetalUtils.inspect(undefined), 'undefined');
  });

  QUnit.test('true', function () {
    equal(_emberMetalUtils.inspect(true), 'true');
  });

  QUnit.test('false', function () {
    equal(_emberMetalUtils.inspect(false), 'false');
  });

  QUnit.test('object', function () {
    equal(_emberMetalUtils.inspect({}), '{}');
    equal(_emberMetalUtils.inspect({ foo: 'bar' }), '{foo: bar}');
    equal(_emberMetalUtils.inspect({ foo: function () {
        return this;
      } }), '{foo: function() { ... }}');
  });

  QUnit.test('objects without a prototype', function () {
    var prototypelessObj = Object.create(null);
    equal(_emberMetalUtils.inspect({ foo: prototypelessObj }), '{foo: [object Object]}');
  });

  QUnit.test('array', function () {
    equal(_emberMetalUtils.inspect([1, 2, 3]), '[1,2,3]');
  });

  QUnit.test('regexp', function () {
    equal(_emberMetalUtils.inspect(/regexp/), '/regexp/');
  });

  QUnit.test('date', function () {
    var inspected = _emberMetalUtils.inspect(new Date('Sat Apr 30 2011 13:24:11'));
    ok(inspected.match(/Sat Apr 30/), 'The inspected date has its date');
    ok(inspected.match(/2011/), 'The inspected date has its year');
    ok(inspected.match(/13:24:11/), 'The inspected date has its time');
  });
});
enifed('ember-metal/tests/core/inspect_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests/core');
  test('ember-metal/tests/core/inspect_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/core/inspect_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/core/inspect_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests/core');
  QUnit.test('ember-metal/tests/core/inspect_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/core/inspect_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/error_test', ['exports', 'ember-metal/core'], function (exports, _emberMetalCore) {
  'use strict';

  QUnit.module('Ember Error Throwing');

  QUnit.test('new Ember.Error displays provided message', function () {
    throws(function () {
      throw new _emberMetalCore.default.Error('A Message');
    }, function (e) {
      return e.message === 'A Message';
    }, 'the assigned message was displayed');
  });
});
enifed('ember-metal/tests/error_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests');
  test('ember-metal/tests/error_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/error_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/error_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests');
  QUnit.test('ember-metal/tests/error_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/error_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/events_test', ['exports', 'ember-metal/mixin', 'ember-metal/utils', 'ember-metal/events'], function (exports, _emberMetalMixin, _emberMetalUtils, _emberMetalEvents) {
  'use strict';

  QUnit.module('system/props/events_test');

  QUnit.test('listener should receive event - removing should remove', function () {
    var obj = {};
    var count = 0;
    var F = function () {
      count++;
    };

    _emberMetalEvents.addListener(obj, 'event!', F);
    equal(count, 0, 'nothing yet');

    _emberMetalEvents.sendEvent(obj, 'event!');
    equal(count, 1, 'received event');

    _emberMetalEvents.removeListener(obj, 'event!', F);

    count = 0;
    _emberMetalEvents.sendEvent(obj, 'event!');
    equal(count, 0, 'received event');
  });

  QUnit.test('listeners should be inherited', function () {
    var obj = {};
    var count = 0;
    var F = function () {
      count++;
    };

    _emberMetalEvents.addListener(obj, 'event!', F);

    var obj2 = Object.create(obj);

    equal(count, 0, 'nothing yet');

    _emberMetalEvents.sendEvent(obj2, 'event!');
    equal(count, 1, 'received event');

    _emberMetalEvents.removeListener(obj2, 'event!', F);

    count = 0;
    _emberMetalEvents.sendEvent(obj2, 'event!');
    equal(count, 0, 'did not receive event');

    _emberMetalEvents.sendEvent(obj, 'event!');
    equal(count, 1, 'should still invoke on parent');
  });

  QUnit.test('adding a listener more than once should only invoke once', function () {

    var obj = {};
    var count = 0;
    var F = function () {
      count++;
    };
    _emberMetalEvents.addListener(obj, 'event!', F);
    _emberMetalEvents.addListener(obj, 'event!', F);

    _emberMetalEvents.sendEvent(obj, 'event!');
    equal(count, 1, 'should only invoke once');
  });

  QUnit.test('adding a listener with a target should invoke with target', function () {
    var obj = {};
    var target;

    target = {
      count: 0,
      method: function () {
        this.count++;
      }
    };

    _emberMetalEvents.addListener(obj, 'event!', target, target.method);
    _emberMetalEvents.sendEvent(obj, 'event!');
    equal(target.count, 1, 'should invoke');
  });

  QUnit.test('suspending a listener should not invoke during callback', function () {
    var obj = {};
    var target, otherTarget;

    target = {
      count: 0,
      method: function () {
        this.count++;
      }
    };

    otherTarget = {
      count: 0,
      method: function () {
        this.count++;
      }
    };

    _emberMetalEvents.addListener(obj, 'event!', target, target.method);
    _emberMetalEvents.addListener(obj, 'event!', otherTarget, otherTarget.method);

    function callback() {
      /*jshint validthis:true */
      equal(this, target);

      _emberMetalEvents.sendEvent(obj, 'event!');

      return 'result';
    }

    _emberMetalEvents.sendEvent(obj, 'event!');

    equal(_emberMetalEvents.suspendListener(obj, 'event!', target, target.method, callback), 'result');

    _emberMetalEvents.sendEvent(obj, 'event!');

    equal(target.count, 2, 'should invoke');
    equal(otherTarget.count, 3, 'should invoke');
  });

  QUnit.test('adding a listener with string method should lookup method on event delivery', function () {
    var obj = {};
    var target;

    target = {
      count: 0,
      method: function () {}
    };

    _emberMetalEvents.addListener(obj, 'event!', target, 'method');
    _emberMetalEvents.sendEvent(obj, 'event!');
    equal(target.count, 0, 'should invoke but do nothing');

    target.method = function () {
      this.count++;
    };
    _emberMetalEvents.sendEvent(obj, 'event!');
    equal(target.count, 1, 'should invoke now');
  });

  QUnit.test('calling sendEvent with extra params should be passed to listeners', function () {

    var obj = {};
    var params = null;
    _emberMetalEvents.addListener(obj, 'event!', function () {
      params = Array.prototype.slice.call(arguments);
    });

    _emberMetalEvents.sendEvent(obj, 'event!', ['foo', 'bar']);
    deepEqual(params, ['foo', 'bar'], 'params should be saved');
  });

  QUnit.test('hasListeners tells you if there are listeners for a given event', function () {

    var obj = {};
    var F = function () {};
    var F2 = function () {};

    equal(_emberMetalEvents.hasListeners(obj, 'event!'), false, 'no listeners at first');

    _emberMetalEvents.addListener(obj, 'event!', F);
    _emberMetalEvents.addListener(obj, 'event!', F2);

    equal(_emberMetalEvents.hasListeners(obj, 'event!'), true, 'has listeners');

    _emberMetalEvents.removeListener(obj, 'event!', F);
    equal(_emberMetalEvents.hasListeners(obj, 'event!'), true, 'has listeners');

    _emberMetalEvents.removeListener(obj, 'event!', F2);
    equal(_emberMetalEvents.hasListeners(obj, 'event!'), false, 'has no more listeners');

    _emberMetalEvents.addListener(obj, 'event!', F);
    equal(_emberMetalEvents.hasListeners(obj, 'event!'), true, 'has listeners');
  });

  QUnit.test('calling removeListener without method should remove all listeners', function () {
    var obj = {};
    var F = function () {};
    var F2 = function () {};

    equal(_emberMetalEvents.hasListeners(obj, 'event!'), false, 'no listeners at first');

    _emberMetalEvents.addListener(obj, 'event!', F);
    _emberMetalEvents.addListener(obj, 'event!', F2);

    equal(_emberMetalEvents.hasListeners(obj, 'event!'), true, 'has listeners');

    _emberMetalEvents.removeListener(obj, 'event!');

    equal(_emberMetalEvents.hasListeners(obj, 'event!'), false, 'has no more listeners');
  });

  QUnit.test('while suspended, it should not be possible to add a duplicate listener', function () {
    var obj = {};
    var target;

    target = {
      count: 0,
      method: function () {
        this.count++;
      }
    };

    _emberMetalEvents.addListener(obj, 'event!', target, target.method);

    function callback() {
      _emberMetalEvents.addListener(obj, 'event!', target, target.method);
    }

    _emberMetalEvents.sendEvent(obj, 'event!');

    _emberMetalEvents.suspendListener(obj, 'event!', target, target.method, callback);

    equal(target.count, 1, 'should invoke');
    equal(_emberMetalUtils.meta(obj).listeners['event!'].length, 3, 'a duplicate listener wasn\'t added');

    // now test suspendListeners...

    _emberMetalEvents.sendEvent(obj, 'event!');

    _emberMetalEvents.suspendListeners(obj, ['event!'], target, target.method, callback);

    equal(target.count, 2, 'should have invoked again');
    equal(_emberMetalUtils.meta(obj).listeners['event!'].length, 3, 'a duplicate listener wasn\'t added');
  });

  QUnit.test('a listener can be added as part of a mixin', function () {
    var triggered = 0;
    var MyMixin = _emberMetalMixin.Mixin.create({
      foo1: _emberMetalEvents.on('bar', function () {
        triggered++;
      }),

      foo2: _emberMetalEvents.on('bar', function () {
        triggered++;
      })
    });

    var obj = {};
    MyMixin.apply(obj);

    _emberMetalEvents.sendEvent(obj, 'bar');
    equal(triggered, 2, 'should invoke listeners');
  });

  QUnit.test('a listener added as part of a mixin may be overridden', function () {

    var triggered = 0;
    var FirstMixin = _emberMetalMixin.Mixin.create({
      foo: _emberMetalEvents.on('bar', function () {
        triggered++;
      })
    });
    var SecondMixin = _emberMetalMixin.Mixin.create({
      foo: _emberMetalEvents.on('baz', function () {
        triggered++;
      })
    });

    var obj = {};
    FirstMixin.apply(obj);
    SecondMixin.apply(obj);

    _emberMetalEvents.sendEvent(obj, 'bar');
    equal(triggered, 0, 'should not invoke from overriden property');

    _emberMetalEvents.sendEvent(obj, 'baz');
    equal(triggered, 1, 'should invoke from subclass property');
  });
});
enifed('ember-metal/tests/events_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests');
  test('ember-metal/tests/events_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/events_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/events_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests');
  QUnit.test('ember-metal/tests/events_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/events_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/expand_properties_test', ['exports', 'ember-metal/expand_properties'], function (exports, _emberMetalExpand_properties) {
  'use strict';

  var foundProperties = [];

  function addProperty(property) {
    foundProperties.push(property);
  }

  QUnit.module('Property Brace Expansion Test', {
    setup: function () {
      foundProperties = [];
    }
  });

  QUnit.test('Properties without expansions are unaffected', function () {
    expect(1);

    _emberMetalExpand_properties.default('a', addProperty);
    _emberMetalExpand_properties.default('a.b', addProperty);
    _emberMetalExpand_properties.default('a.b.[]', addProperty);
    _emberMetalExpand_properties.default('a.b.@each.c', addProperty);

    deepEqual(['a', 'a.b', 'a.b.[]', 'a.b.@each.c'].sort(), foundProperties.sort());
  });

  QUnit.test('A single expansion at the end expands properly', function () {
    expect(1);

    _emberMetalExpand_properties.default('a.b.{c,d}', addProperty);

    deepEqual(['a.b.c', 'a.b.d'].sort(), foundProperties.sort());
  });

  QUnit.test('A property with only a brace expansion expands correctly', function () {
    expect(1);

    _emberMetalExpand_properties.default('{a,b,c}', addProperty);

    var expected = ['a', 'b', 'c'];
    deepEqual(expected.sort(), foundProperties.sort());
  });

  QUnit.test('Expansions with single properties only expand once', function () {
    expect(1);

    _emberMetalExpand_properties.default('a.b.{c}.d.{e}', addProperty);

    deepEqual(['a.b.c.d.e'], foundProperties);
  });

  QUnit.test('A single brace expansion expands correctly', function () {
    expect(1);

    _emberMetalExpand_properties.default('a.{b,c,d}.e', addProperty);

    var expected = ['a.b.e', 'a.c.e', 'a.d.e'];
    deepEqual(expected.sort(), foundProperties.sort());
  });

  QUnit.test('Multiple brace expansions work correctly', function () {
    expect(1);

    _emberMetalExpand_properties.default('{a,b,c}.d.{e,f}.g', addProperty);

    var expected = ['a.d.e.g', 'a.d.f.g', 'b.d.e.g', 'b.d.f.g', 'c.d.e.g', 'c.d.f.g'];
    deepEqual(expected.sort(), foundProperties.sort());
  });

  QUnit.test('A property with only brace expansions expands correctly', function () {
    expect(1);

    _emberMetalExpand_properties.default('{a,b,c}.{d}.{e,f}', addProperty);

    var expected = ['a.d.e', 'a.d.f', 'b.d.e', 'b.d.f', 'c.d.e', 'c.d.f'];
    deepEqual(expected.sort(), foundProperties.sort());
  });
});
enifed('ember-metal/tests/expand_properties_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests');
  test('ember-metal/tests/expand_properties_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/expand_properties_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/expand_properties_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests');
  QUnit.test('ember-metal/tests/expand_properties_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/expand_properties_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/features_test', ['exports', 'ember-metal/core', 'ember-metal/features', 'ember-metal/merge'], function (exports, _emberMetalCore, _emberMetalFeatures, _emberMetalMerge) {
  'use strict';

  var origFeatures, origEnableAll, origEnableOptional;

  QUnit.module('isEnabled', {
    setup: function () {
      origFeatures = _emberMetalMerge.default({}, _emberMetalFeatures.FEATURES);
      origEnableAll = _emberMetalCore.default.ENV.ENABLE_ALL_FEATURES;
      origEnableOptional = _emberMetalCore.default.ENV.ENABLE_OPTIONAL_FEATURES;
    },

    teardown: function () {
      for (var feature in _emberMetalFeatures.FEATURES) {
        delete _emberMetalFeatures.FEATURES[feature];
      }
      _emberMetalMerge.default(_emberMetalFeatures.FEATURES, origFeatures);

      _emberMetalCore.default.ENV.ENABLE_ALL_FEATURES = origEnableAll;
      _emberMetalCore.default.ENV.ENABLE_OPTIONAL_FEATURES = origEnableOptional;
    }
  });

  QUnit.test('ENV.ENABLE_ALL_FEATURES', function () {
    _emberMetalCore.default.ENV.ENABLE_ALL_FEATURES = true;
    _emberMetalFeatures.FEATURES['fred'] = false;
    _emberMetalFeatures.FEATURES['wilma'] = null;

    equal(_emberMetalFeatures.default('fred'), true, 'overrides features set to false');
    equal(_emberMetalFeatures.default('wilma'), true, 'enables optional features');
    equal(_emberMetalFeatures.default('betty'), true, 'enables non-specified features');
  });

  QUnit.test('ENV.ENABLE_OPTIONAL_FEATURES', function () {
    _emberMetalCore.default.ENV.ENABLE_OPTIONAL_FEATURES = true;
    _emberMetalFeatures.FEATURES['fred'] = false;
    _emberMetalFeatures.FEATURES['barney'] = true;
    _emberMetalFeatures.FEATURES['wilma'] = null;

    equal(_emberMetalFeatures.default('fred'), false, 'returns flag value if false');
    equal(_emberMetalFeatures.default('barney'), true, 'returns flag value if true');
    equal(_emberMetalFeatures.default('wilma'), true, 'returns true if flag is not true|false|undefined');
    equal(_emberMetalFeatures.default('betty'), undefined, 'returns flag value if undefined');
  });

  QUnit.test('isEnabled without ENV options', function () {
    _emberMetalCore.default.ENV.ENABLE_ALL_FEATURES = false;
    _emberMetalCore.default.ENV.ENABLE_OPTIONAL_FEATURES = false;

    _emberMetalFeatures.FEATURES['fred'] = false;
    _emberMetalFeatures.FEATURES['barney'] = true;
    _emberMetalFeatures.FEATURES['wilma'] = null;

    equal(_emberMetalFeatures.default('fred'), false, 'returns flag value if false');
    equal(_emberMetalFeatures.default('barney'), true, 'returns flag value if true');
    equal(_emberMetalFeatures.default('wilma'), false, 'returns false if flag is not set');
    equal(_emberMetalFeatures.default('betty'), undefined, 'returns flag value if undefined');
  });
});
enifed('ember-metal/tests/features_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests');
  test('ember-metal/tests/features_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/features_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/features_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests');
  QUnit.test('ember-metal/tests/features_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/features_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/injected_property_test', ['exports', 'ember-metal/properties', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/injected_property'], function (exports, _emberMetalProperties, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalInjected_property) {
  'use strict';

  QUnit.module('InjectedProperty');

  QUnit.test('injected properties should be descriptors', function () {
    ok(new _emberMetalInjected_property.default() instanceof _emberMetalProperties.Descriptor);
  });

  QUnit.test('injected properties should be overridable', function () {
    var obj = {};
    _emberMetalProperties.defineProperty(obj, 'foo', new _emberMetalInjected_property.default());

    _emberMetalProperty_set.set(obj, 'foo', 'bar');

    equal(_emberMetalProperty_get.get(obj, 'foo'), 'bar', 'should return the overriden value');
  });

  QUnit.test('getting on an object without a container should fail assertion', function () {
    var obj = {};
    _emberMetalProperties.defineProperty(obj, 'foo', new _emberMetalInjected_property.default('type', 'name'));

    expectAssertion(function () {
      _emberMetalProperty_get.get(obj, 'foo');
    }, /Attempting to lookup an injected property on an object without a container, ensure that the object was instantiated via a container./);
  });

  QUnit.test('getting should return a lookup on the container', function () {
    expect(2);

    var obj = {
      container: {
        lookup: function (key) {
          ok(true, 'should call container.lookup');
          return key;
        }
      }
    };
    _emberMetalProperties.defineProperty(obj, 'foo', new _emberMetalInjected_property.default('type', 'name'));

    equal(_emberMetalProperty_get.get(obj, 'foo'), 'type:name', 'should return the value of container.lookup');
  });

  QUnit.test('omitting the lookup name should default to the property name', function () {
    var obj = {
      container: {
        lookup: function (key) {
          return key;
        }
      }
    };
    _emberMetalProperties.defineProperty(obj, 'foo', new _emberMetalInjected_property.default('type'));

    equal(_emberMetalProperty_get.get(obj, 'foo'), 'type:foo', 'should lookup the type using the property name');
  });
});
enifed('ember-metal/tests/injected_property_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests');
  test('ember-metal/tests/injected_property_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/injected_property_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/injected_property_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests');
  QUnit.test('ember-metal/tests/injected_property_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/injected_property_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/instrumentation_test', ['exports', 'ember-metal/instrumentation'], function (exports, _emberMetalInstrumentation) {
  'use strict';

  QUnit.module('Ember Instrumentation', {
    setup: function () {},
    teardown: function () {
      _emberMetalInstrumentation.reset();
    }
  });

  QUnit.test('execute block even if no listeners', function () {
    var result = _emberMetalInstrumentation.instrument('render', {}, function () {
      return 'hello';
    });
    equal(result, 'hello', 'called block');
  });

  QUnit.test('subscribing to a simple path receives the listener', function () {
    expect(12);

    var sentPayload = {};
    var count = 0;

    _emberMetalInstrumentation.subscribe('render', {
      before: function (name, timestamp, payload) {
        if (count === 0) {
          strictEqual(name, 'render');
        } else {
          strictEqual(name, 'render.handlebars');
        }

        ok(typeof timestamp === 'number');
        strictEqual(payload, sentPayload);
      },

      after: function (name, timestamp, payload) {
        if (count === 0) {
          strictEqual(name, 'render');
        } else {
          strictEqual(name, 'render.handlebars');
        }

        ok(typeof timestamp === 'number');
        strictEqual(payload, sentPayload);

        count++;
      }
    });

    _emberMetalInstrumentation.instrument('render', sentPayload, function () {});

    _emberMetalInstrumentation.instrument('render.handlebars', sentPayload, function () {});
  });

  QUnit.test('returning a value from the before callback passes it to the after callback', function () {
    expect(2);

    var passthru1 = {};
    var passthru2 = {};

    _emberMetalInstrumentation.subscribe('render', {
      before: function (name, timestamp, payload) {
        return passthru1;
      },
      after: function (name, timestamp, payload, beforeValue) {
        strictEqual(beforeValue, passthru1);
      }
    });

    _emberMetalInstrumentation.subscribe('render', {
      before: function (name, timestamp, payload) {
        return passthru2;
      },
      after: function (name, timestamp, payload, beforeValue) {
        strictEqual(beforeValue, passthru2);
      }
    });

    _emberMetalInstrumentation.instrument('render', null, function () {});
  });

  QUnit.test('instrument with 2 args (name, callback) no payload', function () {
    expect(1);

    _emberMetalInstrumentation.subscribe('render', {
      before: function (name, timestamp, payload) {
        deepEqual(payload, {});
      },
      after: function () {}
    });

    _emberMetalInstrumentation.instrument('render', function () {});
  });

  QUnit.test('instrument with 3 args (name, callback, binding) no payload', function () {
    expect(2);

    var binding = {};
    _emberMetalInstrumentation.subscribe('render', {
      before: function (name, timestamp, payload) {
        deepEqual(payload, {});
      },
      after: function () {}
    });

    _emberMetalInstrumentation.instrument('render', function () {
      deepEqual(this, binding);
    }, binding);
  });

  QUnit.test('instrument with 3 args (name, payload, callback) with payload', function () {
    expect(1);

    var expectedPayload = { hi: 1 };
    _emberMetalInstrumentation.subscribe('render', {
      before: function (name, timestamp, payload) {
        deepEqual(payload, expectedPayload);
      },
      after: function () {}
    });

    _emberMetalInstrumentation.instrument('render', expectedPayload, function () {});
  });

  QUnit.test('instrument with 4 args (name, payload, callback, binding) with payload', function () {
    expect(2);

    var expectedPayload = { hi: 1 };
    var binding = {};
    _emberMetalInstrumentation.subscribe('render', {
      before: function (name, timestamp, payload) {
        deepEqual(payload, expectedPayload);
      },
      after: function () {}
    });

    _emberMetalInstrumentation.instrument('render', expectedPayload, function () {
      deepEqual(this, binding);
    }, binding);
  });

  QUnit.test('raising an exception in the instrumentation attaches it to the payload', function () {
    expect(2);

    var error = new Error('Instrumentation');

    _emberMetalInstrumentation.subscribe('render', {
      before: function () {},
      after: function (name, timestamp, payload) {
        strictEqual(payload.exception, error);
      }
    });

    _emberMetalInstrumentation.subscribe('render', {
      before: function () {},
      after: function (name, timestamp, payload) {
        strictEqual(payload.exception, error);
      }
    });

    _emberMetalInstrumentation.instrument('render.handlebars', null, function () {
      throw error;
    });
  });

  QUnit.test('it is possible to add a new subscriber after the first instrument', function () {
    _emberMetalInstrumentation.instrument('render.handlebars', null, function () {});

    _emberMetalInstrumentation.subscribe('render', {
      before: function () {
        ok(true, 'Before callback was called');
      },
      after: function () {
        ok(true, 'After callback was called');
      }
    });

    _emberMetalInstrumentation.instrument('render.handlebars', null, function () {});
  });

  QUnit.test('it is possible to remove a subscriber', function () {
    expect(4);

    var count = 0;

    var subscriber = _emberMetalInstrumentation.subscribe('render', {
      before: function () {
        equal(count, 0);
        ok(true, 'Before callback was called');
      },
      after: function () {
        equal(count, 0);
        ok(true, 'After callback was called');
        count++;
      }
    });

    _emberMetalInstrumentation.instrument('render.handlebars', null, function () {});

    _emberMetalInstrumentation.unsubscribe(subscriber);

    _emberMetalInstrumentation.instrument('render.handlebars', null, function () {});
  });
});
enifed('ember-metal/tests/instrumentation_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests');
  test('ember-metal/tests/instrumentation_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/instrumentation_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/instrumentation_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests');
  QUnit.test('ember-metal/tests/instrumentation_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/instrumentation_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/is_blank_test', ['exports', 'ember-metal/is_blank'], function (exports, _emberMetalIs_blank) {
  'use strict';

  QUnit.module('Ember.isBlank');

  QUnit.test('Ember.isBlank', function () {
    var string = 'string';
    var fn = function () {};
    var object = { length: 0 };

    equal(true, _emberMetalIs_blank.default(null), 'for null');
    equal(true, _emberMetalIs_blank.default(undefined), 'for undefined');
    equal(true, _emberMetalIs_blank.default(''), 'for an empty String');
    equal(true, _emberMetalIs_blank.default('  '), 'for a whitespace String');
    equal(true, _emberMetalIs_blank.default('\n\t'), 'for another whitespace String');
    equal(false, _emberMetalIs_blank.default('\n\t Hi'), 'for a String with whitespaces');
    equal(false, _emberMetalIs_blank.default(true), 'for true');
    equal(false, _emberMetalIs_blank.default(false), 'for false');
    equal(false, _emberMetalIs_blank.default(string), 'for a String');
    equal(false, _emberMetalIs_blank.default(fn), 'for a Function');
    equal(false, _emberMetalIs_blank.default(0), 'for 0');
    equal(true, _emberMetalIs_blank.default([]), 'for an empty Array');
    equal(false, _emberMetalIs_blank.default({}), 'for an empty Object');
    equal(true, _emberMetalIs_blank.default(object), 'for an Object that has zero \'length\'');
    equal(false, _emberMetalIs_blank.default([1, 2, 3]), 'for a non-empty array');
  });
});
enifed('ember-metal/tests/is_blank_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests');
  test('ember-metal/tests/is_blank_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/is_blank_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/is_blank_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests');
  QUnit.test('ember-metal/tests/is_blank_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/is_blank_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/is_empty_test', ['exports', 'ember-metal/is_empty', 'ember-metal/map'], function (exports, _emberMetalIs_empty, _emberMetalMap) {
  'use strict';

  QUnit.module('Ember.isEmpty');

  QUnit.test('Ember.isEmpty', function () {
    var string = 'string';
    var fn = function () {};
    var object = { length: 0 };

    equal(true, _emberMetalIs_empty.default(null), 'for null');
    equal(true, _emberMetalIs_empty.default(undefined), 'for undefined');
    equal(true, _emberMetalIs_empty.default(''), 'for an empty String');
    equal(false, _emberMetalIs_empty.default(true), 'for true');
    equal(false, _emberMetalIs_empty.default(false), 'for false');
    equal(false, _emberMetalIs_empty.default(string), 'for a String');
    equal(false, _emberMetalIs_empty.default(fn), 'for a Function');
    equal(false, _emberMetalIs_empty.default(0), 'for 0');
    equal(true, _emberMetalIs_empty.default([]), 'for an empty Array');
    equal(false, _emberMetalIs_empty.default({}), 'for an empty Object');
    equal(true, _emberMetalIs_empty.default(object), 'for an Object that has zero \'length\'');
  });

  QUnit.test('Ember.isEmpty Ember.Map', function () {
    var map = new _emberMetalMap.Map();
    equal(true, _emberMetalIs_empty.default(map), 'Empty map is empty');
    map.set('foo', 'bar');
    equal(false, _emberMetalIs_empty.default(map), 'Map is not empty');
  });

  QUnit.test('Ember.isEmpty Ember.OrderedSet', function () {
    var orderedSet = new _emberMetalMap.OrderedSet();
    equal(true, _emberMetalIs_empty.default(orderedSet), 'Empty ordered set is empty');
    orderedSet.add('foo');
    equal(false, _emberMetalIs_empty.default(orderedSet), 'Ordered set is not empty');
  });
});
enifed('ember-metal/tests/is_empty_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests');
  test('ember-metal/tests/is_empty_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/is_empty_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/is_empty_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests');
  QUnit.test('ember-metal/tests/is_empty_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/is_empty_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/is_none_test', ['exports', 'ember-metal/is_none'], function (exports, _emberMetalIs_none) {
  'use strict';

  QUnit.module('Ember.isNone');

  QUnit.test('Ember.isNone', function () {
    var string = 'string';
    var fn = function () {};

    equal(true, _emberMetalIs_none.default(null), 'for null');
    equal(true, _emberMetalIs_none.default(undefined), 'for undefined');
    equal(false, _emberMetalIs_none.default(''), 'for an empty String');
    equal(false, _emberMetalIs_none.default(true), 'for true');
    equal(false, _emberMetalIs_none.default(false), 'for false');
    equal(false, _emberMetalIs_none.default(string), 'for a String');
    equal(false, _emberMetalIs_none.default(fn), 'for a Function');
    equal(false, _emberMetalIs_none.default(0), 'for 0');
    equal(false, _emberMetalIs_none.default([]), 'for an empty Array');
    equal(false, _emberMetalIs_none.default({}), 'for an empty Object');
  });
});
enifed('ember-metal/tests/is_none_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests');
  test('ember-metal/tests/is_none_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/is_none_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/is_none_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests');
  QUnit.test('ember-metal/tests/is_none_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/is_none_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/is_present_test', ['exports', 'ember-metal/is_present'], function (exports, _emberMetalIs_present) {
  'use strict';

  QUnit.module('Ember.isPresent');

  QUnit.test('Ember.isPresent', function () {
    var string = 'string';
    var fn = function () {};
    var object = { length: 0 };

    equal(false, _emberMetalIs_present.default(), 'for no params');
    equal(false, _emberMetalIs_present.default(null), 'for null');
    equal(false, _emberMetalIs_present.default(undefined), 'for undefined');
    equal(false, _emberMetalIs_present.default(''), 'for an empty String');
    equal(false, _emberMetalIs_present.default('  '), 'for a whitespace String');
    equal(false, _emberMetalIs_present.default('\n\t'), 'for another whitespace String');
    equal(true, _emberMetalIs_present.default('\n\t Hi'), 'for a String with whitespaces');
    equal(true, _emberMetalIs_present.default(true), 'for true');
    equal(true, _emberMetalIs_present.default(false), 'for false');
    equal(true, _emberMetalIs_present.default(string), 'for a String');
    equal(true, _emberMetalIs_present.default(fn), 'for a Function');
    equal(true, _emberMetalIs_present.default(0), 'for 0');
    equal(false, _emberMetalIs_present.default([]), 'for an empty Array');
    equal(true, _emberMetalIs_present.default({}), 'for an empty Object');
    equal(false, _emberMetalIs_present.default(object), 'for an Object that has zero \'length\'');
    equal(true, _emberMetalIs_present.default([1, 2, 3]), 'for a non-empty array');
  });
});
enifed('ember-metal/tests/is_present_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests');
  test('ember-metal/tests/is_present_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/is_present_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/is_present_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests');
  QUnit.test('ember-metal/tests/is_present_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/is_present_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/keys_test', ['exports', 'ember-metal/property_set', 'ember-metal/observer'], function (exports, _emberMetalProperty_set, _emberMetalObserver) {
  'use strict';

  function K() {
    return this;
  }

  QUnit.module('Fetch Keys ');

  QUnit.test('should get a key array for a specified object', function () {
    var object1 = {};

    object1.names = 'Rahul';
    object1.age = '23';
    object1.place = 'Mangalore';

    var object2 = Object.keys(object1);

    deepEqual(object2, ['names', 'age', 'place']);
  });

  // This test is for IE8.
  QUnit.test('should get a key array for property that is named the same as prototype property', function () {
    var object1 = {
      toString: function () {}
    };

    var object2 = Object.keys(object1);

    deepEqual(object2, ['toString']);
  });

  QUnit.test('should not contain properties declared in the prototype', function () {
    function Beer() {}
    Beer.prototype.type = 'ipa';

    var beer = new Beer();

    deepEqual(Object.keys(beer), []);
  });

  QUnit.test('should return properties that were set after object creation', function () {
    function Beer() {}
    Beer.prototype.type = 'ipa';

    var beer = new Beer();

    _emberMetalProperty_set.set(beer, 'brand', 'big daddy');

    deepEqual(Object.keys(beer), ['brand']);
  });

  QUnit.module('Keys behavior with observers');

  QUnit.test('should not leak properties on the prototype', function () {
    function Beer() {}
    Beer.prototype.type = 'ipa';

    var beer = new Beer();

    _emberMetalObserver.addObserver(beer, 'type', K);
    deepEqual(Object.keys(beer), []);
    _emberMetalObserver.removeObserver(beer, 'type', K);
  });

  QUnit.test('observing a non existent property', function () {
    function Beer() {}
    Beer.prototype.type = 'ipa';

    var beer = new Beer();

    _emberMetalObserver.addObserver(beer, 'brand', K);

    deepEqual(Object.keys(beer), []);

    _emberMetalProperty_set.set(beer, 'brand', 'Corona');
    deepEqual(Object.keys(beer), ['brand']);

    _emberMetalObserver.removeObserver(beer, 'brand', K);
  });

  QUnit.test('with observers switched on and off', function () {
    function Beer() {}
    Beer.prototype.type = 'ipa';

    var beer = new Beer();

    _emberMetalObserver.addObserver(beer, 'type', K);
    _emberMetalObserver.removeObserver(beer, 'type', K);

    deepEqual(Object.keys(beer), []);
  });

  QUnit.test('observers switched on and off with setter in between', function () {
    function Beer() {}
    Beer.prototype.type = 'ipa';

    var beer = new Beer();

    _emberMetalObserver.addObserver(beer, 'type', K);
    _emberMetalProperty_set.set(beer, 'type', 'ale');
    _emberMetalObserver.removeObserver(beer, 'type', K);

    deepEqual(Object.keys(beer), ['type']);
  });

  QUnit.test('observer switched on and off and then setter', function () {
    function Beer() {}
    Beer.prototype.type = 'ipa';

    var beer = new Beer();

    _emberMetalObserver.addObserver(beer, 'type', K);
    _emberMetalObserver.removeObserver(beer, 'type', K);
    _emberMetalProperty_set.set(beer, 'type', 'ale');

    deepEqual(Object.keys(beer), ['type']);
  });
});
enifed('ember-metal/tests/keys_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests');
  test('ember-metal/tests/keys_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/keys_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/keys_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests');
  QUnit.test('ember-metal/tests/keys_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/keys_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/libraries_test', ['exports', 'ember-metal/core', 'ember-metal/features', 'ember-metal/libraries'], function (exports, _emberMetalCore, _emberMetalFeatures, _emberMetalLibraries) {
  /* globals EmberDev */
  'use strict';

  var libs, registry;

  QUnit.module('Libraries registry', {
    setup: function () {
      libs = new _emberMetalLibraries.default();
      registry = libs._registry;
    },

    teardown: function () {
      libs = null;
      registry = null;
    }
  });

  QUnit.test('core libraries come before other libraries', function () {
    expect(2);

    libs.register('my-lib', '2.0.0a');
    libs.registerCoreLibrary('DS', '1.0.0-beta.2');

    equal(registry[0].name, 'DS');
    equal(registry[1].name, 'my-lib');
  });

  QUnit.test('only the first registration of a library is stored', function () {
    expect(3);

    libs.register('magic', 1.23);
    libs.register('magic', 2.23);

    equal(registry[0].name, 'magic');
    equal(registry[0].version, 1.23);
    equal(registry.length, 1);
  });

  QUnit.test('attempting to register a library that is already registered warns you', function () {
    if (EmberDev && EmberDev.runningProdBuild) {
      ok(true, 'Logging does not occur in production builds');
      return;
    }

    expect(1);

    var oldWarn = _emberMetalCore.default.warn;
    libs.register('magic', 1.23);

    _emberMetalCore.default.warn = function (msg, test) {
      if (!test) {
        equal(msg, 'Library "magic" is already registered with Ember.');
      }
    };

    // Should warn us
    libs.register('magic', 2.23);

    _emberMetalCore.default.warn = oldWarn;
  });

  QUnit.test('libraries can be de-registered', function () {
    expect(2);

    libs.register('lib1', '1.0.0b');
    libs.register('lib2', '1.0.0b');
    libs.register('lib3', '1.0.0b');

    libs.deRegister('lib1');
    libs.deRegister('lib3');

    equal(registry[0].name, 'lib2');
    equal(registry.length, 1);
  });
});
enifed('ember-metal/tests/libraries_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests');
  test('ember-metal/tests/libraries_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/libraries_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/libraries_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests');
  QUnit.test('ember-metal/tests/libraries_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/libraries_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/main_test', ['exports', 'ember-metal'], function (exports, _emberMetal) {
  'use strict';

  // From sindresourhus/semver-regex https://github.com/sindresorhus/semver-regex/blob/795b05628d96597ebcbe6d31ef4a432858365582/index.js#L3
  var SEMVER_REGEX = /^\bv?(?:0|[1-9][0-9]*)\.(?:0|[1-9][0-9]*)\.(?:0|[1-9][0-9]*)(?:-[\da-z\-]+(?:\.[\da-z\-]+)*)?(?:\+[\da-z\-]+(?:\.[\da-z\-]+)*)?\b$/;

  QUnit.module('ember-metal/core/main');

  QUnit.test('Ember registers itself', function () {
    var lib = _emberMetal.default.libraries._registry[0];

    equal(lib.name, 'Ember');
    equal(lib.version, _emberMetal.default.VERSION);
  });

  QUnit.test('Ember.VERSION is in alignment with SemVer v2.0.0', function () {
    ok(SEMVER_REGEX.test(_emberMetal.default.VERSION), 'Ember.VERSION (' + _emberMetal.default.VERSION + ')is valid SemVer v2.0.0');
  });

  QUnit.test('SEMVER_REGEX properly validates and invalidates version numbers', function () {
    function validateVersionString(versionString, expectedResult) {
      equal(SEMVER_REGEX.test(versionString), expectedResult);
    }

    // Postive test cases
    validateVersionString('1.11.3', true);
    validateVersionString('1.0.0-beta.16.1', true);
    validateVersionString('1.12.1+canary.aba1412', true);
    validateVersionString('2.0.0-beta.1+canary.bb344775', true);

    // Negative test cases
    validateVersionString('1.11.3.aba18a', false);
    validateVersionString('1.11', false);
  });

  QUnit.test('Ember.keys is deprecated', function () {
    expectDeprecation(function () {
      _emberMetal.default.keys({});
    }, 'Ember.keys is deprecated in favor of Object.keys');
  });

  QUnit.test('Ember.keys is deprecated', function () {
    expectDeprecation(function () {
      _emberMetal.default.create(null);
    }, 'Ember.create is deprecated in favor of Object.create');
  });
});
enifed('ember-metal/tests/main_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests');
  test('ember-metal/tests/main_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/main_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/main_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests');
  QUnit.test('ember-metal/tests/main_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/main_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/map_test', ['exports', 'ember-metal/map'], function (exports, _emberMetalMap) {
  'use strict';

  var object, number, string, map, variety;
  var varieties = [['Map', _emberMetalMap.Map], ['MapWithDefault', _emberMetalMap.MapWithDefault]];

  function testMap(nameAndFunc) {
    variety = nameAndFunc[0];

    QUnit.module('Ember.' + variety + ' (forEach and get are implicitly tested)', {
      setup: function () {
        object = {};
        number = 42;
        string = 'foo';

        map = nameAndFunc[1].create();
      }
    });

    var mapHasLength = function (expected, theMap) {
      theMap = theMap || map;

      var length = 0;
      theMap.forEach(function () {
        length++;
      });

      equal(length, expected, 'map should contain ' + expected + ' items');
    };

    var mapHasEntries = function (entries, theMap) {
      theMap = theMap || map;

      for (var i = 0, l = entries.length; i < l; i++) {
        equal(theMap.get(entries[i][0]), entries[i][1]);
        equal(theMap.has(entries[i][0]), true);
      }

      mapHasLength(entries.length, theMap);
    };

    var unboundThis;

    (function () {
      unboundThis = this;
    })();

    QUnit.test('set', function () {
      map.set(object, 'winning');
      map.set(number, 'winning');
      map.set(string, 'winning');

      mapHasEntries([[object, 'winning'], [number, 'winning'], [string, 'winning']]);

      map.set(object, 'losing');
      map.set(number, 'losing');
      map.set(string, 'losing');

      mapHasEntries([[object, 'losing'], [number, 'losing'], [string, 'losing']]);

      equal(map.has('nope'), false, 'expected the key `nope` to not be present');
      equal(map.has({}), false, 'expected they key `{}` to not be present');
    });

    QUnit.test('set chaining', function () {
      map.set(object, 'winning').set(number, 'winning').set(string, 'winning');

      mapHasEntries([[object, 'winning'], [number, 'winning'], [string, 'winning']]);

      map.set(object, 'losing').set(number, 'losing').set(string, 'losing');

      mapHasEntries([[object, 'losing'], [number, 'losing'], [string, 'losing']]);

      equal(map.has('nope'), false, 'expected the key `nope` to not be present');
      equal(map.has({}), false, 'expected they key `{}` to not be present');
    });

    QUnit.test('with key with undefined value', function () {
      map.set('foo', undefined);

      map.forEach(function (value, key) {
        equal(value, undefined);
        equal(key, 'foo');
      });

      ok(map.has('foo'), 'has key foo, even with undefined value');

      equal(map.size, 1);
    });

    QUnit.test('arity of forEach is 1 – es6 23.1.3.5', function () {
      equal(map.forEach.length, 1, 'expected arity for map.forEach is 1');
    });

    QUnit.test('forEach throws without a callback as the first argument', function () {

      equal(map.forEach.length, 1, 'expected arity for map.forEach is 1');
    });

    QUnit.test('has empty collection', function () {
      equal(map.has('foo'), false);
      equal(map.has(), false);
    });

    QUnit.test('delete', function () {
      expectNoDeprecation();

      map.set(object, 'winning');
      map.set(number, 'winning');
      map.set(string, 'winning');

      map.delete(object);
      map.delete(number);
      map.delete(string);

      // doesn't explode
      map.delete({});

      mapHasEntries([]);
    });

    QUnit.test('copy and then update', function () {
      map.set(object, 'winning');
      map.set(number, 'winning');
      map.set(string, 'winning');

      var map2 = map.copy();

      map2.set(object, 'losing');
      map2.set(number, 'losing');
      map2.set(string, 'losing');

      mapHasEntries([[object, 'winning'], [number, 'winning'], [string, 'winning']]);

      mapHasEntries([[object, 'losing'], [number, 'losing'], [string, 'losing']], map2);
    });

    QUnit.test('copy and then delete', function () {
      map.set(object, 'winning');
      map.set(number, 'winning');
      map.set(string, 'winning');

      var map2 = map.copy();

      map2.delete(object);
      map2.delete(number);
      map2.delete(string);

      mapHasEntries([[object, 'winning'], [number, 'winning'], [string, 'winning']]);

      mapHasEntries([], map2);
    });

    QUnit.test('size', function () {
      //Add a key twice
      equal(map.size, 0);
      map.set(string, 'a string');
      equal(map.size, 1);
      map.set(string, 'the same string');
      equal(map.size, 1);

      //Add another
      map.set(number, 'a number');
      equal(map.size, 2);

      //Remove one that doesn't exist
      map.delete('does not exist');
      equal(map.size, 2);

      //Check copy
      var copy = map.copy();
      equal(copy.size, 2);

      //Remove a key twice
      map.delete(number);
      equal(map.size, 1);
      map.delete(number);
      equal(map.size, 1);

      //Remove the last key
      map.delete(string);
      equal(map.size, 0);
      map.delete(string);
      equal(map.size, 0);
    });

    QUnit.test('forEach without proper callback', function () {
      QUnit.throws(function () {
        map.forEach();
      }, '[object Undefined] is not a function');

      QUnit.throws(function () {
        map.forEach(undefined);
      }, '[object Undefined] is not a function');

      QUnit.throws(function () {
        map.forEach(1);
      }, '[object Number] is not a function');

      QUnit.throws(function () {
        map.forEach({});
      }, '[object Object] is not a function');

      map.forEach(function (value, key) {
        map.delete(key);
      });
      // ensure the error happens even if no data is present
      equal(map.size, 0);
      QUnit.throws(function () {
        map.forEach({});
      }, '[object Object] is not a function');
    });

    QUnit.test('forEach basic', function () {
      map.set('a', 1);
      map.set('b', 2);
      map.set('c', 3);

      var iteration = 0;

      var expectations = [{ value: 1, key: 'a', context: unboundThis }, { value: 2, key: 'b', context: unboundThis }, { value: 3, key: 'c', context: unboundThis }];

      map.forEach(function (value, key, theMap) {
        var expectation = expectations[iteration];

        equal(value, expectation.value, 'value should be correct');
        equal(key, expectation.key, 'key should be correct');
        equal(this, expectation.context, 'context should be as if it was unbound');
        equal(map, theMap, 'map being iterated over should be passed in');

        iteration++;
      });

      equal(iteration, 3, 'expected 3 iterations');
    });

    QUnit.test('forEach basic /w context', function () {
      map.set('a', 1);
      map.set('b', 2);
      map.set('c', 3);

      var iteration = 0;
      var context = {};
      var expectations = [{ value: 1, key: 'a', context: context }, { value: 2, key: 'b', context: context }, { value: 3, key: 'c', context: context }];

      map.forEach(function (value, key, theMap) {
        var expectation = expectations[iteration];

        equal(value, expectation.value, 'value should be correct');
        equal(key, expectation.key, 'key should be correct');
        equal(this, expectation.context, 'context should be as if it was unbound');
        equal(map, theMap, 'map being iterated over should be passed in');

        iteration++;
      }, context);

      equal(iteration, 3, 'expected 3 iterations');
    });

    QUnit.test('forEach basic /w deletion while enumerating', function () {
      map.set('a', 1);
      map.set('b', 2);
      map.set('c', 3);

      var iteration = 0;

      var expectations = [{ value: 1, key: 'a', context: unboundThis }, { value: 2, key: 'b', context: unboundThis }];

      map.forEach(function (value, key, theMap) {
        if (iteration === 0) {
          map.delete('c');
        }

        var expectation = expectations[iteration];

        equal(value, expectation.value, 'value should be correct');
        equal(key, expectation.key, 'key should be correct');
        equal(this, expectation.context, 'context should be as if it was unbound');
        equal(map, theMap, 'map being iterated over should be passed in');

        iteration++;
      });

      equal(iteration, 2, 'expected 3 iterations');
    });

    QUnit.test('forEach basic /w addition while enumerating', function () {
      map.set('a', 1);
      map.set('b', 2);
      map.set('c', 3);

      var iteration = 0;

      var expectations = [{ value: 1, key: 'a', context: unboundThis }, { value: 2, key: 'b', context: unboundThis }, { value: 3, key: 'c', context: unboundThis }, { value: 4, key: 'd', context: unboundThis }];

      map.forEach(function (value, key, theMap) {
        if (iteration === 0) {
          map.set('d', 4);
        }

        var expectation = expectations[iteration];

        equal(value, expectation.value, 'value should be correct');
        equal(key, expectation.key, 'key should be correct');
        equal(this, expectation.context, 'context should be as if it was unbound');
        equal(map, theMap, 'map being iterated over should be passed in');

        iteration++;
      });

      equal(iteration, 4, 'expected 3 iterations');
    });

    QUnit.test('clear', function () {
      var iterations = 0;

      map.set('a', 1);
      map.set('b', 2);
      map.set('c', 3);
      map.set('d', 4);

      equal(map.size, 4);

      map.forEach(function () {
        iterations++;
      });
      equal(iterations, 4);

      map.clear();
      equal(map.size, 0);
      iterations = 0;
      map.forEach(function () {
        iterations++;
      });
      equal(iterations, 0);
    });

    QUnit.test('-0', function () {
      equal(map.has(-0), false);
      equal(map.has(0), false);

      map.set(-0, 'zero');

      equal(map.has(-0), true);
      equal(map.has(0), true);

      equal(map.get(0), 'zero');
      equal(map.get(-0), 'zero');

      map.forEach(function (value, key) {
        equal(1 / key, Infinity, 'spec says key should be positive zero');
      });
    });

    QUnit.test('NaN', function () {
      equal(map.has(NaN), false);

      map.set(NaN, 'not-a-number');

      equal(map.has(NaN), true);

      equal(map.get(NaN), 'not-a-number');
    });

    QUnit.test('NaN Boxed', function () {
      //jshint -W053
      var boxed = new Number(NaN);
      equal(map.has(boxed), false);

      map.set(boxed, 'not-a-number');

      equal(map.has(boxed), true);
      equal(map.has(NaN), false);

      equal(map.get(NaN), undefined);
      equal(map.get(boxed), 'not-a-number');
    });

    QUnit.test('0 value', function () {
      var obj = {};
      equal(map.has(obj), false);

      equal(map.size, 0);
      map.set(obj, 0);
      equal(map.size, 1);

      equal(map.has(obj), true);
      equal(map.get(obj), 0);

      map.delete(obj);
      equal(map.has(obj), false);
      equal(map.get(obj), undefined);
      equal(map.size, 0);
    });
  }

  for (var i = 0; i < varieties.length; i++) {
    testMap(varieties[i]);
  }

  QUnit.module('MapWithDefault - default values');

  QUnit.test('Retrieving a value that has not been set returns and sets a default value', function () {
    var map = _emberMetalMap.MapWithDefault.create({
      defaultValue: function (key) {
        return [key];
      }
    });

    var value = map.get('ohai');
    deepEqual(value, ['ohai']);

    strictEqual(value, map.get('ohai'));
  });

  QUnit.test('Map.prototype.constructor', function () {
    var map = new _emberMetalMap.Map();
    equal(map.constructor, _emberMetalMap.Map);
  });

  QUnit.test('MapWithDefault.prototype.constructor', function () {
    var map = new _emberMetalMap.MapWithDefault({
      defaultValue: function (key) {
        return key;
      }
    });
    equal(map.constructor, _emberMetalMap.MapWithDefault);
  });

  QUnit.test('Copying a MapWithDefault copies the default value', function () {
    var map = _emberMetalMap.MapWithDefault.create({
      defaultValue: function (key) {
        return [key];
      }
    });

    map.set('ohai', 1);
    map.get('bai');

    var map2 = map.copy();

    equal(map2.get('ohai'), 1);
    deepEqual(map2.get('bai'), ['bai']);

    map2.set('kthx', 3);

    deepEqual(map.get('kthx'), ['kthx']);
    equal(map2.get('kthx'), 3);

    deepEqual(map2.get('default'), ['default']);

    map2.defaultValue = function (key) {
      return ['tom is on', key];
    };

    deepEqual(map2.get('drugs'), ['tom is on', 'drugs']);
  });

  QUnit.module('OrderedSet', {
    setup: function () {
      object = {};
      number = 42;
      string = 'foo';

      map = _emberMetalMap.OrderedSet.create();
    }
  });

  QUnit.test('add returns the set', function () {
    var obj = {};
    equal(map.add(obj), map);
    equal(map.add(obj), map, 'when it is already in the set');
  });
});
enifed('ember-metal/tests/map_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests');
  test('ember-metal/tests/map_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/map_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/map_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests');
  QUnit.test('ember-metal/tests/map_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/map_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/mixin/alias_method_test', ['exports', 'ember-metal/property_get', 'ember-metal/mixin'], function (exports, _emberMetalProperty_get, _emberMetalMixin) {
  'use strict';

  QUnit.module('aliasMethod');

  function validateAliasMethod(obj) {
    equal(obj.fooMethod(), 'FOO', 'obj.fooMethod()');
    equal(obj.barMethod(), 'FOO', 'obj.barMethod should be a copy of foo');
  }

  QUnit.test('methods of another name are aliased when the mixin is applied', function () {
    var MyMixin = _emberMetalMixin.Mixin.create({
      fooMethod: function () {
        return 'FOO';
      },
      barMethod: _emberMetalMixin.aliasMethod('fooMethod')
    });

    var obj = MyMixin.apply({});
    validateAliasMethod(obj);
  });

  QUnit.test('should follow aliasMethods all the way down', function () {
    var MyMixin = _emberMetalMixin.Mixin.create({
      bar: _emberMetalMixin.aliasMethod('foo'), // put first to break ordered iteration
      baz: function () {
        return 'baz';
      },
      foo: _emberMetalMixin.aliasMethod('baz')
    });

    var obj = MyMixin.apply({});
    equal(_emberMetalProperty_get.get(obj, 'bar')(), 'baz', 'should have followed aliasMethods');
  });

  QUnit.test('should alias methods from other dependent mixins', function () {
    var BaseMixin = _emberMetalMixin.Mixin.create({
      fooMethod: function () {
        return 'FOO';
      }
    });

    var MyMixin = _emberMetalMixin.Mixin.create(BaseMixin, {
      barMethod: _emberMetalMixin.aliasMethod('fooMethod')
    });

    var obj = MyMixin.apply({});
    validateAliasMethod(obj);
  });

  QUnit.test('should alias methods from other mixins applied at same time', function () {
    var BaseMixin = _emberMetalMixin.Mixin.create({
      fooMethod: function () {
        return 'FOO';
      }
    });

    var MyMixin = _emberMetalMixin.Mixin.create({
      barMethod: _emberMetalMixin.aliasMethod('fooMethod')
    });

    var obj = _emberMetalMixin.mixin({}, BaseMixin, MyMixin);
    validateAliasMethod(obj);
  });

  QUnit.test('should alias methods from mixins already applied on object', function () {
    var BaseMixin = _emberMetalMixin.Mixin.create({
      quxMethod: function () {
        return 'qux';
      }
    });

    var MyMixin = _emberMetalMixin.Mixin.create({
      bar: _emberMetalMixin.aliasMethod('foo'),
      barMethod: _emberMetalMixin.aliasMethod('fooMethod')
    });

    var obj = {
      fooMethod: function () {
        return 'FOO';
      }
    };

    BaseMixin.apply(obj);
    MyMixin.apply(obj);

    validateAliasMethod(obj);
  });
});
enifed('ember-metal/tests/mixin/alias_method_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests/mixin');
  test('ember-metal/tests/mixin/alias_method_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/mixin/alias_method_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/mixin/alias_method_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests/mixin');
  QUnit.test('ember-metal/tests/mixin/alias_method_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/mixin/alias_method_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/mixin/apply_test', ['exports', 'ember-metal/property_get', 'ember-metal/mixin'], function (exports, _emberMetalProperty_get, _emberMetalMixin) {
  'use strict';

  QUnit.module('Ember.Mixin.apply');

  function K() {}

  QUnit.test('using apply() should apply properties', function () {
    var MixinA = _emberMetalMixin.Mixin.create({ foo: 'FOO', baz: K });
    var obj = {};
    _emberMetalMixin.mixin(obj, MixinA);

    equal(_emberMetalProperty_get.default(obj, 'foo'), 'FOO', 'should apply foo');
    equal(_emberMetalProperty_get.default(obj, 'baz'), K, 'should apply foo');
  });

  QUnit.test('applying anonymous properties', function () {
    var obj = {};
    _emberMetalMixin.mixin(obj, {
      foo: 'FOO',
      baz: K
    });

    equal(_emberMetalProperty_get.default(obj, 'foo'), 'FOO', 'should apply foo');
    equal(_emberMetalProperty_get.default(obj, 'baz'), K, 'should apply foo');
  });

  QUnit.test('applying null values', function () {
    expectAssertion(function () {
      _emberMetalMixin.mixin({}, null);
    });
  });

  QUnit.test('applying a property with an undefined value', function () {
    var obj = { tagName: '' };
    _emberMetalMixin.mixin(obj, { tagName: undefined });

    strictEqual(_emberMetalProperty_get.default(obj, 'tagName'), '');
  });
});
enifed('ember-metal/tests/mixin/apply_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests/mixin');
  test('ember-metal/tests/mixin/apply_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/mixin/apply_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/mixin/apply_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests/mixin');
  QUnit.test('ember-metal/tests/mixin/apply_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/mixin/apply_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/mixin/computed_test', ['exports', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/mixin', 'ember-metal/computed', 'ember-metal/properties'], function (exports, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalMixin, _emberMetalComputed, _emberMetalProperties) {
  'use strict';

  function K() {
    return this;
  }

  QUnit.module('Mixin Computed Properties');

  QUnit.test('overriding computed properties', function () {
    var MixinA, MixinB, MixinC, MixinD;
    var obj;

    MixinA = _emberMetalMixin.Mixin.create({
      aProp: _emberMetalComputed.computed(function () {
        return 'A';
      })
    });

    MixinB = _emberMetalMixin.Mixin.create(MixinA, {
      aProp: _emberMetalComputed.computed(function () {
        return this._super.apply(this, arguments) + 'B';
      })
    });

    MixinC = _emberMetalMixin.Mixin.create(MixinA, {
      aProp: _emberMetalComputed.computed(function () {
        return this._super.apply(this, arguments) + 'C';
      })
    });

    MixinD = _emberMetalMixin.Mixin.create({
      aProp: _emberMetalComputed.computed(function () {
        return this._super.apply(this, arguments) + 'D';
      })
    });

    obj = {};
    MixinB.apply(obj);
    equal(_emberMetalProperty_get.get(obj, 'aProp'), 'AB', 'should expose super for B');

    obj = {};
    MixinC.apply(obj);
    equal(_emberMetalProperty_get.get(obj, 'aProp'), 'AC', 'should expose super for C');

    obj = {};

    MixinA.apply(obj);
    MixinD.apply(obj);
    equal(_emberMetalProperty_get.get(obj, 'aProp'), 'AD', 'should define super for D');

    obj = {};
    _emberMetalProperties.defineProperty(obj, 'aProp', _emberMetalComputed.computed(function (key) {
      return 'obj';
    }));
    MixinD.apply(obj);
    equal(_emberMetalProperty_get.get(obj, 'aProp'), 'objD', 'should preserve original computed property');
  });

  QUnit.test('calling set on overridden computed properties', function () {
    var SuperMixin, SubMixin;
    var obj;

    var superGetOccurred = false;
    var superSetOccurred = false;

    SuperMixin = _emberMetalMixin.Mixin.create({
      aProp: _emberMetalComputed.computed({
        get: function (key) {
          superGetOccurred = true;
        },
        set: function (key, value) {
          superSetOccurred = true;
        }
      })
    });

    SubMixin = _emberMetalMixin.Mixin.create(SuperMixin, {
      aProp: _emberMetalComputed.computed({
        get: function (key) {
          return this._super.apply(this, arguments);
        },
        set: function (key, value) {
          return this._super.apply(this, arguments);
        }
      })
    });

    obj = {};
    SubMixin.apply(obj);

    _emberMetalProperty_set.set(obj, 'aProp', 'set thyself');
    ok(superSetOccurred, 'should pass set to _super');

    superSetOccurred = false; // reset the set assertion

    obj = {};
    SubMixin.apply(obj);

    _emberMetalProperty_get.get(obj, 'aProp');
    ok(superGetOccurred, 'should pass get to _super');

    _emberMetalProperty_set.set(obj, 'aProp', 'set thyself');
    ok(superSetOccurred, 'should pass set to _super after getting');
  });

  QUnit.test('setter behavior works properly when overriding computed properties', function () {
    var obj = {};

    var MixinA = _emberMetalMixin.Mixin.create({
      cpWithSetter2: _emberMetalComputed.computed(K),
      cpWithSetter3: _emberMetalComputed.computed(K),
      cpWithoutSetter: _emberMetalComputed.computed(K)
    });

    var cpWasCalled = false;

    var MixinB = _emberMetalMixin.Mixin.create({
      cpWithSetter2: _emberMetalComputed.computed({
        get: K,
        set: function (k, v) {
          cpWasCalled = true;
        }
      }),

      cpWithSetter3: _emberMetalComputed.computed({
        get: K,
        set: function (k, v) {
          cpWasCalled = true;
        }
      }),

      cpWithoutSetter: _emberMetalComputed.computed(function (k) {
        cpWasCalled = true;
      })
    });

    MixinA.apply(obj);
    MixinB.apply(obj);

    _emberMetalProperty_set.set(obj, 'cpWithSetter2', 'test');
    ok(cpWasCalled, 'The computed property setter was called when defined with two args');
    cpWasCalled = false;

    _emberMetalProperty_set.set(obj, 'cpWithSetter3', 'test');
    ok(cpWasCalled, 'The computed property setter was called when defined with three args');
    cpWasCalled = false;

    _emberMetalProperty_set.set(obj, 'cpWithoutSetter', 'test');
    equal(_emberMetalProperty_get.get(obj, 'cpWithoutSetter'), 'test', 'The default setter was called, the value is correct');
    ok(!cpWasCalled, 'The default setter was called, not the CP itself');
  });
});
enifed('ember-metal/tests/mixin/computed_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests/mixin');
  test('ember-metal/tests/mixin/computed_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/mixin/computed_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/mixin/computed_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests/mixin');
  QUnit.test('ember-metal/tests/mixin/computed_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/mixin/computed_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/mixin/concatenated_properties_test', ['exports', 'ember-metal/property_get', 'ember-metal/mixin'], function (exports, _emberMetalProperty_get, _emberMetalMixin) {
  'use strict';

  QUnit.module('Mixin concatenatedProperties');

  QUnit.test('defining concatenated properties should concat future version', function () {

    var MixinA = _emberMetalMixin.Mixin.create({
      concatenatedProperties: ['foo'],
      foo: ['a', 'b', 'c']
    });

    var MixinB = _emberMetalMixin.Mixin.create({
      foo: ['d', 'e', 'f']
    });

    var obj = _emberMetalMixin.mixin({}, MixinA, MixinB);
    deepEqual(_emberMetalProperty_get.default(obj, 'foo'), ['a', 'b', 'c', 'd', 'e', 'f']);
  });

  QUnit.test('defining concatenated properties should concat future version', function () {

    var MixinA = _emberMetalMixin.Mixin.create({
      concatenatedProperties: null
    });

    var MixinB = _emberMetalMixin.Mixin.create({
      concatenatedProperties: null
    });

    var obj = _emberMetalMixin.mixin({}, MixinA, MixinB);

    deepEqual(obj.concatenatedProperties, []);
  });

  QUnit.test('concatenatedProperties should be concatenated', function () {

    var MixinA = _emberMetalMixin.Mixin.create({
      concatenatedProperties: ['foo'],
      foo: ['a', 'b', 'c']
    });

    var MixinB = _emberMetalMixin.Mixin.create({
      concatenatedProperties: 'bar',
      foo: ['d', 'e', 'f'],
      bar: [1, 2, 3]
    });

    var MixinC = _emberMetalMixin.Mixin.create({
      bar: [4, 5, 6]
    });

    var obj = _emberMetalMixin.mixin({}, MixinA, MixinB, MixinC);
    deepEqual(_emberMetalProperty_get.default(obj, 'concatenatedProperties'), ['foo', 'bar'], 'get concatenatedProperties');
    deepEqual(_emberMetalProperty_get.default(obj, 'foo'), ['a', 'b', 'c', 'd', 'e', 'f'], 'get foo');
    deepEqual(_emberMetalProperty_get.default(obj, 'bar'), [1, 2, 3, 4, 5, 6], 'get bar');
  });

  QUnit.test('adding a prop that is not an array should make array', function () {

    var MixinA = _emberMetalMixin.Mixin.create({
      concatenatedProperties: ['foo'],
      foo: [1, 2, 3]
    });

    var MixinB = _emberMetalMixin.Mixin.create({
      foo: 4
    });

    var obj = _emberMetalMixin.mixin({}, MixinA, MixinB);
    deepEqual(_emberMetalProperty_get.default(obj, 'foo'), [1, 2, 3, 4]);
  });

  QUnit.test('adding a prop that is not an array should make array', function () {

    var MixinA = _emberMetalMixin.Mixin.create({
      concatenatedProperties: ['foo'],
      foo: 'bar'
    });

    var obj = _emberMetalMixin.mixin({}, MixinA);
    deepEqual(_emberMetalProperty_get.default(obj, 'foo'), ['bar']);
  });

  QUnit.test('adding a non-concatenable property that already has a defined value should result in an array with both values', function () {

    var mixinA = _emberMetalMixin.Mixin.create({
      foo: 1
    });

    var mixinB = _emberMetalMixin.Mixin.create({
      concatenatedProperties: ['foo'],
      foo: 2
    });

    var obj = _emberMetalMixin.mixin({}, mixinA, mixinB);
    deepEqual(_emberMetalProperty_get.default(obj, 'foo'), [1, 2]);
  });

  QUnit.test('adding a concatenable property that already has a defined value should result in a concatenated value', function () {

    var mixinA = _emberMetalMixin.Mixin.create({
      foobar: 'foo'
    });

    var mixinB = _emberMetalMixin.Mixin.create({
      concatenatedProperties: ['foobar'],
      foobar: 'bar'
    });

    var obj = _emberMetalMixin.mixin({}, mixinA, mixinB);
    equal(_emberMetalProperty_get.default(obj, 'foobar'), 'foobar');
  });
});
enifed('ember-metal/tests/mixin/concatenated_properties_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests/mixin');
  test('ember-metal/tests/mixin/concatenated_properties_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/mixin/concatenated_properties_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/mixin/concatenated_properties_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests/mixin');
  QUnit.test('ember-metal/tests/mixin/concatenated_properties_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/mixin/concatenated_properties_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/mixin/detect_test', ['exports', 'ember-metal/mixin'], function (exports, _emberMetalMixin) {
  'use strict';

  QUnit.module('Mixin.detect');

  QUnit.test('detect() finds a directly applied mixin', function () {

    var MixinA = _emberMetalMixin.Mixin.create();
    var obj = {};

    equal(MixinA.detect(obj), false, 'MixinA.detect(obj) before apply()');

    MixinA.apply(obj);
    equal(MixinA.detect(obj), true, 'MixinA.detect(obj) after apply()');
  });

  QUnit.test('detect() finds nested mixins', function () {
    var MixinA = _emberMetalMixin.Mixin.create({});
    var MixinB = _emberMetalMixin.Mixin.create(MixinA);
    var obj = {};

    equal(MixinA.detect(obj), false, 'MixinA.detect(obj) before apply()');

    MixinB.apply(obj);
    equal(MixinA.detect(obj), true, 'MixinA.detect(obj) after apply()');
  });

  QUnit.test('detect() finds mixins on other mixins', function () {
    var MixinA = _emberMetalMixin.Mixin.create({});
    var MixinB = _emberMetalMixin.Mixin.create(MixinA);
    equal(MixinA.detect(MixinB), true, 'MixinA is part of MixinB');
    equal(MixinB.detect(MixinA), false, 'MixinB is not part of MixinA');
  });

  QUnit.test('detect handles null values', function () {
    var MixinA = _emberMetalMixin.Mixin.create();
    equal(MixinA.detect(null), false);
  });
});
enifed('ember-metal/tests/mixin/detect_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests/mixin');
  test('ember-metal/tests/mixin/detect_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/mixin/detect_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/mixin/detect_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests/mixin');
  QUnit.test('ember-metal/tests/mixin/detect_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/mixin/detect_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/mixin/introspection_test', ['exports', 'ember-metal/utils', 'ember-metal/mixin'], function (exports, _emberMetalUtils, _emberMetalMixin) {
  // NOTE: A previous iteration differentiated between public and private props
  // as well as methods vs props.  We are just keeping these for testing; the
  // current impl doesn't care about the differences as much...

  'use strict';

  var PrivateProperty = _emberMetalMixin.Mixin.create({
    _foo: '_FOO'
  });

  var PublicProperty = _emberMetalMixin.Mixin.create({
    foo: 'FOO'
  });

  var PrivateMethod = _emberMetalMixin.Mixin.create({
    _fooMethod: function () {}
  });

  var PublicMethod = _emberMetalMixin.Mixin.create({
    fooMethod: function () {}
  });

  var BarProperties = _emberMetalMixin.Mixin.create({
    _bar: '_BAR',
    bar: 'bar'
  });

  var BarMethods = _emberMetalMixin.Mixin.create({
    _barMethod: function () {},
    barMethod: function () {}
  });

  var Combined = _emberMetalMixin.Mixin.create(BarProperties, BarMethods);

  var obj;

  QUnit.module('Basic introspection', {
    setup: function () {
      obj = {};
      _emberMetalMixin.mixin(obj, PrivateProperty, PublicProperty, PrivateMethod, PublicMethod, Combined);
    }
  });

  QUnit.test('Ember.mixins()', function () {

    function mapGuids(ary) {
      return ary.map(function (x) {
        return _emberMetalUtils.guidFor(x);
      });
    }

    deepEqual(mapGuids(_emberMetalMixin.Mixin.mixins(obj)), mapGuids([PrivateProperty, PublicProperty, PrivateMethod, PublicMethod, Combined, BarProperties, BarMethods]), 'should return included mixins');
  });
});
enifed('ember-metal/tests/mixin/introspection_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests/mixin');
  test('ember-metal/tests/mixin/introspection_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/mixin/introspection_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/mixin/introspection_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests/mixin');
  QUnit.test('ember-metal/tests/mixin/introspection_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/mixin/introspection_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/mixin/merged_properties_test', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-metal/mixin'], function (exports, _emberMetalCore, _emberMetalProperty_get, _emberMetalMixin) {
  'use strict';

  QUnit.module('Mixin mergedProperties');

  QUnit.test('defining mergedProperties should merge future version', function () {

    var MixinA = _emberMetalMixin.Mixin.create({
      mergedProperties: ['foo'],
      foo: { a: true, b: true, c: true }
    });

    var MixinB = _emberMetalMixin.Mixin.create({
      foo: { d: true, e: true, f: true }
    });

    var obj = _emberMetalMixin.mixin({}, MixinA, MixinB);
    deepEqual(_emberMetalProperty_get.get(obj, 'foo'), { a: true, b: true, c: true, d: true, e: true, f: true });
  });

  QUnit.test('defining mergedProperties on future mixin should merged into past', function () {

    var MixinA = _emberMetalMixin.Mixin.create({
      foo: { a: true, b: true, c: true }
    });

    var MixinB = _emberMetalMixin.Mixin.create({
      mergedProperties: ['foo'],
      foo: { d: true, e: true, f: true }
    });

    var obj = _emberMetalMixin.mixin({}, MixinA, MixinB);
    deepEqual(_emberMetalProperty_get.get(obj, 'foo'), { a: true, b: true, c: true, d: true, e: true, f: true });
  });

  QUnit.test('defining mergedProperties with null properties should keep properties null', function () {

    var MixinA = _emberMetalMixin.Mixin.create({
      mergedProperties: ['foo'],
      foo: null
    });

    var MixinB = _emberMetalMixin.Mixin.create({
      foo: null
    });

    var obj = _emberMetalMixin.mixin({}, MixinA, MixinB);
    equal(_emberMetalProperty_get.get(obj, 'foo'), null);
  });

  QUnit.test('mergedProperties\' properties can get overwritten', function () {

    var MixinA = _emberMetalMixin.Mixin.create({
      mergedProperties: ['foo'],
      foo: { a: 1 }
    });

    var MixinB = _emberMetalMixin.Mixin.create({
      foo: { a: 2 }
    });

    var obj = _emberMetalMixin.mixin({}, MixinA, MixinB);
    deepEqual(_emberMetalProperty_get.get(obj, 'foo'), { a: 2 });
  });

  QUnit.test('mergedProperties should be concatenated', function () {

    var MixinA = _emberMetalMixin.Mixin.create({
      mergedProperties: ['foo'],
      foo: { a: true, b: true, c: true }
    });

    var MixinB = _emberMetalMixin.Mixin.create({
      mergedProperties: 'bar',
      foo: { d: true, e: true, f: true },
      bar: { a: true, l: true }
    });

    var MixinC = _emberMetalMixin.Mixin.create({
      bar: { e: true, x: true }
    });

    var obj = _emberMetalMixin.mixin({}, MixinA, MixinB, MixinC);
    deepEqual(_emberMetalProperty_get.get(obj, 'mergedProperties'), ['foo', 'bar'], 'get mergedProperties');
    deepEqual(_emberMetalProperty_get.get(obj, 'foo'), { a: true, b: true, c: true, d: true, e: true, f: true }, 'get foo');
    deepEqual(_emberMetalProperty_get.get(obj, 'bar'), { a: true, l: true, e: true, x: true }, 'get bar');
  });

  QUnit.test('mergedProperties should exist even if not explicitly set on create', function () {

    var AnObj = _emberMetalCore.default.Object.extend({
      mergedProperties: ['options'],
      options: {
        a: 'a',
        b: {
          c: 'ccc'
        }
      }
    });

    var obj = AnObj.create({
      options: {
        a: 'A'
      }
    });

    equal(_emberMetalProperty_get.get(obj, 'options').a, 'A');
    equal(_emberMetalProperty_get.get(obj, 'options').b.c, 'ccc');
  });

  QUnit.test('mergedProperties\' overwriting methods can call _super', function () {

    expect(4);

    var MixinA = _emberMetalMixin.Mixin.create({
      mergedProperties: ['foo'],
      foo: {
        meth: function (a) {
          equal(a, 'WOOT', '_super successfully called MixinA\'s `foo.meth` method');
          return 'WAT';
        }
      }
    });

    var MixinB = _emberMetalMixin.Mixin.create({
      foo: {
        meth: function (a) {
          ok(true, 'MixinB\'s `foo.meth` method called');
          return this._super.apply(this, arguments);
        }
      }
    });

    var MixinC = _emberMetalMixin.Mixin.create({
      foo: {
        meth: function (a) {
          ok(true, 'MixinC\'s `foo.meth` method called');
          return this._super(a);
        }
      }
    });

    var obj = _emberMetalMixin.mixin({}, MixinA, MixinB, MixinC);
    equal(obj.foo.meth('WOOT'), 'WAT');
  });

  QUnit.test('Merging an Array should raise an error', function () {

    expect(1);

    var MixinA = _emberMetalMixin.Mixin.create({
      mergedProperties: ['foo'],
      foo: { a: true, b: true, c: true }
    });

    var MixinB = _emberMetalMixin.Mixin.create({
      foo: ['a']
    });

    expectAssertion(function () {
      _emberMetalMixin.mixin({}, MixinA, MixinB);
    }, 'You passed in `["a"]` as the value for `foo` but `foo` cannot be an Array');
  });
});
enifed('ember-metal/tests/mixin/merged_properties_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests/mixin');
  test('ember-metal/tests/mixin/merged_properties_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/mixin/merged_properties_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/mixin/merged_properties_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests/mixin');
  QUnit.test('ember-metal/tests/mixin/merged_properties_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/mixin/merged_properties_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/mixin/method_test', ['exports', 'ember-metal/mixin'], function (exports, _emberMetalMixin) {
  'use strict';

  QUnit.module('Mixin Methods');

  QUnit.test('defining simple methods', function () {

    var MixinA, obj, props;

    props = {
      publicMethod: function () {
        return 'publicMethod';
      },
      _privateMethod: function () {
        return 'privateMethod';
      }
    };

    MixinA = _emberMetalMixin.Mixin.create(props);
    obj = {};
    MixinA.apply(obj);

    // but should be defined
    equal(props.publicMethod(), 'publicMethod', 'publicMethod is func');
    equal(props._privateMethod(), 'privateMethod', 'privateMethod is func');
  });

  QUnit.test('overriding public methods', function () {
    var MixinA, MixinB, MixinD, MixinF, obj;

    MixinA = _emberMetalMixin.Mixin.create({
      publicMethod: function () {
        return 'A';
      }
    });

    MixinB = _emberMetalMixin.Mixin.create(MixinA, {
      publicMethod: function () {
        return this._super.apply(this, arguments) + 'B';
      }
    });

    MixinD = _emberMetalMixin.Mixin.create(MixinA, {
      publicMethod: function () {
        return this._super.apply(this, arguments) + 'D';
      }
    });

    MixinF = _emberMetalMixin.Mixin.create({
      publicMethod: function () {
        return this._super.apply(this, arguments) + 'F';
      }
    });

    obj = {};
    MixinB.apply(obj);
    equal(obj.publicMethod(), 'AB', 'should define super for A and B');

    obj = {};
    MixinD.apply(obj);
    equal(obj.publicMethod(), 'AD', 'should define super for A and B');

    obj = {};
    MixinA.apply(obj);
    MixinF.apply(obj);
    equal(obj.publicMethod(), 'AF', 'should define super for A and F');

    obj = { publicMethod: function () {
        return 'obj';
      } };
    MixinF.apply(obj);
    equal(obj.publicMethod(), 'objF', 'should define super for F');
  });

  QUnit.test('overriding inherited objects', function () {

    var cnt = 0;
    var MixinA = _emberMetalMixin.Mixin.create({
      foo: function () {
        cnt++;
      }
    });

    var MixinB = _emberMetalMixin.Mixin.create({
      foo: function () {
        this._super.apply(this, arguments);
        cnt++;
      }
    });

    var objA = {};
    MixinA.apply(objA);

    var objB = Object.create(objA);
    MixinB.apply(objB);

    cnt = 0;
    objB.foo();
    equal(cnt, 2, 'should invoke both methods');

    cnt = 0;
    objA.foo();
    equal(cnt, 1, 'should not screw w/ parent obj');
  });

  QUnit.test('Including the same mixin more than once will only run once', function () {
    var cnt = 0;
    var MixinA = _emberMetalMixin.Mixin.create({
      foo: function () {
        cnt++;
      }
    });

    var MixinB = _emberMetalMixin.Mixin.create(MixinA, {
      foo: function () {
        this._super.apply(this, arguments);
      }
    });

    var MixinC = _emberMetalMixin.Mixin.create(MixinA, {
      foo: function () {
        this._super.apply(this, arguments);
      }
    });

    var MixinD = _emberMetalMixin.Mixin.create(MixinB, MixinC, MixinA, {
      foo: function () {
        this._super.apply(this, arguments);
      }
    });

    var obj = {};
    MixinD.apply(obj);
    MixinA.apply(obj); // try to apply again..

    cnt = 0;
    obj.foo();

    equal(cnt, 1, 'should invoke MixinA.foo one time');
  });

  QUnit.test('_super from a single mixin with no superclass does not error', function () {
    var MixinA = _emberMetalMixin.Mixin.create({
      foo: function () {
        this._super.apply(this, arguments);
      }
    });

    var obj = {};
    MixinA.apply(obj);

    obj.foo();
    ok(true);
  });

  QUnit.test('_super from a first-of-two mixins with no superclass function does not error', function () {
    // _super was previously calling itself in the second assertion.
    // Use remaining count of calls to ensure it doesn't loop indefinitely.
    var remaining = 3;
    var MixinA = _emberMetalMixin.Mixin.create({
      foo: function () {
        if (remaining-- > 0) {
          this._super.apply(this, arguments);
        }
      }
    });

    var MixinB = _emberMetalMixin.Mixin.create({
      foo: function () {
        this._super.apply(this, arguments);
      }
    });

    var obj = {};
    MixinA.apply(obj);
    MixinB.apply(obj);

    obj.foo();
    ok(true);
  });

  // ..........................................................
  // CONFLICTS
  //

  QUnit.module('Method Conflicts');

  QUnit.test('overriding toString', function () {
    var MixinA = _emberMetalMixin.Mixin.create({
      toString: function () {
        return 'FOO';
      }
    });

    var obj = {};
    MixinA.apply(obj);
    equal(obj.toString(), 'FOO', 'should override toString w/o error');

    obj = {};
    _emberMetalMixin.mixin(obj, { toString: function () {
        return 'FOO';
      } });
    equal(obj.toString(), 'FOO', 'should override toString w/o error');
  });

  // ..........................................................
  // BUGS
  //

  QUnit.module('system/mixin/method_test BUGS');

  QUnit.test('applying several mixins at once with sup already defined causes infinite loop', function () {

    var cnt = 0;
    var MixinA = _emberMetalMixin.Mixin.create({
      foo: function () {
        cnt++;
      }
    });

    var MixinB = _emberMetalMixin.Mixin.create({
      foo: function () {
        this._super.apply(this, arguments);
        cnt++;
      }
    });

    var MixinC = _emberMetalMixin.Mixin.create({
      foo: function () {
        this._super.apply(this, arguments);
        cnt++;
      }
    });

    var obj = {};
    _emberMetalMixin.mixin(obj, MixinA); // sup already exists
    _emberMetalMixin.mixin(obj, MixinB, MixinC); // must be more than one mixin

    cnt = 0;
    obj.foo();
    equal(cnt, 3, 'should invoke all 3 methods');
  });
});
enifed('ember-metal/tests/mixin/method_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests/mixin');
  test('ember-metal/tests/mixin/method_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/mixin/method_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/mixin/method_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests/mixin');
  QUnit.test('ember-metal/tests/mixin/method_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/mixin/method_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/mixin/observer_test', ['exports', 'ember-metal/tests/props_helper', 'ember-metal/mixin', 'ember-metal/watching'], function (exports, _emberMetalTestsProps_helper, _emberMetalMixin, _emberMetalWatching) {
  'use strict';

  QUnit.module('Mixin observer');

  _emberMetalTestsProps_helper.testBoth('global observer helper', function (get, set) {

    var MyMixin = _emberMetalMixin.Mixin.create({

      count: 0,

      foo: _emberMetalMixin.observer('bar', function () {
        set(this, 'count', get(this, 'count') + 1);
      })

    });

    var obj = _emberMetalMixin.mixin({}, MyMixin);
    equal(get(obj, 'count'), 0, 'should not invoke observer immediately');

    set(obj, 'bar', 'BAZ');
    equal(get(obj, 'count'), 1, 'should invoke observer after change');
  });

  _emberMetalTestsProps_helper.testBoth('global observer helper takes multiple params', function (get, set) {

    var MyMixin = _emberMetalMixin.Mixin.create({

      count: 0,

      foo: _emberMetalMixin.observer('bar', 'baz', function () {
        set(this, 'count', get(this, 'count') + 1);
      })

    });

    var obj = _emberMetalMixin.mixin({}, MyMixin);
    equal(get(obj, 'count'), 0, 'should not invoke observer immediately');

    set(obj, 'bar', 'BAZ');
    set(obj, 'baz', 'BAZ');
    equal(get(obj, 'count'), 2, 'should invoke observer after change');
  });

  _emberMetalTestsProps_helper.testBoth('replacing observer should remove old observer', function (get, set) {

    var MyMixin = _emberMetalMixin.Mixin.create({

      count: 0,

      foo: _emberMetalMixin.observer('bar', function () {
        set(this, 'count', get(this, 'count') + 1);
      })

    });

    var Mixin2 = _emberMetalMixin.Mixin.create({
      foo: _emberMetalMixin.observer('baz', function () {
        set(this, 'count', get(this, 'count') + 10);
      })
    });

    var obj = _emberMetalMixin.mixin({}, MyMixin, Mixin2);
    equal(get(obj, 'count'), 0, 'should not invoke observer immediately');

    set(obj, 'bar', 'BAZ');
    equal(get(obj, 'count'), 0, 'should not invoke observer after change');

    set(obj, 'baz', 'BAZ');
    equal(get(obj, 'count'), 10, 'should invoke observer after change');
  });

  _emberMetalTestsProps_helper.testBoth('observing chain with property before', function (get, set) {
    var obj2 = { baz: 'baz' };

    var MyMixin = _emberMetalMixin.Mixin.create({
      count: 0,
      bar: obj2,
      foo: _emberMetalMixin.observer('bar.baz', function () {
        set(this, 'count', get(this, 'count') + 1);
      })
    });

    var obj = _emberMetalMixin.mixin({}, MyMixin);
    equal(get(obj, 'count'), 0, 'should not invoke observer immediately');

    set(obj2, 'baz', 'BAZ');
    equal(get(obj, 'count'), 1, 'should invoke observer after change');
  });

  _emberMetalTestsProps_helper.testBoth('observing chain with property after', function (get, set) {
    var obj2 = { baz: 'baz' };

    var MyMixin = _emberMetalMixin.Mixin.create({
      count: 0,
      foo: _emberMetalMixin.observer('bar.baz', function () {
        set(this, 'count', get(this, 'count') + 1);
      }),
      bar: obj2
    });

    var obj = _emberMetalMixin.mixin({}, MyMixin);
    equal(get(obj, 'count'), 0, 'should not invoke observer immediately');

    set(obj2, 'baz', 'BAZ');
    equal(get(obj, 'count'), 1, 'should invoke observer after change');
  });

  _emberMetalTestsProps_helper.testBoth('observing chain with property in mixin applied later', function (get, set) {
    var obj2 = { baz: 'baz' };

    var MyMixin = _emberMetalMixin.Mixin.create({

      count: 0,
      foo: _emberMetalMixin.observer('bar.baz', function () {
        set(this, 'count', get(this, 'count') + 1);
      })
    });

    var MyMixin2 = _emberMetalMixin.Mixin.create({ bar: obj2 });

    var obj = _emberMetalMixin.mixin({}, MyMixin);
    equal(get(obj, 'count'), 0, 'should not invoke observer immediately');

    MyMixin2.apply(obj);
    equal(get(obj, 'count'), 0, 'should not invoke observer immediately');

    set(obj2, 'baz', 'BAZ');
    equal(get(obj, 'count'), 1, 'should invoke observer after change');
  });

  _emberMetalTestsProps_helper.testBoth('observing chain with existing property', function (get, set) {
    var obj2 = { baz: 'baz' };

    var MyMixin = _emberMetalMixin.Mixin.create({
      count: 0,
      foo: _emberMetalMixin.observer('bar.baz', function () {
        set(this, 'count', get(this, 'count') + 1);
      })
    });

    var obj = _emberMetalMixin.mixin({ bar: obj2 }, MyMixin);
    equal(get(obj, 'count'), 0, 'should not invoke observer immediately');

    set(obj2, 'baz', 'BAZ');
    equal(get(obj, 'count'), 1, 'should invoke observer after change');
  });

  _emberMetalTestsProps_helper.testBoth('observing chain with property in mixin before', function (get, set) {
    var obj2 = { baz: 'baz' };
    var MyMixin2 = _emberMetalMixin.Mixin.create({ bar: obj2 });

    var MyMixin = _emberMetalMixin.Mixin.create({
      count: 0,
      foo: _emberMetalMixin.observer('bar.baz', function () {
        set(this, 'count', get(this, 'count') + 1);
      })
    });

    var obj = _emberMetalMixin.mixin({}, MyMixin2, MyMixin);
    equal(get(obj, 'count'), 0, 'should not invoke observer immediately');

    set(obj2, 'baz', 'BAZ');
    equal(get(obj, 'count'), 1, 'should invoke observer after change');
  });

  _emberMetalTestsProps_helper.testBoth('observing chain with property in mixin after', function (get, set) {
    var obj2 = { baz: 'baz' };
    var MyMixin2 = _emberMetalMixin.Mixin.create({ bar: obj2 });

    var MyMixin = _emberMetalMixin.Mixin.create({
      count: 0,
      foo: _emberMetalMixin.observer('bar.baz', function () {
        set(this, 'count', get(this, 'count') + 1);
      })
    });

    var obj = _emberMetalMixin.mixin({}, MyMixin, MyMixin2);
    equal(get(obj, 'count'), 0, 'should not invoke observer immediately');

    set(obj2, 'baz', 'BAZ');
    equal(get(obj, 'count'), 1, 'should invoke observer after change');
  });

  _emberMetalTestsProps_helper.testBoth('observing chain with overriden property', function (get, set) {
    var obj2 = { baz: 'baz' };
    var obj3 = { baz: 'foo' };

    var MyMixin2 = _emberMetalMixin.Mixin.create({ bar: obj3 });

    var MyMixin = _emberMetalMixin.Mixin.create({
      count: 0,
      foo: _emberMetalMixin.observer('bar.baz', function () {
        set(this, 'count', get(this, 'count') + 1);
      })
    });

    var obj = _emberMetalMixin.mixin({ bar: obj2 }, MyMixin, MyMixin2);
    equal(get(obj, 'count'), 0, 'should not invoke observer immediately');

    equal(_emberMetalWatching.isWatching(obj2, 'baz'), false, 'should not be watching baz');
    equal(_emberMetalWatching.isWatching(obj3, 'baz'), true, 'should be watching baz');

    set(obj2, 'baz', 'BAZ');
    equal(get(obj, 'count'), 0, 'should not invoke observer after change');

    set(obj3, 'baz', 'BEAR');
    equal(get(obj, 'count'), 1, 'should invoke observer after change');
  });

  _emberMetalTestsProps_helper.testBoth('providing the arguments in reverse order is deprecated', function (get, set) {
    expectDeprecation(/Passing the dependentKeys after the callback function in Ember\.observer is deprecated. Ensure the callback function is the last argument/);

    _emberMetalMixin.Mixin.create({
      count: 0,
      foo: _emberMetalMixin.observer(function () {
        set(this, 'count', get(this, 'count') + 1);
      }, 'bar.baz')
    });
  });
});
enifed('ember-metal/tests/mixin/observer_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests/mixin');
  test('ember-metal/tests/mixin/observer_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/mixin/observer_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/mixin/observer_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests/mixin');
  QUnit.test('ember-metal/tests/mixin/observer_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/mixin/observer_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/mixin/reopen_test', ['exports', 'ember-metal/run_loop', 'ember-metal/property_get', 'ember-runtime/system/object', 'ember-metal/mixin'], function (exports, _emberMetalRun_loop, _emberMetalProperty_get, _emberRuntimeSystemObject, _emberMetalMixin) {
  'use strict';

  QUnit.module('Ember.Mixin#reopen');

  QUnit.test('using reopen() to add more properties to a simple', function () {
    var MixinA = _emberMetalMixin.default.create({ foo: 'FOO', baz: 'BAZ' });
    MixinA.reopen({ bar: 'BAR', foo: 'FOO2' });
    var obj = {};
    MixinA.apply(obj);

    equal(_emberMetalProperty_get.default(obj, 'foo'), 'FOO2', 'mixin() should override');
    equal(_emberMetalProperty_get.default(obj, 'baz'), 'BAZ', 'preserve MixinA props');
    equal(_emberMetalProperty_get.default(obj, 'bar'), 'BAR', 'include MixinB props');
  });

  QUnit.test('using reopen() and calling _super where there is not a super function does not cause infinite recursion', function () {
    var Taco = _emberRuntimeSystemObject.default.extend({
      createBreakfast: function () {
        // There is no original createBreakfast function.
        // Calling the wrapped _super function here
        // used to end in an infinite call loop
        this._super.apply(this, arguments);
        return 'Breakfast!';
      }
    });

    Taco.reopen({
      createBreakfast: function () {
        return this._super.apply(this, arguments);
      }
    });

    var taco = Taco.create();

    var result;
    _emberMetalRun_loop.default(function () {
      try {
        result = taco.createBreakfast();
      } catch (e) {
        result = 'Your breakfast was interrupted by an infinite stack error.';
      }
    });

    equal(result, 'Breakfast!');
  });
});
enifed('ember-metal/tests/mixin/reopen_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests/mixin');
  test('ember-metal/tests/mixin/reopen_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/mixin/reopen_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/mixin/reopen_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests/mixin');
  QUnit.test('ember-metal/tests/mixin/reopen_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/mixin/reopen_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/mixin/required_test', ['exports', 'ember-metal/mixin', 'ember-metal/property_get'], function (exports, _emberMetalMixin, _emberMetalProperty_get) {
  'use strict';

  var PartialMixin, FinalMixin, obj;

  QUnit.module('Module.required', {
    setup: function () {
      expectDeprecation(function () {
        PartialMixin = _emberMetalMixin.Mixin.create({
          foo: _emberMetalMixin.required(),
          bar: 'BAR'
        });
      }, 'Ember.required is deprecated as its behavior is inconsistent and unreliable.');

      FinalMixin = _emberMetalMixin.Mixin.create({
        foo: 'FOO'
      });

      obj = {};
    },

    teardown: function () {
      PartialMixin = FinalMixin = obj = null;
    }
  });

  QUnit.test('applying a mixin to meet requirement', function () {
    FinalMixin.apply(obj);
    PartialMixin.apply(obj);
    equal(_emberMetalProperty_get.get(obj, 'foo'), 'FOO', 'should now be defined');
  });

  QUnit.test('combined mixins to meet requirement', function () {
    _emberMetalMixin.Mixin.create(PartialMixin, FinalMixin).apply(obj);
    equal(_emberMetalProperty_get.get(obj, 'foo'), 'FOO', 'should now be defined');
  });

  QUnit.test('merged mixin', function () {
    _emberMetalMixin.Mixin.create(PartialMixin, { foo: 'FOO' }).apply(obj);
    equal(_emberMetalProperty_get.get(obj, 'foo'), 'FOO', 'should now be defined');
  });

  QUnit.test('define property on source object', function () {
    obj.foo = 'FOO';
    PartialMixin.apply(obj);
    equal(_emberMetalProperty_get.get(obj, 'foo'), 'FOO', 'should now be defined');
  });

  QUnit.test('using apply', function () {
    _emberMetalMixin.mixin(obj, PartialMixin, { foo: 'FOO' });
    equal(_emberMetalProperty_get.get(obj, 'foo'), 'FOO', 'should now be defined');
  });
});
enifed('ember-metal/tests/mixin/required_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests/mixin');
  test('ember-metal/tests/mixin/required_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/mixin/required_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/mixin/required_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests/mixin');
  QUnit.test('ember-metal/tests/mixin/required_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/mixin/required_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/mixin/without_test', ['exports', 'ember-metal/mixin'], function (exports, _emberMetalMixin) {
  'use strict';

  QUnit.test('without should create a new mixin excluding named properties', function () {

    var MixinA = _emberMetalMixin.Mixin.create({
      foo: 'FOO',
      bar: 'BAR'
    });

    var MixinB = MixinA.without('bar');

    var obj = {};
    MixinB.apply(obj);

    equal(obj.foo, 'FOO', 'should defined foo');
    equal(obj.bar, undefined, 'should not define bar');
  });
});
enifed('ember-metal/tests/mixin/without_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests/mixin');
  test('ember-metal/tests/mixin/without_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/mixin/without_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/mixin/without_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests/mixin');
  QUnit.test('ember-metal/tests/mixin/without_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/mixin/without_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/observer_test', ['exports', 'ember-metal/core', 'ember-metal/tests/props_helper', 'ember-metal/observer', 'ember-metal/property_events', 'ember-metal/properties', 'ember-metal/computed', 'ember-metal/mixin', 'ember-metal/run_loop'], function (exports, _emberMetalCore, _emberMetalTestsProps_helper, _emberMetalObserver, _emberMetalProperty_events, _emberMetalProperties, _emberMetalComputed, _emberMetalMixin, _emberMetalRun_loop) {
  'use strict';

  // ..........................................................
  // ADD OBSERVER
  //

  QUnit.module('addObserver');

  _emberMetalTestsProps_helper.testBoth('observer should fire when property is modified', function (get, set) {

    var obj = {};
    var count = 0;

    _emberMetalObserver.addObserver(obj, 'foo', function () {
      equal(get(obj, 'foo'), 'bar', 'should invoke AFTER value changed');
      count++;
    });

    set(obj, 'foo', 'bar');
    equal(count, 1, 'should have invoked observer');
  });

  _emberMetalTestsProps_helper.testBoth('observer should fire when dependent property is modified', function (get, set) {
    var obj = { bar: 'bar' };
    _emberMetalProperties.defineProperty(obj, 'foo', _emberMetalComputed.computed(function () {
      return get(this, 'bar').toUpperCase();
    }).property('bar'));

    get(obj, 'foo');

    var count = 0;
    _emberMetalObserver.addObserver(obj, 'foo', function () {
      equal(get(obj, 'foo'), 'BAZ', 'should have invoked after prop change');
      count++;
    });

    set(obj, 'bar', 'baz');
    equal(count, 1, 'should have invoked observer');
  });

  _emberMetalTestsProps_helper.testBoth('observer should continue to fire after dependent properties are accessed', function (get, set) {
    var observerCount = 0;
    var obj = {};

    _emberMetalProperties.defineProperty(obj, 'prop', _emberMetalComputed.computed(function () {
      return Math.random();
    }));
    _emberMetalProperties.defineProperty(obj, 'anotherProp', _emberMetalComputed.computed('prop', function () {
      return get(this, 'prop') + Math.random();
    }));

    _emberMetalObserver.addObserver(obj, 'prop', function () {
      observerCount++;
    });

    get(obj, 'anotherProp');

    for (var i = 0; i < 10; i++) {
      _emberMetalProperty_events.propertyWillChange(obj, 'prop');
      _emberMetalProperty_events.propertyDidChange(obj, 'prop');
    }

    equal(observerCount, 10, 'should continue to fire indefinitely');
  });

  if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
    _emberMetalTestsProps_helper.testBoth('observer added declaratively via brace expansion should fire when property changes', function (get, set) {
      var obj = {};
      var count = 0;

      _emberMetalMixin.mixin(obj, {
        observeFooAndBar: (function () {
          count++;
        }).observes('{foo,bar}')
      });

      set(obj, 'foo', 'foo');
      equal(count, 1, 'observer specified via brace expansion invoked on property change');

      set(obj, 'bar', 'bar');
      equal(count, 2, 'observer specified via brace expansion invoked on property change');

      set(obj, 'baz', 'baz');
      equal(count, 2, 'observer not invoked on unspecified property');
    });

    _emberMetalTestsProps_helper.testBoth('observer specified declaratively via brace expansion should fire when dependent property changes', function (get, set) {
      var obj = { baz: 'Initial' };
      var count = 0;

      _emberMetalProperties.defineProperty(obj, 'foo', _emberMetalComputed.computed(function () {
        return get(this, 'bar').toLowerCase();
      }).property('bar'));

      _emberMetalProperties.defineProperty(obj, 'bar', _emberMetalComputed.computed(function () {
        return get(this, 'baz').toUpperCase();
      }).property('baz'));

      _emberMetalMixin.mixin(obj, {
        fooAndBarWatcher: (function () {
          count++;
        }).observes('{foo,bar}')
      });

      get(obj, 'foo');
      set(obj, 'baz', 'Baz');
      // fire once for foo, once for bar
      equal(count, 2, 'observer specified via brace expansion invoked on dependent property change');

      set(obj, 'quux', 'Quux');
      equal(count, 2, 'observer not fired on unspecified property');
    });
  }

  _emberMetalTestsProps_helper.testBoth('observers watching multiple properties via brace expansion should fire when the properties change', function (get, set) {
    var obj = {};
    var count = 0;

    _emberMetalMixin.mixin(obj, {
      observeFooAndBar: _emberMetalMixin.observer('{foo,bar}', function () {
        count++;
      })
    });

    set(obj, 'foo', 'foo');
    equal(count, 1, 'observer specified via brace expansion invoked on property change');

    set(obj, 'bar', 'bar');
    equal(count, 2, 'observer specified via brace expansion invoked on property change');

    set(obj, 'baz', 'baz');
    equal(count, 2, 'observer not invoked on unspecified property');
  });

  _emberMetalTestsProps_helper.testBoth('observers watching multiple properties via brace expansion should fire when dependent properties change', function (get, set) {
    var obj = { baz: 'Initial' };
    var count = 0;

    _emberMetalProperties.defineProperty(obj, 'foo', _emberMetalComputed.computed(function () {
      return get(this, 'bar').toLowerCase();
    }).property('bar'));

    _emberMetalProperties.defineProperty(obj, 'bar', _emberMetalComputed.computed(function () {
      return get(this, 'baz').toUpperCase();
    }).property('baz'));

    _emberMetalMixin.mixin(obj, {
      fooAndBarWatcher: _emberMetalMixin.observer('{foo,bar}', function () {
        count++;
      })
    });

    get(obj, 'foo');
    set(obj, 'baz', 'Baz');
    // fire once for foo, once for bar
    equal(count, 2, 'observer specified via brace expansion invoked on dependent property change');

    set(obj, 'quux', 'Quux');
    equal(count, 2, 'observer not fired on unspecified property');
  });

  _emberMetalTestsProps_helper.testBoth('nested observers should fire in order', function (get, set) {
    var obj = { foo: 'foo', bar: 'bar' };
    var fooCount = 0;
    var barCount = 0;

    _emberMetalObserver.addObserver(obj, 'foo', function () {
      fooCount++;
    });
    _emberMetalObserver.addObserver(obj, 'bar', function () {
      set(obj, 'foo', 'BAZ');
      equal(fooCount, 1, 'fooCount should have fired already');
      barCount++;
    });

    set(obj, 'bar', 'BIFF');
    equal(barCount, 1, 'barCount should have fired');
    equal(fooCount, 1, 'foo should have fired');
  });

  _emberMetalTestsProps_helper.testBoth('removing an chain observer on change should not fail', function (get, set) {
    var foo = { bar: 'bar' };
    var obj1 = { foo: foo };
    var obj2 = { foo: foo };
    var obj3 = { foo: foo };
    var obj4 = { foo: foo };
    var count1 = 0;
    var count2 = 0;
    var count3 = 0;
    var count4 = 0;

    function observer1() {
      count1++;
    }
    function observer2() {
      count2++;
    }
    function observer3() {
      count3++;
      _emberMetalObserver.removeObserver(obj1, 'foo.bar', observer1);
      _emberMetalObserver.removeObserver(obj2, 'foo.bar', observer2);
      _emberMetalObserver.removeObserver(obj4, 'foo.bar', observer4);
    }
    function observer4() {
      count4++;
    }

    _emberMetalObserver.addObserver(obj1, 'foo.bar', observer1);
    _emberMetalObserver.addObserver(obj2, 'foo.bar', observer2);
    _emberMetalObserver.addObserver(obj3, 'foo.bar', observer3);
    _emberMetalObserver.addObserver(obj4, 'foo.bar', observer4);

    set(foo, 'bar', 'baz');

    equal(count1, 1, 'observer1 fired');
    equal(count2, 1, 'observer2 fired');
    equal(count3, 1, 'observer3 fired');
    equal(count4, 0, 'observer4 did not fire');
  });

  _emberMetalTestsProps_helper.testBoth('removing an chain before observer on change should not fail', function (get, set) {
    var foo = { bar: 'bar' };
    var obj1 = { foo: foo };
    var obj2 = { foo: foo };
    var obj3 = { foo: foo };
    var obj4 = { foo: foo };
    var count1 = 0;
    var count2 = 0;
    var count3 = 0;
    var count4 = 0;

    function observer1() {
      count1++;
    }
    function observer2() {
      count2++;
    }
    function observer3() {
      count3++;
      _emberMetalObserver._removeBeforeObserver(obj1, 'foo.bar', observer1);
      _emberMetalObserver._removeBeforeObserver(obj2, 'foo.bar', observer2);
      _emberMetalObserver._removeBeforeObserver(obj4, 'foo.bar', observer4);
    }
    function observer4() {
      count4++;
    }

    _emberMetalObserver._addBeforeObserver(obj1, 'foo.bar', observer1);
    _emberMetalObserver._addBeforeObserver(obj2, 'foo.bar', observer2);
    _emberMetalObserver._addBeforeObserver(obj3, 'foo.bar', observer3);
    _emberMetalObserver._addBeforeObserver(obj4, 'foo.bar', observer4);

    set(foo, 'bar', 'baz');

    equal(count1, 1, 'observer1 fired');
    equal(count2, 1, 'observer2 fired');
    equal(count3, 1, 'observer3 fired');
    equal(count4, 0, 'observer4 did not fire');
  });

  _emberMetalTestsProps_helper.testBoth('suspending an observer should not fire during callback', function (get, set) {
    var obj = {};
    var target, otherTarget;

    target = {
      values: [],
      method: function () {
        this.values.push(get(obj, 'foo'));
      }
    };

    otherTarget = {
      values: [],
      method: function () {
        this.values.push(get(obj, 'foo'));
      }
    };

    _emberMetalObserver.addObserver(obj, 'foo', target, target.method);
    _emberMetalObserver.addObserver(obj, 'foo', otherTarget, otherTarget.method);

    function callback() {
      /*jshint validthis:true */
      equal(this, target);

      set(obj, 'foo', '2');

      return 'result';
    }

    set(obj, 'foo', '1');

    equal(_emberMetalObserver._suspendObserver(obj, 'foo', target, target.method, callback), 'result');

    set(obj, 'foo', '3');

    deepEqual(target.values, ['1', '3'], 'should invoke');
    deepEqual(otherTarget.values, ['1', '2', '3'], 'should invoke');
  });

  _emberMetalTestsProps_helper.testBoth('suspending an observer should not defer change notifications during callback', function (get, set) {
    var obj = {};
    var target, otherTarget;

    target = {
      values: [],
      method: function () {
        this.values.push(get(obj, 'foo'));
      }
    };

    otherTarget = {
      values: [],
      method: function () {
        this.values.push(get(obj, 'foo'));
      }
    };

    _emberMetalObserver.addObserver(obj, 'foo', target, target.method);
    _emberMetalObserver.addObserver(obj, 'foo', otherTarget, otherTarget.method);

    function callback() {
      /*jshint validthis:true */
      equal(this, target);

      set(obj, 'foo', '2');

      return 'result';
    }

    set(obj, 'foo', '1');

    _emberMetalProperty_events.beginPropertyChanges();
    equal(_emberMetalObserver._suspendObserver(obj, 'foo', target, target.method, callback), 'result');
    _emberMetalProperty_events.endPropertyChanges();

    set(obj, 'foo', '3');

    deepEqual(target.values, ['1', '3'], 'should invoke');
    deepEqual(otherTarget.values, ['1', '2', '3'], 'should invoke');
  });

  _emberMetalTestsProps_helper.testBoth('suspending observers should not fire during callback', function (get, set) {
    var obj = {};
    var target, otherTarget;

    target = {
      values: [],
      method: function () {
        this.values.push(get(obj, 'foo'));
      }
    };

    otherTarget = {
      values: [],
      method: function () {
        this.values.push(get(obj, 'foo'));
      }
    };

    _emberMetalObserver.addObserver(obj, 'foo', target, target.method);
    _emberMetalObserver.addObserver(obj, 'foo', otherTarget, otherTarget.method);

    function callback() {
      /*jshint validthis:true */
      equal(this, target);

      set(obj, 'foo', '2');

      return 'result';
    }

    set(obj, 'foo', '1');

    equal(_emberMetalObserver._suspendObservers(obj, ['foo'], target, target.method, callback), 'result');

    set(obj, 'foo', '3');

    deepEqual(target.values, ['1', '3'], 'should invoke');
    deepEqual(otherTarget.values, ['1', '2', '3'], 'should invoke');
  });

  _emberMetalTestsProps_helper.testBoth('suspending observers should not defer change notifications during callback', function (get, set) {
    var obj = {};
    var target, otherTarget;

    target = {
      values: [],
      method: function () {
        this.values.push(get(obj, 'foo'));
      }
    };

    otherTarget = {
      values: [],
      method: function () {
        this.values.push(get(obj, 'foo'));
      }
    };

    _emberMetalObserver.addObserver(obj, 'foo', target, target.method);
    _emberMetalObserver.addObserver(obj, 'foo', otherTarget, otherTarget.method);

    function callback() {
      /*jshint validthis:true */
      equal(this, target);

      set(obj, 'foo', '2');

      return 'result';
    }

    set(obj, 'foo', '1');

    _emberMetalProperty_events.beginPropertyChanges();
    equal(_emberMetalObserver._suspendObservers(obj, ['foo'], target, target.method, callback), 'result');
    _emberMetalProperty_events.endPropertyChanges();

    set(obj, 'foo', '3');

    deepEqual(target.values, ['1', '3'], 'should invoke');
    deepEqual(otherTarget.values, ['1', '2', '3'], 'should invoke');
  });

  _emberMetalTestsProps_helper.testBoth('deferring property change notifications', function (get, set) {
    var obj = { foo: 'foo' };
    var fooCount = 0;

    _emberMetalObserver.addObserver(obj, 'foo', function () {
      fooCount++;
    });

    _emberMetalProperty_events.beginPropertyChanges(obj);
    set(obj, 'foo', 'BIFF');
    set(obj, 'foo', 'BAZ');
    _emberMetalProperty_events.endPropertyChanges(obj);

    equal(fooCount, 1, 'foo should have fired once');
  });

  _emberMetalTestsProps_helper.testBoth('deferring property change notifications safely despite exceptions', function (get, set) {
    var obj = { foo: 'foo' };
    var fooCount = 0;
    var exc = new Error('Something unexpected happened!');

    expect(2);
    _emberMetalObserver.addObserver(obj, 'foo', function () {
      fooCount++;
    });

    try {
      _emberMetalProperty_events.changeProperties(function () {
        set(obj, 'foo', 'BIFF');
        set(obj, 'foo', 'BAZ');
        throw exc;
      });
    } catch (err) {
      if (err !== exc) {
        throw err;
      }
    }

    equal(fooCount, 1, 'foo should have fired once');

    _emberMetalProperty_events.changeProperties(function () {
      set(obj, 'foo', 'BIFF2');
      set(obj, 'foo', 'BAZ2');
    });

    equal(fooCount, 2, 'foo should have fired again once');
  });

  _emberMetalTestsProps_helper.testBoth('deferring property change notifications will not defer before observers', function (get, set) {
    var obj = { foo: 'foo' };
    var fooCount = 0;

    _emberMetalObserver._addBeforeObserver(obj, 'foo', function () {
      fooCount++;
    });

    _emberMetalProperty_events.beginPropertyChanges(obj);
    set(obj, 'foo', 'BIFF');
    equal(fooCount, 1, 'should fire before observer immediately');
    set(obj, 'foo', 'BAZ');
    _emberMetalProperty_events.endPropertyChanges(obj);

    equal(fooCount, 1, 'should not fire before observer twice');
  });

  _emberMetalTestsProps_helper.testBoth('addObserver should propagate through prototype', function (get, set) {
    var obj = { foo: 'foo', count: 0 };
    var obj2;

    _emberMetalObserver.addObserver(obj, 'foo', function () {
      this.count++;
    });
    obj2 = Object.create(obj);

    set(obj2, 'foo', 'bar');

    equal(obj2.count, 1, 'should have invoked observer on inherited');
    equal(obj.count, 0, 'should not have invoked observer on parent');

    obj2.count = 0;
    set(obj, 'foo', 'baz');
    equal(obj.count, 1, 'should have invoked observer on parent');
    equal(obj2.count, 0, 'should not have invoked observer on inherited');
  });

  _emberMetalTestsProps_helper.testBoth('addObserver should respect targets with methods', function (get, set) {
    var observed = { foo: 'foo' };

    var target1 = {
      count: 0,

      didChange: function (obj, keyName) {
        var value = get(obj, keyName);
        equal(this, target1, 'should invoke with this');
        equal(obj, observed, 'param1 should be observed object');
        equal(keyName, 'foo', 'param2 should be keyName');
        equal(value, 'BAZ', 'param3 should new value');
        this.count++;
      }
    };

    var target2 = {
      count: 0,

      didChange: function (obj, keyName) {
        var value = get(obj, keyName);
        equal(this, target2, 'should invoke with this');
        equal(obj, observed, 'param1 should be observed object');
        equal(keyName, 'foo', 'param2 should be keyName');
        equal(value, 'BAZ', 'param3 should new value');
        this.count++;
      }
    };

    _emberMetalObserver.addObserver(observed, 'foo', target1, 'didChange');
    _emberMetalObserver.addObserver(observed, 'foo', target2, target2.didChange);

    set(observed, 'foo', 'BAZ');
    equal(target1.count, 1, 'target1 observer should have fired');
    equal(target2.count, 1, 'target2 observer should have fired');
  });

  _emberMetalTestsProps_helper.testBoth('addObserver should allow multiple objects to observe a property', function (get, set) {
    var observed = { foo: 'foo' };

    var target1 = {
      count: 0,

      didChange: function (obj, keyName, value) {
        this.count++;
      }
    };

    var target2 = {
      count: 0,

      didChange: function (obj, keyName, value) {
        this.count++;
      }
    };

    _emberMetalObserver.addObserver(observed, 'foo', target1, 'didChange');
    _emberMetalObserver.addObserver(observed, 'foo', target2, 'didChange');

    set(observed, 'foo', 'BAZ');
    equal(target1.count, 1, 'target1 observer should have fired');
    equal(target2.count, 1, 'target2 observer should have fired');
  });

  // ..........................................................
  // REMOVE OBSERVER
  //

  QUnit.module('removeObserver');

  _emberMetalTestsProps_helper.testBoth('removing observer should stop firing', function (get, set) {

    var obj = {};
    var count = 0;
    function F() {
      count++;
    }
    _emberMetalObserver.addObserver(obj, 'foo', F);

    set(obj, 'foo', 'bar');
    equal(count, 1, 'should have invoked observer');

    _emberMetalObserver.removeObserver(obj, 'foo', F);

    set(obj, 'foo', 'baz');
    equal(count, 1, 'removed observer shouldn\'t fire');
  });

  _emberMetalTestsProps_helper.testBoth('local observers can be removed', function (get, set) {
    var barObserved = 0;

    var MyMixin = _emberMetalMixin.Mixin.create({
      foo1: _emberMetalMixin.observer('bar', function () {
        barObserved++;
      }),

      foo2: _emberMetalMixin.observer('bar', function () {
        barObserved++;
      })
    });

    var obj = {};
    MyMixin.apply(obj);

    set(obj, 'bar', 'HI!');
    equal(barObserved, 2, 'precond - observers should be fired');

    _emberMetalObserver.removeObserver(obj, 'bar', null, 'foo1');

    barObserved = 0;
    set(obj, 'bar', 'HI AGAIN!');

    equal(barObserved, 1, 'removed observers should not be called');
  });

  _emberMetalTestsProps_helper.testBoth('removeObserver should respect targets with methods', function (get, set) {
    var observed = { foo: 'foo' };

    var target1 = {
      count: 0,

      didChange: function () {
        this.count++;
      }
    };

    var target2 = {
      count: 0,

      didChange: function () {
        this.count++;
      }
    };

    _emberMetalObserver.addObserver(observed, 'foo', target1, 'didChange');
    _emberMetalObserver.addObserver(observed, 'foo', target2, target2.didChange);

    set(observed, 'foo', 'BAZ');
    equal(target1.count, 1, 'target1 observer should have fired');
    equal(target2.count, 1, 'target2 observer should have fired');

    _emberMetalObserver.removeObserver(observed, 'foo', target1, 'didChange');
    _emberMetalObserver.removeObserver(observed, 'foo', target2, target2.didChange);

    target1.count = target2.count = 0;
    set(observed, 'foo', 'BAZ');
    equal(target1.count, 0, 'target1 observer should not fire again');
    equal(target2.count, 0, 'target2 observer should not fire again');
  });

  // ..........................................................
  // BEFORE OBSERVER
  //

  QUnit.module('_addBeforeObserver');

  _emberMetalTestsProps_helper.testBoth('observer should fire before a property is modified', function (get, set) {

    var obj = { foo: 'foo' };
    var count = 0;

    _emberMetalObserver._addBeforeObserver(obj, 'foo', function () {
      equal(get(obj, 'foo'), 'foo', 'should invoke before value changed');
      count++;
    });

    set(obj, 'foo', 'bar');
    equal(count, 1, 'should have invoked observer');
  });

  _emberMetalTestsProps_helper.testBoth('observer should fire before dependent property is modified', function (get, set) {
    var obj = { bar: 'bar' };
    _emberMetalProperties.defineProperty(obj, 'foo', _emberMetalComputed.computed(function () {
      return get(this, 'bar').toUpperCase();
    }).property('bar'));

    get(obj, 'foo');

    var count = 0;
    _emberMetalObserver._addBeforeObserver(obj, 'foo', function () {
      equal(get(obj, 'foo'), 'BAR', 'should have invoked after prop change');
      count++;
    });

    set(obj, 'bar', 'baz');
    equal(count, 1, 'should have invoked observer');
  });

  _emberMetalTestsProps_helper.testBoth('before observer watching multiple properties via brace expansion should fire when properties change', function (get, set) {
    var obj = {};
    var count = 0;

    _emberMetalMixin.mixin(obj, {
      fooAndBarWatcher: _emberMetalMixin._beforeObserver('{foo,bar}', function () {
        count++;
      })
    });

    set(obj, 'foo', 'foo');
    equal(count, 1, 'observer specified via brace expansion invoked on property change');

    set(obj, 'bar', 'bar');
    equal(count, 2, 'observer specified via brace expansion invoked on property change');

    set(obj, 'baz', 'baz');
    equal(count, 2, 'observer not invoked on unspecified property');
  });

  _emberMetalTestsProps_helper.testBoth('before observer watching multiple properties via brace expansion should fire when dependent property changes', function (get, set) {
    var obj = { baz: 'Initial' };
    var count = 0;

    _emberMetalProperties.defineProperty(obj, 'foo', _emberMetalComputed.computed(function () {
      return get(this, 'bar').toLowerCase();
    }).property('bar'));

    _emberMetalProperties.defineProperty(obj, 'bar', _emberMetalComputed.computed(function () {
      return get(this, 'baz').toUpperCase();
    }).property('baz'));

    _emberMetalMixin.mixin(obj, {
      fooAndBarWatcher: _emberMetalMixin._beforeObserver('{foo,bar}', function () {
        count++;
      })
    });

    get(obj, 'foo');
    set(obj, 'baz', 'Baz');
    // fire once for foo, once for bar
    equal(count, 2, 'observer specified via brace expansion invoked on dependent property change');

    set(obj, 'quux', 'Quux');
    equal(count, 2, 'observer not fired on unspecified property');
  });

  _emberMetalTestsProps_helper.testBoth('_addBeforeObserver should propagate through prototype', function (get, set) {
    var obj = { foo: 'foo', count: 0 };
    var obj2;

    _emberMetalObserver._addBeforeObserver(obj, 'foo', function () {
      this.count++;
    });
    obj2 = Object.create(obj);

    set(obj2, 'foo', 'bar');
    equal(obj2.count, 1, 'should have invoked observer on inherited');
    equal(obj.count, 0, 'should not have invoked observer on parent');

    obj2.count = 0;
    set(obj, 'foo', 'baz');
    equal(obj.count, 1, 'should have invoked observer on parent');
    equal(obj2.count, 0, 'should not have invoked observer on inherited');
  });

  _emberMetalTestsProps_helper.testBoth('_addBeforeObserver should respect targets with methods', function (get, set) {
    var observed = { foo: 'foo' };

    var target1 = {
      count: 0,

      willChange: function (obj, keyName) {
        var value = get(obj, keyName);
        equal(this, target1, 'should invoke with this');
        equal(obj, observed, 'param1 should be observed object');
        equal(keyName, 'foo', 'param2 should be keyName');
        equal(value, 'foo', 'param3 should old value');
        this.count++;
      }
    };

    var target2 = {
      count: 0,

      willChange: function (obj, keyName) {
        var value = get(obj, keyName);
        equal(this, target2, 'should invoke with this');
        equal(obj, observed, 'param1 should be observed object');
        equal(keyName, 'foo', 'param2 should be keyName');
        equal(value, 'foo', 'param3 should old value');
        this.count++;
      }
    };

    _emberMetalObserver._addBeforeObserver(observed, 'foo', target1, 'willChange');
    _emberMetalObserver._addBeforeObserver(observed, 'foo', target2, target2.willChange);

    set(observed, 'foo', 'BAZ');
    equal(target1.count, 1, 'target1 observer should have fired');
    equal(target2.count, 1, 'target2 observer should have fired');
  });

  // ..........................................................
  // CHAINED OBSERVERS
  //

  var obj, count, lookup;
  var originalLookup = _emberMetalCore.default.lookup;

  QUnit.module('addObserver - dependentkey with chained properties', {
    setup: function () {
      obj = {
        foo: {
          bar: {
            baz: {
              biff: 'BIFF'
            }
          }
        }
      };

      _emberMetalCore.default.lookup = lookup = {
        Global: {
          foo: {
            bar: {
              baz: {
                biff: 'BIFF'
              }
            }
          }
        }
      };

      count = 0;
    },

    teardown: function () {
      obj = count = null;
      _emberMetalCore.default.lookup = originalLookup;
    }
  });

  _emberMetalTestsProps_helper.testBoth('depending on a chain with a computed property', function (get, set) {
    _emberMetalProperties.defineProperty(obj, 'computed', _emberMetalComputed.computed(function () {
      return { foo: 'bar' };
    }));

    var changed = 0;
    _emberMetalObserver.addObserver(obj, 'computed.foo', function () {
      changed++;
    });

    equal(_emberMetalComputed.cacheFor(obj, 'computed'), undefined, 'addObserver should not compute CP');

    set(obj, 'computed.foo', 'baz');

    equal(changed, 1, 'should fire observer');
  });

  _emberMetalTestsProps_helper.testBoth('depending on a simple chain', function (get, set) {

    var val;
    _emberMetalObserver.addObserver(obj, 'foo.bar.baz.biff', function (target, key) {
      val = get(target, key);
      count++;
    });

    set(get(obj, 'foo.bar.baz'), 'biff', 'BUZZ');
    equal(val, 'BUZZ');
    equal(count, 1);

    set(get(obj, 'foo.bar'), 'baz', { biff: 'BLARG' });
    equal(val, 'BLARG');
    equal(count, 2);

    set(get(obj, 'foo'), 'bar', { baz: { biff: 'BOOM' } });
    equal(val, 'BOOM');
    equal(count, 3);

    set(obj, 'foo', { bar: { baz: { biff: 'BLARG' } } });
    equal(val, 'BLARG');
    equal(count, 4);

    set(get(obj, 'foo.bar.baz'), 'biff', 'BUZZ');
    equal(val, 'BUZZ');
    equal(count, 5);

    var foo = get(obj, 'foo');

    set(obj, 'foo', 'BOO');
    equal(val, undefined);
    equal(count, 6);

    set(foo.bar.baz, 'biff', 'BOOM');
    equal(count, 6, 'should be not have invoked observer');
  });

  _emberMetalTestsProps_helper.testBoth('depending on a Global chain', function (get, set) {
    var Global = lookup.Global;
    var val;

    _emberMetalObserver.addObserver(obj, 'Global.foo.bar.baz.biff', function (target, key) {
      val = get(lookup, key);
      count++;
    });

    set(get(Global, 'foo.bar.baz'), 'biff', 'BUZZ');
    equal(val, 'BUZZ');
    equal(count, 1);

    set(get(Global, 'foo.bar'), 'baz', { biff: 'BLARG' });
    equal(val, 'BLARG');
    equal(count, 2);

    set(get(Global, 'foo'), 'bar', { baz: { biff: 'BOOM' } });
    equal(val, 'BOOM');
    equal(count, 3);

    set(Global, 'foo', { bar: { baz: { biff: 'BLARG' } } });
    equal(val, 'BLARG');
    equal(count, 4);

    set(get(Global, 'foo.bar.baz'), 'biff', 'BUZZ');
    equal(val, 'BUZZ');
    equal(count, 5);

    var foo = get(obj, 'foo');

    set(Global, 'foo', 'BOO');
    equal(val, undefined);
    equal(count, 6);

    set(foo.bar.baz, 'biff', 'BOOM');
    equal(count, 6, 'should be not have invoked observer');
  });

  QUnit.module('_removeBeforeObserver');

  // ..........................................................
  // SETTING IDENTICAL VALUES
  //

  QUnit.module('props/observer_test - setting identical values');

  _emberMetalTestsProps_helper.testBoth('setting simple prop should not trigger', function (get, set) {

    var obj = { foo: 'bar' };
    var count = 0;

    _emberMetalObserver.addObserver(obj, 'foo', function () {
      count++;
    });

    set(obj, 'foo', 'bar');
    equal(count, 0, 'should not trigger observer');

    set(obj, 'foo', 'baz');
    equal(count, 1, 'should trigger observer');

    set(obj, 'foo', 'baz');
    equal(count, 1, 'should not trigger observer again');
  });

  // The issue here is when a computed property is directly set with a value, then has a
  // dependent key change (which triggers a cache expiration and recomputation), observers will
  // not be fired if the CP setter is called with the last set value.
  _emberMetalTestsProps_helper.testBoth('setting a cached computed property whose value has changed should trigger', function (get, set) {
    var obj = {};

    _emberMetalProperties.defineProperty(obj, 'foo', _emberMetalComputed.computed({
      get: function () {
        return get(this, 'baz');
      },
      set: function (key, value) {
        return value;
      }
    }).property('baz'));

    var count = 0;

    _emberMetalObserver.addObserver(obj, 'foo', function () {
      count++;
    });

    set(obj, 'foo', 'bar');
    equal(count, 1);
    equal(get(obj, 'foo'), 'bar');

    set(obj, 'baz', 'qux');
    equal(count, 2);
    equal(get(obj, 'foo'), 'qux');

    get(obj, 'foo');
    set(obj, 'foo', 'bar');
    equal(count, 3);
    equal(get(obj, 'foo'), 'bar');
  });

  QUnit.module('Ember.immediateObserver (Deprecated)');

  _emberMetalTestsProps_helper.testBoth('immediate observers should fire synchronously', function (get, set) {
    expectDeprecation(/Usage of `Ember.immediateObserver` is deprecated, use `Ember.observer` instead./);
    var obj = {};
    var observerCalled = 0;
    var mixin;

    // explicitly create a run loop so we do not inadvertently
    // trigger deferred behavior
    _emberMetalRun_loop.default(function () {
      mixin = _emberMetalMixin.Mixin.create({
        fooDidChange: _emberMetalMixin._immediateObserver('foo', function () {
          observerCalled++;
          equal(get(this, 'foo'), 'barbaz', 'newly set value is immediately available');
        })
      });

      mixin.apply(obj);

      _emberMetalProperties.defineProperty(obj, 'foo', _emberMetalComputed.computed({
        get: function () {
          return 'yes hello this is foo';
        },
        set: function (key, value) {
          return value;
        }
      }));

      equal(get(obj, 'foo'), 'yes hello this is foo', 'precond - computed property returns a value');
      equal(observerCalled, 0, 'observer has not yet been called');

      set(obj, 'foo', 'barbaz');

      equal(observerCalled, 1, 'observer was called once');
    });
  });

  if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
    _emberMetalTestsProps_helper.testBoth('immediate observers added declaratively via brace expansion fire synchronously', function (get, set) {
      var obj = {};
      var observerCalled = 0;
      var mixin;

      // explicitly create a run loop so we do not inadvertently
      // trigger deferred behavior
      _emberMetalRun_loop.default(function () {
        expectDeprecation(function () {
          mixin = _emberMetalMixin.Mixin.create({
            fooDidChange: (function () {
              observerCalled++;
              equal(get(this, 'foo'), 'barbaz', 'newly set value is immediately available');
            }).observesImmediately('{foo,bar}')
          });
        }, /Function#observesImmediately is deprecated. Use Function#observes instead/);

        mixin.apply(obj);

        _emberMetalProperties.defineProperty(obj, 'foo', _emberMetalComputed.computed({
          get: function (key) {
            return 'yes hello this is foo';
          },
          set: function (key, value) {
            return value;
          }
        }));

        equal(get(obj, 'foo'), 'yes hello this is foo', 'precond - computed property returns a value');
        equal(observerCalled, 0, 'observer has not yet been called');

        set(obj, 'foo', 'barbaz');

        equal(observerCalled, 1, 'observer was called once');
      });
    });
  }

  _emberMetalTestsProps_helper.testBoth('immediate observers watching multiple properties via brace expansion fire synchronously', function (get, set) {
    expectDeprecation(/Usage of `Ember.immediateObserver` is deprecated, use `Ember.observer` instead./);
    var obj = {};
    var observerCalled = 0;
    var mixin;

    // explicitly create a run loop so we do not inadvertently
    // trigger deferred behavior
    _emberMetalRun_loop.default(function () {
      mixin = _emberMetalMixin.Mixin.create({
        fooDidChange: _emberMetalMixin._immediateObserver('{foo,bar}', function () {
          observerCalled++;
          equal(get(this, 'foo'), 'barbaz', 'newly set value is immediately available');
        })
      });

      mixin.apply(obj);

      _emberMetalProperties.defineProperty(obj, 'foo', _emberMetalComputed.computed({
        get: function () {
          return 'yes hello this is foo';
        },
        set: function (key, value) {
          return value;
        }
      }));

      equal(get(obj, 'foo'), 'yes hello this is foo', 'precond - computed property returns a value');
      equal(observerCalled, 0, 'observer has not yet been called');

      set(obj, 'foo', 'barbaz');

      equal(observerCalled, 1, 'observer was called once');
    });
  });

  _emberMetalTestsProps_helper.testBoth('immediate observers are for internal properties only', function (get, set) {
    expectDeprecation(/Usage of `Ember.immediateObserver` is deprecated, use `Ember.observer` instead./);
    expectAssertion(function () {
      _emberMetalMixin._immediateObserver('foo.bar', function () {
        return this;
      });
    }, 'Immediate observers must observe internal properties only, not properties on other objects.');
  });

  QUnit.module('changeProperties');

  _emberMetalTestsProps_helper.testBoth('observers added/removed during changeProperties should do the right thing.', function (get, set) {
    var obj = {
      foo: 0
    };
    function Observer() {
      this.willChangeCount = 0;
      this.didChangeCount = 0;
    }
    Observer.prototype = {
      add: function () {
        _emberMetalObserver._addBeforeObserver(obj, 'foo', this, 'willChange');
        _emberMetalObserver.addObserver(obj, 'foo', this, 'didChange');
      },
      remove: function () {
        _emberMetalObserver._removeBeforeObserver(obj, 'foo', this, 'willChange');
        _emberMetalObserver.removeObserver(obj, 'foo', this, 'didChange');
      },
      willChange: function () {
        this.willChangeCount++;
      },
      didChange: function () {
        this.didChangeCount++;
      }
    };
    var addedBeforeFirstChangeObserver = new Observer();
    var addedAfterFirstChangeObserver = new Observer();
    var addedAfterLastChangeObserver = new Observer();
    var removedBeforeFirstChangeObserver = new Observer();
    var removedBeforeLastChangeObserver = new Observer();
    var removedAfterLastChangeObserver = new Observer();
    removedBeforeFirstChangeObserver.add();
    removedBeforeLastChangeObserver.add();
    removedAfterLastChangeObserver.add();
    _emberMetalProperty_events.changeProperties(function () {
      removedBeforeFirstChangeObserver.remove();
      addedBeforeFirstChangeObserver.add();

      set(obj, 'foo', 1);

      equal(addedBeforeFirstChangeObserver.willChangeCount, 1, '_addBeforeObserver called before the first change invoked immediately');
      equal(addedBeforeFirstChangeObserver.didChangeCount, 0, 'addObserver called before the first change is deferred');

      addedAfterFirstChangeObserver.add();
      removedBeforeLastChangeObserver.remove();

      set(obj, 'foo', 2);

      equal(addedAfterFirstChangeObserver.willChangeCount, 1, '_addBeforeObserver called after the first change invoked immediately');
      equal(addedAfterFirstChangeObserver.didChangeCount, 0, 'addObserver called after the first change is deferred');

      addedAfterLastChangeObserver.add();
      removedAfterLastChangeObserver.remove();
    });

    equal(removedBeforeFirstChangeObserver.willChangeCount, 0, '_removeBeforeObserver called before the first change sees none');
    equal(removedBeforeFirstChangeObserver.didChangeCount, 0, 'removeObserver called before the first change sees none');
    equal(addedBeforeFirstChangeObserver.willChangeCount, 1, '_addBeforeObserver called before the first change sees only 1');
    equal(addedBeforeFirstChangeObserver.didChangeCount, 1, 'addObserver called before the first change sees only 1');
    equal(addedAfterFirstChangeObserver.willChangeCount, 1, '_addBeforeObserver called after the first change sees 1');
    equal(addedAfterFirstChangeObserver.didChangeCount, 1, 'addObserver called after the first change sees 1');
    equal(addedAfterLastChangeObserver.willChangeCount, 0, '_addBeforeObserver called after the last change sees none');
    equal(addedAfterLastChangeObserver.didChangeCount, 0, 'addObserver called after the last change sees none');
    equal(removedBeforeLastChangeObserver.willChangeCount, 1, '_removeBeforeObserver called before the last change still sees 1');
    equal(removedBeforeLastChangeObserver.didChangeCount, 1, 'removeObserver called before the last change still sees 1');
    equal(removedAfterLastChangeObserver.willChangeCount, 1, '_removeBeforeObserver called after the last change still sees 1');
    equal(removedAfterLastChangeObserver.didChangeCount, 1, 'removeObserver called after the last change still sees 1');
  });
});
enifed('ember-metal/tests/observer_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests');
  test('ember-metal/tests/observer_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/observer_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/observer_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests');
  QUnit.test('ember-metal/tests/observer_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/observer_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/performance_test', ['exports', 'ember-metal/property_set', 'ember-metal/property_get', 'ember-metal/computed', 'ember-metal/properties', 'ember-metal/property_events', 'ember-metal/observer'], function (exports, _emberMetalProperty_set, _emberMetalProperty_get, _emberMetalComputed, _emberMetalProperties, _emberMetalProperty_events, _emberMetalObserver) {
  'use strict';

  /*
    This test file is designed to capture performance regressions related to
    deferred computation. Things like run loops, computed properties, and bindings
    should run the minimum amount of times to achieve best performance, so any
    bugs that cause them to get evaluated more than necessary should be put here.
  */

  QUnit.module('Computed Properties - Number of times evaluated');

  QUnit.test('computed properties that depend on multiple properties should run only once per run loop', function () {
    var obj = { a: 'a', b: 'b', c: 'c' };
    var cpCount = 0;
    var obsCount = 0;

    _emberMetalProperties.defineProperty(obj, 'abc', _emberMetalComputed.computed(function (key) {
      cpCount++;
      return 'computed ' + key;
    }).property('a', 'b', 'c'));

    _emberMetalProperty_get.get(obj, 'abc');

    cpCount = 0;

    _emberMetalObserver.addObserver(obj, 'abc', function () {
      obsCount++;
    });

    _emberMetalProperty_events.beginPropertyChanges();
    _emberMetalProperty_set.set(obj, 'a', 'aa');
    _emberMetalProperty_set.set(obj, 'b', 'bb');
    _emberMetalProperty_set.set(obj, 'c', 'cc');
    _emberMetalProperty_events.endPropertyChanges();

    _emberMetalProperty_get.get(obj, 'abc');

    equal(cpCount, 1, 'The computed property is only invoked once');
    equal(obsCount, 1, 'The observer is only invoked once');
  });

  QUnit.test('computed properties are not executed if they are the last segment of an observer chain pain', function () {
    var foo = { bar: { baz: {} } };

    var count = 0;

    _emberMetalProperties.defineProperty(foo.bar.baz, 'bam', _emberMetalComputed.computed(function () {
      count++;
    }));

    _emberMetalObserver.addObserver(foo, 'bar.baz.bam', function () {});

    _emberMetalProperty_events.propertyDidChange(_emberMetalProperty_get.get(foo, 'bar.baz'), 'bam');

    equal(count, 0, 'should not have recomputed property');
  });
});
enifed('ember-metal/tests/performance_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests');
  test('ember-metal/tests/performance_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/performance_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/performance_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests');
  QUnit.test('ember-metal/tests/performance_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/performance_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/properties_test', ['exports', 'ember-metal/computed', 'ember-metal/properties', 'ember-metal/deprecate_property'], function (exports, _emberMetalComputed, _emberMetalProperties, _emberMetalDeprecate_property) {
  'use strict';

  QUnit.module('Ember.defineProperty');

  QUnit.test('toString', function () {

    var obj = {};
    _emberMetalProperties.defineProperty(obj, 'toString', undefined, function () {
      return 'FOO';
    });
    equal(obj.toString(), 'FOO', 'should replace toString');
  });

  QUnit.test('for data properties, didDefineProperty hook should be called if implemented', function () {
    expect(2);

    var obj = {
      didDefineProperty: function (obj, keyName, value) {
        equal(keyName, 'foo', 'key name should be foo');
        equal(value, 'bar', 'value should be bar');
      }
    };

    _emberMetalProperties.defineProperty(obj, 'foo', undefined, 'bar');
  });

  QUnit.test('for computed properties, didDefineProperty hook should be called if implemented', function () {
    expect(2);

    var computedProperty = _emberMetalComputed.computed(function () {
      return this;
    });

    var obj = {
      didDefineProperty: function (obj, keyName, value) {
        equal(keyName, 'foo', 'key name should be foo');
        strictEqual(value, computedProperty, 'value should be passed as computed property');
      }
    };

    _emberMetalProperties.defineProperty(obj, 'foo', computedProperty);
  });

  QUnit.test('for descriptor properties, didDefineProperty hook should be called if implemented', function () {
    expect(2);

    var descriptor = {
      writable: true,
      configurable: false,
      enumerable: true,
      value: 42
    };

    var obj = {
      didDefineProperty: function (obj, keyName, value) {
        equal(keyName, 'answer', 'key name should be answer');
        strictEqual(value, descriptor, 'value should be passed as descriptor');
      }
    };

    _emberMetalProperties.defineProperty(obj, 'answer', descriptor);
  });

  QUnit.module('Ember.deprecateProperty');

  QUnit.test('enables access to deprecated property and returns the value of the new property', function () {
    expect(3);
    var obj = { foo: 'bar' };

    _emberMetalDeprecate_property.deprecateProperty(obj, 'baz', 'foo');

    expectDeprecation();
    equal(obj.baz, obj.foo, 'baz and foo are equal');

    obj.foo = 'blammo';
    equal(obj.baz, obj.foo, 'baz and foo are equal');
  });

  QUnit.test('deprecatedKey is not enumerable', function () {
    expect(2);
    var obj = { foo: 'bar', blammo: 'whammy' };

    _emberMetalDeprecate_property.deprecateProperty(obj, 'baz', 'foo');

    for (var prop in obj) {
      if (obj.hasOwnProperty(prop)) {
        notEqual(prop, 'baz');
      }
    }
  });

  QUnit.test('enables setter to deprecated property and updates the value of the new property', function () {
    expect(3);
    var obj = { foo: 'bar' };

    _emberMetalDeprecate_property.deprecateProperty(obj, 'baz', 'foo');

    expectDeprecation();
    obj.baz = 'bloop';
    equal(obj.foo, 'bloop', 'updating baz updates foo');
    equal(obj.baz, obj.foo, 'baz and foo are equal');
  });
});
enifed('ember-metal/tests/properties_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests');
  test('ember-metal/tests/properties_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/properties_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/properties_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests');
  QUnit.test('ember-metal/tests/properties_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/properties_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/props_helper', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-metal/property_set'], function (exports, _emberMetalCore, _emberMetalProperty_get, _emberMetalProperty_set) {
  'use strict';

  // used by unit tests to test both accessor mode and non-accessor mode
  var testBoth = function (testname, callback) {

    function emberget(x, y) {
      return _emberMetalProperty_get.get(x, y);
    }
    function emberset(x, y, z) {
      return _emberMetalProperty_set.set(x, y, z);
    }
    function aget(x, y) {
      return x[y];
    }
    function aset(x, y, z) {
      return x[y] = z;
    }

    QUnit.test(testname + ' using getFromEmberMetal()/Ember.set()', function () {
      callback(emberget, emberset);
    });

    QUnit.test(testname + ' using accessors', function () {
      if (_emberMetalCore.default.USES_ACCESSORS) {
        callback(aget, aset);
      } else {
        ok('SKIPPING ACCESSORS');
      }
    });
  };

  var testWithDefault = function (testname, callback) {
    function emberget(x, y) {
      return _emberMetalProperty_get.get(x, y);
    }
    function embergetwithdefault(x, y, z) {
      return _emberMetalProperty_get.getWithDefault(x, y, z);
    }
    function getwithdefault(x, y, z) {
      return x.getWithDefault(y, z);
    }
    function emberset(x, y, z) {
      return _emberMetalProperty_set.set(x, y, z);
    }
    function aget(x, y) {
      return x[y];
    }
    function aset(x, y, z) {
      return x[y] = z;
    }

    QUnit.test(testname + ' using obj.get()', function () {
      callback(emberget, emberset);
    });

    QUnit.test(testname + ' using obj.getWithDefault()', function () {
      callback(getwithdefault, emberset);
    });

    QUnit.test(testname + ' using getFromEmberMetal()', function () {
      callback(emberget, emberset);
    });

    QUnit.test(testname + ' using Ember.getWithDefault()', function () {
      callback(embergetwithdefault, emberset);
    });

    QUnit.test(testname + ' using accessors', function () {
      if (_emberMetalCore.default.USES_ACCESSORS) {
        callback(aget, aset);
      } else {
        ok('SKIPPING ACCESSORS');
      }
    });
  };

  exports.testWithDefault = testWithDefault;
  exports.testBoth = testBoth;
});
enifed('ember-metal/tests/props_helper.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests');
  test('ember-metal/tests/props_helper.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/props_helper.js should pass jscs.');
  });
});
enifed('ember-metal/tests/props_helper.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests');
  QUnit.test('ember-metal/tests/props_helper.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/props_helper.js should pass jshint.');
  });
});
enifed('ember-metal/tests/run_loop/add_queue_test', ['exports', 'ember-metal/run_loop'], function (exports, _emberMetalRun_loop) {
  'use strict';

  var originalQueues = _emberMetalRun_loop.default.queues;
  var queues;

  QUnit.module('system/run_loop/add_queue_test', {
    setup: function () {
      _emberMetalRun_loop.default.queues = queues = ['blork', 'bleep'];
    },
    teardown: function () {
      _emberMetalRun_loop.default.queues = originalQueues;
    }
  });

  QUnit.test('adds a queue after a specified one', function () {
    _emberMetalRun_loop.default._addQueue('testeroo', 'blork');

    equal(queues.indexOf('testeroo'), 1, 'new queue was added after specified queue');
  });

  QUnit.test('does not add the queue if it already exists', function () {
    _emberMetalRun_loop.default._addQueue('testeroo', 'blork');
    _emberMetalRun_loop.default._addQueue('testeroo', 'blork');

    equal(queues.length, 3, 'queue was not added twice');
  });
});
enifed('ember-metal/tests/run_loop/add_queue_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests/run_loop');
  test('ember-metal/tests/run_loop/add_queue_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/run_loop/add_queue_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/run_loop/add_queue_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests/run_loop');
  QUnit.test('ember-metal/tests/run_loop/add_queue_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/run_loop/add_queue_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/run_loop/debounce_test', ['exports', 'ember-metal/run_loop'], function (exports, _emberMetalRun_loop) {
  'use strict';

  var originalDebounce = _emberMetalRun_loop.default.backburner.debounce;
  var wasCalled = false;
  QUnit.module('Ember.run.debounce', {
    setup: function () {
      _emberMetalRun_loop.default.backburner.debounce = function () {
        wasCalled = true;
      };
    },
    teardown: function () {
      _emberMetalRun_loop.default.backburner.debounce = originalDebounce;
    }
  });

  QUnit.test('Ember.run.debounce uses Backburner.debounce', function () {
    _emberMetalRun_loop.default.debounce(function () {});
    ok(wasCalled, 'Ember.run.debounce used');
  });
});
enifed('ember-metal/tests/run_loop/debounce_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests/run_loop');
  test('ember-metal/tests/run_loop/debounce_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/run_loop/debounce_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/run_loop/debounce_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests/run_loop');
  QUnit.test('ember-metal/tests/run_loop/debounce_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/run_loop/debounce_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/run_loop/later_test', ['exports', 'ember-metal/is_none', 'ember-metal/run_loop'], function (exports, _emberMetalIs_none, _emberMetalRun_loop) {
  'use strict';

  var originalSetTimeout = window.setTimeout;
  var originalDateValueOf = Date.prototype.valueOf;

  function wait(callback, maxWaitCount) {
    maxWaitCount = _emberMetalIs_none.default(maxWaitCount) ? 100 : maxWaitCount;

    originalSetTimeout(function () {
      if (maxWaitCount > 0 && (_emberMetalRun_loop.default.hasScheduledTimers() || _emberMetalRun_loop.default.currentRunLoop)) {
        wait(callback, maxWaitCount - 1);

        return;
      }

      callback();
    }, 10);
  }

  // Synchronous "sleep". This simulates work being done
  // after run.later was called but before the run loop
  // has flushed. In previous versions, this would have
  // caused the run.later callback to have run from
  // within the run loop flush, since by the time the
  // run loop has to flush, it would have considered
  // the timer already expired.
  function pauseUntil(time) {
    // jscs:disable
    while (+new Date() < time) {} /* do nothing - sleeping */
    // jscs:enable
  }

  QUnit.module('run.later', {
    teardown: function () {
      window.setTimeout = originalSetTimeout;
      Date.prototype.valueOf = originalDateValueOf;
    }
  });

  asyncTest('should invoke after specified period of time - function only', function () {

    var invoked = false;

    _emberMetalRun_loop.default(function () {
      _emberMetalRun_loop.default.later(function () {
        invoked = true;
      }, 100);
    });

    wait(function () {
      QUnit.start();
      equal(invoked, true, 'should have invoked later item');
    });
  });

  asyncTest('should invoke after specified period of time - target/method', function () {

    var obj = { invoked: false };

    _emberMetalRun_loop.default(function () {
      _emberMetalRun_loop.default.later(obj, function () {
        this.invoked = true;
      }, 100);
    });

    wait(function () {
      QUnit.start();
      equal(obj.invoked, true, 'should have invoked later item');
    });
  });

  asyncTest('should invoke after specified period of time - target/method/args', function () {

    var obj = { invoked: 0 };

    _emberMetalRun_loop.default(function () {
      _emberMetalRun_loop.default.later(obj, function (amt) {
        this.invoked += amt;
      }, 10, 100);
    });

    wait(function () {
      QUnit.start();
      equal(obj.invoked, 10, 'should have invoked later item');
    });
  });

  asyncTest('should always invoke within a separate runloop', function () {
    var obj = { invoked: 0 };
    var firstRunLoop, secondRunLoop;

    _emberMetalRun_loop.default(function () {
      firstRunLoop = _emberMetalRun_loop.default.currentRunLoop;

      _emberMetalRun_loop.default.later(obj, function (amt) {
        this.invoked += amt;
        secondRunLoop = _emberMetalRun_loop.default.currentRunLoop;
      }, 10, 1);

      pauseUntil(+new Date() + 100);
    });

    ok(firstRunLoop, 'first run loop captured');
    ok(!_emberMetalRun_loop.default.currentRunLoop, 'shouldn\'t be in a run loop after flush');
    equal(obj.invoked, 0, 'shouldn\'t have invoked later item yet');

    wait(function () {
      QUnit.start();
      equal(obj.invoked, 10, 'should have invoked later item');
      ok(secondRunLoop, 'second run loop took place');
      ok(secondRunLoop !== firstRunLoop, 'two different run loops took place');
    });
  });

  // Our current implementation doesn't allow us to correctly enforce this ordering.
  // We should probably implement a queue to provide this guarantee.
  // See https://github.com/emberjs/ember.js/issues/3526 for more information.

  // asyncTest('callback order', function() {
  //   var array = [];
  //   function fn(val) { array.push(val); }

  //   run(function() {
  //     run.later(this, fn, 4, 5);
  //     run.later(this, fn, 1, 1);
  //     run.later(this, fn, 5, 10);
  //     run.later(this, fn, 2, 3);
  //     run.later(this, fn, 3, 3);
  //   });

  //   deepEqual(array, []);

  //   wait(function() {
  //     QUnit.start();
  //     deepEqual(array, [1,2,3,4,5], 'callbacks were called in expected order');
  //   });
  // });

  // Out current implementation doesn't allow us to properly enforce what is tested here.
  // We should probably fix it, but it's not technically a bug right now.
  // See https://github.com/emberjs/ember.js/issues/3522 for more information.

  // asyncTest('callbacks coalesce into same run loop if expiring at the same time', function() {
  //   var array = [];
  //   function fn(val) { array.push(run.currentRunLoop); }

  //   run(function() {

  //     // Force +new Date to return the same result while scheduling
  //     // run.later timers. Otherwise: non-determinism!
  //     var now = +new Date();
  //     Date.prototype.valueOf = function() { return now; };

  //     run.later(this, fn, 10);
  //     run.later(this, fn, 200);
  //     run.later(this, fn, 200);

  //     Date.prototype.valueOf = originalDateValueOf;
  //   });

  //   deepEqual(array, []);

  //   wait(function() {
  //     QUnit.start();
  //     equal(array.length, 3, 'all callbacks called');
  //     ok(array[0] !== array[1], 'first two callbacks have different run loops');
  //     ok(array[0], 'first runloop present');
  //     ok(array[1], 'second runloop present');
  //     equal(array[1], array[2], 'last two callbacks got the same run loop');
  //   });
  // });

  asyncTest('inception calls to run.later should run callbacks in separate run loops', function () {

    var runLoop, finished;

    _emberMetalRun_loop.default(function () {
      runLoop = _emberMetalRun_loop.default.currentRunLoop;
      ok(runLoop);

      _emberMetalRun_loop.default.later(function () {
        ok(_emberMetalRun_loop.default.currentRunLoop && _emberMetalRun_loop.default.currentRunLoop !== runLoop, 'first later callback has own run loop');
        runLoop = _emberMetalRun_loop.default.currentRunLoop;

        _emberMetalRun_loop.default.later(function () {
          ok(_emberMetalRun_loop.default.currentRunLoop && _emberMetalRun_loop.default.currentRunLoop !== runLoop, 'second later callback has own run loop');
          finished = true;
        }, 40);
      }, 40);
    });

    wait(function () {
      QUnit.start();
      ok(finished, 'all .later callbacks run');
    });
  });

  asyncTest('setTimeout should never run with a negative wait', function () {

    // Rationale: The old run loop code was susceptible to an occasional
    // bug where invokeLaterTimers would be scheduled with a setTimeout
    // with a negative wait. Modern browsers normalize this to 0, but
    // older browsers (IE <= 8) break with a negative wait, which
    // happens when an expired timer callback takes a while to run,
    // which is what we simulate here.
    var newSetTimeoutUsed;
    window.setTimeout = function () {
      var wait = arguments[arguments.length - 1];
      newSetTimeoutUsed = true;
      ok(!isNaN(wait) && wait >= 0, 'wait is a non-negative number');
      // In IE8, `setTimeout.apply` is `undefined`.
      var apply = Function.prototype.apply;
      return apply.apply(originalSetTimeout, [this, arguments]);
    };

    var count = 0;
    _emberMetalRun_loop.default(function () {

      _emberMetalRun_loop.default.later(function () {
        count++;

        // This will get run first. Waste some time.
        // This is intended to break invokeLaterTimers code by taking a
        // long enough time that other timers should technically expire. It's
        // fine that they're not called in this run loop; just need to
        // make sure that invokeLaterTimers doesn't end up scheduling
        // a negative setTimeout.
        pauseUntil(+new Date() + 60);
      }, 1);

      _emberMetalRun_loop.default.later(function () {
        equal(count, 1, 'callbacks called in order');
      }, 50);
    });

    wait(function () {
      window.setTimeout = originalSetTimeout;
      QUnit.start();
      ok(newSetTimeoutUsed, 'stub setTimeout was used');
    });
  });
});
enifed('ember-metal/tests/run_loop/later_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests/run_loop');
  test('ember-metal/tests/run_loop/later_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/run_loop/later_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/run_loop/later_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests/run_loop');
  QUnit.test('ember-metal/tests/run_loop/later_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/run_loop/later_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/run_loop/next_test', ['exports', 'ember-metal/run_loop'], function (exports, _emberMetalRun_loop) {
  'use strict';

  QUnit.module('run.next');

  asyncTest('should invoke immediately on next timeout', function () {

    var invoked = false;

    _emberMetalRun_loop.default(function () {
      _emberMetalRun_loop.default.next(function () {
        invoked = true;
      });
    });

    equal(invoked, false, 'should not have invoked yet');

    setTimeout(function () {
      QUnit.start();
      equal(invoked, true, 'should have invoked later item');
    }, 20);
  });

  asyncTest('callback should be called from within separate loop', function () {
    var firstRunLoop, secondRunLoop;
    _emberMetalRun_loop.default(function () {
      firstRunLoop = _emberMetalRun_loop.default.currentRunLoop;
      _emberMetalRun_loop.default.next(function () {
        secondRunLoop = _emberMetalRun_loop.default.currentRunLoop;
      });
    });

    setTimeout(function () {
      QUnit.start();
      ok(secondRunLoop, 'callback was called from within run loop');
      ok(firstRunLoop && secondRunLoop !== firstRunLoop, 'two separate run loops were invoked');
    }, 20);
  });

  asyncTest('multiple calls to run.next share coalesce callbacks into same run loop', function () {
    var firstRunLoop, secondRunLoop, thirdRunLoop;
    _emberMetalRun_loop.default(function () {
      firstRunLoop = _emberMetalRun_loop.default.currentRunLoop;
      _emberMetalRun_loop.default.next(function () {
        secondRunLoop = _emberMetalRun_loop.default.currentRunLoop;
      });
      _emberMetalRun_loop.default.next(function () {
        thirdRunLoop = _emberMetalRun_loop.default.currentRunLoop;
      });
    });

    setTimeout(function () {
      QUnit.start();
      ok(secondRunLoop && secondRunLoop === thirdRunLoop, 'callbacks coalesced into same run loop');
    }, 20);
  });
});
enifed('ember-metal/tests/run_loop/next_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests/run_loop');
  test('ember-metal/tests/run_loop/next_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/run_loop/next_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/run_loop/next_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests/run_loop');
  QUnit.test('ember-metal/tests/run_loop/next_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/run_loop/next_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/run_loop/once_test', ['exports', 'ember-metal/run_loop'], function (exports, _emberMetalRun_loop) {
  'use strict';

  QUnit.module('system/run_loop/once_test');

  QUnit.test('calling invokeOnce more than once invokes only once', function () {

    var count = 0;
    _emberMetalRun_loop.default(function () {
      var F = function () {
        count++;
      };
      _emberMetalRun_loop.default.once(F);
      _emberMetalRun_loop.default.once(F);
      _emberMetalRun_loop.default.once(F);
    });

    equal(count, 1, 'should have invoked once');
  });

  QUnit.test('should differentiate based on target', function () {

    var A = { count: 0 };
    var B = { count: 0 };
    _emberMetalRun_loop.default(function () {
      var F = function () {
        this.count++;
      };
      _emberMetalRun_loop.default.once(A, F);
      _emberMetalRun_loop.default.once(B, F);
      _emberMetalRun_loop.default.once(A, F);
      _emberMetalRun_loop.default.once(B, F);
    });

    equal(A.count, 1, 'should have invoked once on A');
    equal(B.count, 1, 'should have invoked once on B');
  });

  QUnit.test('should ignore other arguments - replacing previous ones', function () {

    var A = { count: 0 };
    var B = { count: 0 };
    _emberMetalRun_loop.default(function () {
      var F = function (amt) {
        this.count += amt;
      };
      _emberMetalRun_loop.default.once(A, F, 10);
      _emberMetalRun_loop.default.once(B, F, 20);
      _emberMetalRun_loop.default.once(A, F, 30);
      _emberMetalRun_loop.default.once(B, F, 40);
    });

    equal(A.count, 30, 'should have invoked once on A');
    equal(B.count, 40, 'should have invoked once on B');
  });

  QUnit.test('should be inside of a runloop when running', function () {

    _emberMetalRun_loop.default(function () {
      _emberMetalRun_loop.default.once(function () {
        ok(!!_emberMetalRun_loop.default.currentRunLoop, 'should have a runloop');
      });
    });
  });
});
enifed('ember-metal/tests/run_loop/once_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests/run_loop');
  test('ember-metal/tests/run_loop/once_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/run_loop/once_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/run_loop/once_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests/run_loop');
  QUnit.test('ember-metal/tests/run_loop/once_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/run_loop/once_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/run_loop/onerror_test', ['exports', 'ember-metal', 'ember-metal/run_loop'], function (exports, _emberMetal, _emberMetalRun_loop) {
  'use strict';

  QUnit.module('system/run_loop/onerror_test');

  QUnit.test('With Ember.onerror undefined, errors in Ember.run are thrown', function () {
    var thrown = new Error('Boom!');
    var caught;

    try {
      _emberMetalRun_loop.default(function () {
        throw thrown;
      });
    } catch (error) {
      caught = error;
    }

    deepEqual(caught, thrown);
  });

  QUnit.test('With Ember.onerror set, errors in Ember.run are caught', function () {
    var thrown = new Error('Boom!');
    var caught;

    _emberMetal.default.onerror = function (error) {
      caught = error;
    };

    _emberMetalRun_loop.default(function () {
      throw thrown;
    });

    deepEqual(caught, thrown);

    _emberMetal.default.onerror = undefined;
  });
});
enifed('ember-metal/tests/run_loop/onerror_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests/run_loop');
  test('ember-metal/tests/run_loop/onerror_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/run_loop/onerror_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/run_loop/onerror_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests/run_loop');
  QUnit.test('ember-metal/tests/run_loop/onerror_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/run_loop/onerror_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/run_loop/run_bind_test', ['exports', 'ember-metal/run_loop'], function (exports, _emberMetalRun_loop) {
  'use strict';

  QUnit.module('system/run_loop/run_bind_test');

  QUnit.test('Ember.run.bind builds a run-loop wrapped callback handler', function () {
    expect(3);

    var obj = {
      value: 0,
      increment: function (increment) {
        ok(_emberMetalRun_loop.default.currentRunLoop, 'expected a run-loop');
        return this.value += increment;
      }
    };

    var proxiedFunction = _emberMetalRun_loop.default.bind(obj, obj.increment, 1);
    equal(proxiedFunction(), 1);
    equal(obj.value, 1);
  });

  QUnit.test('Ember.run.bind keeps the async callback arguments', function () {
    expect(4);

    var asyncCallback = function (increment, increment2, increment3) {
      ok(_emberMetalRun_loop.default.currentRunLoop, 'expected a run-loop');
      equal(increment, 1);
      equal(increment2, 2);
      equal(increment3, 3);
    };

    var asyncFunction = function (fn) {
      fn(2, 3);
    };

    asyncFunction(_emberMetalRun_loop.default.bind(asyncCallback, asyncCallback, 1));
  });
});
enifed('ember-metal/tests/run_loop/run_bind_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests/run_loop');
  test('ember-metal/tests/run_loop/run_bind_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/run_loop/run_bind_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/run_loop/run_bind_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests/run_loop');
  QUnit.test('ember-metal/tests/run_loop/run_bind_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/run_loop/run_bind_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/run_loop/run_test', ['exports', 'ember-metal/run_loop'], function (exports, _emberMetalRun_loop) {
  'use strict';

  QUnit.module('system/run_loop/run_test');

  QUnit.test('Ember.run invokes passed function, returning value', function () {
    var obj = {
      foo: function () {
        return [this.bar, 'FOO'];
      },
      bar: 'BAR',
      checkArgs: function (arg1, arg2) {
        return [arg1, this.bar, arg2];
      }
    };

    equal(_emberMetalRun_loop.default(function () {
      return 'FOO';
    }), 'FOO', 'pass function only');
    deepEqual(_emberMetalRun_loop.default(obj, obj.foo), ['BAR', 'FOO'], 'pass obj and obj.method');
    deepEqual(_emberMetalRun_loop.default(obj, 'foo'), ['BAR', 'FOO'], 'pass obj and "method"');
    deepEqual(_emberMetalRun_loop.default(obj, obj.checkArgs, 'hello', 'world'), ['hello', 'BAR', 'world'], 'pass obj, obj.method, and extra arguments');
  });
});
enifed('ember-metal/tests/run_loop/run_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests/run_loop');
  test('ember-metal/tests/run_loop/run_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/run_loop/run_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/run_loop/run_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests/run_loop');
  QUnit.test('ember-metal/tests/run_loop/run_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/run_loop/run_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/run_loop/schedule_test', ['exports', 'ember-metal/run_loop'], function (exports, _emberMetalRun_loop) {
  'use strict';

  QUnit.module('system/run_loop/schedule_test');

  QUnit.test('scheduling item in queue should defer until finished', function () {
    var cnt = 0;

    _emberMetalRun_loop.default(function () {
      _emberMetalRun_loop.default.schedule('actions', function () {
        cnt++;
      });
      _emberMetalRun_loop.default.schedule('actions', function () {
        cnt++;
      });
      equal(cnt, 0, 'should not run action yet');
    });

    equal(cnt, 2, 'should flush actions now');
  });

  QUnit.test('nested runs should queue each phase independently', function () {
    var cnt = 0;

    _emberMetalRun_loop.default(function () {
      _emberMetalRun_loop.default.schedule('actions', function () {
        cnt++;
      });
      equal(cnt, 0, 'should not run action yet');

      _emberMetalRun_loop.default(function () {
        _emberMetalRun_loop.default.schedule('actions', function () {
          cnt++;
        });
      });
      equal(cnt, 1, 'should not run action yet');
    });

    equal(cnt, 2, 'should flush actions now');
  });

  QUnit.test('prior queues should be flushed before moving on to next queue', function () {
    var order = [];

    _emberMetalRun_loop.default(function () {
      var runLoop = _emberMetalRun_loop.default.currentRunLoop;
      ok(runLoop, 'run loop present');

      _emberMetalRun_loop.default.schedule('sync', function () {
        order.push('sync');
        equal(runLoop, _emberMetalRun_loop.default.currentRunLoop, 'same run loop used');
      });
      _emberMetalRun_loop.default.schedule('actions', function () {
        order.push('actions');
        equal(runLoop, _emberMetalRun_loop.default.currentRunLoop, 'same run loop used');

        _emberMetalRun_loop.default.schedule('actions', function () {
          order.push('actions');
          equal(runLoop, _emberMetalRun_loop.default.currentRunLoop, 'same run loop used');
        });

        _emberMetalRun_loop.default.schedule('sync', function () {
          order.push('sync');
          equal(runLoop, _emberMetalRun_loop.default.currentRunLoop, 'same run loop used');
        });
      });
      _emberMetalRun_loop.default.schedule('destroy', function () {
        order.push('destroy');
        equal(runLoop, _emberMetalRun_loop.default.currentRunLoop, 'same run loop used');
      });
    });

    deepEqual(order, ['sync', 'actions', 'sync', 'actions', 'destroy']);
  });

  QUnit.test('makes sure it does not trigger an autorun during testing', function () {
    expectAssertion(function () {
      _emberMetalRun_loop.default.schedule('actions', function () {});
    }, /wrap any code with asynchronous side-effects in a run/);

    // make sure not just the first violation is asserted.
    expectAssertion(function () {
      _emberMetalRun_loop.default.schedule('actions', function () {});
    }, /wrap any code with asynchronous side-effects in a run/);
  });
});
enifed('ember-metal/tests/run_loop/schedule_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests/run_loop');
  test('ember-metal/tests/run_loop/schedule_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/run_loop/schedule_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/run_loop/schedule_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests/run_loop');
  QUnit.test('ember-metal/tests/run_loop/schedule_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/run_loop/schedule_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/run_loop/sync_test', ['exports', 'ember-metal/run_loop'], function (exports, _emberMetalRun_loop) {
  'use strict';

  QUnit.module('system/run_loop/sync_test');

  QUnit.test('sync() will immediately flush the sync queue only', function () {
    var cnt = 0;

    _emberMetalRun_loop.default(function () {

      function cntup() {
        cnt++;
      }

      function syncfunc() {
        if (++cnt < 5) {
          _emberMetalRun_loop.default.schedule('sync', syncfunc);
        }
        _emberMetalRun_loop.default.schedule('actions', cntup);
      }

      syncfunc();

      equal(cnt, 1, 'should not run action yet');
      _emberMetalRun_loop.default.sync();

      equal(cnt, 5, 'should have run sync queue continuously');
    });

    equal(cnt, 10, 'should flush actions now too');
  });

  QUnit.test('calling sync() outside a run loop does not cause an error', function () {
    expect(0);

    _emberMetalRun_loop.default.sync();
  });
});
enifed('ember-metal/tests/run_loop/sync_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests/run_loop');
  test('ember-metal/tests/run_loop/sync_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/run_loop/sync_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/run_loop/sync_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests/run_loop');
  QUnit.test('ember-metal/tests/run_loop/sync_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/run_loop/sync_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/run_loop/unwind_test', ['exports', 'ember-metal/run_loop', 'ember-metal/error'], function (exports, _emberMetalRun_loop, _emberMetalError) {
  'use strict';

  QUnit.module('system/run_loop/unwind_test');

  QUnit.test('RunLoop unwinds despite unhandled exception', function () {
    var initialRunLoop = _emberMetalRun_loop.default.currentRunLoop;

    throws(function () {
      _emberMetalRun_loop.default(function () {
        _emberMetalRun_loop.default.schedule('actions', function () {
          throw new _emberMetalError.default('boom!');
        });
      });
    }, Error, 'boom!');

    // The real danger at this point is that calls to autorun will stick
    // tasks into the already-dead runloop, which will never get
    // flushed. I can't easily demonstrate this in a unit test because
    // autorun explicitly doesn't work in test mode. - ef4
    equal(_emberMetalRun_loop.default.currentRunLoop, initialRunLoop, 'Previous run loop should be cleaned up despite exception');

    // Prevent a failure in this test from breaking subsequent tests.
    _emberMetalRun_loop.default.currentRunLoop = initialRunLoop;
  });

  QUnit.test('run unwinds despite unhandled exception', function () {
    var initialRunLoop = _emberMetalRun_loop.default.currentRunLoop;

    throws(function () {
      _emberMetalRun_loop.default(function () {
        throw new _emberMetalError.default('boom!');
      });
    }, _emberMetalError.default, 'boom!');

    equal(_emberMetalRun_loop.default.currentRunLoop, initialRunLoop, 'Previous run loop should be cleaned up despite exception');

    // Prevent a failure in this test from breaking subsequent tests.
    _emberMetalRun_loop.default.currentRunLoop = initialRunLoop;
  });
});
enifed('ember-metal/tests/run_loop/unwind_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests/run_loop');
  test('ember-metal/tests/run_loop/unwind_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/run_loop/unwind_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/run_loop/unwind_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests/run_loop');
  QUnit.test('ember-metal/tests/run_loop/unwind_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/run_loop/unwind_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/set_properties_test', ['exports', 'ember-metal/set_properties'], function (exports, _emberMetalSet_properties) {
  'use strict';

  QUnit.module('Ember.setProperties');

  QUnit.test('supports setting multiple attributes at once', function () {
    deepEqual(_emberMetalSet_properties.default(null, null), null, 'noop for null properties and null object');
    deepEqual(_emberMetalSet_properties.default(undefined, undefined), undefined, 'noop for undefined properties and undefined object');

    deepEqual(_emberMetalSet_properties.default({}), undefined, 'noop for no properties');
    deepEqual(_emberMetalSet_properties.default({}, undefined), undefined, 'noop for undefined');
    deepEqual(_emberMetalSet_properties.default({}, null), null, 'noop for null');
    deepEqual(_emberMetalSet_properties.default({}, NaN), NaN, 'noop for NaN');
    deepEqual(_emberMetalSet_properties.default({}, {}), {}, 'meh');

    deepEqual(_emberMetalSet_properties.default({}, { foo: 1 }), { foo: 1 }, 'Set a single property');

    deepEqual(_emberMetalSet_properties.default({}, { foo: 1, bar: 1 }), { foo: 1, bar: 1 }, 'Set multiple properties');

    deepEqual(_emberMetalSet_properties.default({ foo: 2, baz: 2 }, { foo: 1 }), { foo: 1 }, 'Set one of multiple properties');

    deepEqual(_emberMetalSet_properties.default({ foo: 2, baz: 2 }, { bar: 2 }), {
      bar: 2
    }, 'Set an additional, previously unset property');
  });
});
enifed('ember-metal/tests/set_properties_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests');
  test('ember-metal/tests/set_properties_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/set_properties_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/set_properties_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests');
  QUnit.test('ember-metal/tests/set_properties_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/set_properties_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/streams/concat_test', ['exports', 'ember-metal/streams/stream', 'ember-metal/streams/utils'], function (exports, _emberMetalStreamsStream, _emberMetalStreamsUtils) {
  'use strict';

  function hasSubscribers(stream) {
    // this uses the private internal property `subscriberHead`
    // for the purposes of ensuring that subscription is cleared
    // after deactivation.  Adding a util helper to the `Stream` code
    // just for the test seems dubious, as does accessing the private
    // property directly in the test.
    return stream && !!stream.subscriberHead;
  }

  QUnit.module('Stream - concat');

  QUnit.test('returns string if no streams were in the array', function (assert) {
    var result = _emberMetalStreamsUtils.concat(['foo', 'bar', 'baz'], ' ');

    assert.equal(result, 'foo bar baz');
  });

  QUnit.test('returns a stream if a stream is in the array', function (assert) {
    var stream = new _emberMetalStreamsStream.default(function () {
      return 'bar';
    });
    var result = _emberMetalStreamsUtils.concat(['foo', stream, 'baz'], ' ');

    assert.ok(result.isStream, 'a stream is returned');
    assert.equal(_emberMetalStreamsUtils.read(result), 'foo bar baz');
  });

  QUnit.test('returns updated value upon input dirtied', function (assert) {
    var value = 'bar';
    var stream = new _emberMetalStreamsStream.default(function () {
      return value;
    });
    var result = _emberMetalStreamsUtils.concat(['foo', stream, 'baz'], ' ');
    result.activate();

    assert.equal(_emberMetalStreamsUtils.read(result), 'foo bar baz');

    value = 'qux';
    stream.notify();

    assert.equal(_emberMetalStreamsUtils.read(result), 'foo qux baz');
  });

  QUnit.test('removes dependencies when unsubscribeDependencies is called', function (assert) {
    var stream = new _emberMetalStreamsStream.default(function () {
      return 'bar';
    });
    var result = _emberMetalStreamsUtils.concat(['foo', stream, 'baz'], ' ');
    result.activate();

    assert.equal(hasSubscribers(stream), true, 'subscribers are present from the concat stream');

    result.maybeDeactivate();

    assert.equal(hasSubscribers(stream), false, 'subscribers are removed after concat stream is deactivated');
  });
});
enifed('ember-metal/tests/streams/concat_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests/streams');
  test('ember-metal/tests/streams/concat_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/streams/concat_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/streams/concat_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests/streams');
  QUnit.test('ember-metal/tests/streams/concat_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/streams/concat_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/streams/key-stream-test', ['exports', 'ember-metal/watching', 'ember-metal/streams/stream', 'ember-metal/streams/key-stream', 'ember-metal/property_set'], function (exports, _emberMetalWatching, _emberMetalStreamsStream, _emberMetalStreamsKeyStream, _emberMetalProperty_set) {
  'use strict';

  var source, object, count;

  function incrementCount() {
    count++;
  }

  QUnit.module('KeyStream', {
    setup: function () {
      count = 0;
      object = { name: 'mmun' };

      source = new _emberMetalStreamsStream.default(function () {
        return object;
      });
    },
    teardown: function () {
      count = undefined;
      object = undefined;
      source = undefined;
    }
  });

  QUnit.test('can be instantiated manually', function () {
    var nameStream = new _emberMetalStreamsKeyStream.default(source, 'name');
    equal(nameStream.value(), 'mmun', 'Stream value is correct');
  });

  QUnit.test('can be instantiated via `Stream.prototype.get`', function () {
    var nameStream = source.get('name');
    equal(nameStream.value(), 'mmun', 'Stream value is correct');
  });

  QUnit.test('is notified when the observed object\'s property is mutated', function () {
    var nameStream = source.get('name');
    nameStream.subscribe(incrementCount);

    equal(count, 0, 'Subscribers called correct number of times');
    equal(nameStream.value(), 'mmun', 'Stream value is correct');

    _emberMetalProperty_set.set(object, 'name', 'wycats');

    equal(count, 1, 'Subscribers called correct number of times');
    equal(nameStream.value(), 'wycats', 'Stream value is correct');
  });

  QUnit.test('is notified when the source stream\'s value changes to a new object', function () {
    var nameStream = source.get('name');
    nameStream.subscribe(incrementCount);

    equal(count, 0, 'Subscribers called correct number of times');
    equal(nameStream.value(), 'mmun', 'Stream value is correct');

    object = { name: 'wycats' };
    source.notify();

    equal(count, 1, 'Subscribers called correct number of times');
    equal(nameStream.value(), 'wycats', 'Stream value is correct');

    _emberMetalProperty_set.set(object, 'name', 'kris');

    equal(count, 2, 'Subscribers called correct number of times');
    equal(nameStream.value(), 'kris', 'Stream value is correct');
  });

  QUnit.test('is notified when the source stream\'s value changes to the same object', function () {
    var nameStream = source.get('name');
    nameStream.subscribe(incrementCount);

    equal(count, 0, 'Subscribers called correct number of times');
    equal(nameStream.value(), 'mmun', 'Stream value is correct');

    source.notify();

    equal(count, 1, 'Subscribers called correct number of times');
    equal(nameStream.value(), 'mmun', 'Stream value is correct');

    _emberMetalProperty_set.set(object, 'name', 'kris');

    equal(count, 2, 'Subscribers called correct number of times');
    equal(nameStream.value(), 'kris', 'Stream value is correct');
  });

  QUnit.test('is notified when setSource is called with a new stream whose value is a new object', function () {
    var nameStream = source.get('name');
    nameStream.subscribe(incrementCount);

    equal(count, 0, 'Subscribers called correct number of times');
    equal(nameStream.value(), 'mmun', 'Stream value is correct');

    object = { name: 'wycats' };
    nameStream.setSource(new _emberMetalStreamsStream.default(function () {
      return object;
    }));

    equal(count, 1, 'Subscribers called correct number of times');
    equal(nameStream.value(), 'wycats', 'Stream value is correct');

    _emberMetalProperty_set.set(object, 'name', 'kris');

    equal(count, 2, 'Subscribers called correct number of times');
    equal(nameStream.value(), 'kris', 'Stream value is correct');
  });

  QUnit.test('is notified when setSource is called with a new stream whose value is the same object', function () {
    var nameStream = source.get('name');
    nameStream.subscribe(incrementCount);

    equal(count, 0, 'Subscribers called correct number of times');
    equal(nameStream.value(), 'mmun', 'Stream value is correct');

    nameStream.setSource(new _emberMetalStreamsStream.default(function () {
      return object;
    }));

    equal(count, 1, 'Subscribers called correct number of times');
    equal(nameStream.value(), 'mmun', 'Stream value is correct');

    _emberMetalProperty_set.set(object, 'name', 'kris');

    equal(count, 2, 'Subscribers called correct number of times');
    equal(nameStream.value(), 'kris', 'Stream value is correct');
  });

  QUnit.test('adds and removes key observers on activation and deactivation', function () {
    var nameStream = source.get('name');

    ok(!_emberMetalWatching.isWatching(object, 'name'), 'Key is not observered immediately after creation');

    nameStream.value();

    ok(!_emberMetalWatching.isWatching(object, 'name'), 'Key is not observered after calling value with no subscribers');

    var firstCallback = function () {};
    nameStream.subscribe(firstCallback);

    ok(!_emberMetalWatching.isWatching(object, 'name'), 'Key is not observered immediately after first subscription');

    nameStream.value();

    ok(_emberMetalWatching.isWatching(object, 'name'), 'Key is observered after activation');

    var secondCallback = function () {};
    nameStream.subscribe(secondCallback);

    ok(_emberMetalWatching.isWatching(object, 'name'), 'Key is still observered after second subscription is added');

    nameStream.unsubscribe(secondCallback);

    ok(_emberMetalWatching.isWatching(object, 'name'), 'Key is still observered after second subscription is removed');

    nameStream.unsubscribe(firstCallback);

    ok(!_emberMetalWatching.isWatching(object, 'name'), 'Key is not observered after deactivation');
  });

  QUnit.test('removes key observers on destruction', function () {
    var nameStream = source.get('name');
    nameStream.subscribe(function () {});
    nameStream.value();

    ok(_emberMetalWatching.isWatching(object, 'name'), '(Precondition) Key is observered after activation');

    nameStream.destroy();

    ok(!_emberMetalWatching.isWatching(object, 'name'), 'Key is not observered after destruction');
  });

  QUnit.test('manages key observers correctly when the object changes', function () {
    var nameStream = source.get('name');
    nameStream.subscribe(function () {});
    nameStream.value();

    ok(_emberMetalWatching.isWatching(object, 'name'), '(Precondition) Key is observered after activation');

    var prevObject = object;
    object = { name: 'wycats' };
    source.notify();

    ok(_emberMetalWatching.isWatching(prevObject, 'name'), 'Key is still observered on the previous object before recomputing');
    ok(!_emberMetalWatching.isWatching(object, 'name'), 'Key is still not observered on the new object before recomputing');

    nameStream.value();

    ok(!_emberMetalWatching.isWatching(prevObject, 'name'), 'Key is not observered on the previous object after recomputing');
    ok(_emberMetalWatching.isWatching(object, 'name'), 'Key is observered on the new object after recomputing');
  });
});
enifed('ember-metal/tests/streams/key-stream-test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests/streams');
  test('ember-metal/tests/streams/key-stream-test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/streams/key-stream-test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/streams/key-stream-test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests/streams');
  QUnit.test('ember-metal/tests/streams/key-stream-test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/streams/key-stream-test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/streams/proxy-stream-test', ['exports', 'ember-metal/streams/stream', 'ember-metal/streams/proxy-stream'], function (exports, _emberMetalStreamsStream, _emberMetalStreamsProxyStream) {
  'use strict';

  var source, value;

  QUnit.module('ProxyStream', {
    setup: function () {
      value = 'zlurp';

      source = new _emberMetalStreamsStream.default(function () {
        return value;
      });

      source.setValue = function (_value) {
        value = _value;
        this.notify();
      };
    },
    teardown: function () {
      value = undefined;
      source = undefined;
    }
  });

  QUnit.test('supports a stream argument', function () {
    var stream = new _emberMetalStreamsProxyStream.default(source);
    equal(stream.value(), 'zlurp');

    stream.setValue('blorg');
    equal(stream.value(), 'blorg');
  });

  QUnit.test('supports a non-stream argument', function () {
    var stream = new _emberMetalStreamsProxyStream.default(value);
    equal(stream.value(), 'zlurp');

    stream.setValue('blorg');
    equal(stream.value(), 'zlurp');
  });
});
enifed('ember-metal/tests/streams/proxy-stream-test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests/streams');
  test('ember-metal/tests/streams/proxy-stream-test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/streams/proxy-stream-test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/streams/proxy-stream-test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests/streams');
  QUnit.test('ember-metal/tests/streams/proxy-stream-test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/streams/proxy-stream-test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/streams/stream-test', ['exports', 'ember-metal/streams/stream', 'ember-runtime/system/object_proxy', 'ember-metal/property_get'], function (exports, _emberMetalStreamsStream, _emberRuntimeSystemObject_proxy, _emberMetalProperty_get) {
  'use strict';

  var stream, value, count;

  function incrementCount() {
    count++;
  }

  QUnit.module('Stream - Proxy compatibility', {
    setup: function () {
      count = 0;
      value = 'zlurp';

      stream = new _emberMetalStreamsStream.default(function () {
        return value;
      });
    },
    teardown: function () {
      value = undefined;
      stream = undefined;
    }
  });

  QUnit.test('is notified when a proxy\'s content changes', function () {
    stream.subscribe(incrementCount);
    stream.value();

    value = _emberRuntimeSystemObject_proxy.default.create({
      content: { message: 'foo' }
    });

    equal(count, 0);

    stream.notify();

    equal(count, 1);
    equal(_emberMetalProperty_get.get(stream.value(), 'message'), 'foo');

    value.set('content', { message: 'bar' });

    equal(count, 2);
    equal(_emberMetalProperty_get.get(stream.value(), 'message'), 'bar');
  });
});
enifed('ember-metal/tests/streams/stream-test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests/streams');
  test('ember-metal/tests/streams/stream-test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/streams/stream-test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/streams/stream-test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests/streams');
  QUnit.test('ember-metal/tests/streams/stream-test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/streams/stream-test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/utils/can_invoke_test', ['exports', 'ember-metal/utils'], function (exports, _emberMetalUtils) {
  'use strict';

  var obj;

  QUnit.module('Ember.canInvoke', {
    setup: function () {
      obj = {
        foobar: 'foobar',
        aMethodThatExists: function () {}
      };
    },

    teardown: function () {
      obj = undefined;
    }
  });

  QUnit.test('should return false if the object doesn\'t exist', function () {
    equal(_emberMetalUtils.canInvoke(undefined, 'aMethodThatDoesNotExist'), false);
  });

  QUnit.test('should return true if the method exists on the object', function () {
    equal(_emberMetalUtils.canInvoke(obj, 'aMethodThatExists'), true);
  });

  QUnit.test('should return false if the method doesn\'t exist on the object', function () {
    equal(_emberMetalUtils.canInvoke(obj, 'aMethodThatDoesNotExist'), false);
  });

  QUnit.test('should return false if the property exists on the object but is a non-function', function () {
    equal(_emberMetalUtils.canInvoke(obj, 'foobar'), false);
  });
});
enifed('ember-metal/tests/utils/can_invoke_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests/utils');
  test('ember-metal/tests/utils/can_invoke_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/utils/can_invoke_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/utils/can_invoke_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests/utils');
  QUnit.test('ember-metal/tests/utils/can_invoke_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/utils/can_invoke_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/utils/generate_guid_test', ['exports', 'ember-metal/utils'], function (exports, _emberMetalUtils) {
  'use strict';

  QUnit.module('Ember.generateGuid');

  QUnit.test('Prefix', function () {
    var a = {};

    ok(_emberMetalUtils.generateGuid(a, 'tyrell').indexOf('tyrell') > -1, 'guid can be prefixed');
  });
});
enifed('ember-metal/tests/utils/generate_guid_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests/utils');
  test('ember-metal/tests/utils/generate_guid_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/utils/generate_guid_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/utils/generate_guid_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests/utils');
  QUnit.test('ember-metal/tests/utils/generate_guid_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/utils/generate_guid_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/utils/guid_for_test', ['exports', 'ember-metal/utils'], function (exports, _emberMetalUtils) {
  'use strict';

  QUnit.module('guidFor');

  var sameGuid = function (a, b, message) {
    equal(_emberMetalUtils.guidFor(a), _emberMetalUtils.guidFor(b), message);
  };

  var diffGuid = function (a, b, message) {
    ok(_emberMetalUtils.guidFor(a) !== _emberMetalUtils.guidFor(b), message);
  };

  var nanGuid = function (obj) {
    var type = typeof obj;
    ok(isNaN(parseInt(_emberMetalUtils.guidFor(obj), 0)), 'guids for ' + type + 'don\'t parse to numbers');
  };

  QUnit.test('Object', function () {
    var a = {};
    var b = {};

    sameGuid(a, a, 'same object always yields same guid');
    diffGuid(a, b, 'different objects yield different guids');
    nanGuid(a);
  });

  QUnit.test('strings', function () {
    var a = 'string A';
    var aprime = 'string A';
    var b = 'String B';

    sameGuid(a, a, 'same string always yields same guid');
    sameGuid(a, aprime, 'identical strings always yield the same guid');
    diffGuid(a, b, 'different strings yield different guids');
    nanGuid(a);
  });

  QUnit.test('numbers', function () {
    var a = 23;
    var aprime = 23;
    var b = 34;

    sameGuid(a, a, 'same numbers always yields same guid');
    sameGuid(a, aprime, 'identical numbers always yield the same guid');
    diffGuid(a, b, 'different numbers yield different guids');
    nanGuid(a);
  });

  QUnit.test('numbers', function () {
    var a = true;
    var aprime = true;
    var b = false;

    sameGuid(a, a, 'same booleans always yields same guid');
    sameGuid(a, aprime, 'identical booleans always yield the same guid');
    diffGuid(a, b, 'different boolean yield different guids');
    nanGuid(a);
    nanGuid(b);
  });

  QUnit.test('null and undefined', function () {
    var a = null;
    var aprime = null;
    var b;

    sameGuid(a, a, 'null always returns the same guid');
    sameGuid(b, b, 'undefined always returns the same guid');
    sameGuid(a, aprime, 'different nulls return the same guid');
    diffGuid(a, b, 'null and undefined return different guids');
    nanGuid(a);
    nanGuid(b);
  });

  QUnit.test('arrays', function () {
    var a = ['a', 'b', 'c'];
    var aprime = ['a', 'b', 'c'];
    var b = ['1', '2', '3'];

    sameGuid(a, a, 'same instance always yields same guid');
    diffGuid(a, aprime, 'identical arrays always yield the same guid');
    diffGuid(a, b, 'different arrays yield different guids');
    nanGuid(a);
  });
});
enifed('ember-metal/tests/utils/guid_for_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests/utils');
  test('ember-metal/tests/utils/guid_for_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/utils/guid_for_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/utils/guid_for_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests/utils');
  QUnit.test('ember-metal/tests/utils/guid_for_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/utils/guid_for_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/utils/meta_test', ['exports', 'ember-metal/utils'], function (exports, _emberMetalUtils) {
  'use strict';

  QUnit.module('Ember.meta');

  QUnit.test('should return the same hash for an object', function () {
    var obj = {};

    _emberMetalUtils.meta(obj).foo = 'bar';

    equal(_emberMetalUtils.meta(obj).foo, 'bar', 'returns same hash with multiple calls to Ember.meta()');
  });

  QUnit.module('Ember.meta enumerable');

  QUnit.test('meta is not enumerable', function () {
    var proto, obj, props, prop;
    proto = { foo: 'bar' };
    _emberMetalUtils.meta(proto);
    obj = Object.create(proto);
    _emberMetalUtils.meta(obj);
    obj.bar = 'baz';
    props = [];
    for (prop in obj) {
      props.push(prop);
    }
    deepEqual(props.sort(), ['bar', 'foo']);
    if (typeof JSON !== 'undefined' && 'stringify' in JSON) {
      try {
        JSON.stringify(obj);
      } catch (e) {
        ok(false, 'meta should not fail JSON.stringify');
      }
    }
  });

  QUnit.test('meta is not enumerable', function () {
    var proto, obj, props, prop;
    proto = { foo: 'bar' };
    _emberMetalUtils.meta(proto);
    obj = Object.create(proto);
    _emberMetalUtils.meta(obj);
    obj.bar = 'baz';
    props = [];
    for (prop in obj) {
      props.push(prop);
    }
    deepEqual(props.sort(), ['bar', 'foo']);
    if (typeof JSON !== 'undefined' && 'stringify' in JSON) {
      try {
        JSON.stringify(obj);
      } catch (e) {
        ok(false, 'meta should not fail JSON.stringify');
      }
    }
  });
});
enifed('ember-metal/tests/utils/meta_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests/utils');
  test('ember-metal/tests/utils/meta_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/utils/meta_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/utils/meta_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests/utils');
  QUnit.test('ember-metal/tests/utils/meta_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/utils/meta_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/utils/try_invoke_test', ['exports', 'ember-metal/utils'], function (exports, _emberMetalUtils) {
  'use strict';

  var obj;

  QUnit.module('Ember.tryInvoke', {
    setup: function () {
      obj = {
        aMethodThatExists: function () {
          return true;
        },
        aMethodThatTakesArguments: function (arg1, arg2) {
          return arg1 === arg2;
        }
      };
    },

    teardown: function () {
      obj = undefined;
    }
  });

  QUnit.test('should return undefined when the object doesn\'t exist', function () {
    equal(_emberMetalUtils.tryInvoke(undefined, 'aMethodThatDoesNotExist'), undefined);
  });

  QUnit.test('should return undefined when asked to perform a method that doesn\'t exist on the object', function () {
    equal(_emberMetalUtils.tryInvoke(obj, 'aMethodThatDoesNotExist'), undefined);
  });

  QUnit.test('should return what the method returns when asked to perform a method that exists on the object', function () {
    equal(_emberMetalUtils.tryInvoke(obj, 'aMethodThatExists'), true);
  });

  QUnit.test('should return what the method returns when asked to perform a method that takes arguments and exists on the object', function () {
    equal(_emberMetalUtils.tryInvoke(obj, 'aMethodThatTakesArguments', [true, true]), true);
  });
});
enifed('ember-metal/tests/utils/try_invoke_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests/utils');
  test('ember-metal/tests/utils/try_invoke_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/utils/try_invoke_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/utils/try_invoke_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests/utils');
  QUnit.test('ember-metal/tests/utils/try_invoke_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/utils/try_invoke_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/utils_test', ['exports', 'ember-metal/utils'], function (exports, _emberMetalUtils) {
  'use strict';

  QUnit.module('Ember Metal Utils');

  QUnit.test('inspect outputs the toString() representation of Symbols', function () {
    // Symbol is not defined on pre-ES2015 runtimes, so this let's us safely test
    // for it's existence (where a simple `if (Symbol)` would ReferenceError)
    var Symbol = Symbol || null;

    if (Symbol) {
      var symbol = Symbol('test');
      equal(_emberMetalUtils.inspect(symbol), 'Symbol(test)');
    } else {
      expect(0);
    }
  });
});
enifed('ember-metal/tests/utils_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests');
  test('ember-metal/tests/utils_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/utils_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/utils_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests');
  QUnit.test('ember-metal/tests/utils_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/utils_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/watching/is_watching_test', ['exports', 'ember-metal/computed', 'ember-metal/property_get', 'ember-metal/properties', 'ember-metal/mixin', 'ember-metal/observer', 'ember-metal/watching'], function (exports, _emberMetalComputed, _emberMetalProperty_get, _emberMetalProperties, _emberMetalMixin, _emberMetalObserver, _emberMetalWatching) {
  'use strict';

  QUnit.module('isWatching');

  function testObserver(setup, teardown, key) {
    var obj = {};
    var fn = function () {};
    key = key || 'foo';

    equal(_emberMetalWatching.isWatching(obj, key), false, 'precond - isWatching is false by default');
    setup(obj, key, fn);
    equal(_emberMetalWatching.isWatching(obj, key), true, 'isWatching is true when observers are added');
    teardown(obj, key, fn);
    equal(_emberMetalWatching.isWatching(obj, key), false, 'isWatching is false after observers are removed');
  }

  QUnit.test('isWatching is true for regular local observers', function () {
    testObserver(function (obj, key, fn) {
      _emberMetalMixin.Mixin.create({
        didChange: _emberMetalMixin.observer(key, fn)
      }).apply(obj);
    }, function (obj, key, fn) {
      _emberMetalObserver.removeObserver(obj, key, obj, fn);
    });
  });

  QUnit.test('isWatching is true for nonlocal observers', function () {
    testObserver(function (obj, key, fn) {
      _emberMetalObserver.addObserver(obj, key, obj, fn);
    }, function (obj, key, fn) {
      _emberMetalObserver.removeObserver(obj, key, obj, fn);
    });
  });

  QUnit.test('isWatching is true for chained observers', function () {
    testObserver(function (obj, key, fn) {
      _emberMetalObserver.addObserver(obj, key + '.bar', obj, fn);
    }, function (obj, key, fn) {
      _emberMetalObserver.removeObserver(obj, key + '.bar', obj, fn);
    });
  });

  QUnit.test('isWatching is true for computed properties', function () {
    testObserver(function (obj, key, fn) {
      _emberMetalProperties.defineProperty(obj, 'computed', _emberMetalComputed.computed(fn).property(key));
      _emberMetalProperty_get.get(obj, 'computed');
    }, function (obj, key, fn) {
      _emberMetalProperties.defineProperty(obj, 'computed', null);
    });
  });

  QUnit.test('isWatching is true for chained computed properties', function () {
    testObserver(function (obj, key, fn) {
      _emberMetalProperties.defineProperty(obj, 'computed', _emberMetalComputed.computed(fn).property(key + '.bar'));
      _emberMetalProperty_get.get(obj, 'computed');
    }, function (obj, key, fn) {
      _emberMetalProperties.defineProperty(obj, 'computed', null);
    });
  });

  // can't watch length on Array - it is special...
  // But you should be able to watch a length property of an object
  QUnit.test('isWatching is true for \'length\' property on object', function () {
    testObserver(function (obj, key, fn) {
      _emberMetalProperties.defineProperty(obj, 'length', null, '26.2 miles');
      _emberMetalObserver.addObserver(obj, 'length', obj, fn);
    }, function (obj, key, fn) {
      _emberMetalObserver.removeObserver(obj, 'length', obj, fn);
    }, 'length');
  });
});
enifed('ember-metal/tests/watching/is_watching_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests/watching');
  test('ember-metal/tests/watching/is_watching_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/watching/is_watching_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/watching/is_watching_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests/watching');
  QUnit.test('ember-metal/tests/watching/is_watching_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/watching/is_watching_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/watching/unwatch_test', ['exports', 'ember-metal/tests/props_helper', 'ember-metal/watching', 'ember-metal/properties', 'ember-metal/events', 'ember-metal/computed', 'ember-metal/property_set'], function (exports, _emberMetalTestsProps_helper, _emberMetalWatching, _emberMetalProperties, _emberMetalEvents, _emberMetalComputed, _emberMetalProperty_set) {
  'use strict';

  var willCount, didCount;

  QUnit.module('unwatch', {
    setup: function () {
      willCount = didCount = 0;
    }
  });

  function addListeners(obj, keyPath) {
    _emberMetalEvents.addListener(obj, keyPath + ':before', function () {
      willCount++;
    });
    _emberMetalEvents.addListener(obj, keyPath + ':change', function () {
      didCount++;
    });
  }

  _emberMetalTestsProps_helper.testBoth('unwatching a computed property - regular get/set', function (get, set) {

    var obj = {};
    _emberMetalProperties.defineProperty(obj, 'foo', _emberMetalComputed.computed({
      get: function () {
        return this.__foo;
      },
      set: function (keyName, value) {
        this.__foo = value;
        return this.__foo;
      }
    }));
    addListeners(obj, 'foo');

    _emberMetalWatching.watch(obj, 'foo');
    set(obj, 'foo', 'bar');
    equal(willCount, 1, 'should have invoked willCount');
    equal(didCount, 1, 'should have invoked didCount');

    _emberMetalWatching.unwatch(obj, 'foo');
    willCount = didCount = 0;
    set(obj, 'foo', 'BAZ');
    equal(willCount, 0, 'should NOT have invoked willCount');
    equal(didCount, 0, 'should NOT have invoked didCount');
  });

  _emberMetalTestsProps_helper.testBoth('unwatching a regular property - regular get/set', function (get, set) {

    var obj = { foo: 'BIFF' };
    addListeners(obj, 'foo');

    _emberMetalWatching.watch(obj, 'foo');
    set(obj, 'foo', 'bar');
    equal(willCount, 1, 'should have invoked willCount');
    equal(didCount, 1, 'should have invoked didCount');

    _emberMetalWatching.unwatch(obj, 'foo');
    willCount = didCount = 0;
    set(obj, 'foo', 'BAZ');
    equal(willCount, 0, 'should NOT have invoked willCount');
    equal(didCount, 0, 'should NOT have invoked didCount');
  });

  QUnit.test('unwatching should be nested', function () {

    var obj = { foo: 'BIFF' };
    addListeners(obj, 'foo');

    _emberMetalWatching.watch(obj, 'foo');
    _emberMetalWatching.watch(obj, 'foo');
    _emberMetalProperty_set.set(obj, 'foo', 'bar');
    equal(willCount, 1, 'should have invoked willCount');
    equal(didCount, 1, 'should have invoked didCount');

    _emberMetalWatching.unwatch(obj, 'foo');
    willCount = didCount = 0;
    _emberMetalProperty_set.set(obj, 'foo', 'BAZ');
    equal(willCount, 1, 'should NOT have invoked willCount');
    equal(didCount, 1, 'should NOT have invoked didCount');

    _emberMetalWatching.unwatch(obj, 'foo');
    willCount = didCount = 0;
    _emberMetalProperty_set.set(obj, 'foo', 'BAZ');
    equal(willCount, 0, 'should NOT have invoked willCount');
    equal(didCount, 0, 'should NOT have invoked didCount');
  });

  _emberMetalTestsProps_helper.testBoth('unwatching "length" property on an object', function (get, set) {

    var obj = { foo: 'RUN' };
    addListeners(obj, 'length');

    // Can watch length when it is undefined
    _emberMetalWatching.watch(obj, 'length');
    set(obj, 'length', '10k');
    equal(willCount, 1, 'should have invoked willCount');
    equal(didCount, 1, 'should have invoked didCount');

    // Should stop watching despite length now being defined (making object 'array-like')
    _emberMetalWatching.unwatch(obj, 'length');
    willCount = didCount = 0;
    set(obj, 'length', '5k');
    equal(willCount, 0, 'should NOT have invoked willCount');
    equal(didCount, 0, 'should NOT have invoked didCount');
  });
});
enifed('ember-metal/tests/watching/unwatch_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests/watching');
  test('ember-metal/tests/watching/unwatch_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/watching/unwatch_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/watching/unwatch_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests/watching');
  QUnit.test('ember-metal/tests/watching/unwatch_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/watching/unwatch_test.js should pass jshint.');
  });
});
enifed('ember-metal/tests/watching/watch_test', ['exports', 'ember-metal/core', 'ember-metal/tests/props_helper', 'ember-metal/events', 'ember-metal/watching'], function (exports, _emberMetalCore, _emberMetalTestsProps_helper, _emberMetalEvents, _emberMetalWatching) {
  'use strict';

  var willCount, didCount, willKeys, didKeys, originalLookup, lookup, Global;

  QUnit.module('watch', {
    setup: function () {
      willCount = didCount = 0;
      willKeys = [];
      didKeys = [];

      originalLookup = _emberMetalCore.default.lookup;
      _emberMetalCore.default.lookup = lookup = {};
    },

    teardown: function () {
      _emberMetalCore.default.lookup = originalLookup;
    }
  });

  function addListeners(obj, keyPath) {
    _emberMetalEvents.addListener(obj, keyPath + ':before', function () {
      willCount++;
      willKeys.push(keyPath);
    });
    _emberMetalEvents.addListener(obj, keyPath + ':change', function () {
      didCount++;
      didKeys.push(keyPath);
    });
  }

  _emberMetalTestsProps_helper.testBoth('watching a computed property', function (get, set) {
    var obj = {};
    _emberMetalCore.default.defineProperty(obj, 'foo', _emberMetalCore.default.computed({
      get: function () {
        return this.__foo;
      },
      set: function (keyName, value) {
        if (value !== undefined) {
          this.__foo = value;
        }
        return this.__foo;
      }
    }));
    addListeners(obj, 'foo');

    _emberMetalWatching.watch(obj, 'foo');
    set(obj, 'foo', 'bar');
    equal(willCount, 1, 'should have invoked willCount');
    equal(didCount, 1, 'should have invoked didCount');
  });

  _emberMetalTestsProps_helper.testBoth('watching a regular defined property', function (get, set) {
    var obj = { foo: 'baz' };
    addListeners(obj, 'foo');

    _emberMetalWatching.watch(obj, 'foo');
    equal(get(obj, 'foo'), 'baz', 'should have original prop');

    set(obj, 'foo', 'bar');
    equal(willCount, 1, 'should have invoked willCount');
    equal(didCount, 1, 'should have invoked didCount');

    equal(get(obj, 'foo'), 'bar', 'should get new value');
    equal(obj.foo, 'bar', 'property should be accessible on obj');
  });

  _emberMetalTestsProps_helper.testBoth('watching a regular undefined property', function (get, set) {
    var obj = {};
    addListeners(obj, 'foo');

    _emberMetalWatching.watch(obj, 'foo');

    equal('foo' in obj, false, 'precond undefined');

    set(obj, 'foo', 'bar');

    equal(willCount, 1, 'should have invoked willCount');
    equal(didCount, 1, 'should have invoked didCount');

    equal(get(obj, 'foo'), 'bar', 'should get new value');
    equal(obj.foo, 'bar', 'property should be accessible on obj');
  });

  _emberMetalTestsProps_helper.testBoth('watches should inherit', function (get, set) {
    var obj = { foo: 'baz' };
    var objB = Object.create(obj);

    addListeners(obj, 'foo');
    _emberMetalWatching.watch(obj, 'foo');
    equal(get(obj, 'foo'), 'baz', 'should have original prop');

    set(obj, 'foo', 'bar');
    set(objB, 'foo', 'baz');
    equal(willCount, 2, 'should have invoked willCount once only');
    equal(didCount, 2, 'should have invoked didCount once only');
  });

  QUnit.test('watching an object THEN defining it should work also', function () {
    var obj = {};
    addListeners(obj, 'foo');

    _emberMetalWatching.watch(obj, 'foo');

    _emberMetalCore.default.defineProperty(obj, 'foo');
    _emberMetalCore.default.set(obj, 'foo', 'bar');

    equal(_emberMetalCore.default.get(obj, 'foo'), 'bar', 'should have set');
    equal(willCount, 1, 'should have invoked willChange once');
    equal(didCount, 1, 'should have invoked didChange once');
  });

  QUnit.test('watching a chain then defining the property', function () {
    var obj = {};
    var foo = { bar: 'bar' };
    addListeners(obj, 'foo.bar');
    addListeners(foo, 'bar');

    _emberMetalWatching.watch(obj, 'foo.bar');

    _emberMetalCore.default.defineProperty(obj, 'foo', undefined, foo);
    _emberMetalCore.default.set(foo, 'bar', 'baz');

    deepEqual(willKeys, ['foo.bar', 'bar'], 'should have invoked willChange with bar, foo.bar');
    deepEqual(didKeys, ['foo.bar', 'bar'], 'should have invoked didChange with bar, foo.bar');
    equal(willCount, 2, 'should have invoked willChange twice');
    equal(didCount, 2, 'should have invoked didChange twice');
  });

  QUnit.test('watching a chain then defining the nested property', function () {
    var bar = {};
    var obj = { foo: bar };
    var baz = { baz: 'baz' };
    addListeners(obj, 'foo.bar.baz');
    addListeners(baz, 'baz');

    _emberMetalWatching.watch(obj, 'foo.bar.baz');

    _emberMetalCore.default.defineProperty(bar, 'bar', undefined, baz);
    _emberMetalCore.default.set(baz, 'baz', 'BOO');

    deepEqual(willKeys, ['foo.bar.baz', 'baz'], 'should have invoked willChange with bar, foo.bar');
    deepEqual(didKeys, ['foo.bar.baz', 'baz'], 'should have invoked didChange with bar, foo.bar');
    equal(willCount, 2, 'should have invoked willChange twice');
    equal(didCount, 2, 'should have invoked didChange twice');
  });

  _emberMetalTestsProps_helper.testBoth('watching an object value then unwatching should restore old value', function (get, set) {
    var obj = { foo: { bar: { baz: { biff: 'BIFF' } } } };
    addListeners(obj, 'foo.bar.baz.biff');

    _emberMetalWatching.watch(obj, 'foo.bar.baz.biff');

    var foo = _emberMetalCore.default.get(obj, 'foo');
    equal(get(get(get(foo, 'bar'), 'baz'), 'biff'), 'BIFF', 'biff should exist');

    _emberMetalWatching.unwatch(obj, 'foo.bar.baz.biff');
    equal(get(get(get(foo, 'bar'), 'baz'), 'biff'), 'BIFF', 'biff should exist');
  });

  _emberMetalTestsProps_helper.testBoth('watching a global object that does not yet exist should queue', function (get, set) {
    lookup['Global'] = Global = null;

    var obj = {};
    addListeners(obj, 'Global.foo');

    _emberMetalWatching.watch(obj, 'Global.foo'); // only works on global chained props

    equal(willCount, 0, 'should not have fired yet');
    equal(didCount, 0, 'should not have fired yet');

    lookup['Global'] = Global = { foo: 'bar' };
    addListeners(Global, 'foo');

    _emberMetalWatching.watch.flushPending(); // this will also be invoked automatically on ready

    equal(willCount, 0, 'should not have fired yet');
    equal(didCount, 0, 'should not have fired yet');

    set(Global, 'foo', 'baz');

    // should fire twice because this is a chained property (once on key, once
    // on path)
    equal(willCount, 2, 'should be watching');
    equal(didCount, 2, 'should be watching');

    lookup['Global'] = Global = null; // reset
  });

  QUnit.test('when watching a global object, destroy should remove chain watchers from the global object', function () {
    lookup['Global'] = Global = { foo: 'bar' };
    var obj = {};
    addListeners(obj, 'Global.foo');

    _emberMetalWatching.watch(obj, 'Global.foo');

    var meta_Global = _emberMetalCore.default.meta(Global);
    var chainNode = _emberMetalCore.default.meta(obj).chains._chains.Global._chains.foo;

    equal(meta_Global.watching.foo, 1, 'should be watching foo');
    equal(meta_Global.chainWatchers.has('foo', chainNode), true, 'should have chain watcher');

    _emberMetalWatching.destroy(obj);

    equal(meta_Global.watching.foo, 0, 'should not be watching foo');
    equal(meta_Global.chainWatchers.has('foo', chainNode), false, 'should not have chain watcher');

    lookup['Global'] = Global = null; // reset
  });

  QUnit.test('when watching another object, destroy should remove chain watchers from the other object', function () {
    var objA = {};
    var objB = { foo: 'bar' };
    objA.b = objB;
    addListeners(objA, 'b.foo');

    _emberMetalWatching.watch(objA, 'b.foo');

    var meta_objB = _emberMetalCore.default.meta(objB);
    var chainNode = _emberMetalCore.default.meta(objA).chains._chains.b._chains.foo;

    equal(meta_objB.watching.foo, 1, 'should be watching foo');
    equal(meta_objB.chainWatchers.has('foo', chainNode), true, 'should have chain watcher');

    _emberMetalWatching.destroy(objA);

    equal(meta_objB.watching.foo, 0, 'should not be watching foo');
    equal(meta_objB.chainWatchers.has('foo', chainNode), false, 'should not have chain watcher');
  });

  // TESTS for length property

  _emberMetalTestsProps_helper.testBoth('watching "length" property on an object', function (get, set) {
    var obj = { length: '26.2 miles' };
    addListeners(obj, 'length');

    _emberMetalWatching.watch(obj, 'length');
    equal(get(obj, 'length'), '26.2 miles', 'should have original prop');

    set(obj, 'length', '10k');
    equal(willCount, 1, 'should have invoked willCount');
    equal(didCount, 1, 'should have invoked didCount');

    equal(get(obj, 'length'), '10k', 'should get new value');
    equal(obj.length, '10k', 'property should be accessible on obj');
  });

  _emberMetalTestsProps_helper.testBoth('watching "length" property on an array', function (get, set) {
    var arr = [];
    addListeners(arr, 'length');

    _emberMetalWatching.watch(arr, 'length');
    equal(get(arr, 'length'), 0, 'should have original prop');

    set(arr, 'length', '10');
    equal(willCount, 0, 'should NOT have invoked willCount');
    equal(didCount, 0, 'should NOT have invoked didCount');

    equal(get(arr, 'length'), 10, 'should get new value');
    equal(arr.length, 10, 'property should be accessible on arr');
  });
});
enifed('ember-metal/tests/watching/watch_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal/tests/watching');
  test('ember-metal/tests/watching/watch_test.js should pass jscs', function () {
    ok(true, 'ember-metal/tests/watching/watch_test.js should pass jscs.');
  });
});
enifed('ember-metal/tests/watching/watch_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal/tests/watching');
  QUnit.test('ember-metal/tests/watching/watch_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/tests/watching/watch_test.js should pass jshint.');
  });
});
enifed('ember-metal/utils.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal');
  test('ember-metal/utils.js should pass jscs', function () {
    ok(true, 'ember-metal/utils.js should pass jscs.');
  });
});
enifed('ember-metal/utils.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal');
  QUnit.test('ember-metal/utils.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/utils.js should pass jshint.');
  });
});
enifed('ember-metal/watch_key.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal');
  test('ember-metal/watch_key.js should pass jscs', function () {
    ok(true, 'ember-metal/watch_key.js should pass jscs.');
  });
});
enifed('ember-metal/watch_key.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal');
  QUnit.test('ember-metal/watch_key.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/watch_key.js should pass jshint.');
  });
});
enifed('ember-metal/watch_path.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal');
  test('ember-metal/watch_path.js should pass jscs', function () {
    ok(true, 'ember-metal/watch_path.js should pass jscs.');
  });
});
enifed('ember-metal/watch_path.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal');
  QUnit.test('ember-metal/watch_path.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/watch_path.js should pass jshint.');
  });
});
enifed('ember-metal/watching.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-metal');
  test('ember-metal/watching.js should pass jscs', function () {
    ok(true, 'ember-metal/watching.js should pass jscs.');
  });
});
enifed('ember-metal/watching.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-metal');
  QUnit.test('ember-metal/watching.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-metal/watching.js should pass jshint.');
  });
});
enifed('ember-routing-htmlbars.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - .');
  test('ember-routing-htmlbars.js should pass jscs', function () {
    ok(true, 'ember-routing-htmlbars.js should pass jscs.');
  });
});
enifed('ember-routing-htmlbars.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - .');
  QUnit.test('ember-routing-htmlbars.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-routing-htmlbars.js should pass jshint.');
  });
});
enifed('ember-routing-htmlbars/helpers/query-params.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-routing-htmlbars/helpers');
  test('ember-routing-htmlbars/helpers/query-params.js should pass jscs', function () {
    ok(true, 'ember-routing-htmlbars/helpers/query-params.js should pass jscs.');
  });
});
enifed('ember-routing-htmlbars/helpers/query-params.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-routing-htmlbars/helpers');
  QUnit.test('ember-routing-htmlbars/helpers/query-params.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-routing-htmlbars/helpers/query-params.js should pass jshint.');
  });
});
enifed('ember-routing-htmlbars/keywords/action.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-routing-htmlbars/keywords');
  test('ember-routing-htmlbars/keywords/action.js should pass jscs', function () {
    ok(true, 'ember-routing-htmlbars/keywords/action.js should pass jscs.');
  });
});
enifed('ember-routing-htmlbars/keywords/action.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-routing-htmlbars/keywords');
  QUnit.test('ember-routing-htmlbars/keywords/action.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-routing-htmlbars/keywords/action.js should pass jshint.');
  });
});
enifed('ember-routing-htmlbars/keywords/closure-action.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-routing-htmlbars/keywords');
  test('ember-routing-htmlbars/keywords/closure-action.js should pass jscs', function () {
    ok(true, 'ember-routing-htmlbars/keywords/closure-action.js should pass jscs.');
  });
});
enifed('ember-routing-htmlbars/keywords/closure-action.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-routing-htmlbars/keywords');
  QUnit.test('ember-routing-htmlbars/keywords/closure-action.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-routing-htmlbars/keywords/closure-action.js should pass jshint.');
  });
});
enifed('ember-routing-htmlbars/keywords/element-action.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-routing-htmlbars/keywords');
  test('ember-routing-htmlbars/keywords/element-action.js should pass jscs', function () {
    ok(true, 'ember-routing-htmlbars/keywords/element-action.js should pass jscs.');
  });
});
enifed('ember-routing-htmlbars/keywords/element-action.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-routing-htmlbars/keywords');
  QUnit.test('ember-routing-htmlbars/keywords/element-action.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-routing-htmlbars/keywords/element-action.js should pass jshint.');
  });
});
enifed('ember-routing-htmlbars/keywords/link-to.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-routing-htmlbars/keywords');
  test('ember-routing-htmlbars/keywords/link-to.js should pass jscs', function () {
    ok(true, 'ember-routing-htmlbars/keywords/link-to.js should pass jscs.');
  });
});
enifed('ember-routing-htmlbars/keywords/link-to.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-routing-htmlbars/keywords');
  QUnit.test('ember-routing-htmlbars/keywords/link-to.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-routing-htmlbars/keywords/link-to.js should pass jshint.');
  });
});
enifed('ember-routing-htmlbars/keywords/render.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-routing-htmlbars/keywords');
  test('ember-routing-htmlbars/keywords/render.js should pass jscs', function () {
    ok(true, 'ember-routing-htmlbars/keywords/render.js should pass jscs.');
  });
});
enifed('ember-routing-htmlbars/keywords/render.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-routing-htmlbars/keywords');
  QUnit.test('ember-routing-htmlbars/keywords/render.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-routing-htmlbars/keywords/render.js should pass jshint.');
  });
});
enifed('ember-routing-htmlbars/tests/helpers/closure_action_test', ['exports', 'ember-metal/features', 'ember-metal/run_loop', 'ember-template-compiler/system/compile', 'ember-views/views/component', 'ember-metal/computed', 'ember-runtime/tests/utils', 'ember-htmlbars/tests/utils', 'ember-htmlbars/keywords/view'], function (exports, _emberMetalFeatures, _emberMetalRun_loop, _emberTemplateCompilerSystemCompile, _emberViewsViewsComponent, _emberMetalComputed, _emberRuntimeTestsUtils, _emberHtmlbarsTestsUtils, _emberHtmlbarsKeywordsView) {
  'use strict';

  var innerComponent, outerComponent, originalViewKeyword;

  QUnit.module('ember-routing-htmlbars: action helper', {
    setup: function () {
      originalViewKeyword = _emberHtmlbarsTestsUtils.registerKeyword('view', _emberHtmlbarsKeywordsView.default);
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(innerComponent);
      _emberRuntimeTestsUtils.runDestroy(outerComponent);
      _emberHtmlbarsTestsUtils.resetKeyword('view', originalViewKeyword);
    }
  });

  QUnit.test('action should be called', function (assert) {
    assert.expect(1);

    innerComponent = _emberViewsViewsComponent.default.extend({
      fireAction: function () {
        this.attrs.submit();
      }
    }).create();

    outerComponent = _emberViewsViewsComponent.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('{{view innerComponent submit=(action outerSubmit)}}'),
      innerComponent: innerComponent,
      outerSubmit: function () {
        assert.ok(true, 'action is called');
      }
    }).create();

    _emberRuntimeTestsUtils.runAppend(outerComponent);

    _emberMetalRun_loop.default(function () {
      innerComponent.fireAction();
    });
  });

  QUnit.test('action value is returned', function (assert) {
    assert.expect(1);

    var returnedValue = 'terrible tom';

    innerComponent = _emberViewsViewsComponent.default.extend({
      fireAction: function () {
        var actualReturnedValue = this.attrs.submit();
        assert.equal(actualReturnedValue, returnedValue, 'action can return to caller');
      }
    }).create();

    outerComponent = _emberViewsViewsComponent.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('{{view innerComponent submit=(action outerSubmit)}}'),
      innerComponent: innerComponent,
      outerSubmit: function () {
        return returnedValue;
      }
    }).create();

    _emberRuntimeTestsUtils.runAppend(outerComponent);

    _emberMetalRun_loop.default(function () {
      innerComponent.fireAction();
    });
  });

  QUnit.test('action should be called on the correct scope', function (assert) {
    assert.expect(1);

    innerComponent = _emberViewsViewsComponent.default.extend({
      fireAction: function () {
        this.attrs.submit();
      }
    }).create();

    outerComponent = _emberViewsViewsComponent.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('{{view innerComponent submit=(action outerSubmit)}}'),
      innerComponent: innerComponent,
      isOuterComponent: true,
      outerSubmit: function () {
        assert.ok(this.isOuterComponent, 'action has the correct context');
      }
    }).create();

    _emberRuntimeTestsUtils.runAppend(outerComponent);

    _emberMetalRun_loop.default(function () {
      innerComponent.fireAction();
    });
  });

  QUnit.test('arguments to action are passed, curry', function (assert) {
    assert.expect(4);

    var first = 'mitch';
    var second = 'martin';
    var third = 'matt';
    var fourth = 'wacky wycats';

    innerComponent = _emberViewsViewsComponent.default.extend({
      fireAction: function () {
        this.attrs.submit(fourth);
      }
    }).create();

    outerComponent = _emberViewsViewsComponent.default.extend({
      third: third,
      layout: _emberTemplateCompilerSystemCompile.default('\n        {{view innerComponent submit=(action (action outerSubmit "' + first + '") "' + second + '" third)}}\n      '),
      innerComponent: innerComponent,
      outerSubmit: function (actualFirst, actualSecond, actualThird, actualFourth) {
        assert.equal(actualFirst, first, 'action has the correct first arg');
        assert.equal(actualSecond, second, 'action has the correct second arg');
        assert.equal(actualThird, third, 'action has the correct third arg');
        assert.equal(actualFourth, fourth, 'action has the correct fourth arg');
      }
    }).create();

    _emberRuntimeTestsUtils.runAppend(outerComponent);

    _emberMetalRun_loop.default(function () {
      innerComponent.fireAction();
    });
  });

  QUnit.test('arguments to action are bound', function (assert) {
    assert.expect(1);

    var value = 'lazy leah';

    innerComponent = _emberViewsViewsComponent.default.extend({
      fireAction: function () {
        this.attrs.submit();
      }
    }).create();

    outerComponent = _emberViewsViewsComponent.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('\n        {{view innerComponent submit=(action outerSubmit value)}}\n      '),
      innerComponent: innerComponent,
      value: '',
      outerSubmit: function (actualValue) {
        assert.equal(actualValue, value, 'action has the correct first arg');
      }
    }).create();

    _emberRuntimeTestsUtils.runAppend(outerComponent);

    _emberMetalRun_loop.default(function () {
      outerComponent.set('value', value);
    });

    innerComponent.fireAction();
  });

  QUnit.test('array arguments are passed correctly to action', function (assert) {
    assert.expect(3);

    var first = 'foo';
    var second = [3, 5];
    var third = [4, 9];

    innerComponent = _emberViewsViewsComponent.default.extend({
      fireAction: function () {
        this.attrs.submit(second, third);
      }
    }).create();

    outerComponent = _emberViewsViewsComponent.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('\n        {{view innerComponent submit=(action outerSubmit first)}}\n      '),
      innerComponent: innerComponent,
      value: '',
      outerSubmit: function (actualFirst, actualSecond, actualThird) {
        assert.equal(actualFirst, first, 'action has the correct first arg');
        assert.equal(actualSecond, second, 'action has the correct second arg');
        assert.equal(actualThird, third, 'action has the correct third arg');
      }
    }).create();

    _emberRuntimeTestsUtils.runAppend(outerComponent);

    _emberMetalRun_loop.default(function () {
      outerComponent.set('first', first);
      outerComponent.set('second', second);
    });

    innerComponent.fireAction();
  });

  QUnit.test('mut values can be wrapped in actions, are settable', function (assert) {
    assert.expect(1);

    var newValue = 'trollin trek';

    innerComponent = _emberViewsViewsComponent.default.extend({
      fireAction: function () {
        this.attrs.submit(newValue);
      }
    }).create();

    outerComponent = _emberViewsViewsComponent.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('\n        {{view innerComponent submit=(action (mut outerMut))}}\n      '),
      innerComponent: innerComponent,
      outerMut: 'patient peter'
    }).create();

    _emberRuntimeTestsUtils.runAppend(outerComponent);

    _emberMetalRun_loop.default(function () {
      innerComponent.fireAction();
      assert.equal(outerComponent.get('outerMut'), newValue, 'mut value is set');
    });
  });

  QUnit.test('mut values can be wrapped in actions, are settable with a curry', function (assert) {
    assert.expect(1);

    var newValue = 'trollin trek';

    innerComponent = _emberViewsViewsComponent.default.extend({
      fireAction: function () {
        this.attrs.submit();
      }
    }).create();

    outerComponent = _emberViewsViewsComponent.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('\n        {{view innerComponent submit=(action (mut outerMut) \'' + newValue + '\')}}\n      '),
      innerComponent: innerComponent,
      outerMut: 'patient peter'
    }).create();

    _emberRuntimeTestsUtils.runAppend(outerComponent);

    _emberMetalRun_loop.default(function () {
      innerComponent.fireAction();
      assert.equal(outerComponent.get('outerMut'), newValue, 'mut value is set');
    });
  });

  QUnit.test('action can create closures over actions', function (assert) {
    assert.expect(3);

    var first = 'raging robert';
    var second = 'mild machty';
    var returnValue = 'butch brian';

    innerComponent = _emberViewsViewsComponent.default.extend({
      fireAction: function () {
        var actualReturnedValue = this.attrs.submit(second);
        assert.equal(actualReturnedValue, returnValue, 'return value is present');
      }
    }).create();

    outerComponent = _emberViewsViewsComponent.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('\n        {{view innerComponent submit=(action \'outerAction\' \'' + first + '\')}}\n      '),
      innerComponent: innerComponent,
      actions: {
        outerAction: function (actualFirst, actualSecond) {
          assert.equal(actualFirst, first, 'first argument is correct');
          assert.equal(actualSecond, second, 'second argument is correct');
          return returnValue;
        }
      }
    }).create();

    _emberRuntimeTestsUtils.runAppend(outerComponent);

    _emberMetalRun_loop.default(function () {
      innerComponent.fireAction();
    });
  });

  QUnit.test('provides a helpful error if an action is not present', function (assert) {
    assert.expect(1);

    innerComponent = _emberViewsViewsComponent.default.create();

    outerComponent = _emberViewsViewsComponent.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('\n        {{view innerComponent submit=(action \'doesNotExist\')}}\n      '),
      innerComponent: innerComponent,
      actions: {
        something: function () {
          // this is present to ensure `actions` hash is present
          // a different error is triggered if `actions` is missing
          // completely
        }
      }
    }).create();

    throws(function () {
      _emberRuntimeTestsUtils.runAppend(outerComponent);
    }, /An action named 'doesNotExist' was not found in /);
  });

  QUnit.test('provides a helpful error if actions hash is not present', function (assert) {
    assert.expect(1);

    innerComponent = _emberViewsViewsComponent.default.create();

    outerComponent = _emberViewsViewsComponent.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('\n        {{view innerComponent submit=(action \'doesNotExist\')}}\n      '),
      innerComponent: innerComponent
    }).create();

    throws(function () {
      _emberRuntimeTestsUtils.runAppend(outerComponent);
    }, /An action named 'doesNotExist' was not found in /);
  });

  QUnit.test('action can create closures over actions with target', function (assert) {
    assert.expect(1);

    innerComponent = _emberViewsViewsComponent.default.extend({
      fireAction: function () {
        this.attrs.submit();
      }
    }).create();

    outerComponent = _emberViewsViewsComponent.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('\n        {{view innerComponent submit=(action \'outerAction\' target=otherComponent)}}\n      '),
      innerComponent: innerComponent,
      otherComponent: _emberMetalComputed.computed(function () {
        return {
          actions: {
            outerAction: function (actualFirst, actualSecond) {
              assert.ok(true, 'action called on otherComponent');
            }
          }
        };
      })
    }).create();

    _emberRuntimeTestsUtils.runAppend(outerComponent);

    _emberMetalRun_loop.default(function () {
      innerComponent.fireAction();
    });
  });

  QUnit.test('value can be used with action over actions', function (assert) {
    assert.expect(1);

    var newValue = 'yelping yehuda';

    innerComponent = _emberViewsViewsComponent.default.extend({
      fireAction: function () {
        this.attrs.submit({
          readProp: newValue
        });
      }
    }).create();

    outerComponent = _emberViewsViewsComponent.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('\n        {{view innerComponent submit=(action \'outerAction\' value="readProp")}}\n      '),
      innerComponent: innerComponent,
      outerContent: {
        readProp: newValue
      },
      actions: {
        outerAction: function (actualValue) {
          assert.equal(actualValue, newValue, 'value is read');
        }
      }
    }).create();

    _emberRuntimeTestsUtils.runAppend(outerComponent);

    _emberMetalRun_loop.default(function () {
      innerComponent.fireAction();
    });
  });

  QUnit.test('action will read the value of a first property', function (assert) {
    assert.expect(1);

    var newValue = 'irate igor';

    innerComponent = _emberViewsViewsComponent.default.extend({
      fireAction: function () {
        this.attrs.submit({
          readProp: newValue
        });
      }
    }).create();

    outerComponent = _emberViewsViewsComponent.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('\n        {{view innerComponent submit=(action outerAction value="readProp")}}\n      '),
      innerComponent: innerComponent,
      outerAction: function (actualNewValue) {
        assert.equal(actualNewValue, newValue, 'property is read');
      }
    }).create();

    _emberRuntimeTestsUtils.runAppend(outerComponent);

    _emberMetalRun_loop.default(function () {
      innerComponent.fireAction();
    });
  });

  QUnit.test('action will read the value of a curried first argument property', function (assert) {
    assert.expect(1);

    var newValue = 'kissing kris';

    innerComponent = _emberViewsViewsComponent.default.extend({
      fireAction: function () {
        this.attrs.submit();
      }
    }).create();

    outerComponent = _emberViewsViewsComponent.default.extend({
      layout: _emberTemplateCompilerSystemCompile.default('\n        {{view innerComponent submit=(action outerAction objectArgument value="readProp")}}\n      '),
      innerComponent: innerComponent,
      objectArgument: {
        readProp: newValue
      },
      outerAction: function (actualNewValue) {
        assert.equal(actualNewValue, newValue, 'property is read');
      }
    }).create();

    _emberRuntimeTestsUtils.runAppend(outerComponent);

    _emberMetalRun_loop.default(function () {
      innerComponent.fireAction();
    });
  });

  QUnit.test('action closure does not get auto-mut wrapped', function (assert) {
    assert.expect(3);

    var first = 'raging robert';
    var second = 'mild machty';
    var returnValue = 'butch brian';

    innerComponent = _emberViewsViewsComponent.default.extend({
      middleComponent: middleComponent,

      fireAction: function () {
        var actualReturnedValue = this.attrs.submit(second);
        assert.equal(actualReturnedValue, returnValue, 'return value is present');
      }
    }).create();

    var middleComponent = _emberViewsViewsComponent.default.extend({
      innerComponent: innerComponent,

      layout: _emberTemplateCompilerSystemCompile.default('\n        {{view innerComponent submit=attrs.submit}}\n      ')
    }).create();

    outerComponent = _emberViewsViewsComponent.default.extend({
      middleComponent: middleComponent,

      layout: _emberTemplateCompilerSystemCompile.default('\n        {{view middleComponent submit=(action \'outerAction\' \'' + first + '\')}}\n      '),

      actions: {
        outerAction: function (actualFirst, actualSecond) {
          assert.equal(actualFirst, first, 'first argument is correct');
          assert.equal(actualSecond, second, 'second argument is correct');

          return returnValue;
        }
      }
    }).create();

    _emberRuntimeTestsUtils.runAppend(outerComponent);

    _emberMetalRun_loop.default(function () {
      innerComponent.fireAction();
    });
  });
});
enifed('ember-routing-htmlbars/tests/helpers/closure_action_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-routing-htmlbars/tests/helpers');
  test('ember-routing-htmlbars/tests/helpers/closure_action_test.js should pass jscs', function () {
    ok(true, 'ember-routing-htmlbars/tests/helpers/closure_action_test.js should pass jscs.');
  });
});
enifed('ember-routing-htmlbars/tests/helpers/closure_action_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-routing-htmlbars/tests/helpers');
  QUnit.test('ember-routing-htmlbars/tests/helpers/closure_action_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-routing-htmlbars/tests/helpers/closure_action_test.js should pass jshint.');
  });
});
enifed('ember-routing-htmlbars/tests/helpers/element_action_test', ['exports', 'ember-metal/core', 'ember-metal/features', 'ember-metal/property_set', 'ember-metal/run_loop', 'ember-views/system/event_dispatcher', 'ember-views/system/action_manager', 'ember-runtime/system/object', 'ember-runtime/controllers/controller', 'ember-template-compiler/system/compile', 'ember-views/views/view', 'ember-views/views/component', 'ember-views/system/jquery', 'ember-routing-htmlbars/keywords/element-action', 'ember-htmlbars/tests/utils', 'ember-htmlbars/keywords/view', 'ember-runtime/tests/utils'], function (exports, _emberMetalCore, _emberMetalFeatures, _emberMetalProperty_set, _emberMetalRun_loop, _emberViewsSystemEvent_dispatcher, _emberViewsSystemAction_manager, _emberRuntimeSystemObject, _emberRuntimeControllersController, _emberTemplateCompilerSystemCompile, _emberViewsViewsView, _emberViewsViewsComponent, _emberViewsSystemJquery, _emberRoutingHtmlbarsKeywordsElementAction, _emberHtmlbarsTestsUtils, _emberHtmlbarsKeywordsView, _emberRuntimeTestsUtils) {
  'use strict';

  var dispatcher, view, originalViewKeyword;
  var originalRegisterAction = _emberRoutingHtmlbarsKeywordsElementAction.ActionHelper.registerAction;

  QUnit.module('ember-routing-htmlbars: action helper', {
    setup: function () {
      originalViewKeyword = _emberHtmlbarsTestsUtils.registerKeyword('view', _emberHtmlbarsKeywordsView.default);
      dispatcher = _emberViewsSystemEvent_dispatcher.default.create();
      dispatcher.setup();
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(view);
      _emberRuntimeTestsUtils.runDestroy(dispatcher);
      _emberHtmlbarsTestsUtils.resetKeyword('view', originalViewKeyword);

      _emberRoutingHtmlbarsKeywordsElementAction.ActionHelper.registerAction = originalRegisterAction;
    }
  });

  QUnit.test('should output a data attribute with a guid', function () {
    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('<a href="#" {{action "edit"}}>edit</a>')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    ok(view.$('a').attr('data-ember-action').match(/\d+/), 'A data-ember-action attribute with a guid was added');
  });

  QUnit.test('should by default register a click event', function () {
    var registeredEventName;

    _emberRoutingHtmlbarsKeywordsElementAction.ActionHelper.registerAction = function (_ref) {
      var eventName = _ref.eventName;

      registeredEventName = eventName;
    };

    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('<a href="#" {{action "edit"}}>edit</a>')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(registeredEventName, 'click', 'The click event was properly registered');
  });

  QUnit.test('should allow alternative events to be handled', function () {
    var registeredEventName;

    _emberRoutingHtmlbarsKeywordsElementAction.ActionHelper.registerAction = function (_ref2) {
      var eventName = _ref2.eventName;

      registeredEventName = eventName;
    };

    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('<a href="#" {{action "edit" on="mouseUp"}}>edit</a>')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(registeredEventName, 'mouseUp', 'The alternative mouseUp event was properly registered');
  });

  QUnit.test('should by default target the view\'s controller', function () {
    var registeredTarget;
    var controller = {};

    _emberRoutingHtmlbarsKeywordsElementAction.ActionHelper.registerAction = function (_ref3) {
      var node = _ref3.node;

      registeredTarget = node.state.target;
    };

    view = _emberViewsViewsView.default.create({
      controller: controller,
      template: _emberTemplateCompilerSystemCompile.default('<a href="#" {{action "edit"}}>edit</a>')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(registeredTarget, controller, 'The controller was registered as the target');
  });

  QUnit.test('Inside a yield, the target points at the original target', function () {
    var watted = false;

    var component = _emberViewsViewsComponent.default.extend({
      boundText: 'inner',
      truthy: true,
      obj: {},
      layout: _emberTemplateCompilerSystemCompile.default('<div>{{boundText}}</div><div>{{#if truthy}}{{yield}}{{/if}}</div>')
    });

    view = _emberViewsViewsView.default.create({
      controller: {
        boundText: 'outer',
        truthy: true,
        wat: function () {
          watted = true;
        },
        component: component
      },
      template: _emberTemplateCompilerSystemCompile.default('{{#if truthy}}{{#view component}}{{#if truthy}}<div {{action "wat"}} class="wat">{{boundText}}</div>{{/if}}{{/view}}{{/if}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    _emberMetalRun_loop.default(function () {
      view.$('.wat').click();
    });

    equal(watted, true, 'The action was called on the right context');
  });

  QUnit.test('should allow a target to be specified', function () {
    var registeredTarget;

    _emberRoutingHtmlbarsKeywordsElementAction.ActionHelper.registerAction = function (_ref4) {
      var node = _ref4.node;

      registeredTarget = node.state.target;
    };

    var anotherTarget = _emberViewsViewsView.default.create();

    view = _emberViewsViewsView.default.create({
      controller: {},
      template: _emberTemplateCompilerSystemCompile.default('<a href="#" {{action "edit" target=view.anotherTarget}}>edit</a>'),
      anotherTarget: anotherTarget
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(registeredTarget, anotherTarget, 'The specified target was registered');

    _emberRuntimeTestsUtils.runDestroy(anotherTarget);
  });

  QUnit.test('should lazily evaluate the target', function () {
    var firstEdit = 0;
    var secondEdit = 0;
    var controller = {};
    var first = {
      edit: function () {
        firstEdit++;
      }
    };

    var second = {
      edit: function () {
        secondEdit++;
      }
    };

    controller.theTarget = first;

    view = _emberViewsViewsView.default.create({
      controller: controller,
      template: _emberTemplateCompilerSystemCompile.default('<a href="#" {{action "edit" target=theTarget}}>edit</a>')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    _emberMetalRun_loop.default(function () {
      _emberViewsSystemJquery.default('a').trigger('click');
    });

    equal(firstEdit, 1);

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(controller, 'theTarget', second);
    });

    _emberMetalRun_loop.default(function () {
      _emberViewsSystemJquery.default('a').trigger('click');
    });

    equal(firstEdit, 1);
    equal(secondEdit, 1);
  });

  QUnit.test('should register an event handler', function () {
    var eventHandlerWasCalled = false;

    var controller = _emberRuntimeControllersController.default.extend({
      actions: { edit: function () {
          eventHandlerWasCalled = true;
        } }
    }).create();

    view = _emberViewsViewsView.default.create({
      controller: controller,
      template: _emberTemplateCompilerSystemCompile.default('<a href="#" {{action "edit"}}>click me</a>')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    var actionId = view.$('a[data-ember-action]').attr('data-ember-action');

    ok(_emberViewsSystemAction_manager.default.registeredActions[actionId], 'The action was registered');

    view.$('a').trigger('click');

    ok(eventHandlerWasCalled, 'The event handler was called');
  });

  QUnit.test('handles whitelisted modifier keys', function () {
    var eventHandlerWasCalled = false;
    var shortcutHandlerWasCalled = false;

    var controller = _emberRuntimeControllersController.default.extend({
      actions: {
        edit: function () {
          eventHandlerWasCalled = true;
        },
        shortcut: function () {
          shortcutHandlerWasCalled = true;
        }
      }
    }).create();

    view = _emberViewsViewsView.default.create({
      controller: controller,
      template: _emberTemplateCompilerSystemCompile.default('<a href="#" {{action "edit" allowedKeys="alt"}}>click me</a> <div {{action "shortcut" allowedKeys="any"}}>click me too</div>')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    var actionId = view.$('a[data-ember-action]').attr('data-ember-action');

    ok(_emberViewsSystemAction_manager.default.registeredActions[actionId], 'The action was registered');

    var e = _emberViewsSystemJquery.default.Event('click');
    e.altKey = true;
    view.$('a').trigger(e);

    ok(eventHandlerWasCalled, 'The event handler was called');

    e = _emberViewsSystemJquery.default.Event('click');
    e.ctrlKey = true;
    view.$('div').trigger(e);

    ok(shortcutHandlerWasCalled, 'The "any" shortcut\'s event handler was called');
  });

  QUnit.test('should be able to use action more than once for the same event within a view', function () {
    var editWasCalled = false;
    var deleteWasCalled = false;
    var originalEventHandlerWasCalled = false;

    var controller = _emberRuntimeControllersController.default.extend({
      actions: {
        edit: function () {
          editWasCalled = true;
        },
        'delete': function () {
          deleteWasCalled = true;
        }
      }
    }).create();

    view = _emberViewsViewsView.default.create({
      controller: controller,
      template: _emberTemplateCompilerSystemCompile.default('<a id="edit" href="#" {{action "edit"}}>edit</a><a id="delete" href="#" {{action "delete"}}>delete</a>'),
      click: function () {
        originalEventHandlerWasCalled = true;
      }
    });

    _emberRuntimeTestsUtils.runAppend(view);

    view.$('#edit').trigger('click');

    equal(editWasCalled, true, 'The edit action was called');
    equal(deleteWasCalled, false, 'The delete action was not called');

    editWasCalled = deleteWasCalled = originalEventHandlerWasCalled = false;

    view.$('#delete').trigger('click');

    equal(editWasCalled, false, 'The edit action was not called');
    equal(deleteWasCalled, true, 'The delete action was called');

    editWasCalled = deleteWasCalled = originalEventHandlerWasCalled = false;

    view.$().trigger('click');

    equal(editWasCalled, false, 'The edit action was not called');
    equal(deleteWasCalled, false, 'The delete action was not called');
  });

  QUnit.test('the event should not bubble if `bubbles=false` is passed', function () {
    var editWasCalled = false;
    var deleteWasCalled = false;
    var originalEventHandlerWasCalled = false;

    var controller = _emberRuntimeControllersController.default.extend({
      actions: {
        edit: function () {
          editWasCalled = true;
        },
        'delete': function () {
          deleteWasCalled = true;
        }
      }
    }).create();

    view = _emberViewsViewsView.default.create({
      controller: controller,
      template: _emberTemplateCompilerSystemCompile.default('<a id="edit" href="#" {{action "edit" bubbles=false}}>edit</a><a id="delete" href="#" {{action "delete" bubbles=false}}>delete</a>'),
      click: function () {
        originalEventHandlerWasCalled = true;
      }
    });

    _emberRuntimeTestsUtils.runAppend(view);

    view.$('#edit').trigger('click');

    equal(editWasCalled, true, 'The edit action was called');
    equal(deleteWasCalled, false, 'The delete action was not called');
    equal(originalEventHandlerWasCalled, false, 'The original event handler was not called');

    editWasCalled = deleteWasCalled = originalEventHandlerWasCalled = false;

    view.$('#delete').trigger('click');

    equal(editWasCalled, false, 'The edit action was not called');
    equal(deleteWasCalled, true, 'The delete action was called');
    equal(originalEventHandlerWasCalled, false, 'The original event handler was not called');

    editWasCalled = deleteWasCalled = originalEventHandlerWasCalled = false;

    view.$().trigger('click');

    equal(editWasCalled, false, 'The edit action was not called');
    equal(deleteWasCalled, false, 'The delete action was not called');
    equal(originalEventHandlerWasCalled, true, 'The original event handler was called');
  });

  QUnit.test('should work properly in an #each block', function () {
    var eventHandlerWasCalled = false;

    var controller = _emberRuntimeControllersController.default.extend({
      actions: { edit: function () {
          eventHandlerWasCalled = true;
        } }
    }).create();

    view = _emberViewsViewsView.default.create({
      controller: controller,
      items: _emberMetalCore.default.A([1, 2, 3, 4]),
      template: _emberTemplateCompilerSystemCompile.default('{{#each view.items as |item|}}<a href="#" {{action "edit"}}>click me</a>{{/each}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    view.$('a').trigger('click');

    ok(eventHandlerWasCalled, 'The event handler was called');
  });

  QUnit.test('should work properly in a {{#with foo as |bar|}} block', function () {
    var eventHandlerWasCalled = false;

    var controller = _emberRuntimeControllersController.default.extend({
      actions: { edit: function () {
          eventHandlerWasCalled = true;
        } }
    }).create();

    view = _emberViewsViewsView.default.create({
      controller: controller,
      something: { ohai: 'there' },
      template: _emberTemplateCompilerSystemCompile.default('{{#with view.something as |somethingElse|}}<a href="#" {{action "edit"}}>click me</a>{{/with}}')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    view.$('a').trigger('click');

    ok(eventHandlerWasCalled, 'The event handler was called');
  });

  QUnit.test('should unregister event handlers on rerender', function () {
    var eventHandlerWasCalled = false;

    view = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('{{#if view.active}}<a href="#" {{action "edit"}}>click me</a>{{/if}}'),
      active: true,
      actions: { edit: function () {
          eventHandlerWasCalled = true;
        } }
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    var previousActionId = view.$('a[data-ember-action]').attr('data-ember-action');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'active', false);
    });

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'active', true);
    });

    ok(!_emberViewsSystemAction_manager.default.registeredActions[previousActionId], 'On rerender, the event handler was removed');

    var newActionId = view.$('a[data-ember-action]').attr('data-ember-action');

    ok(_emberViewsSystemAction_manager.default.registeredActions[newActionId], 'After rerender completes, a new event handler was added');
  });

  QUnit.test('should unregister event handlers on inside virtual views', function () {
    var things = _emberMetalCore.default.A([{
      name: 'Thingy'
    }]);
    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('{{#each view.things as |thing|}}<a href="#" {{action "edit"}}>click me</a>{{/each}}'),
      things: things
    });

    _emberRuntimeTestsUtils.runAppend(view);

    var actionId = view.$('a[data-ember-action]').attr('data-ember-action');

    _emberMetalRun_loop.default(function () {
      things.removeAt(0);
    });

    ok(!_emberViewsSystemAction_manager.default.registeredActions[actionId], 'After the virtual view was destroyed, the action was unregistered');
  });

  QUnit.test('should properly capture events on child elements of a container with an action', function () {
    var eventHandlerWasCalled = false;

    var controller = _emberRuntimeControllersController.default.extend({
      actions: { edit: function () {
          eventHandlerWasCalled = true;
        } }
    }).create();

    view = _emberViewsViewsView.default.create({
      controller: controller,
      template: _emberTemplateCompilerSystemCompile.default('<div {{action "edit"}}><button>click me</button></div>')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    view.$('button').trigger('click');

    ok(eventHandlerWasCalled, 'Event on a child element triggered the action of its parent');
  });

  QUnit.test('should allow bubbling of events from action helper to original parent event', function () {
    var eventHandlerWasCalled = false;
    var originalEventHandlerWasCalled = false;

    var controller = _emberRuntimeControllersController.default.extend({
      actions: { edit: function () {
          eventHandlerWasCalled = true;
        } }
    }).create();

    view = _emberViewsViewsView.default.create({
      controller: controller,
      template: _emberTemplateCompilerSystemCompile.default('<a href="#" {{action "edit"}}>click me</a>'),
      click: function () {
        originalEventHandlerWasCalled = true;
      }
    });

    _emberRuntimeTestsUtils.runAppend(view);

    view.$('a').trigger('click');

    ok(eventHandlerWasCalled && originalEventHandlerWasCalled, 'Both event handlers were called');
  });

  QUnit.test('should not bubble an event from action helper to original parent event if `bubbles=false` is passed', function () {
    var eventHandlerWasCalled = false;
    var originalEventHandlerWasCalled = false;

    var controller = _emberRuntimeControllersController.default.extend({
      actions: { edit: function () {
          eventHandlerWasCalled = true;
        } }
    }).create();

    view = _emberViewsViewsView.default.create({
      controller: controller,
      template: _emberTemplateCompilerSystemCompile.default('<a href="#" {{action "edit" bubbles=false}}>click me</a>'),
      click: function () {
        originalEventHandlerWasCalled = true;
      }
    });

    _emberRuntimeTestsUtils.runAppend(view);

    view.$('a').trigger('click');

    ok(eventHandlerWasCalled, 'The child handler was called');
    ok(!originalEventHandlerWasCalled, 'The parent handler was not called');
  });

  QUnit.test('should allow \'send\' as action name (#594)', function () {
    var eventHandlerWasCalled = false;

    var controller = _emberRuntimeControllersController.default.extend({
      send: function () {
        eventHandlerWasCalled = true;
      }
    }).create();

    view = _emberViewsViewsView.default.create({
      controller: controller,
      template: _emberTemplateCompilerSystemCompile.default('<a href="#" {{action "send"}}>send</a>')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    view.$('a').trigger('click');

    ok(eventHandlerWasCalled, 'The view\'s send method was called');
  });

  QUnit.test('should send the view, event and current context to the action', function () {
    var passedTarget;
    var passedContext;

    var aTarget = _emberRuntimeControllersController.default.extend({
      actions: {
        edit: function (context) {
          passedTarget = this;
          passedContext = context;
        }
      }
    }).create();

    var aContext = { aTarget: aTarget };

    view = _emberViewsViewsView.default.create({
      context: aContext,
      template: _emberTemplateCompilerSystemCompile.default('<a id="edit" href="#" {{action "edit" this target=aTarget}}>edit</a>')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    view.$('#edit').trigger('click');

    strictEqual(passedTarget, aTarget, 'the action is called with the target as this');
    strictEqual(passedContext, aContext, 'the parameter is passed along');
  });

  QUnit.test('should only trigger actions for the event they were registered on', function () {
    var editWasCalled = false;

    view = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('<a href="#" {{action "edit"}}>edit</a>'),
      actions: { edit: function () {
          editWasCalled = true;
        } }
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    view.$('a').trigger('mouseover');

    ok(!editWasCalled, 'The action wasn\'t called');
  });

  QUnit.test('should unwrap controllers passed as a context', function () {
    var passedContext;
    var model = _emberRuntimeSystemObject.default.create();
    var controller = _emberRuntimeControllersController.default.extend({
      model: model,
      actions: {
        edit: function (context) {
          passedContext = context;
        }
      }
    }).create();

    view = _emberViewsViewsView.default.create({
      controller: controller,
      template: _emberTemplateCompilerSystemCompile.default('<button {{action "edit" this}}>edit</button>')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    view.$('button').trigger('click');

    equal(passedContext, model, 'the action was passed the unwrapped model');
  });

  QUnit.test('should not unwrap controllers passed as `controller`', function () {
    var passedContext;
    var model = _emberRuntimeSystemObject.default.create();
    var controller = _emberRuntimeControllersController.default.extend({
      model: model,
      actions: {
        edit: function (context) {
          passedContext = context;
        }
      }
    }).create();

    view = _emberViewsViewsView.default.create({
      controller: controller,
      template: _emberTemplateCompilerSystemCompile.default('<button {{action "edit" controller}}>edit</button>')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    view.$('button').trigger('click');

    equal(passedContext, controller, 'the action was passed the controller');
  });

  QUnit.test('should allow multiple contexts to be specified', function () {
    var passedContexts;
    var models = [_emberRuntimeSystemObject.default.create(), _emberRuntimeSystemObject.default.create()];

    var controller = _emberRuntimeControllersController.default.extend({
      actions: {
        edit: function () {
          passedContexts = [].slice.call(arguments);
        }
      }
    }).create();

    view = _emberViewsViewsView.default.create({
      controller: controller,
      modelA: models[0],
      modelB: models[1],
      template: _emberTemplateCompilerSystemCompile.default('<button {{action "edit" view.modelA view.modelB}}>edit</button>')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    view.$('button').trigger('click');

    deepEqual(passedContexts, models, 'the action was called with the passed contexts');
  });

  QUnit.test('should allow multiple contexts to be specified mixed with string args', function () {
    var passedParams;
    var model = _emberRuntimeSystemObject.default.create();

    var controller = _emberRuntimeControllersController.default.extend({
      actions: {
        edit: function () {
          passedParams = [].slice.call(arguments);
        }
      }
    }).create();

    view = _emberViewsViewsView.default.create({
      controller: controller,
      modelA: model,
      template: _emberTemplateCompilerSystemCompile.default('<button {{action "edit" "herp" view.modelA}}>edit</button>')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    view.$('button').trigger('click');

    deepEqual(passedParams, ['herp', model], 'the action was called with the passed contexts');
  });

  QUnit.test('it does not trigger action with special clicks', function () {
    var showCalled = false;

    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('<a {{action \'show\' href=true}}>Hi</a>')
    });

    var controller = _emberRuntimeControllersController.default.extend({
      actions: {
        show: function () {
          showCalled = true;
        }
      }
    }).create();

    _emberMetalRun_loop.default(function () {
      view.set('controller', controller);
      view.appendTo('#qunit-fixture');
    });

    function checkClick(prop, value, expected) {
      var event = _emberViewsSystemJquery.default.Event('click');
      event[prop] = value;
      view.$('a').trigger(event);
      if (expected) {
        ok(showCalled, 'should call action with ' + prop + ':' + value);
        ok(event.isDefaultPrevented(), 'should prevent default');
      } else {
        ok(!showCalled, 'should not call action with ' + prop + ':' + value);
        ok(!event.isDefaultPrevented(), 'should not prevent default');
      }
    }

    checkClick('ctrlKey', true, false);
    checkClick('altKey', true, false);
    checkClick('metaKey', true, false);
    checkClick('shiftKey', true, false);
    checkClick('which', 2, false);

    checkClick('which', 1, true);
    checkClick('which', undefined, true); // IE <9
  });

  QUnit.test('it can trigger actions for keyboard events', function () {
    var showCalled = false;

    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('<input type=\'text\' {{action \'show\' on=\'keyUp\'}}>')
    });

    var controller = _emberRuntimeControllersController.default.extend({
      actions: {
        show: function () {
          showCalled = true;
        }
      }
    }).create();

    _emberMetalRun_loop.default(function () {
      view.set('controller', controller);
      view.appendTo('#qunit-fixture');
    });

    var event = _emberViewsSystemJquery.default.Event('keyup');
    event.char = 'a';
    event.which = 65;
    view.$('input').trigger(event);
    ok(showCalled, 'should call action with keyup');
  });

  QUnit.test('a quoteless parameter should allow dynamic lookup of the actionName', function () {
    expect(4);
    var lastAction;
    var actionOrder = [];

    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('<a id=\'woot-bound-param\' {{action hookMeUp}}>Hi</a>')
    });

    var controller = _emberRuntimeControllersController.default.extend({
      hookMeUp: 'biggityBoom',
      actions: {
        biggityBoom: function () {
          lastAction = 'biggityBoom';
          actionOrder.push(lastAction);
        },
        whompWhomp: function () {
          lastAction = 'whompWhomp';
          actionOrder.push(lastAction);
        },
        sloopyDookie: function () {
          lastAction = 'sloopyDookie';
          actionOrder.push(lastAction);
        }
      }
    }).create();

    _emberMetalRun_loop.default(function () {
      view.set('controller', controller);
      view.appendTo('#qunit-fixture');
    });

    var testBoundAction = function (propertyValue) {
      _emberMetalRun_loop.default(function () {
        controller.set('hookMeUp', propertyValue);
      });

      _emberMetalRun_loop.default(function () {
        view.$('#woot-bound-param').click();
      });

      equal(lastAction, propertyValue, 'lastAction set to ' + propertyValue);
    };

    testBoundAction('whompWhomp');
    testBoundAction('sloopyDookie');
    testBoundAction('biggityBoom');

    deepEqual(actionOrder, ['whompWhomp', 'sloopyDookie', 'biggityBoom'], 'action name was looked up properly');
  });

  QUnit.test('a quoteless parameter should lookup actionName in context [DEPRECATED]', function () {
    expect(4);
    var lastAction;
    var actionOrder = [];

    ignoreDeprecation(function () {
      view = _emberViewsViewsView.default.create({
        template: _emberTemplateCompilerSystemCompile.default('{{#each allactions as |allacation|}}<a id="{{allacation.name}}" {{action allacation.name}}>{{allacation.title}}</a>{{/each}}')
      });
    });

    var controller = _emberRuntimeControllersController.default.extend({
      allactions: _emberMetalCore.default.A([{ title: 'Biggity Boom', name: 'biggityBoom' }, { title: 'Whomp Whomp', name: 'whompWhomp' }, { title: 'Sloopy Dookie', name: 'sloopyDookie' }]),
      actions: {
        biggityBoom: function () {
          lastAction = 'biggityBoom';
          actionOrder.push(lastAction);
        },
        whompWhomp: function () {
          lastAction = 'whompWhomp';
          actionOrder.push(lastAction);
        },
        sloopyDookie: function () {
          lastAction = 'sloopyDookie';
          actionOrder.push(lastAction);
        }
      }
    }).create();

    _emberMetalRun_loop.default(function () {
      view.set('controller', controller);
      view.appendTo('#qunit-fixture');
    });

    var testBoundAction = function (propertyValue) {
      _emberMetalRun_loop.default(function () {
        view.$('#' + propertyValue).click();
      });

      equal(lastAction, propertyValue, 'lastAction set to ' + propertyValue);
    };

    testBoundAction('whompWhomp');
    testBoundAction('sloopyDookie');
    testBoundAction('biggityBoom');

    deepEqual(actionOrder, ['whompWhomp', 'sloopyDookie', 'biggityBoom'], 'action name was looked up properly');
  });

  QUnit.test('a quoteless string parameter should resolve actionName, including path', function () {
    expect(4);
    var lastAction;
    var actionOrder = [];

    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('{{#each allactions as |item|}}<a id="{{item.name}}" {{action item.name}}>{{item.title}}</a>{{/each}}')
    });

    var controller = _emberRuntimeControllersController.default.extend({
      allactions: _emberMetalCore.default.A([{ title: 'Biggity Boom', name: 'biggityBoom' }, { title: 'Whomp Whomp', name: 'whompWhomp' }, { title: 'Sloopy Dookie', name: 'sloopyDookie' }]),
      actions: {
        biggityBoom: function () {
          lastAction = 'biggityBoom';
          actionOrder.push(lastAction);
        },
        whompWhomp: function () {
          lastAction = 'whompWhomp';
          actionOrder.push(lastAction);
        },
        sloopyDookie: function () {
          lastAction = 'sloopyDookie';
          actionOrder.push(lastAction);
        }
      }
    }).create();

    _emberMetalRun_loop.default(function () {
      view.set('controller', controller);
      view.appendTo('#qunit-fixture');
    });

    var testBoundAction = function (propertyValue) {
      _emberMetalRun_loop.default(function () {
        view.$('#' + propertyValue).click();
      });

      equal(lastAction, propertyValue, 'lastAction set to ' + propertyValue);
    };

    testBoundAction('whompWhomp');
    testBoundAction('sloopyDookie');
    testBoundAction('biggityBoom');

    deepEqual(actionOrder, ['whompWhomp', 'sloopyDookie', 'biggityBoom'], 'action name was looked up properly');
  });

  QUnit.test('a quoteless function parameter should be called, including arguments', function () {
    expect(2);

    var arg = 'rough ray';

    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('<a {{action submit \'' + arg + '\'}}></a>')
    });

    var controller = _emberRuntimeControllersController.default.extend({
      submit: function (actualArg) {
        ok(true, 'submit function called');
        equal(actualArg, arg, 'argument passed');
      }
    }).create();

    _emberMetalRun_loop.default(function () {
      view.set('controller', controller);
      view.appendTo('#qunit-fixture');
    });

    _emberMetalRun_loop.default(function () {
      view.$('a').click();
    });
  });

  QUnit.test('a quoteless parameter that does not resolve to a value asserts', function () {

    var controller = _emberRuntimeControllersController.default.extend({
      actions: {
        ohNoeNotValid: function () {}
      }
    }).create();

    view = _emberViewsViewsView.default.create({
      controller: controller,
      template: _emberTemplateCompilerSystemCompile.default('<a id=\'oops-bound-param\' {{action ohNoeNotValid}}>Hi</a>')
    });

    expectAssertion(function () {
      _emberMetalRun_loop.default(function () {
        view.appendTo('#qunit-fixture');
      });
    }, 'You specified a quoteless path to the {{action}} helper ' + 'which did not resolve to an action name (a string). ' + 'Perhaps you meant to use a quoted actionName? (e.g. {{action \'save\'}}).');
  });

  QUnit.test('allows multiple actions on a single element', function () {
    var clickActionWasCalled = false;
    var doubleClickActionWasCalled = false;

    var controller = _emberRuntimeControllersController.default.extend({
      actions: {
        clicked: function () {
          clickActionWasCalled = true;
        },

        doubleClicked: function () {
          doubleClickActionWasCalled = true;
        }
      }
    }).create();

    view = _emberViewsViewsView.default.create({
      controller: controller,
      template: _emberTemplateCompilerSystemCompile.default('\n      <a href="#"\n        {{action "clicked" on="click"}}\n        {{action "doubleClicked" on="doubleClick"}}\n      >click me</a>\n    ')
    });

    _emberRuntimeTestsUtils.runAppend(view);

    var actionId = view.$('a[data-ember-action]').attr('data-ember-action');

    ok(_emberViewsSystemAction_manager.default.registeredActions[actionId], 'The action was registered');

    view.$('a').trigger('click');

    ok(clickActionWasCalled, 'The clicked action was called');

    view.$('a').trigger('dblclick');

    ok(doubleClickActionWasCalled, 'The double click handler was called');
  });

  QUnit.module('ember-routing-htmlbars: action helper - deprecated invoking directly on target', {
    setup: function () {
      dispatcher = _emberViewsSystemEvent_dispatcher.default.create();
      dispatcher.setup();
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(view);
      _emberRuntimeTestsUtils.runDestroy(dispatcher);
    }
  });

  QUnit.test('should respect preventDefault=false option if provided', function () {
    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('<a {{action \'show\' preventDefault=false}}>Hi</a>')
    });

    var controller = _emberRuntimeControllersController.default.extend({
      actions: {
        show: function () {}
      }
    }).create();

    _emberMetalRun_loop.default(function () {
      view.set('controller', controller);
      _emberRuntimeTestsUtils.runAppend(view);
    });

    var event = _emberViewsSystemJquery.default.Event('click');
    view.$('a').trigger(event);

    equal(event.isDefaultPrevented(), false, 'should not preventDefault');
  });
});
// A, FEATURES, assert
enifed('ember-routing-htmlbars/tests/helpers/element_action_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-routing-htmlbars/tests/helpers');
  test('ember-routing-htmlbars/tests/helpers/element_action_test.js should pass jscs', function () {
    ok(true, 'ember-routing-htmlbars/tests/helpers/element_action_test.js should pass jscs.');
  });
});
enifed('ember-routing-htmlbars/tests/helpers/element_action_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-routing-htmlbars/tests/helpers');
  QUnit.test('ember-routing-htmlbars/tests/helpers/element_action_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-routing-htmlbars/tests/helpers/element_action_test.js should pass jshint.');
  });
});
enifed('ember-routing-htmlbars/tests/helpers/link-to_test', ['exports', 'ember-routing-htmlbars', 'ember-metal/run_loop', 'ember-views/views/view', 'ember-template-compiler/system/compile', 'ember-metal/property_set', 'ember-runtime/controllers/controller', 'ember-runtime/system/container', 'ember-runtime/tests/utils', 'ember-runtime/system/object', 'ember-views/component_lookup', 'ember-routing-views/views/link'], function (exports, _emberRoutingHtmlbars, _emberMetalRun_loop, _emberViewsViewsView, _emberTemplateCompilerSystemCompile, _emberMetalProperty_set, _emberRuntimeControllersController, _emberRuntimeSystemContainer, _emberRuntimeTestsUtils, _emberRuntimeSystemObject, _emberViewsComponent_lookup, _emberRoutingViewsViewsLink) {
  'use strict';

  var view;
  var container;
  var registry = new _emberRuntimeSystemContainer.Registry();

  // These tests don't rely on the routing service, but LinkComponent makes
  // some assumptions that it will exist. This small stub service ensures
  // that the LinkComponent can render without raising an exception.
  //
  // TODO: Add tests that test actual behavior. Currently, all behavior
  // is tested integration-style in the `ember` package.
  registry.register('service:-routing', _emberRuntimeSystemObject.default.extend({
    availableRoutes: function () {
      return ['index'];
    },
    hasRoute: function (name) {
      return name === 'index';
    },
    isActiveForRoute: function () {
      return true;
    },
    generateURL: function () {
      return '/';
    }
  }));

  registry.register('component-lookup:main', _emberViewsComponent_lookup.default);
  registry.register('component:-link-to', _emberRoutingViewsViewsLink.default);

  QUnit.module('ember-routing-htmlbars: link-to helper', {
    setup: function () {
      container = registry.container();
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(view);
    }
  });

  QUnit.test('should be able to be inserted in DOM when the router is not present', function () {
    var template = '{{#link-to \'index\'}}Go to Index{{/link-to}}';
    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default(template),
      container: container
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'Go to Index');
  });

  QUnit.test('re-renders when title changes', function () {
    var template = '{{link-to title routeName}}';
    view = _emberViewsViewsView.default.create({
      controller: {
        title: 'foo',
        routeName: 'index'
      },
      template: _emberTemplateCompilerSystemCompile.default(template),
      container: container
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'foo');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'controller.title', 'bar');
    });

    equal(view.$().text(), 'bar');
  });

  QUnit.test('can read bound title', function () {
    var template = '{{link-to title routeName}}';
    view = _emberViewsViewsView.default.create({
      controller: {
        title: 'foo',
        routeName: 'index'
      },
      template: _emberTemplateCompilerSystemCompile.default(template),
      container: container
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'foo');
  });

  QUnit.test('escaped inline form (double curlies) escapes link title', function () {
    view = _emberViewsViewsView.default.create({
      title: '<b>blah</b>',
      template: _emberTemplateCompilerSystemCompile.default('{{link-to view.title}}'),
      container: container
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('b').length, 0, 'no <b> were found');
  });

  QUnit.test('unescaped inline form (triple curlies) does not escape link title', function () {
    view = _emberViewsViewsView.default.create({
      title: '<b>blah</b>',
      template: _emberTemplateCompilerSystemCompile.default('{{{link-to view.title}}}'),
      container: container
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$('b').length, 1, '<b> was found');
  });

  QUnit.test('unwraps controllers', function () {
    var template = '{{#link-to \'index\' view.otherController}}Text{{/link-to}}';

    view = _emberViewsViewsView.default.create({
      otherController: _emberRuntimeControllersController.default.create({
        model: 'foo'
      }),

      template: _emberTemplateCompilerSystemCompile.default(template),
      container: container
    });

    expectDeprecation(function () {
      _emberRuntimeTestsUtils.runAppend(view);
    }, /Providing `{{link-to}}` with a param that is wrapped in a controller is deprecated./);

    equal(view.$().text(), 'Text');
  });
});
enifed('ember-routing-htmlbars/tests/helpers/link-to_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-routing-htmlbars/tests/helpers');
  test('ember-routing-htmlbars/tests/helpers/link-to_test.js should pass jscs', function () {
    ok(true, 'ember-routing-htmlbars/tests/helpers/link-to_test.js should pass jscs.');
  });
});
enifed('ember-routing-htmlbars/tests/helpers/link-to_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-routing-htmlbars/tests/helpers');
  QUnit.test('ember-routing-htmlbars/tests/helpers/link-to_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-routing-htmlbars/tests/helpers/link-to_test.js should pass jshint.');
  });
});
enifed('ember-routing-htmlbars/tests/helpers/outlet_test', ['exports', 'ember-metal/core', 'ember-metal/run_loop', 'ember-runtime/system/namespace', 'ember-runtime/controllers/controller', 'ember-views/views/view', 'ember-views/system/jquery', 'ember-template-compiler/system/compile', 'ember-runtime/tests/utils', 'ember-routing-htmlbars/tests/utils'], function (exports, _emberMetalCore, _emberMetalRun_loop, _emberRuntimeSystemNamespace, _emberRuntimeControllersController, _emberViewsViewsView, _emberViewsSystemJquery, _emberTemplateCompilerSystemCompile, _emberRuntimeTestsUtils, _emberRoutingHtmlbarsTestsUtils) {
  'use strict';

  var trim = _emberViewsSystemJquery.default.trim;

  var registry, container, top;

  QUnit.module('ember-routing-htmlbars: {{outlet}} helper', {
    setup: function () {
      var namespace = _emberRuntimeSystemNamespace.default.create();
      registry = _emberRoutingHtmlbarsTestsUtils.buildRegistry(namespace);
      container = registry.container();

      var CoreOutlet = container.lookupFactory('view:core-outlet');
      top = CoreOutlet.create();
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(container);
      _emberRuntimeTestsUtils.runDestroy(top);
      registry = container = top = null;
    }
  });

  QUnit.test('view should render the outlet when set after dom insertion', function () {
    var routerState = withTemplate('<h1>HI</h1>{{outlet}}');
    top.setOutletState(routerState);
    _emberRuntimeTestsUtils.runAppend(top);

    equal(top.$().text(), 'HI');

    routerState.outlets.main = withTemplate('<p>BYE</p>');

    _emberMetalRun_loop.default(function () {
      top.setOutletState(routerState);
    });

    // Replace whitespace for older IE
    equal(trim(top.$().text()), 'HIBYE');
  });

  QUnit.test('a top-level outlet should always be a view', function () {
    registry.register('view:toplevel', _emberViewsViewsView.default.extend({
      elementId: 'top-level'
    }));
    var routerState = withTemplate('<h1>HI</h1>{{outlet}}');
    top.setOutletState(routerState);
    routerState.outlets.main = withTemplate('<p>BYE</p>');
    _emberRuntimeTestsUtils.runAppend(top);

    // Replace whitespace for older IE
    equal(trim(top.$('#top-level').text()), 'HIBYE');
  });

  QUnit.test('a top-level outlet should have access to `{{controller}}`', function () {
    var routerState = withTemplate('<h1>{{controller.salutation}}</h1>{{outlet}}');
    routerState.render.controller = _emberRuntimeControllersController.default.create({
      salutation: 'HI'
    });
    top.setOutletState(routerState);
    routerState.outlets.main = withTemplate('<p>BYE</p>');
    _emberRuntimeTestsUtils.runAppend(top);

    // Replace whitespace for older IE
    equal(trim(top.$().text()), 'HIBYE');
  });

  QUnit.test('a non top-level outlet should have access to `{{controller}}`', function () {
    var routerState = withTemplate('<h1>HI</h1>{{outlet}}');
    top.setOutletState(routerState);
    routerState.outlets.main = withTemplate('<p>BYE</p>');
    routerState.outlets.main.render.controller = _emberRuntimeControllersController.default.create({
      salutation: 'BYE'
    });

    _emberRuntimeTestsUtils.runAppend(top);

    // Replace whitespace for older IE
    equal(trim(top.$().text()), 'HIBYE');
  });

  QUnit.test('view should render the outlet when set before dom insertion', function () {
    var routerState = withTemplate('<h1>HI</h1>{{outlet}}');
    routerState.outlets.main = withTemplate('<p>BYE</p>');
    top.setOutletState(routerState);
    _emberRuntimeTestsUtils.runAppend(top);

    // Replace whitespace for older IE
    equal(trim(top.$().text()), 'HIBYE');
  });

  QUnit.test('outlet should support an optional name', function () {
    var routerState = withTemplate('<h1>HI</h1>{{outlet \'mainView\'}}');
    top.setOutletState(routerState);
    _emberRuntimeTestsUtils.runAppend(top);

    equal(top.$().text(), 'HI');

    routerState.outlets.mainView = withTemplate('<p>BYE</p>');

    _emberMetalRun_loop.default(function () {
      top.setOutletState(routerState);
    });

    // Replace whitespace for older IE
    equal(trim(top.$().text()), 'HIBYE');
  });

  QUnit.test('Outlets bind to the current view, not the current concrete view', function () {
    var routerState = withTemplate('<h1>HI</h1>{{outlet}}');
    top.setOutletState(routerState);
    _emberRuntimeTestsUtils.runAppend(top);
    routerState.outlets.main = withTemplate('<h2>MIDDLE</h2>{{outlet}}');
    _emberMetalRun_loop.default(function () {
      top.setOutletState(routerState);
    });
    routerState.outlets.main.outlets.main = withTemplate('<h3>BOTTOM</h3>');
    _emberMetalRun_loop.default(function () {
      top.setOutletState(routerState);
    });

    var output = _emberViewsSystemJquery.default('#qunit-fixture h1 ~ h2 ~ h3').text();
    equal(output, 'BOTTOM', 'all templates were rendered');
  });

  QUnit.test('Outlets bind to the current template\'s view, not inner contexts [DEPRECATED]', function () {
    var parentTemplate = '<h1>HI</h1>{{#if view.alwaysTrue}}{{outlet}}{{/if}}';
    var bottomTemplate = '<h3>BOTTOM</h3>';

    var routerState = {
      render: {
        ViewClass: _emberViewsViewsView.default.extend({
          alwaysTrue: true,
          template: _emberTemplateCompilerSystemCompile.default(parentTemplate)
        })
      },
      outlets: {}
    };

    top.setOutletState(routerState);

    _emberRuntimeTestsUtils.runAppend(top);

    routerState.outlets.main = withTemplate(bottomTemplate);

    _emberMetalRun_loop.default(function () {
      top.setOutletState(routerState);
    });

    var output = _emberViewsSystemJquery.default('#qunit-fixture h1 ~ h3').text();
    equal(output, 'BOTTOM', 'all templates were rendered');
  });

  QUnit.test('should not throw deprecations if {{outlet}} is used without a name', function () {
    expectNoDeprecation();
    top.setOutletState(withTemplate('{{outlet}}'));
    _emberRuntimeTestsUtils.runAppend(top);
  });

  QUnit.test('should not throw deprecations if {{outlet}} is used with a quoted name', function () {
    expectNoDeprecation();
    top.setOutletState(withTemplate('{{outlet "foo"}}'));
    _emberRuntimeTestsUtils.runAppend(top);
  });

  QUnit.test('{{outlet}} should work with an unquoted name', function () {
    var routerState = {
      render: {
        controller: _emberMetalCore.default.Controller.create({
          outletName: 'magical'
        }),
        template: _emberTemplateCompilerSystemCompile.default('{{outlet outletName}}')
      },
      outlets: {
        magical: withTemplate('It\'s magic')
      }
    };

    top.setOutletState(routerState);
    _emberRuntimeTestsUtils.runAppend(top);

    equal(top.$().text().trim(), 'It\'s magic');
  });

  QUnit.test('{{outlet}} should rerender when bound name changes', function () {
    var routerState = {
      render: {
        controller: _emberMetalCore.default.Controller.create({
          outletName: 'magical'
        }),
        template: _emberTemplateCompilerSystemCompile.default('{{outlet outletName}}')
      },
      outlets: {
        magical: withTemplate('It\'s magic'),
        second: withTemplate('second')
      }
    };

    top.setOutletState(routerState);
    _emberRuntimeTestsUtils.runAppend(top);
    equal(top.$().text().trim(), 'It\'s magic');
    _emberMetalRun_loop.default(function () {
      routerState.render.controller.set('outletName', 'second');
    });
    equal(top.$().text().trim(), 'second');
  });

  QUnit.test('views created by {{outlet}} should get destroyed', function () {
    var inserted = 0;
    var destroyed = 0;
    var routerState = {
      render: {
        ViewClass: _emberViewsViewsView.default.extend({
          didInsertElement: function () {
            inserted++;
          },
          willDestroyElement: function () {
            destroyed++;
          }
        })
      },
      outlets: {}
    };
    top.setOutletState(routerState);
    _emberRuntimeTestsUtils.runAppend(top);
    equal(inserted, 1, 'expected to see view inserted');
    _emberMetalRun_loop.default(function () {
      top.setOutletState(withTemplate('hello world'));
    });
    equal(destroyed, 1, 'expected to see view destroyed');
  });

  function withTemplate(string) {
    return {
      render: {
        template: _emberTemplateCompilerSystemCompile.default(string)
      },
      outlets: {}
    };
  }
});
enifed('ember-routing-htmlbars/tests/helpers/outlet_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-routing-htmlbars/tests/helpers');
  test('ember-routing-htmlbars/tests/helpers/outlet_test.js should pass jscs', function () {
    ok(true, 'ember-routing-htmlbars/tests/helpers/outlet_test.js should pass jscs.');
  });
});
enifed('ember-routing-htmlbars/tests/helpers/outlet_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-routing-htmlbars/tests/helpers');
  QUnit.test('ember-routing-htmlbars/tests/helpers/outlet_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-routing-htmlbars/tests/helpers/outlet_test.js should pass jshint.');
  });
});
enifed('ember-routing-htmlbars/tests/helpers/render_test', ['exports', 'ember-metal/core', 'ember-metal/property_set', 'ember-metal/run_loop', 'ember-metal/mixin', 'ember-runtime/system/namespace', 'ember-runtime/controllers/controller', 'ember-template-compiler/system/compile', 'ember-views/views/view', 'ember-views/system/jquery', 'ember-views/system/action_manager', 'ember-routing-htmlbars/tests/utils', 'ember-runtime/tests/utils'], function (exports, _emberMetalCore, _emberMetalProperty_set, _emberMetalRun_loop, _emberMetalMixin, _emberRuntimeSystemNamespace, _emberRuntimeControllersController, _emberTemplateCompilerSystemCompile, _emberViewsViewsView, _emberViewsSystemJquery, _emberViewsSystemAction_manager, _emberRoutingHtmlbarsTestsUtils, _emberRuntimeTestsUtils) {
  'use strict';

  function runSet(object, key, value) {
    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(object, key, value);
    });
  }

  var view, container;

  QUnit.module('ember-routing-htmlbars: {{render}} helper', {
    setup: function () {
      var namespace = _emberRuntimeSystemNamespace.default.create();
      var registry = _emberRoutingHtmlbarsTestsUtils.buildRegistry(namespace);
      container = registry.container();
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(container);
      _emberRuntimeTestsUtils.runDestroy(view);

      _emberMetalCore.default.TEMPLATES = {};
    }
  });

  QUnit.test('{{render}} helper should render given template', function () {
    var template = '<h1>HI</h1>{{render \'home\'}}';
    var controller = _emberRuntimeControllersController.default.extend({ container: container });
    view = _emberViewsViewsView.default.create({
      container: container,
      controller: controller.create(),
      template: _emberTemplateCompilerSystemCompile.default(template)
    });

    _emberMetalCore.default.TEMPLATES['home'] = _emberTemplateCompilerSystemCompile.default('<p>BYE</p>');

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'HIBYE');
    // This is a poor assertion. What is really being tested is that
    // a second render with the same name will throw an assert.
    ok(container.lookup('router:main')._lookupActiveComponentNode('home'), 'should register home as active view');
  });

  QUnit.test('{{render}} helper should render nested helpers', function () {
    var template = '<h1>HI</h1>{{render \'foo\'}}';
    var controller = _emberRuntimeControllersController.default.extend({ container: container });
    view = _emberViewsViewsView.default.create({
      container: container,
      controller: controller.create(),
      template: _emberTemplateCompilerSystemCompile.default(template)
    });

    _emberMetalCore.default.TEMPLATES['foo'] = _emberTemplateCompilerSystemCompile.default('<p>FOO</p>{{render \'bar\'}}');
    _emberMetalCore.default.TEMPLATES['bar'] = _emberTemplateCompilerSystemCompile.default('<p>BAR</p>{{render \'baz\'}}');
    _emberMetalCore.default.TEMPLATES['baz'] = _emberTemplateCompilerSystemCompile.default('<p>BAZ</p>');

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'HIFOOBARBAZ');
  });

  QUnit.test('{{render}} helper should have assertion if neither template nor view exists', function () {
    var template = '<h1>HI</h1>{{render \'oops\'}}';
    var controller = _emberRuntimeControllersController.default.extend({ container: container });
    view = _emberViewsViewsView.default.create({
      container: container,
      controller: controller.create(),
      template: _emberTemplateCompilerSystemCompile.default(template)
    });

    expectAssertion(function () {
      _emberRuntimeTestsUtils.runAppend(view);
    }, 'You used `{{render \'oops\'}}`, but \'oops\' can not be found as either a template or a view.');
  });

  QUnit.test('{{render}} helper should not have assertion if template is supplied in block-form', function () {
    var template = '<h1>HI</h1>{{#render \'good\'}} {{name}}{{/render}}';
    var controller = _emberRuntimeControllersController.default.extend({ container: container });
    container._registry.register('controller:good', _emberRuntimeControllersController.default.extend({ name: 'Rob' }));
    view = _emberViewsViewsView.default.create({
      container: container,
      controller: controller.create(),
      template: _emberTemplateCompilerSystemCompile.default(template)
    });

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'HI Rob');
  });

  QUnit.test('{{render}} helper should not have assertion if view exists without a template', function () {
    var template = '<h1>HI</h1>{{render \'oops\'}}';
    var controller = _emberRuntimeControllersController.default.extend({ container: container });
    view = _emberViewsViewsView.default.create({
      container: container,
      controller: controller.create(),
      template: _emberTemplateCompilerSystemCompile.default(template)
    });

    container._registry.register('view:oops', _emberViewsViewsView.default.extend());

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'HI');
  });

  QUnit.test('{{render}} helper should render given template with a supplied model', function () {
    var template = '<h1>HI</h1>{{render \'post\' post}}';
    var post = {
      title: 'Rails is omakase'
    };

    var Controller = _emberRuntimeControllersController.default.extend({
      container: container,
      post: post
    });

    var controller = Controller.create({});

    view = _emberViewsViewsView.default.create({
      container: container,
      controller: controller,
      template: _emberTemplateCompilerSystemCompile.default(template)
    });

    var postController;
    var PostController = _emberRuntimeControllersController.default.extend({
      init: function () {
        this._super.apply(this, arguments);
        postController = this;
      }
    });
    container._registry.register('controller:post', PostController);

    _emberMetalCore.default.TEMPLATES['post'] = _emberTemplateCompilerSystemCompile.default('<p>{{model.title}}</p>');

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'HIRails is omakase');
    equal(postController.get('model'), post);

    runSet(controller, 'post', { title: 'Rails is unagi' });

    equal(view.$().text(), 'HIRails is unagi');
    deepEqual(postController.get('model'), { title: 'Rails is unagi' });
  });

  QUnit.test('{{render}} helper with a supplied model should not fire observers on the controller', function () {
    var template = '<h1>HI</h1>{{render \'post\' post}}';
    var post = {
      title: 'Rails is omakase'
    };

    view = _emberViewsViewsView.default.create({
      container: container,
      controller: _emberRuntimeControllersController.default.create({
        container: container,
        post: post
      }),
      template: _emberTemplateCompilerSystemCompile.default(template)
    });

    var PostController = _emberRuntimeControllersController.default.extend({
      modelDidChange: _emberMetalMixin.observer('model', function () {
        modelDidChange++;
      })
    });

    container._registry.register('controller:post', PostController);

    _emberMetalCore.default.TEMPLATES['post'] = _emberTemplateCompilerSystemCompile.default('<p>{{title}}</p>');

    var modelDidChange = 0;
    _emberRuntimeTestsUtils.runAppend(view);
    equal(modelDidChange, 0, 'model observer did not fire');
  });

  QUnit.test('{{render}} helper should raise an error when a given controller name does not resolve to a controller', function () {
    var template = '<h1>HI</h1>{{render "home" controller="postss"}}';
    var controller = _emberRuntimeControllersController.default.extend({ container: container });
    container._registry.register('controller:posts', _emberRuntimeControllersController.default.extend());
    view = _emberViewsViewsView.default.create({
      container: container,
      controller: controller.create(),
      template: _emberTemplateCompilerSystemCompile.default(template)
    });

    _emberMetalCore.default.TEMPLATES['home'] = _emberTemplateCompilerSystemCompile.default('<p>BYE</p>');

    expectAssertion(function () {
      _emberRuntimeTestsUtils.runAppend(view);
    }, 'The controller name you supplied \'postss\' did not resolve to a controller.');
  });

  QUnit.test('{{render}} helper should render with given controller', function () {
    var template = '{{render "home" controller="posts"}}';
    var controller = _emberRuntimeControllersController.default.extend({ container: container });
    var id = 0;
    container._registry.register('controller:posts', _emberRuntimeControllersController.default.extend({
      init: function () {
        this._super.apply(this, arguments);
        this.uniqueId = id++;
      }
    }));
    view = _emberViewsViewsView.default.create({
      container: container,
      controller: controller.create(),
      template: _emberTemplateCompilerSystemCompile.default(template)
    });

    _emberMetalCore.default.TEMPLATES['home'] = _emberTemplateCompilerSystemCompile.default('{{uniqueId}}');

    _emberRuntimeTestsUtils.runAppend(view);

    var uniqueId = container.lookup('controller:posts').get('uniqueId');
    equal(uniqueId, 0, 'precond - first uniqueId is used for singleton');
    equal(uniqueId, view.$().html(), 'rendered with singleton controller');
  });

  QUnit.test('{{render}} helper should render a template without a model only once', function () {
    var template = '<h1>HI</h1>{{render \'home\'}}<hr/>{{render \'home\'}}';
    var controller = _emberRuntimeControllersController.default.extend({ container: container });
    view = _emberViewsViewsView.default.create({
      container: container,
      controller: controller.create(),
      template: _emberTemplateCompilerSystemCompile.default(template)
    });

    _emberMetalCore.default.TEMPLATES['home'] = _emberTemplateCompilerSystemCompile.default('<p>BYE</p>');

    expectAssertion(function () {
      _emberRuntimeTestsUtils.runAppend(view);
    }, /\{\{render\}\} helper once/i);
  });

  QUnit.test('{{render}} helper should render templates with models multiple times', function () {
    var template = '<h1>HI</h1> {{render \'post\' post1}} {{render \'post\' post2}}';
    var post1 = {
      title: 'Me first'
    };
    var post2 = {
      title: 'Then me'
    };

    var Controller = _emberRuntimeControllersController.default.extend({
      container: container,
      post1: post1,
      post2: post2
    });

    var controller = Controller.create();

    view = _emberViewsViewsView.default.create({
      container: container,
      controller: controller,
      template: _emberTemplateCompilerSystemCompile.default(template)
    });

    var postController1, postController2;
    var PostController = _emberRuntimeControllersController.default.extend({
      init: function () {
        this._super.apply(this, arguments);
        if (!postController1) {
          postController1 = this;
        } else if (!postController2) {
          postController2 = this;
        }
      }
    });
    container._registry.register('controller:post', PostController, { singleton: false });

    _emberMetalCore.default.TEMPLATES['post'] = _emberTemplateCompilerSystemCompile.default('<p>{{model.title}}</p>');

    _emberRuntimeTestsUtils.runAppend(view);

    ok(view.$().text().match(/^HI ?Me first ?Then me$/));
    equal(postController1.get('model'), post1);
    equal(postController2.get('model'), post2);

    runSet(controller, 'post1', { title: 'I am new' });

    ok(view.$().text().match(/^HI ?I am new ?Then me$/));
    deepEqual(postController1.get('model'), { title: 'I am new' });
  });

  QUnit.test('{{render}} helper should not leak controllers', function () {
    var template = '<h1>HI</h1> {{render \'post\' post1}}';
    var post1 = {
      title: 'Me first'
    };

    var Controller = _emberRuntimeControllersController.default.extend({
      container: container,
      post1: post1
    });

    var controller = Controller.create();

    view = _emberViewsViewsView.default.create({
      container: container,
      controller: controller,
      template: _emberTemplateCompilerSystemCompile.default(template)
    });

    var postController;
    var PostController = _emberRuntimeControllersController.default.extend({
      init: function () {
        this._super.apply(this, arguments);
        postController = this;
      }
    });
    container._registry.register('controller:post', PostController);

    _emberMetalCore.default.TEMPLATES['post'] = _emberTemplateCompilerSystemCompile.default('<p>{{title}}</p>');

    _emberRuntimeTestsUtils.runAppend(view);

    _emberRuntimeTestsUtils.runDestroy(view);

    ok(postController.isDestroyed, 'expected postController to be destroyed');
  });

  QUnit.test('{{render}} helper should not treat invocations with falsy contexts as context-less', function () {
    var template = '<h1>HI</h1> {{render \'post\' zero}} {{render \'post\' nonexistent}}';

    view = _emberViewsViewsView.default.create({
      container: container,
      controller: _emberRuntimeControllersController.default.create({
        container: container,
        zero: false
      }),
      template: _emberTemplateCompilerSystemCompile.default(template)
    });

    var postController1, postController2;
    var PostController = _emberRuntimeControllersController.default.extend({
      init: function () {
        this._super.apply(this, arguments);
        if (!postController1) {
          postController1 = this;
        } else if (!postController2) {
          postController2 = this;
        }
      }
    });
    container._registry.register('controller:post', PostController, { singleton: false });

    _emberMetalCore.default.TEMPLATES['post'] = _emberTemplateCompilerSystemCompile.default('<p>{{#unless model}}NOTHING{{/unless}}</p>');

    _emberRuntimeTestsUtils.runAppend(view);

    ok(view.$().text().match(/^HI ?NOTHING ?NOTHING$/));
    equal(postController1.get('model'), 0);
    equal(postController2.get('model'), undefined);
  });

  QUnit.test('{{render}} helper should render templates both with and without models', function () {
    var template = '<h1>HI</h1> {{render \'post\'}} {{render \'post\' post}}';
    var post = {
      title: 'Rails is omakase'
    };

    var Controller = _emberRuntimeControllersController.default.extend({
      container: container,
      post: post
    });

    var controller = Controller.create();

    view = _emberViewsViewsView.default.create({
      container: container,
      controller: controller,
      template: _emberTemplateCompilerSystemCompile.default(template)
    });

    var postController1, postController2;
    var PostController = _emberRuntimeControllersController.default.extend({
      init: function () {
        this._super.apply(this, arguments);
        if (!postController1) {
          postController1 = this;
        } else if (!postController2) {
          postController2 = this;
        }
      }
    });
    container._registry.register('controller:post', PostController, { singleton: false });

    _emberMetalCore.default.TEMPLATES['post'] = _emberTemplateCompilerSystemCompile.default('<p>Title:{{model.title}}</p>');

    _emberRuntimeTestsUtils.runAppend(view);

    ok(view.$().text().match(/^HI ?Title: ?Title:Rails is omakase$/));
    equal(postController1.get('model'), null);
    equal(postController2.get('model'), post);

    runSet(controller, 'post', { title: 'Rails is unagi' });

    ok(view.$().text().match(/^HI ?Title: ?Title:Rails is unagi$/));
    deepEqual(postController2.get('model'), { title: 'Rails is unagi' });
  });

  QUnit.test('{{render}} helper should link child controllers to the parent controller', function () {
    var parentTriggered = 0;

    var template = '<h1>HI</h1>{{render "posts"}}';
    var controller = _emberRuntimeControllersController.default.extend({
      container: container,
      actions: {
        parentPlease: function () {
          parentTriggered++;
        }
      },
      role: 'Mom'
    });

    container._registry.register('controller:posts', _emberRuntimeControllersController.default.extend());

    view = _emberViewsViewsView.default.create({
      container: container,
      controller: controller.create(),
      template: _emberTemplateCompilerSystemCompile.default(template)
    });

    _emberMetalCore.default.TEMPLATES['posts'] = _emberTemplateCompilerSystemCompile.default('<button id="parent-action" {{action "parentPlease"}}>Go to {{parentController.role}}</button>');

    _emberRuntimeTestsUtils.runAppend(view);

    var button = _emberViewsSystemJquery.default('#parent-action');
    var actionId = button.data('ember-action');
    var _ActionManager$registeredActions$actionId = _emberViewsSystemAction_manager.default.registeredActions[actionId];
    var action = _ActionManager$registeredActions$actionId[0];

    var handler = action.handler;

    equal(button.text(), 'Go to Mom', 'The parentController property is set on the child controller');

    _emberMetalRun_loop.default(null, handler, new _emberViewsSystemJquery.default.Event('click'));

    equal(parentTriggered, 1, 'The event bubbled to the parent');
  });

  QUnit.test('{{render}} helper should be able to render a template again when it was removed', function () {
    var controller = _emberRuntimeControllersController.default.extend({ container: container });
    var CoreOutlet = container.lookupFactory('view:core-outlet');
    view = CoreOutlet.create({
      container: container
    });

    _emberMetalCore.default.TEMPLATES['home'] = _emberTemplateCompilerSystemCompile.default('<p>BYE</p>');

    var liveRoutes = {
      render: {
        template: _emberTemplateCompilerSystemCompile.default('<h1>HI</h1>{{outlet}}')
      },
      outlets: {}
    };

    _emberMetalRun_loop.default(function () {
      liveRoutes.outlets.main = {
        render: {
          controller: controller.create(),
          template: _emberTemplateCompilerSystemCompile.default('<div>1{{render \'home\'}}</div>')
        }
      };
      view.setOutletState(liveRoutes);
    });
    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'HI1BYE');

    _emberMetalRun_loop.default(function () {
      liveRoutes.outlets.main = {
        render: {
          controller: controller.create(),
          template: _emberTemplateCompilerSystemCompile.default('<div>2{{render \'home\'}}</div>')
        }
      };
      view.setOutletState(liveRoutes);
    });

    equal(view.$().text(), 'HI2BYE');
  });

  QUnit.test('{{render}} works with dot notation', function () {
    var template = '{{render "blog.post"}}';

    var ContextController = _emberRuntimeControllersController.default.extend({ container: container });

    var controller;
    var id = 0;
    var BlogPostController = _emberRuntimeControllersController.default.extend({
      init: function () {
        this._super.apply(this, arguments);
        controller = this;
        this.uniqueId = id++;
      }
    });
    container._registry.register('controller:blog.post', BlogPostController);

    view = _emberViewsViewsView.default.create({
      container: container,
      controller: ContextController.create(),
      template: _emberTemplateCompilerSystemCompile.default(template)
    });

    _emberMetalCore.default.TEMPLATES['blog.post'] = _emberTemplateCompilerSystemCompile.default('{{uniqueId}}');

    _emberRuntimeTestsUtils.runAppend(view);

    var singletonController = container.lookup('controller:blog.post');
    equal(singletonController.uniqueId, view.$().html(), 'rendered with correct singleton controller');
  });

  QUnit.test('throws an assertion if {{render}} is called with an unquoted template name', function () {
    var template = '<h1>HI</h1>{{render home}}';
    var controller = _emberRuntimeControllersController.default.extend({ container: container });
    view = _emberViewsViewsView.default.create({
      container: container,
      controller: controller.create(),
      template: _emberTemplateCompilerSystemCompile.default(template)
    });

    _emberMetalCore.default.TEMPLATES['home'] = _emberTemplateCompilerSystemCompile.default('<p>BYE</p>');

    expectAssertion(function () {
      _emberRuntimeTestsUtils.runAppend(view);
    }, 'The first argument of {{render}} must be quoted, e.g. {{render "sidebar"}}.');
  });

  QUnit.test('throws an assertion if {{render}} is called with a literal for a model', function () {
    var template = '<h1>HI</h1>{{render "home" "model"}}';
    var controller = _emberRuntimeControllersController.default.extend({ container: container });
    view = _emberViewsViewsView.default.create({
      container: container,
      controller: controller.create(),
      template: _emberTemplateCompilerSystemCompile.default(template)
    });

    _emberMetalCore.default.TEMPLATES['home'] = _emberTemplateCompilerSystemCompile.default('<p>BYE</p>');

    expectAssertion(function () {
      _emberRuntimeTestsUtils.runAppend(view);
    }, 'The second argument of {{render}} must be a path, e.g. {{render "post" post}}.');
  });

  QUnit.test('{{render}} helper should let view provide its own template', function () {
    var template = '{{render \'fish\'}}';
    var controller = _emberRuntimeControllersController.default.extend({ container: container });
    view = _emberViewsViewsView.default.create({
      container: container,
      controller: controller.create(),
      template: _emberTemplateCompilerSystemCompile.default(template)
    });

    container._registry.register('template:fish', _emberTemplateCompilerSystemCompile.default('Hello fish!'));
    container._registry.register('template:other', _emberTemplateCompilerSystemCompile.default('Hello other!'));

    container._registry.register('view:fish', _emberViewsViewsView.default.extend({
      templateName: 'other'
    }));

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'Hello other!');
  });

  QUnit.test('{{render}} helper should not require view to provide its own template', function () {
    var template = '{{render \'fish\'}}';
    var controller = _emberRuntimeControllersController.default.extend({ container: container });
    view = _emberViewsViewsView.default.create({
      container: container,
      controller: controller.create(),
      template: _emberTemplateCompilerSystemCompile.default(template)
    });

    container._registry.register('template:fish', _emberTemplateCompilerSystemCompile.default('Hello fish!'));

    container._registry.register('view:fish', _emberViewsViewsView.default.extend());

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'Hello fish!');
  });
});
// TEMPLATES
enifed('ember-routing-htmlbars/tests/helpers/render_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-routing-htmlbars/tests/helpers');
  test('ember-routing-htmlbars/tests/helpers/render_test.js should pass jscs', function () {
    ok(true, 'ember-routing-htmlbars/tests/helpers/render_test.js should pass jscs.');
  });
});
enifed('ember-routing-htmlbars/tests/helpers/render_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-routing-htmlbars/tests/helpers');
  QUnit.test('ember-routing-htmlbars/tests/helpers/render_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-routing-htmlbars/tests/helpers/render_test.js should pass jshint.');
  });
});
enifed('ember-routing-htmlbars/tests/utils', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-runtime/system/string', 'container/registry', 'ember-runtime/controllers/controller', 'ember-views/views/view', 'ember-routing/system/router', 'ember-routing-views/views/outlet', 'ember-routing/location/hash_location'], function (exports, _emberMetalCore, _emberMetalProperty_get, _emberMetalProperty_set, _emberRuntimeSystemString, _containerRegistry, _emberRuntimeControllersController, _emberViewsViewsView, _emberRoutingSystemRouter, _emberRoutingViewsViewsOutlet, _emberRoutingLocationHash_location) {
  'use strict';

  function resolverFor(namespace) {
    return function (fullName) {
      var nameParts = fullName.split(':');
      var type = nameParts[0];
      var name = nameParts[1];

      if (type === 'template') {
        var templateName = _emberRuntimeSystemString.decamelize(name);
        if (_emberMetalCore.default.TEMPLATES[templateName]) {
          return _emberMetalCore.default.TEMPLATES[templateName];
        }
      }

      var className = _emberRuntimeSystemString.classify(name) + _emberRuntimeSystemString.classify(type);
      var factory = _emberMetalProperty_get.get(namespace, className);

      if (factory) {
        return factory;
      }
    };
  }

  function buildRegistry(namespace) {
    var registry = new _containerRegistry.default();

    registry.set = _emberMetalProperty_set.set;
    registry.resolver = resolverFor(namespace);
    registry.optionsForType('view', { singleton: false });
    registry.optionsForType('template', { instantiate: false });
    registry.register('application:main', namespace, { instantiate: false });
    registry.injection('router:main', 'namespace', 'application:main');

    registry.register('location:hash', _emberRoutingLocationHash_location.default);

    registry.register('controller:basic', _emberRuntimeControllersController.default, { instantiate: false });

    registry.register('view:toplevel', _emberViewsViewsView.default.extend());
    registry.register('view:-outlet', _emberRoutingViewsViewsOutlet.OutletView);
    registry.register('view:core-outlet', _emberRoutingViewsViewsOutlet.CoreOutletView);
    registry.register('router:main', _emberRoutingSystemRouter.default.extend());

    registry.typeInjection('route', 'router', 'router:main');

    return registry;
  }

  exports.resolverFor = resolverFor;
  exports.buildRegistry = buildRegistry;
});
enifed('ember-routing-htmlbars/tests/utils.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-routing-htmlbars/tests');
  test('ember-routing-htmlbars/tests/utils.js should pass jscs', function () {
    ok(true, 'ember-routing-htmlbars/tests/utils.js should pass jscs.');
  });
});
enifed('ember-routing-htmlbars/tests/utils.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-routing-htmlbars/tests');
  QUnit.test('ember-routing-htmlbars/tests/utils.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-routing-htmlbars/tests/utils.js should pass jshint.');
  });
});
enifed('ember-routing-views.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - .');
  test('ember-routing-views.js should pass jscs', function () {
    ok(true, 'ember-routing-views.js should pass jscs.');
  });
});
enifed('ember-routing-views.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - .');
  QUnit.test('ember-routing-views.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-routing-views.js should pass jshint.');
  });
});
enifed('ember-routing-views/tests/main_test', ['exports', 'ember-routing-views'], function (exports, _emberRoutingViews) {
  'use strict';

  QUnit.module('ember-routing-views');

  QUnit.test('exports correctly', function () {
    ok(_emberRoutingViews.default.LinkComponent, 'LinkComponent is exported correctly');
    ok(_emberRoutingViews.default.OutletView, 'OutletView is exported correctly');
  });

  QUnit.test('`LinkComponent#currentWhen` is deprecated in favour of `current-when` (DEPRECATED)', function () {
    expectDeprecation(/Usage of `currentWhen` is deprecated, use `current-when` instead/);
    var link = _emberRoutingViews.default.LinkComponent.create();
    link.get('currentWhen');
  });
});
enifed('ember-routing-views/tests/main_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-routing-views/tests');
  test('ember-routing-views/tests/main_test.js should pass jscs', function () {
    ok(true, 'ember-routing-views/tests/main_test.js should pass jscs.');
  });
});
enifed('ember-routing-views/tests/main_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-routing-views/tests');
  QUnit.test('ember-routing-views/tests/main_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-routing-views/tests/main_test.js should pass jshint.');
  });
});
enifed('ember-routing-views/views/link.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-routing-views/views');
  test('ember-routing-views/views/link.js should pass jscs', function () {
    ok(true, 'ember-routing-views/views/link.js should pass jscs.');
  });
});
enifed('ember-routing-views/views/link.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-routing-views/views');
  QUnit.test('ember-routing-views/views/link.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-routing-views/views/link.js should pass jshint.');
  });
});
enifed('ember-routing-views/views/outlet.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-routing-views/views');
  test('ember-routing-views/views/outlet.js should pass jscs', function () {
    ok(true, 'ember-routing-views/views/outlet.js should pass jscs.');
  });
});
enifed('ember-routing-views/views/outlet.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-routing-views/views');
  QUnit.test('ember-routing-views/views/outlet.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-routing-views/views/outlet.js should pass jshint.');
  });
});
enifed('ember-routing.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - .');
  test('ember-routing.js should pass jscs', function () {
    ok(true, 'ember-routing.js should pass jscs.');
  });
});
enifed('ember-routing.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - .');
  QUnit.test('ember-routing.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-routing.js should pass jshint.');
  });
});
enifed('ember-routing/ext/controller.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-routing/ext');
  test('ember-routing/ext/controller.js should pass jscs', function () {
    ok(true, 'ember-routing/ext/controller.js should pass jscs.');
  });
});
enifed('ember-routing/ext/controller.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-routing/ext');
  QUnit.test('ember-routing/ext/controller.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-routing/ext/controller.js should pass jshint.');
  });
});
enifed('ember-routing/ext/run_loop.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-routing/ext');
  test('ember-routing/ext/run_loop.js should pass jscs', function () {
    ok(true, 'ember-routing/ext/run_loop.js should pass jscs.');
  });
});
enifed('ember-routing/ext/run_loop.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-routing/ext');
  QUnit.test('ember-routing/ext/run_loop.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-routing/ext/run_loop.js should pass jshint.');
  });
});
enifed('ember-routing/initializers/routing-service.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-routing/initializers');
  test('ember-routing/initializers/routing-service.js should pass jscs', function () {
    ok(true, 'ember-routing/initializers/routing-service.js should pass jscs.');
  });
});
enifed('ember-routing/initializers/routing-service.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-routing/initializers');
  QUnit.test('ember-routing/initializers/routing-service.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-routing/initializers/routing-service.js should pass jshint.');
  });
});
enifed('ember-routing/location/api.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-routing/location');
  test('ember-routing/location/api.js should pass jscs', function () {
    ok(true, 'ember-routing/location/api.js should pass jscs.');
  });
});
enifed('ember-routing/location/api.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-routing/location');
  QUnit.test('ember-routing/location/api.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-routing/location/api.js should pass jshint.');
  });
});
enifed('ember-routing/location/auto_location.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-routing/location');
  test('ember-routing/location/auto_location.js should pass jscs', function () {
    ok(true, 'ember-routing/location/auto_location.js should pass jscs.');
  });
});
enifed('ember-routing/location/auto_location.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-routing/location');
  QUnit.test('ember-routing/location/auto_location.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-routing/location/auto_location.js should pass jshint.');
  });
});
enifed('ember-routing/location/hash_location.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-routing/location');
  test('ember-routing/location/hash_location.js should pass jscs', function () {
    ok(true, 'ember-routing/location/hash_location.js should pass jscs.');
  });
});
enifed('ember-routing/location/hash_location.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-routing/location');
  QUnit.test('ember-routing/location/hash_location.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-routing/location/hash_location.js should pass jshint.');
  });
});
enifed('ember-routing/location/history_location.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-routing/location');
  test('ember-routing/location/history_location.js should pass jscs', function () {
    ok(true, 'ember-routing/location/history_location.js should pass jscs.');
  });
});
enifed('ember-routing/location/history_location.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-routing/location');
  QUnit.test('ember-routing/location/history_location.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-routing/location/history_location.js should pass jshint.');
  });
});
enifed('ember-routing/location/none_location.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-routing/location');
  test('ember-routing/location/none_location.js should pass jscs', function () {
    ok(true, 'ember-routing/location/none_location.js should pass jscs.');
  });
});
enifed('ember-routing/location/none_location.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-routing/location');
  QUnit.test('ember-routing/location/none_location.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-routing/location/none_location.js should pass jshint.');
  });
});
enifed('ember-routing/location/util.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-routing/location');
  test('ember-routing/location/util.js should pass jscs', function () {
    ok(true, 'ember-routing/location/util.js should pass jscs.');
  });
});
enifed('ember-routing/location/util.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-routing/location');
  QUnit.test('ember-routing/location/util.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-routing/location/util.js should pass jshint.');
  });
});
enifed('ember-routing/services/routing.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-routing/services');
  test('ember-routing/services/routing.js should pass jscs', function () {
    ok(true, 'ember-routing/services/routing.js should pass jscs.');
  });
});
enifed('ember-routing/services/routing.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-routing/services');
  QUnit.test('ember-routing/services/routing.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-routing/services/routing.js should pass jshint.');
  });
});
enifed('ember-routing/system/cache.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-routing/system');
  test('ember-routing/system/cache.js should pass jscs', function () {
    ok(true, 'ember-routing/system/cache.js should pass jscs.');
  });
});
enifed('ember-routing/system/cache.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-routing/system');
  QUnit.test('ember-routing/system/cache.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-routing/system/cache.js should pass jshint.');
  });
});
enifed('ember-routing/system/controller_for.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-routing/system');
  test('ember-routing/system/controller_for.js should pass jscs', function () {
    ok(true, 'ember-routing/system/controller_for.js should pass jscs.');
  });
});
enifed('ember-routing/system/controller_for.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-routing/system');
  QUnit.test('ember-routing/system/controller_for.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-routing/system/controller_for.js should pass jshint.');
  });
});
enifed('ember-routing/system/dsl.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-routing/system');
  test('ember-routing/system/dsl.js should pass jscs', function () {
    ok(true, 'ember-routing/system/dsl.js should pass jscs.');
  });
});
enifed('ember-routing/system/dsl.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-routing/system');
  QUnit.test('ember-routing/system/dsl.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-routing/system/dsl.js should pass jshint.');
  });
});
enifed('ember-routing/system/generate_controller.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-routing/system');
  test('ember-routing/system/generate_controller.js should pass jscs', function () {
    ok(true, 'ember-routing/system/generate_controller.js should pass jscs.');
  });
});
enifed('ember-routing/system/generate_controller.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-routing/system');
  QUnit.test('ember-routing/system/generate_controller.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-routing/system/generate_controller.js should pass jshint.');
  });
});
enifed('ember-routing/system/query_params.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-routing/system');
  test('ember-routing/system/query_params.js should pass jscs', function () {
    ok(true, 'ember-routing/system/query_params.js should pass jscs.');
  });
});
enifed('ember-routing/system/query_params.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-routing/system');
  QUnit.test('ember-routing/system/query_params.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-routing/system/query_params.js should pass jshint.');
  });
});
enifed('ember-routing/system/route.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-routing/system');
  test('ember-routing/system/route.js should pass jscs', function () {
    ok(true, 'ember-routing/system/route.js should pass jscs.');
  });
});
enifed('ember-routing/system/route.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-routing/system');
  QUnit.test('ember-routing/system/route.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-routing/system/route.js should pass jshint.');
  });
});
enifed('ember-routing/system/router.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-routing/system');
  test('ember-routing/system/router.js should pass jscs', function () {
    ok(true, 'ember-routing/system/router.js should pass jscs.');
  });
});
enifed('ember-routing/system/router.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-routing/system');
  QUnit.test('ember-routing/system/router.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-routing/system/router.js should pass jshint.');
  });
});
enifed('ember-routing/system/router_state.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-routing/system');
  test('ember-routing/system/router_state.js should pass jscs', function () {
    ok(true, 'ember-routing/system/router_state.js should pass jscs.');
  });
});
enifed('ember-routing/system/router_state.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-routing/system');
  QUnit.test('ember-routing/system/router_state.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-routing/system/router_state.js should pass jshint.');
  });
});
enifed('ember-routing/tests/location/auto_location_test', ['exports', 'ember-metal/property_get', 'ember-metal/run_loop', 'ember-metal/merge', 'ember-routing/location/auto_location', 'ember-routing/location/history_location', 'ember-routing/location/hash_location', 'ember-routing/location/none_location', 'container/registry'], function (exports, _emberMetalProperty_get, _emberMetalRun_loop, _emberMetalMerge, _emberRoutingLocationAuto_location, _emberRoutingLocationHistory_location, _emberRoutingLocationHash_location, _emberRoutingLocationNone_location, _containerRegistry) {
  'use strict';

  function mockBrowserLocation(overrides) {
    return _emberMetalMerge.default({
      href: 'http://test.com/',
      pathname: '/',
      hash: '',
      search: '',
      replace: function () {
        ok(false, 'location.replace should not be called during testing');
      }
    }, overrides);
  }

  function mockBrowserHistory(overrides) {
    return _emberMetalMerge.default({
      pushState: function () {
        ok(false, 'history.pushState should not be called during testing');
      },
      replaceState: function () {
        ok(false, 'history.replaceState should not be called during testing');
      }
    }, overrides);
  }

  function createLocation(location, history) {
    var registry = new _containerRegistry.default();

    registry.register('location:history', _emberRoutingLocationHistory_location.default);
    registry.register('location:hash', _emberRoutingLocationHash_location.default);
    registry.register('location:none', _emberRoutingLocationNone_location.default);

    return _emberRoutingLocationAuto_location.default.create({
      container: registry.container(),
      location: location,
      history: history,
      global: {}
    });
  }

  var location;

  QUnit.module('Ember.AutoLocation', {
    teardown: function () {
      if (location) {
        _emberMetalRun_loop.default(location, 'destroy');
      }
    }
  });

  QUnit.test('AutoLocation should return concrete implementation\'s value for `getURL`', function () {
    expect(1);

    var browserLocation = mockBrowserLocation();
    var browserHistory = mockBrowserHistory();

    location = createLocation(browserLocation, browserHistory);
    location.detect();

    var concreteImplementation = _emberMetalProperty_get.get(location, 'concreteImplementation');

    concreteImplementation.getURL = function () {
      return '/lincoln/park';
    };

    equal(location.getURL(), '/lincoln/park');
  });

  QUnit.test('AutoLocation should use a HistoryLocation instance when pushStates is supported', function () {
    expect(1);

    var browserLocation = mockBrowserLocation();
    var browserHistory = mockBrowserHistory();

    location = createLocation(browserLocation, browserHistory);
    location.detect();

    ok(_emberMetalProperty_get.get(location, 'concreteImplementation') instanceof _emberRoutingLocationHistory_location.default);
  });

  QUnit.test('AutoLocation should use a HashLocation instance when pushStates are not supported, but hashchange events are and the URL is already in the HashLocation format', function () {
    expect(1);

    var browserLocation = mockBrowserLocation({
      hash: '#/testd'
    });

    location = createLocation(browserLocation);
    location.global = {
      onhashchange: function () {}
    };

    location.detect();
    ok(_emberMetalProperty_get.get(location, 'concreteImplementation') instanceof _emberRoutingLocationHash_location.default);
  });

  QUnit.test('AutoLocation should use a NoneLocation instance when neither history nor hashchange are supported.', function () {
    expect(1);

    location = createLocation(mockBrowserLocation());
    location.detect();

    ok(_emberMetalProperty_get.get(location, 'concreteImplementation') instanceof _emberRoutingLocationNone_location.default);
  });

  QUnit.test('AutoLocation should use an index path (i.e. \'/\') without any location.hash as OK for HashLocation', function () {
    expect(1);

    var browserLocation = mockBrowserLocation({
      href: 'http://test.com/',
      pathname: '/',
      hash: '',
      search: '',
      replace: function (path) {
        ok(false, 'location.replace should not be called');
      }
    });

    location = createLocation(browserLocation);
    location.global = {
      onhashchange: function () {}
    };

    location.detect();

    ok(_emberMetalProperty_get.get(location, 'concreteImplementation') instanceof _emberRoutingLocationHash_location.default, 'uses a HashLocation');
  });

  QUnit.test('AutoLocation should transform the URL for hashchange-only browsers viewing a HistoryLocation-formatted path', function () {
    expect(3);

    var browserLocation = mockBrowserLocation({
      hash: '',
      hostname: 'test.com',
      href: 'http://test.com/test',
      pathname: '/test',
      protocol: 'http:',
      port: '',
      search: '',

      replace: function (path) {
        equal(path, 'http://test.com/#/test', 'location.replace should be called with normalized HashLocation path');
      }
    });

    var location = createLocation(browserLocation);
    location.global = {
      onhashchange: function () {}
    };

    location.detect();

    ok(_emberMetalProperty_get.get(location, 'concreteImplementation') instanceof _emberRoutingLocationNone_location.default, 'NoneLocation should be used while we attempt to location.replace()');
    equal(_emberMetalProperty_get.get(location, 'cancelRouterSetup'), true, 'cancelRouterSetup should be set so the router knows.');
  });

  QUnit.test('AutoLocation should replace the URL for pushState-supported browsers viewing a HashLocation-formatted url', function () {
    expect(2);

    var browserLocation = mockBrowserLocation({
      hash: '#/test',
      hostname: 'test.com',
      href: 'http://test.com/#/test',
      pathname: '/',
      protocol: 'http:',
      port: '',
      search: ''
    });

    var browserHistory = mockBrowserHistory({
      replaceState: function (state, title, path) {
        equal(path, '/test', 'history.replaceState should be called with normalized HistoryLocation url');
      }
    });

    var location = createLocation(browserLocation, browserHistory);
    location.detect();

    ok(_emberMetalProperty_get.get(location, 'concreteImplementation'), _emberRoutingLocationHistory_location.default);
  });

  QUnit.test('AutoLocation requires any rootURL given to end in a trailing forward slash', function () {
    expect(3);
    var browserLocation = mockBrowserLocation();
    var expectedMsg = /rootURL must end with a trailing forward slash e.g. "\/app\/"/;

    location = createLocation(browserLocation);
    location.rootURL = 'app';

    expectAssertion(function () {
      location.detect();
    }, expectedMsg);

    location.rootURL = '/app';
    expectAssertion(function () {
      location.detect();
    }, expectedMsg);

    // Note the trailing whitespace
    location.rootURL = '/app/ ';
    expectAssertion(function () {
      location.detect();
    }, expectedMsg);
  });

  QUnit.test('AutoLocation provides its rootURL to the concreteImplementation', function () {
    expect(1);
    var browserLocation = mockBrowserLocation({
      pathname: '/some/subdir/derp'
    });
    var browserHistory = mockBrowserHistory();

    location = createLocation(browserLocation, browserHistory);
    location.rootURL = '/some/subdir/';

    location.detect();

    var concreteLocation = _emberMetalProperty_get.get(location, 'concreteImplementation');
    equal(location.rootURL, concreteLocation.rootURL);
  });

  QUnit.test('getHistoryPath() should return a normalized, HistoryLocation-supported path', function () {
    expect(3);

    var browserLocation = mockBrowserLocation({
      href: 'http://test.com/app/about?foo=bar#foo',
      pathname: '/app/about',
      search: '?foo=bar',
      hash: '#foo'
    });

    equal(_emberRoutingLocationAuto_location.getHistoryPath('/app/', browserLocation), '/app/about?foo=bar#foo', 'URLs already in HistoryLocation form should come out the same');

    browserLocation = mockBrowserLocation({
      href: 'http://test.com/app/#/about?foo=bar#foo',
      pathname: '/app/',
      search: '',
      hash: '#/about?foo=bar#foo'
    });
    equal(_emberRoutingLocationAuto_location.getHistoryPath('/app/', browserLocation), '/app/about?foo=bar#foo', 'HashLocation formed URLs should be normalized');

    browserLocation = mockBrowserLocation({
      href: 'http://test.com/app/#about?foo=bar#foo',
      pathname: '/app/',
      search: '',
      hash: '#about?foo=bar#foo'
    });
    equal(_emberRoutingLocationAuto_location.getHistoryPath('/app', browserLocation), '/app/#about?foo=bar#foo', 'URLs with a hash not following #/ convention shouldn\'t be normalized as a route');
  });

  QUnit.test('getHashPath() should return a normalized, HashLocation-supported path', function () {
    expect(3);

    var browserLocation = mockBrowserLocation({
      href: 'http://test.com/app/#/about?foo=bar#foo',
      pathname: '/app/',
      search: '',
      hash: '#/about?foo=bar#foo'
    });
    equal(_emberRoutingLocationAuto_location.getHashPath('/app/', browserLocation), '/app/#/about?foo=bar#foo', 'URLs already in HistoryLocation form should come out the same');

    browserLocation = mockBrowserLocation({
      href: 'http://test.com/app/about?foo=bar#foo',
      pathname: '/app/about',
      search: '?foo=bar',
      hash: '#foo'
    });
    equal(_emberRoutingLocationAuto_location.getHashPath('/app/', browserLocation), '/app/#/about?foo=bar#foo', 'HistoryLocation formed URLs should be normalized');

    browserLocation = mockBrowserLocation({
      href: 'http://test.com/app/#about?foo=bar#foo',
      pathname: '/app/',
      search: '',
      hash: '#about?foo=bar#foo'
    });

    equal(_emberRoutingLocationAuto_location.getHashPath('/app/', browserLocation), '/app/#/#about?foo=bar#foo', 'URLs with a hash not following #/ convention shouldn\'t be normalized as a route');
  });
});
enifed('ember-routing/tests/location/auto_location_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-routing/tests/location');
  test('ember-routing/tests/location/auto_location_test.js should pass jscs', function () {
    ok(true, 'ember-routing/tests/location/auto_location_test.js should pass jscs.');
  });
});
enifed('ember-routing/tests/location/auto_location_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-routing/tests/location');
  QUnit.test('ember-routing/tests/location/auto_location_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-routing/tests/location/auto_location_test.js should pass jshint.');
  });
});
enifed('ember-routing/tests/location/hash_location_test', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-metal/utils', 'ember-metal/run_loop', 'ember-routing/location/hash_location'], function (exports, _emberMetalCore, _emberMetalProperty_get, _emberMetalUtils, _emberMetalRun_loop, _emberRoutingLocationHash_location) {
  'use strict';

  var HashTestLocation, location;

  function createLocation(options) {
    if (!options) {
      options = {};
    }
    location = HashTestLocation.create(options);
  }

  function mockBrowserLocation(path) {
    // This is a neat trick to auto-magically extract the hostname from any
    // url by letting the browser do the work ;)
    var tmp = document.createElement('a');
    tmp.href = path;

    var protocol = !tmp.protocol || tmp.protocol === ':' ? 'http' : tmp.protocol;
    var pathname = tmp.pathname.match(/^\//) ? tmp.pathname : '/' + tmp.pathname;

    return {
      hash: tmp.hash,
      host: tmp.host || 'localhost',
      hostname: tmp.hostname || 'localhost',
      href: tmp.href,
      pathname: pathname,
      port: tmp.port || '',
      protocol: protocol,
      search: tmp.search
    };
  }

  QUnit.module('Ember.HashLocation', {
    setup: function () {
      HashTestLocation = _emberRoutingLocationHash_location.default.extend({
        _location: {
          href: 'http://test.com/',
          pathname: '/',
          hash: '',
          search: '',
          replace: function () {
            ok(false, 'location.replace should not be called during testing');
          }
        }
      });
    },

    teardown: function () {
      _emberMetalRun_loop.default(function () {
        if (location) {
          location.destroy();
        }
      });
    }
  });

  QUnit.test('HashLocation.getURL() returns the current url', function () {
    expect(1);

    createLocation({
      _location: mockBrowserLocation('/#/foo/bar')
    });

    equal(location.getURL(), '/foo/bar');
  });

  QUnit.test('HashLocation.getURL() includes extra hashes', function () {
    expect(1);

    createLocation({
      _location: mockBrowserLocation('/#/foo#bar#car')
    });

    equal(location.getURL(), '/foo#bar#car');
  });

  QUnit.test('HashLocation.getURL() assumes location.hash without #/ prefix is not a route path', function () {
    expect(1);

    createLocation({
      _location: mockBrowserLocation('/#foo#bar')
    });

    equal(location.getURL(), '/#foo#bar');
  });

  QUnit.test('HashLocation.getURL() returns a normal forward slash when there is no location.hash', function () {
    expect(1);

    createLocation({
      _location: mockBrowserLocation('/')
    });

    equal(location.getURL(), '/');
  });

  QUnit.test('HashLocation.setURL() correctly sets the url', function () {
    expect(2);

    createLocation();

    location.setURL('/bar');

    equal(_emberMetalProperty_get.get(location, 'location.hash'), '/bar');
    equal(_emberMetalProperty_get.get(location, 'lastSetURL'), '/bar');
  });

  QUnit.test('HashLocation.replaceURL() correctly replaces to the path with a page reload', function () {
    expect(2);

    createLocation({
      _location: {
        replace: function (path) {
          equal(path, '#/foo');
        }
      }
    });

    location.replaceURL('/foo');

    equal(_emberMetalProperty_get.get(location, 'lastSetURL'), '/foo');
  });

  QUnit.test('HashLocation.onUpdateURL() registers a hashchange callback', function () {
    expect(3);

    var oldJquery = _emberMetalCore.default.$;

    _emberMetalCore.default.$ = function (element) {
      equal(element, window);
      return {
        on: function (eventName, callback) {
          equal(eventName, 'hashchange.ember-location-' + guid);
          equal(Object.prototype.toString.call(callback), '[object Function]');
        }
      };
    };

    createLocation({
      // Mock so test teardown doesn't fail
      willDestroy: function () {}
    });

    var guid = _emberMetalUtils.guidFor(location);

    location.onUpdateURL(function () {});

    // clean up
    _emberMetalCore.default.$ = oldJquery;
  });

  QUnit.test('HashLocation.onUpdateURL callback executes as expected', function () {
    expect(1);

    createLocation({
      _location: mockBrowserLocation('/#/foo/bar')
    });

    var callback = function (param) {
      equal(param, '/foo/bar', 'path is passed as param');
    };

    location.onUpdateURL(callback);

    _emberMetalCore.default.$(window).trigger('hashchange');
  });

  QUnit.test('HashLocation.onUpdateURL doesn\'t execute callback if lastSetURL === path', function () {
    expect(0);

    createLocation({
      _location: {
        href: '/#/foo/bar'
      },
      lastSetURL: '/foo/bar'
    });

    var callback = function (param) {
      ok(false, 'callback should not be called');
    };

    location.onUpdateURL(callback);

    _emberMetalCore.default.$(window).trigger('hashchange');
  });

  QUnit.test('HashLocation.formatURL() prepends a # to the provided string', function () {
    expect(1);

    createLocation();

    equal(location.formatURL('/foo#bar'), '#/foo#bar');
  });

  QUnit.test('HashLocation.willDestroy() cleans up hashchange event listener', function () {
    expect(2);

    var oldJquery = _emberMetalCore.default.$;

    _emberMetalCore.default.$ = function (element) {
      equal(element, window);

      return {
        off: function (eventName) {
          equal(eventName, 'hashchange.ember-location-' + guid);
        }
      };
    };

    createLocation();

    var guid = _emberMetalUtils.guidFor(location);

    location.willDestroy();

    // noop so test teardown doesn't call our mocked jQuery again
    location.willDestroy = function () {};

    // clean up
    _emberMetalCore.default.$ = oldJquery;
  });
});
enifed('ember-routing/tests/location/hash_location_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-routing/tests/location');
  test('ember-routing/tests/location/hash_location_test.js should pass jscs', function () {
    ok(true, 'ember-routing/tests/location/hash_location_test.js should pass jscs.');
  });
});
enifed('ember-routing/tests/location/hash_location_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-routing/tests/location');
  QUnit.test('ember-routing/tests/location/hash_location_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-routing/tests/location/hash_location_test.js should pass jshint.');
  });
});
enifed('ember-routing/tests/location/history_location_test', ['exports', 'ember-metal/property_set', 'ember-metal/run_loop', 'ember-routing/location/history_location'], function (exports, _emberMetalProperty_set, _emberMetalRun_loop, _emberRoutingLocationHistory_location) {
  'use strict';

  var FakeHistory, HistoryTestLocation, location;

  function createLocation(options) {
    if (!options) {
      options = {};
    }
    location = HistoryTestLocation.create(options);
  }

  function mockBrowserLocation(path) {
    // This is a neat trick to auto-magically extract the hostname from any
    // url by letting the browser do the work ;)
    var tmp = document.createElement('a');
    tmp.href = path;

    var protocol = !tmp.protocol || tmp.protocol === ':' ? 'http' : tmp.protocol;
    var pathname = tmp.pathname.match(/^\//) ? tmp.pathname : '/' + tmp.pathname;

    return {
      hash: tmp.hash,
      host: tmp.host || 'localhost',
      hostname: tmp.hostname || 'localhost',
      href: tmp.href,
      pathname: pathname,
      port: tmp.port || '',
      protocol: protocol,
      search: tmp.search
    };
  }

  QUnit.module('Ember.HistoryLocation', {
    setup: function () {
      FakeHistory = {
        state: null,
        _states: [],
        replaceState: function (state, title, url) {
          this.state = state;
          this._states[0] = state;
        },
        pushState: function (state, title, url) {
          this.state = state;
          this._states.unshift(state);
        }
      };

      HistoryTestLocation = _emberRoutingLocationHistory_location.default.extend({
        history: FakeHistory
      });
    },

    teardown: function () {
      _emberMetalRun_loop.default(function () {
        if (location) {
          location.destroy();
        }
      });
    }
  });

  QUnit.test('HistoryLocation initState does not get fired on init', function () {
    expect(1);

    HistoryTestLocation.reopen({
      init: function () {
        ok(true, 'init was called');
        this._super.apply(this, arguments);
      },
      initState: function () {
        ok(false, 'initState() should not be called automatically');
      }
    });

    createLocation();
  });

  QUnit.test('webkit doesn\'t fire popstate on page load', function () {
    expect(1);

    HistoryTestLocation.reopen({
      initState: function () {
        this._super.apply(this, arguments);
        // these two should be equal to be able
        // to successfully detect webkit initial popstate
        equal(this._previousURL, this.getURL());
      }
    });

    createLocation();
    location.initState();
  });

  QUnit.test('base URL is removed when retrieving the current pathname', function () {
    expect(1);

    HistoryTestLocation.reopen({
      init: function () {
        this._super.apply(this, arguments);

        _emberMetalProperty_set.set(this, 'location', mockBrowserLocation('/base/foo/bar'));
        _emberMetalProperty_set.set(this, 'baseURL', '/base/');
      },

      initState: function () {
        this._super.apply(this, arguments);

        equal(this.getURL(), '/foo/bar');
      }
    });

    createLocation();
    location.initState();
  });

  QUnit.test('base URL is preserved when moving around', function () {
    expect(1);

    HistoryTestLocation.reopen({
      init: function () {
        this._super.apply(this, arguments);

        _emberMetalProperty_set.set(this, 'location', mockBrowserLocation('/base/foo/bar'));
        _emberMetalProperty_set.set(this, 'baseURL', '/base/');
      }
    });

    createLocation();
    location.initState();
    location.setURL('/one/two');

    equal(location._historyState.path, '/base/one/two');
  });

  QUnit.test('setURL continues to set even with a null state (iframes may set this)', function () {
    expect(1);

    createLocation();
    location.initState();

    FakeHistory.pushState(null);
    location.setURL('/three/four');

    equal(location._historyState.path, '/three/four');
  });

  QUnit.test('replaceURL continues to set even with a null state (iframes may set this)', function () {
    expect(1);

    createLocation();
    location.initState();

    FakeHistory.pushState(null);
    location.replaceURL('/three/four');

    equal(location._historyState.path, '/three/four');
  });

  QUnit.test('HistoryLocation.getURL() returns the current url, excluding both rootURL and baseURL', function () {
    expect(1);

    HistoryTestLocation.reopen({
      init: function () {
        this._super.apply(this, arguments);

        _emberMetalProperty_set.set(this, 'location', mockBrowserLocation('/base/foo/bar'));
        _emberMetalProperty_set.set(this, 'rootURL', '/app/');
        _emberMetalProperty_set.set(this, 'baseURL', '/base/');
      }
    });

    createLocation();

    equal(location.getURL(), '/foo/bar');
  });

  QUnit.test('HistoryLocation.getURL() includes location.search', function () {
    expect(1);

    HistoryTestLocation.reopen({
      init: function () {
        this._super.apply(this, arguments);
        _emberMetalProperty_set.set(this, 'location', mockBrowserLocation('/foo/bar?time=morphin'));
      }
    });

    createLocation();

    equal(location.getURL(), '/foo/bar?time=morphin');
  });

  QUnit.test('HistoryLocation.getURL() includes location.hash', function () {
    expect(1);

    HistoryTestLocation.reopen({
      init: function () {
        this._super.apply(this, arguments);
        _emberMetalProperty_set.set(this, 'location', mockBrowserLocation('/foo/bar#pink-power-ranger'));
      }
    });

    createLocation();

    equal(location.getURL(), '/foo/bar#pink-power-ranger');
  });

  QUnit.test('HistoryLocation.getURL() includes location.hash and location.search', function () {
    expect(1);

    HistoryTestLocation.reopen({
      init: function () {
        this._super.apply(this, arguments);
        _emberMetalProperty_set.set(this, 'location', mockBrowserLocation('/foo/bar?time=morphin#pink-power-ranger'));
      }
    });

    createLocation();

    equal(location.getURL(), '/foo/bar?time=morphin#pink-power-ranger');
  });
});
enifed('ember-routing/tests/location/history_location_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-routing/tests/location');
  test('ember-routing/tests/location/history_location_test.js should pass jscs', function () {
    ok(true, 'ember-routing/tests/location/history_location_test.js should pass jscs.');
  });
});
enifed('ember-routing/tests/location/history_location_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-routing/tests/location');
  QUnit.test('ember-routing/tests/location/history_location_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-routing/tests/location/history_location_test.js should pass jshint.');
  });
});
enifed('ember-routing/tests/location/util_test', ['exports', 'ember-metal/merge', 'ember-routing/location/util'], function (exports, _emberMetalMerge, _emberRoutingLocationUtil) {
  'use strict';

  function mockBrowserLocation(overrides) {
    return _emberMetalMerge.default({
      href: 'http://test.com/',
      pathname: '/',
      hash: '',
      search: '',
      replace: function () {
        ok(false, 'location.replace should not be called during testing');
      }
    }, overrides);
  }

  QUnit.module('Location Utilities');

  QUnit.test('replacePath cannot be used to redirect to a different origin', function () {
    expect(1);

    var expectedURL;

    var location = {
      protocol: 'http:',
      hostname: 'emberjs.com',
      port: '1337',

      replace: function (url) {
        equal(url, expectedURL);
      }
    };

    expectedURL = 'http://emberjs.com:1337//google.com';
    _emberRoutingLocationUtil.replacePath(location, '//google.com');
  });

  QUnit.test('getPath() should normalize location.pathname, making sure it always returns a leading slash', function () {
    expect(2);

    var location = mockBrowserLocation({ pathname: 'test' });
    equal(_emberRoutingLocationUtil.getPath(location), '/test', 'When there is no leading slash, one is added.');

    location = mockBrowserLocation({ pathname: '/test' });
    equal(_emberRoutingLocationUtil.getPath(location), '/test', 'When a leading slash is already there, it isn\'t added again');
  });

  QUnit.test('getQuery() should return location.search as-is', function () {
    expect(1);

    var location = mockBrowserLocation({ search: '?foo=bar' });
    equal(_emberRoutingLocationUtil.getQuery(location), '?foo=bar');
  });

  QUnit.test('getFullPath() should return full pathname including query and hash', function () {
    expect(1);

    var location = mockBrowserLocation({
      href: 'http://test.com/about?foo=bar#foo',
      pathname: '/about',
      search: '?foo=bar',
      hash: '#foo'
    });

    equal(_emberRoutingLocationUtil.getFullPath(location), '/about?foo=bar#foo');
  });

  QUnit.test('Feature-Detecting onhashchange', function () {
    equal(_emberRoutingLocationUtil.supportsHashChange(undefined, { onhashchange: function () {} }), true, 'When not in IE, use onhashchange existence as evidence of the feature');
    equal(_emberRoutingLocationUtil.supportsHashChange(undefined, {}), false, 'When not in IE, use onhashchange absence as evidence of the feature absence');
    equal(_emberRoutingLocationUtil.supportsHashChange(7, { onhashchange: function () {} }), false, 'When in IE7 compatibility mode, never report existence of the feature');
    equal(_emberRoutingLocationUtil.supportsHashChange(8, { onhashchange: function () {} }), true, 'When in IE8+, use onhashchange existence as evidence of the feature');
  });

  // jscs:disable
  QUnit.test("Feature-detecting the history API", function () {
    equal(_emberRoutingLocationUtil.supportsHistory("", { pushState: true }), true, "returns true if not Android Gingerbread and history.pushState exists");
    equal(_emberRoutingLocationUtil.supportsHistory("", {}), false, "returns false if history.pushState doesn't exist");
    equal(_emberRoutingLocationUtil.supportsHistory("", undefined), false, "returns false if history doesn't exist");

    equal(_emberRoutingLocationUtil.supportsHistory("Mozilla/5.0 (Linux; U; Android 2.3.5; en-us; HTC Vision Build/GRI40) AppleWebKit/533.1 (KHTML, like Gecko) Version/4.0 Mobile Safari/533.1", { pushState: true }), false, "returns false if Android 2.x stock browser (not Chrome) claiming to support pushState");

    equal(_emberRoutingLocationUtil.supportsHistory("Mozilla/5.0 (Linux; U; Android 4.0.3; nl-nl; GT-N7000 Build/IML74K) AppleWebKit/534.30 (KHTML, like Gecko) Version/4.0 Mobile Safari/534.30", { pushState: true }), false, "returns false for Android 4.0.x stock browser (not Chrome) claiming to support pushState");

    equal(_emberRoutingLocationUtil.supportsHistory("Mozilla/5.0 (Linux; U; Android 20.3.5; en-us; HTC Vision Build/GRI40) AppleWebKit/533.1 (KHTML, like Gecko) Version/4.0 Mobile Safari/533.1", { pushState: true }), true, "returns true if Android version begins with 2, but is greater than 2");

    equal(_emberRoutingLocationUtil.supportsHistory("Mozilla/5.0 (Linux; Android 4.0.4; Galaxy Nexus Build/IMM76B) AppleWebKit/535.19 (KHTML, like Gecko) Chrome/18.0.1025.133 Mobile Safari/535.19", { pushState: true }), true, "returns true for Chrome (not stock browser) on Android 4.0.x");

    // Windows Phone UA and History API: https://github.com/Modernizr/Modernizr/issues/1471
    equal(_emberRoutingLocationUtil.supportsHistory("Mozilla/5.0 (Mobile; Windows Phone 8.1; Android 4.0; ARM; Trident/7.0; Touch; rv:11.0; IEMobile/11.0; Microsoft; Virtual) like iPhone OS 7_0_3 Mac OS X AppleWebKit/537 (KHTML, like Gecko) Mobile Safari/537", { pushState: true }), true, "returns true for Windows Phone 8.1 with misleading user agent string");
  });
  // jscs:enable
});
enifed('ember-routing/tests/location/util_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-routing/tests/location');
  test('ember-routing/tests/location/util_test.js should pass jscs', function () {
    ok(true, 'ember-routing/tests/location/util_test.js should pass jscs.');
  });
});
enifed('ember-routing/tests/location/util_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-routing/tests/location');
  QUnit.test('ember-routing/tests/location/util_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-routing/tests/location/util_test.js should pass jshint.');
  });
});
enifed('ember-routing/tests/system/controller_for_test', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/run_loop', 'container/registry', 'ember-runtime/system/namespace', 'ember-runtime/system/string', 'ember-runtime/controllers/controller', 'ember-routing/system/controller_for', 'ember-routing/system/generate_controller'], function (exports, _emberMetalCore, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalRun_loop, _containerRegistry, _emberRuntimeSystemNamespace, _emberRuntimeSystemString, _emberRuntimeControllersController, _emberRoutingSystemController_for, _emberRoutingSystemGenerate_controller) {
  'use strict';

  var buildContainer = function (namespace) {
    var registry = new _containerRegistry.default();
    var container = registry.container();

    registry.set = _emberMetalProperty_set.set;
    registry.resolver = resolverFor(namespace);
    registry.optionsForType('view', { singleton: false });

    registry.register('application:main', namespace, { instantiate: false });

    registry.register('controller:basic', _emberRuntimeControllersController.default, { instantiate: false });

    return container;
  };

  function resolverFor(namespace) {
    return function (fullName) {
      var nameParts = fullName.split(':');
      var type = nameParts[0];
      var name = nameParts[1];

      if (name === 'basic') {
        name = '';
      }
      var className = _emberRuntimeSystemString.classify(name) + _emberRuntimeSystemString.classify(type);
      var factory = _emberMetalProperty_get.get(namespace, className);

      if (factory) {
        return factory;
      }
    };
  }

  var container, appController, namespace;

  QUnit.module('Ember.controllerFor', {
    setup: function () {
      namespace = _emberRuntimeSystemNamespace.default.create();
      container = buildContainer(namespace);
      container._registry.register('controller:app', _emberRuntimeControllersController.default.extend());
      appController = container.lookup('controller:app');
    },
    teardown: function () {
      _emberMetalRun_loop.default(function () {
        container.destroy();
        namespace.destroy();
      });
    }
  });

  QUnit.test('controllerFor should lookup for registered controllers', function () {
    var controller = _emberRoutingSystemController_for.default(container, 'app');

    equal(appController, controller, 'should find app controller');
  });

  QUnit.module('Ember.generateController', {
    setup: function () {
      namespace = _emberRuntimeSystemNamespace.default.create();
      container = buildContainer(namespace);
    },
    teardown: function () {
      _emberMetalRun_loop.default(function () {
        container.destroy();
        namespace.destroy();
      });
    }
  });

  QUnit.test('generateController and generateControllerFactory are properties on the root namespace', function () {
    equal(_emberMetalCore.default.generateController, _emberRoutingSystemGenerate_controller.default, 'should export generateController');
    equal(_emberMetalCore.default.generateControllerFactory, _emberRoutingSystemGenerate_controller.generateControllerFactory, 'should export generateControllerFactory');
  });

  QUnit.test('generateController should create Ember.Controller', function () {
    var controller = _emberRoutingSystemGenerate_controller.default(container, 'home');

    ok(controller instanceof _emberRuntimeControllersController.default, 'should create controller');
  });

  QUnit.test('generateController should create App.Controller if provided', function () {
    var controller;
    namespace.Controller = _emberRuntimeControllersController.default.extend();

    controller = _emberRoutingSystemGenerate_controller.default(container, 'home');

    ok(controller instanceof namespace.Controller, 'should create controller');
  });
});
// A
enifed('ember-routing/tests/system/controller_for_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-routing/tests/system');
  test('ember-routing/tests/system/controller_for_test.js should pass jscs', function () {
    ok(true, 'ember-routing/tests/system/controller_for_test.js should pass jscs.');
  });
});
enifed('ember-routing/tests/system/controller_for_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-routing/tests/system');
  QUnit.test('ember-routing/tests/system/controller_for_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-routing/tests/system/controller_for_test.js should pass jshint.');
  });
});
enifed('ember-routing/tests/system/dsl_test', ['exports', 'ember-metal/features', 'ember-routing/system/router'], function (exports, _emberMetalFeatures, _emberRoutingSystemRouter) {
  'use strict';

  var Router;

  QUnit.module('Ember Router DSL', {
    setup: function () {
      Router = _emberRoutingSystemRouter.default.extend();
    },
    teardown: function () {
      Router = null;
    }
  });

  QUnit.test('should fail when using a reserved route name', function () {
    expectDeprecation('this.resource() is deprecated. Use this.route(\'name\', { resetNamespace: true }, function () {}) instead.');
    var reservedNames = ['array', 'basic', 'object', 'application'];

    expect(reservedNames.length * 2 + 1);

    reservedNames.forEach(function (reservedName) {
      expectAssertion(function () {
        Router = _emberRoutingSystemRouter.default.extend();

        Router.map(function () {
          this.route(reservedName);
        });

        var router = Router.create();
        router._initRouterJs();
      }, '\'' + reservedName + '\' cannot be used as a route name.');

      expectAssertion(function () {
        Router = _emberRoutingSystemRouter.default.extend();

        Router.map(function () {
          this.resource(reservedName);
        });

        var router = Router.create();
        router._initRouterJs();
      }, '\'' + reservedName + '\' cannot be used as a route name.');
    });
  });

  QUnit.test('should reset namespace if nested with resource', function () {
    expectDeprecation('this.resource() is deprecated. Use this.route(\'name\', { resetNamespace: true }, function () {}) instead.');

    Router = Router.map(function () {
      this.resource('bleep', function () {
        this.resource('bloop', function () {
          this.resource('blork');
        });
      });
    });

    var router = Router.create();
    router._initRouterJs();

    ok(router.router.recognizer.names['bleep'], 'nested resources do not contain parent name');
    ok(router.router.recognizer.names['bloop'], 'nested resources do not contain parent name');
    ok(router.router.recognizer.names['blork'], 'nested resources do not contain parent name');
  });

  QUnit.test('should retain resource namespace if nested with routes', function () {
    Router = Router.map(function () {
      this.route('bleep', function () {
        this.route('bloop', function () {
          this.route('blork');
        });
      });
    });

    var router = Router.create();
    router._initRouterJs();

    ok(router.router.recognizer.names['bleep'], 'parent name was used as base of nested routes');
    ok(router.router.recognizer.names['bleep.bloop'], 'parent name was used as base of nested routes');
    ok(router.router.recognizer.names['bleep.bloop.blork'], 'parent name was used as base of nested routes');
  });

  // jscs:disable validateIndentation

  QUnit.test('should add loading and error routes if _isRouterMapResult is true', function () {
    Router.map(function () {
      this.route('blork');
    });

    var router = Router.create();
    router._initRouterJs(true);

    ok(router.router.recognizer.names['blork'], 'main route was created');
    ok(router.router.recognizer.names['blork_loading'], 'loading route was added');
    ok(router.router.recognizer.names['blork_error'], 'error route was added');
  });

  QUnit.test('should not add loading and error routes if _isRouterMapResult is false', function () {
    Router.map(function () {
      this.route('blork');
    });

    var router = Router.create();
    router._initRouterJs(false);

    ok(router.router.recognizer.names['blork'], 'main route was created');
    ok(!router.router.recognizer.names['blork_loading'], 'loading route was not added');
    ok(!router.router.recognizer.names['blork_error'], 'error route was not added');
  });

  // jscs:enable validateIndentation
});
enifed('ember-routing/tests/system/dsl_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-routing/tests/system');
  test('ember-routing/tests/system/dsl_test.js should pass jscs', function () {
    ok(true, 'ember-routing/tests/system/dsl_test.js should pass jscs.');
  });
});
enifed('ember-routing/tests/system/dsl_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-routing/tests/system');
  QUnit.test('ember-routing/tests/system/dsl_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-routing/tests/system/dsl_test.js should pass jshint.');
  });
});
enifed('ember-routing/tests/system/route_test', ['exports', 'ember-runtime/tests/utils', 'container/registry', 'ember-runtime/system/service', 'ember-runtime/system/object', 'ember-routing/system/route', 'ember-runtime/inject'], function (exports, _emberRuntimeTestsUtils, _containerRegistry, _emberRuntimeSystemService, _emberRuntimeSystemObject, _emberRoutingSystemRoute, _emberRuntimeInject) {
  'use strict';

  var route, routeOne, routeTwo, lookupHash;

  function setup() {
    route = _emberRoutingSystemRoute.default.create();
  }

  function teardown() {
    _emberRuntimeTestsUtils.runDestroy(route);
  }

  QUnit.module('Ember.Route', {
    setup: setup,
    teardown: teardown
  });

  QUnit.test('default store utilizes the container to acquire the model factory', function () {
    expect(4);

    var Post = _emberRuntimeSystemObject.default.extend();
    var post = {};

    Post.reopenClass({
      find: function (id) {
        return post;
      }
    });

    route.container = {
      has: function () {
        return true;
      },

      lookupFactory: function (fullName) {
        equal(fullName, 'model:post', 'correct factory was looked up');

        return Post;
      }
    };

    route.set('_qp', null);

    equal(route.model({ post_id: 1 }), post);
    equal(route.findModel('post', 1), post, '#findModel returns the correct post');
  });

  QUnit.test('\'store\' can be injected by data persistence frameworks', function () {
    expect(8);
    _emberRuntimeTestsUtils.runDestroy(route);

    var registry = new _containerRegistry.default();
    var container = registry.container();
    var post = {
      id: 1
    };

    var Store = _emberRuntimeSystemObject.default.extend({
      find: function (type, value) {
        ok(true, 'injected model was called');
        equal(type, 'post', 'correct type was called');
        equal(value, 1, 'correct value was called');
        return post;
      }
    });

    registry.register('route:index', _emberRoutingSystemRoute.default);
    registry.register('store:main', Store);

    registry.injection('route', 'store', 'store:main');

    route = container.lookup('route:index');

    equal(route.model({ post_id: 1 }), post, '#model returns the correct post');
    equal(route.findModel('post', 1), post, '#findModel returns the correct post');
  });

  QUnit.test('assert if \'store.find\' method is not found', function () {
    expect(1);
    _emberRuntimeTestsUtils.runDestroy(route);

    var registry = new _containerRegistry.default();
    var container = registry.container();
    var Post = _emberRuntimeSystemObject.default.extend();

    registry.register('route:index', _emberRoutingSystemRoute.default);
    registry.register('model:post', Post);

    route = container.lookup('route:index');

    expectAssertion(function () {
      route.findModel('post', 1);
    }, 'Post has no method `find`.');
  });

  QUnit.test('asserts if model class is not found', function () {
    expect(1);
    _emberRuntimeTestsUtils.runDestroy(route);

    var registry = new _containerRegistry.default();
    var container = registry.container();
    registry.register('route:index', _emberRoutingSystemRoute.default);

    route = container.lookup('route:index');

    expectAssertion(function () {
      route.model({ post_id: 1 });
    }, 'You used the dynamic segment post_id in your route undefined, but undefined.Post did not exist and you did not override your route\'s `model` hook.');
  });

  QUnit.test('\'store\' does not need to be injected', function () {
    expect(1);

    _emberRuntimeTestsUtils.runDestroy(route);

    var registry = new _containerRegistry.default();
    var container = registry.container();

    registry.register('route:index', _emberRoutingSystemRoute.default);

    route = container.lookup('route:index');

    ignoreAssertion(function () {
      route.model({ post_id: 1 });
    });

    ok(true, 'no error was raised');
  });

  QUnit.test('modelFor doesn\'t require the router', function () {
    var registry = new _containerRegistry.default();
    var container = registry.container();
    route.container = container;

    var foo = { name: 'foo' };

    var fooRoute = _emberRoutingSystemRoute.default.extend({
      container: container,
      currentModel: foo
    });

    registry.register('route:foo', fooRoute);

    equal(route.modelFor('foo'), foo);
  });

  QUnit.test('.send just calls an action if the router is absent', function () {
    expect(7);
    var route = _emberRoutingSystemRoute.default.extend({
      actions: {
        returnsTrue: function (foo, bar) {
          equal(foo, 1);
          equal(bar, 2);
          equal(this, route);
          return true;
        },

        returnsFalse: function () {
          ok(true, 'returnsFalse was called');
          return false;
        }
      }
    }).create();

    equal(true, route.send('returnsTrue', 1, 2));
    equal(false, route.send('returnsFalse'));
    equal(undefined, route.send('nonexistent', 1, 2, 3));
  });

  QUnit.test('.send just calls an action if the routers internal router property is absent', function () {
    expect(7);
    var route = _emberRoutingSystemRoute.default.extend({
      router: {},
      actions: {
        returnsTrue: function (foo, bar) {
          equal(foo, 1);
          equal(bar, 2);
          equal(this, route);
          return true;
        },

        returnsFalse: function () {
          ok(true, 'returnsFalse was called');
          return false;
        }
      }
    }).create();

    equal(true, route.send('returnsTrue', 1, 2));
    equal(false, route.send('returnsFalse'));
    equal(undefined, route.send('nonexistent', 1, 2, 3));
  });

  QUnit.test('can access `actions` hash via `_actions` [DEPRECATED]', function () {
    expect(2);

    var route = _emberRoutingSystemRoute.default.extend({
      actions: {
        foo: function () {
          ok(true, 'called foo action');
        }
      }
    }).create();

    expectDeprecation(function () {
      route._actions.foo();
    }, 'Usage of `_actions` is deprecated, use `actions` instead.');
  });

  QUnit.test('actions in both `_actions` and `actions` results in an assertion', function () {
    expectAssertion(function () {
      _emberRoutingSystemRoute.default.extend({
        _actions: {},
        actions: {}
      }).create();
    }, 'Specifying `_actions` and `actions` in the same mixin is not supported.');
  });

  QUnit.test('actions added via `_actions` can be used [DEPRECATED]', function () {
    expect(3);

    var route = undefined;
    expectDeprecation(function () {
      route = _emberRoutingSystemRoute.default.extend({
        _actions: {
          bar: function () {
            ok(true, 'called bar action');
          }
        }
      }, {
        actions: {
          foo: function () {
            ok(true, 'called foo action');
          }
        }
      }).create();
    }, 'Specifying actions in `_actions` is deprecated, please use `actions` instead.');

    route.send('foo');
    route.send('bar');
  });

  QUnit.module('Ember.Route serialize', {
    setup: setup,
    teardown: teardown
  });

  QUnit.test('returns the models properties if params does not include *_id', function () {
    var model = { id: 2, firstName: 'Ned', lastName: 'Ryerson' };

    deepEqual(route.serialize(model, ['firstName', 'lastName']), { firstName: 'Ned', lastName: 'Ryerson' }, 'serialized correctly');
  });

  QUnit.test('returns model.id if params include *_id', function () {
    var model = { id: 2 };

    deepEqual(route.serialize(model, ['post_id']), { post_id: 2 }, 'serialized correctly');
  });

  QUnit.test('returns checks for existence of model.post_id before trying model.id', function () {
    var model = { post_id: 3 };

    deepEqual(route.serialize(model, ['post_id']), { post_id: 3 }, 'serialized correctly');
  });

  QUnit.test('returns undefined if model is not set', function () {
    equal(route.serialize(undefined, ['post_id']), undefined, 'serialized correctly');
  });

  QUnit.module('Ember.Route interaction', {
    setup: function () {
      var container = {
        lookup: function (fullName) {
          return lookupHash[fullName];
        }
      };

      routeOne = _emberRoutingSystemRoute.default.create({ container: container, routeName: 'one' });
      routeTwo = _emberRoutingSystemRoute.default.create({ container: container, routeName: 'two' });

      lookupHash = {
        'route:one': routeOne,
        'route:two': routeTwo
      };
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(routeOne);
      _emberRuntimeTestsUtils.runDestroy(routeTwo);
    }
  });

  QUnit.test('controllerFor uses route\'s controllerName if specified', function () {
    var testController = {};
    lookupHash['controller:test'] = testController;

    routeOne.controllerName = 'test';

    equal(routeTwo.controllerFor('one'), testController);
  });

  QUnit.module('Route injected properties');

  QUnit.test('services can be injected into routes', function () {
    var registry = new _containerRegistry.default();
    var container = registry.container();

    registry.register('route:application', _emberRoutingSystemRoute.default.extend({
      authService: _emberRuntimeInject.default.service('auth')
    }));

    registry.register('service:auth', _emberRuntimeSystemService.default.extend());

    var appRoute = container.lookup('route:application');
    var authService = container.lookup('service:auth');

    equal(authService, appRoute.get('authService'), 'service.auth is injected');
  });
});
enifed('ember-routing/tests/system/route_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-routing/tests/system');
  test('ember-routing/tests/system/route_test.js should pass jscs', function () {
    ok(true, 'ember-routing/tests/system/route_test.js should pass jscs.');
  });
});
enifed('ember-routing/tests/system/route_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-routing/tests/system');
  QUnit.test('ember-routing/tests/system/route_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-routing/tests/system/route_test.js should pass jshint.');
  });
});
enifed('ember-routing/tests/system/router_test', ['exports', 'ember-metal/merge', 'container/registry', 'ember-routing/location/hash_location', 'ember-routing/location/history_location', 'ember-routing/location/auto_location', 'ember-routing/location/none_location', 'ember-routing/system/router', 'ember-runtime/tests/utils'], function (exports, _emberMetalMerge, _containerRegistry, _emberRoutingLocationHash_location, _emberRoutingLocationHistory_location, _emberRoutingLocationAuto_location, _emberRoutingLocationNone_location, _emberRoutingSystemRouter, _emberRuntimeTestsUtils) {
  'use strict';

  var registry, container;

  function createRouter(overrides, disableSetup) {
    var opts = _emberMetalMerge.default({ container: container }, overrides);
    var routerWithContainer = _emberRoutingSystemRouter.default.extend();
    var router = routerWithContainer.create(opts);

    if (!disableSetup) {
      router.setupRouter();
    }

    return router;
  }

  QUnit.module('Ember Router', {
    setup: function () {
      registry = new _containerRegistry.default();
      container = registry.container();

      //register the HashLocation (the default)
      registry.register('location:hash', _emberRoutingLocationHash_location.default);
      registry.register('location:history', _emberRoutingLocationHistory_location.default);
      registry.register('location:auto', _emberRoutingLocationAuto_location.default);
      registry.register('location:none', _emberRoutingLocationNone_location.default);
    },
    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(container);
      registry = container = null;
    }
  });

  QUnit.test('can create a router without a container', function () {
    createRouter({ container: null }, true);

    ok(true, 'no errors were thrown when creating without a container');
  });

  QUnit.test('should not create a router.js instance upon init', function () {
    var router = createRouter(null, true);

    ok(!router.router);
  });

  QUnit.test('should not reify location until setupRouter is called', function () {
    var router = createRouter(null, true);
    equal(typeof router.location, 'string', 'location is specified as a string');

    router.setupRouter();

    equal(typeof router.location, 'object', 'location is reified into an object');
  });

  QUnit.test('should destroy its location upon destroying the routers container.', function () {
    var router = createRouter();
    var location = router.get('location');

    _emberRuntimeTestsUtils.runDestroy(container);

    ok(location.isDestroyed, 'location should be destroyed');
  });

  QUnit.test('should instantiate its location with its `rootURL`', function () {
    var router = createRouter({
      rootURL: '/rootdir/'
    });
    var location = router.get('location');

    equal(location.get('rootURL'), '/rootdir/');
  });

  QUnit.test('replacePath should be called with the right path', function () {
    expect(1);

    var location = container.lookup('location:auto');

    var browserLocation = {
      href: 'http://test.com/rootdir/welcome',
      origin: 'http://test.com',
      pathname: '/rootdir/welcome',
      hash: '',
      search: '',
      replace: function (url) {
        equal(url, 'http://test.com/rootdir/#/welcome');
      }
    };

    location.location = browserLocation;
    location.global = { onhashchange: function () {} };
    location.history = null;

    createRouter({
      location: 'auto',
      rootURL: '/rootdir/'
    });
  });

  QUnit.test('Ember.Router._routePath should consume identical prefixes', function () {
    createRouter();

    expect(8);

    function routePath(s1, s2, s3) {
      var handlerInfos = Array.prototype.slice.call(arguments).map(function (s) {
        return { name: s };
      });
      handlerInfos.unshift({ name: 'ignored' });

      return _emberRoutingSystemRouter.default._routePath(handlerInfos);
    }

    equal(routePath('foo'), 'foo');
    equal(routePath('foo', 'bar', 'baz'), 'foo.bar.baz');
    equal(routePath('foo', 'foo.bar'), 'foo.bar');
    equal(routePath('foo', 'foo.bar', 'foo.bar.baz'), 'foo.bar.baz');
    equal(routePath('foo', 'foo.bar', 'foo.bar.baz.wow'), 'foo.bar.baz.wow');
    equal(routePath('foo', 'foo.bar.baz.wow'), 'foo.bar.baz.wow');
    equal(routePath('foo.bar', 'bar.baz.wow'), 'foo.bar.baz.wow');

    // This makes no sense, not trying to handle it, just
    // making sure it doesn't go boom.
    equal(routePath('foo.bar.baz', 'foo'), 'foo.bar.baz.foo');
  });

  QUnit.test('Router should cancel routing setup when the Location class says so via cancelRouterSetup', function () {
    expect(0);

    var router;
    var FakeLocation = {
      cancelRouterSetup: true,
      create: function () {
        return this;
      }
    };

    registry.register('location:fake', FakeLocation);

    router = createRouter({
      container: container,
      location: 'fake',

      _setupRouter: function () {
        ok(false, '_setupRouter should not be called');
      }
    });

    router.startRouting();
  });

  QUnit.test('AutoLocation should replace the url when it\'s not in the preferred format', function () {
    expect(1);

    var location = container.lookup('location:auto');

    location.location = {
      href: 'http://test.com/rootdir/welcome',
      origin: 'http://test.com',
      pathname: '/rootdir/welcome',
      hash: '',
      search: '',
      replace: function (url) {
        equal(url, 'http://test.com/rootdir/#/welcome');
      }
    };
    location.history = null;
    location.global = {
      onhashchange: function () {}
    };

    createRouter({
      location: 'auto',
      rootURL: '/rootdir/'
    });
  });

  QUnit.test('Router#handleURL should remove any #hashes before doing URL transition', function () {
    expect(2);

    var router = createRouter({
      container: container,

      _doURLTransition: function (routerJsMethod, url) {
        equal(routerJsMethod, 'handleURL');
        equal(url, '/foo/bar?time=morphin');
      }
    });

    router.handleURL('/foo/bar?time=morphin#pink-power-ranger');
  });
});
enifed('ember-routing/tests/system/router_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-routing/tests/system');
  test('ember-routing/tests/system/router_test.js should pass jscs', function () {
    ok(true, 'ember-routing/tests/system/router_test.js should pass jscs.');
  });
});
enifed('ember-routing/tests/system/router_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-routing/tests/system');
  QUnit.test('ember-routing/tests/system/router_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-routing/tests/system/router_test.js should pass jshint.');
  });
});
enifed('ember-routing/tests/utils_test', ['exports', 'ember-routing/utils'], function (exports, _emberRoutingUtils) {
  'use strict';

  QUnit.module('Routing query parameter utils - normalizeControllerQueryParams');

  QUnit.test('returns the cached value if that has been previously set', function (assert) {
    var cached = {};
    var params = ['foo'];
    params._qpMap = cached;

    var normalized = _emberRoutingUtils.normalizeControllerQueryParams(params);
    equal(cached, normalized, 'cached value returned if previously set');
  });

  QUnit.test('converts array style into verbose object style', function (assert) {
    var paramName = 'foo';
    var params = [paramName];
    var normalized = _emberRoutingUtils.normalizeControllerQueryParams(params);

    ok(normalized[paramName], 'turns the query param name into key');
    equal(normalized[paramName].as, null, 'includes a blank alias in \'as\' key');
    equal(normalized[paramName].scope, 'model', 'defaults scope to model');
  });

  QUnit.test('converts object stlye [{foo: \'an_alias\'}]', function (assert) {
    var paramName = 'foo';
    var params = [{ 'foo': 'an_alias' }];
    var normalized = _emberRoutingUtils.normalizeControllerQueryParams(params);

    ok(normalized[paramName], 'retains the query param name as key');
    equal(normalized[paramName].as, 'an_alias', 'includes the provided alias in \'as\' key');
    equal(normalized[paramName].scope, 'model', 'defaults scope to model');
  });

  QUnit.test('retains maximally verbose object stlye [{foo: {as: \'foo\'}}]', function (assert) {
    var paramName = 'foo';
    var params = [{ 'foo': { as: 'an_alias' } }];
    var normalized = _emberRoutingUtils.normalizeControllerQueryParams(params);

    ok(normalized[paramName], 'retains the query param name as key');
    equal(normalized[paramName].as, 'an_alias', 'includes the provided alias in \'as\' key');
    equal(normalized[paramName].scope, 'model', 'defaults scope to model');
  });
});
enifed('ember-routing/tests/utils_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-routing/tests');
  test('ember-routing/tests/utils_test.js should pass jscs', function () {
    ok(true, 'ember-routing/tests/utils_test.js should pass jscs.');
  });
});
enifed('ember-routing/tests/utils_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-routing/tests');
  QUnit.test('ember-routing/tests/utils_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-routing/tests/utils_test.js should pass jshint.');
  });
});
enifed('ember-routing/utils.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-routing');
  test('ember-routing/utils.js should pass jscs', function () {
    ok(true, 'ember-routing/utils.js should pass jscs.');
  });
});
enifed('ember-routing/utils.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-routing');
  QUnit.test('ember-routing/utils.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-routing/utils.js should pass jshint.');
  });
});
enifed('ember-runtime.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - .');
  test('ember-runtime.js should pass jscs', function () {
    ok(true, 'ember-runtime.js should pass jscs.');
  });
});
enifed('ember-runtime.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - .');
  QUnit.test('ember-runtime.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime.js should pass jshint.');
  });
});
enifed('ember-runtime/compare.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime');
  test('ember-runtime/compare.js should pass jscs', function () {
    ok(true, 'ember-runtime/compare.js should pass jscs.');
  });
});
enifed('ember-runtime/compare.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime');
  QUnit.test('ember-runtime/compare.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/compare.js should pass jshint.');
  });
});
enifed('ember-runtime/computed/reduce_computed_macros.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/computed');
  test('ember-runtime/computed/reduce_computed_macros.js should pass jscs', function () {
    ok(true, 'ember-runtime/computed/reduce_computed_macros.js should pass jscs.');
  });
});
enifed('ember-runtime/computed/reduce_computed_macros.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/computed');
  QUnit.test('ember-runtime/computed/reduce_computed_macros.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/computed/reduce_computed_macros.js should pass jshint.');
  });
});
enifed('ember-runtime/controllers/controller.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/controllers');
  test('ember-runtime/controllers/controller.js should pass jscs', function () {
    ok(true, 'ember-runtime/controllers/controller.js should pass jscs.');
  });
});
enifed('ember-runtime/controllers/controller.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/controllers');
  QUnit.test('ember-runtime/controllers/controller.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/controllers/controller.js should pass jshint.');
  });
});
enifed('ember-runtime/copy.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime');
  test('ember-runtime/copy.js should pass jscs', function () {
    ok(true, 'ember-runtime/copy.js should pass jscs.');
  });
});
enifed('ember-runtime/copy.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime');
  QUnit.test('ember-runtime/copy.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/copy.js should pass jshint.');
  });
});
enifed('ember-runtime/core.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime');
  test('ember-runtime/core.js should pass jscs', function () {
    ok(true, 'ember-runtime/core.js should pass jscs.');
  });
});
enifed('ember-runtime/core.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime');
  QUnit.test('ember-runtime/core.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/core.js should pass jshint.');
  });
});
enifed('ember-runtime/ext/function.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/ext');
  test('ember-runtime/ext/function.js should pass jscs', function () {
    ok(true, 'ember-runtime/ext/function.js should pass jscs.');
  });
});
enifed('ember-runtime/ext/function.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/ext');
  QUnit.test('ember-runtime/ext/function.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/ext/function.js should pass jshint.');
  });
});
enifed("ember-runtime/ext/rsvp.jscs-test", ["exports"], function (exports) {
  "use strict";
});
enifed('ember-runtime/ext/rsvp.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/ext');
  QUnit.test('ember-runtime/ext/rsvp.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(false, 'ember-runtime/ext/rsvp.js should pass jshint.\nember-runtime/ext/rsvp.js: line 1, col 1, \'RSVP\' is defined but never used.\n\n1 error');
  });
});
enifed('ember-runtime/ext/string.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/ext');
  test('ember-runtime/ext/string.js should pass jscs', function () {
    ok(true, 'ember-runtime/ext/string.js should pass jscs.');
  });
});
enifed('ember-runtime/ext/string.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/ext');
  QUnit.test('ember-runtime/ext/string.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/ext/string.js should pass jshint.');
  });
});
enifed('ember-runtime/inject.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime');
  test('ember-runtime/inject.js should pass jscs', function () {
    ok(true, 'ember-runtime/inject.js should pass jscs.');
  });
});
enifed('ember-runtime/inject.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime');
  QUnit.test('ember-runtime/inject.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/inject.js should pass jshint.');
  });
});
enifed('ember-runtime/mixins/-proxy.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/mixins');
  test('ember-runtime/mixins/-proxy.js should pass jscs', function () {
    ok(true, 'ember-runtime/mixins/-proxy.js should pass jscs.');
  });
});
enifed('ember-runtime/mixins/-proxy.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/mixins');
  QUnit.test('ember-runtime/mixins/-proxy.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/mixins/-proxy.js should pass jshint.');
  });
});
enifed('ember-runtime/mixins/action_handler.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/mixins');
  test('ember-runtime/mixins/action_handler.js should pass jscs', function () {
    ok(true, 'ember-runtime/mixins/action_handler.js should pass jscs.');
  });
});
enifed('ember-runtime/mixins/action_handler.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/mixins');
  QUnit.test('ember-runtime/mixins/action_handler.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/mixins/action_handler.js should pass jshint.');
  });
});
enifed('ember-runtime/mixins/array.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/mixins');
  test('ember-runtime/mixins/array.js should pass jscs', function () {
    ok(true, 'ember-runtime/mixins/array.js should pass jscs.');
  });
});
enifed('ember-runtime/mixins/array.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/mixins');
  QUnit.test('ember-runtime/mixins/array.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/mixins/array.js should pass jshint.');
  });
});
enifed('ember-runtime/mixins/comparable.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/mixins');
  test('ember-runtime/mixins/comparable.js should pass jscs', function () {
    ok(true, 'ember-runtime/mixins/comparable.js should pass jscs.');
  });
});
enifed('ember-runtime/mixins/comparable.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/mixins');
  QUnit.test('ember-runtime/mixins/comparable.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/mixins/comparable.js should pass jshint.');
  });
});
enifed('ember-runtime/mixins/controller.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/mixins');
  test('ember-runtime/mixins/controller.js should pass jscs', function () {
    ok(true, 'ember-runtime/mixins/controller.js should pass jscs.');
  });
});
enifed('ember-runtime/mixins/controller.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/mixins');
  QUnit.test('ember-runtime/mixins/controller.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/mixins/controller.js should pass jshint.');
  });
});
enifed('ember-runtime/mixins/controller_content_model_alias_deprecation.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/mixins');
  test('ember-runtime/mixins/controller_content_model_alias_deprecation.js should pass jscs', function () {
    ok(true, 'ember-runtime/mixins/controller_content_model_alias_deprecation.js should pass jscs.');
  });
});
enifed('ember-runtime/mixins/controller_content_model_alias_deprecation.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/mixins');
  QUnit.test('ember-runtime/mixins/controller_content_model_alias_deprecation.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/mixins/controller_content_model_alias_deprecation.js should pass jshint.');
  });
});
enifed('ember-runtime/mixins/copyable.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/mixins');
  test('ember-runtime/mixins/copyable.js should pass jscs', function () {
    ok(true, 'ember-runtime/mixins/copyable.js should pass jscs.');
  });
});
enifed('ember-runtime/mixins/copyable.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/mixins');
  QUnit.test('ember-runtime/mixins/copyable.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/mixins/copyable.js should pass jshint.');
  });
});
enifed('ember-runtime/mixins/enumerable.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/mixins');
  test('ember-runtime/mixins/enumerable.js should pass jscs', function () {
    ok(true, 'ember-runtime/mixins/enumerable.js should pass jscs.');
  });
});
enifed('ember-runtime/mixins/enumerable.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/mixins');
  QUnit.test('ember-runtime/mixins/enumerable.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/mixins/enumerable.js should pass jshint.');
  });
});
enifed('ember-runtime/mixins/evented.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/mixins');
  test('ember-runtime/mixins/evented.js should pass jscs', function () {
    ok(true, 'ember-runtime/mixins/evented.js should pass jscs.');
  });
});
enifed('ember-runtime/mixins/evented.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/mixins');
  QUnit.test('ember-runtime/mixins/evented.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/mixins/evented.js should pass jshint.');
  });
});
enifed('ember-runtime/mixins/freezable.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/mixins');
  test('ember-runtime/mixins/freezable.js should pass jscs', function () {
    ok(true, 'ember-runtime/mixins/freezable.js should pass jscs.');
  });
});
enifed('ember-runtime/mixins/freezable.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/mixins');
  QUnit.test('ember-runtime/mixins/freezable.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/mixins/freezable.js should pass jshint.');
  });
});
enifed('ember-runtime/mixins/mutable_array.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/mixins');
  test('ember-runtime/mixins/mutable_array.js should pass jscs', function () {
    ok(true, 'ember-runtime/mixins/mutable_array.js should pass jscs.');
  });
});
enifed('ember-runtime/mixins/mutable_array.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/mixins');
  QUnit.test('ember-runtime/mixins/mutable_array.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/mixins/mutable_array.js should pass jshint.');
  });
});
enifed('ember-runtime/mixins/mutable_enumerable.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/mixins');
  test('ember-runtime/mixins/mutable_enumerable.js should pass jscs', function () {
    ok(true, 'ember-runtime/mixins/mutable_enumerable.js should pass jscs.');
  });
});
enifed('ember-runtime/mixins/mutable_enumerable.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/mixins');
  QUnit.test('ember-runtime/mixins/mutable_enumerable.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/mixins/mutable_enumerable.js should pass jshint.');
  });
});
enifed('ember-runtime/mixins/observable.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/mixins');
  test('ember-runtime/mixins/observable.js should pass jscs', function () {
    ok(true, 'ember-runtime/mixins/observable.js should pass jscs.');
  });
});
enifed('ember-runtime/mixins/observable.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/mixins');
  QUnit.test('ember-runtime/mixins/observable.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/mixins/observable.js should pass jshint.');
  });
});
enifed('ember-runtime/mixins/promise_proxy.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/mixins');
  test('ember-runtime/mixins/promise_proxy.js should pass jscs', function () {
    ok(true, 'ember-runtime/mixins/promise_proxy.js should pass jscs.');
  });
});
enifed('ember-runtime/mixins/promise_proxy.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/mixins');
  QUnit.test('ember-runtime/mixins/promise_proxy.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/mixins/promise_proxy.js should pass jshint.');
  });
});
enifed('ember-runtime/mixins/target_action_support.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/mixins');
  test('ember-runtime/mixins/target_action_support.js should pass jscs', function () {
    ok(true, 'ember-runtime/mixins/target_action_support.js should pass jscs.');
  });
});
enifed('ember-runtime/mixins/target_action_support.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/mixins');
  QUnit.test('ember-runtime/mixins/target_action_support.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/mixins/target_action_support.js should pass jshint.');
  });
});
enifed('ember-runtime/system/application.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/system');
  test('ember-runtime/system/application.js should pass jscs', function () {
    ok(true, 'ember-runtime/system/application.js should pass jscs.');
  });
});
enifed('ember-runtime/system/application.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/system');
  QUnit.test('ember-runtime/system/application.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/system/application.js should pass jshint.');
  });
});
enifed('ember-runtime/system/array_proxy.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/system');
  test('ember-runtime/system/array_proxy.js should pass jscs', function () {
    ok(true, 'ember-runtime/system/array_proxy.js should pass jscs.');
  });
});
enifed('ember-runtime/system/array_proxy.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/system');
  QUnit.test('ember-runtime/system/array_proxy.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/system/array_proxy.js should pass jshint.');
  });
});
enifed('ember-runtime/system/container.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/system');
  test('ember-runtime/system/container.js should pass jscs', function () {
    ok(true, 'ember-runtime/system/container.js should pass jscs.');
  });
});
enifed('ember-runtime/system/container.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/system');
  QUnit.test('ember-runtime/system/container.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/system/container.js should pass jshint.');
  });
});
enifed('ember-runtime/system/core_object.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/system');
  test('ember-runtime/system/core_object.js should pass jscs', function () {
    ok(true, 'ember-runtime/system/core_object.js should pass jscs.');
  });
});
enifed('ember-runtime/system/core_object.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/system');
  QUnit.test('ember-runtime/system/core_object.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/system/core_object.js should pass jshint.');
  });
});
enifed('ember-runtime/system/each_proxy.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/system');
  test('ember-runtime/system/each_proxy.js should pass jscs', function () {
    ok(true, 'ember-runtime/system/each_proxy.js should pass jscs.');
  });
});
enifed('ember-runtime/system/each_proxy.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/system');
  QUnit.test('ember-runtime/system/each_proxy.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/system/each_proxy.js should pass jshint.');
  });
});
enifed('ember-runtime/system/lazy_load.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/system');
  test('ember-runtime/system/lazy_load.js should pass jscs', function () {
    ok(true, 'ember-runtime/system/lazy_load.js should pass jscs.');
  });
});
enifed('ember-runtime/system/lazy_load.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/system');
  QUnit.test('ember-runtime/system/lazy_load.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/system/lazy_load.js should pass jshint.');
  });
});
enifed('ember-runtime/system/namespace.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/system');
  test('ember-runtime/system/namespace.js should pass jscs', function () {
    ok(true, 'ember-runtime/system/namespace.js should pass jscs.');
  });
});
enifed('ember-runtime/system/namespace.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/system');
  QUnit.test('ember-runtime/system/namespace.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/system/namespace.js should pass jshint.');
  });
});
enifed('ember-runtime/system/native_array.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/system');
  test('ember-runtime/system/native_array.js should pass jscs', function () {
    ok(true, 'ember-runtime/system/native_array.js should pass jscs.');
  });
});
enifed('ember-runtime/system/native_array.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/system');
  QUnit.test('ember-runtime/system/native_array.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/system/native_array.js should pass jshint.');
  });
});
enifed('ember-runtime/system/object.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/system');
  test('ember-runtime/system/object.js should pass jscs', function () {
    ok(true, 'ember-runtime/system/object.js should pass jscs.');
  });
});
enifed('ember-runtime/system/object.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/system');
  QUnit.test('ember-runtime/system/object.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/system/object.js should pass jshint.');
  });
});
enifed('ember-runtime/system/object_proxy.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/system');
  test('ember-runtime/system/object_proxy.js should pass jscs', function () {
    ok(true, 'ember-runtime/system/object_proxy.js should pass jscs.');
  });
});
enifed('ember-runtime/system/object_proxy.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/system');
  QUnit.test('ember-runtime/system/object_proxy.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/system/object_proxy.js should pass jshint.');
  });
});
enifed('ember-runtime/system/service.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/system');
  test('ember-runtime/system/service.js should pass jscs', function () {
    ok(true, 'ember-runtime/system/service.js should pass jscs.');
  });
});
enifed('ember-runtime/system/service.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/system');
  QUnit.test('ember-runtime/system/service.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/system/service.js should pass jshint.');
  });
});
enifed('ember-runtime/system/string.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/system');
  test('ember-runtime/system/string.js should pass jscs', function () {
    ok(true, 'ember-runtime/system/string.js should pass jscs.');
  });
});
enifed('ember-runtime/system/string.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/system');
  QUnit.test('ember-runtime/system/string.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/system/string.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/computed/computed_macros_test', ['exports', 'ember-metal/core', 'ember-metal/computed', 'ember-metal/computed_macros', 'ember-metal/alias', 'ember-metal/properties', 'ember-runtime/system/object', 'ember-metal/tests/props_helper'], function (exports, _emberMetalCore, _emberMetalComputed, _emberMetalComputed_macros, _emberMetalAlias, _emberMetalProperties, _emberRuntimeSystemObject, _emberMetalTestsProps_helper) {
  'use strict';

  QUnit.module('CP macros');

  _emberMetalTestsProps_helper.testBoth('Ember.computed.empty', function (get, set) {
    var obj = _emberRuntimeSystemObject.default.extend({
      bestLannister: null,
      lannisters: null,

      bestLannisterUnspecified: _emberMetalComputed_macros.empty('bestLannister'),
      noLannistersKnown: _emberMetalComputed_macros.empty('lannisters')
    }).create({
      lannisters: _emberMetalCore.default.A([])
    });

    equal(get(obj, 'bestLannisterUnspecified'), true, 'bestLannister initially empty');
    equal(get(obj, 'noLannistersKnown'), true, 'lannisters initially empty');

    get(obj, 'lannisters').pushObject('Tyrion');
    set(obj, 'bestLannister', 'Tyrion');

    equal(get(obj, 'bestLannisterUnspecified'), false, 'empty respects strings');
    equal(get(obj, 'noLannistersKnown'), false, 'empty respects array mutations');
  });

  _emberMetalTestsProps_helper.testBoth('Ember.computed.notEmpty', function (get, set) {
    var obj = _emberRuntimeSystemObject.default.extend({
      bestLannister: null,
      lannisters: null,

      bestLannisterSpecified: _emberMetalComputed_macros.notEmpty('bestLannister'),
      LannistersKnown: _emberMetalComputed_macros.notEmpty('lannisters')
    }).create({
      lannisters: _emberMetalCore.default.A([])
    });

    equal(get(obj, 'bestLannisterSpecified'), false, 'bestLannister initially empty');
    equal(get(obj, 'LannistersKnown'), false, 'lannisters initially empty');

    get(obj, 'lannisters').pushObject('Tyrion');
    set(obj, 'bestLannister', 'Tyrion');

    equal(get(obj, 'bestLannisterSpecified'), true, 'empty respects strings');
    equal(get(obj, 'LannistersKnown'), true, 'empty respects array mutations');
  });

  _emberMetalTestsProps_helper.testBoth('computed.not', function (get, set) {
    var obj = { foo: true };
    _emberMetalProperties.defineProperty(obj, 'notFoo', _emberMetalComputed_macros.not('foo'));
    equal(get(obj, 'notFoo'), false);

    obj = { foo: { bar: true } };
    _emberMetalProperties.defineProperty(obj, 'notFoo', _emberMetalComputed_macros.not('foo.bar'));
    equal(get(obj, 'notFoo'), false);
  });

  _emberMetalTestsProps_helper.testBoth('computed.empty', function (get, set) {
    var obj = { foo: [], bar: undefined, baz: null, quz: '' };
    _emberMetalProperties.defineProperty(obj, 'fooEmpty', _emberMetalComputed_macros.empty('foo'));
    _emberMetalProperties.defineProperty(obj, 'barEmpty', _emberMetalComputed_macros.empty('bar'));
    _emberMetalProperties.defineProperty(obj, 'bazEmpty', _emberMetalComputed_macros.empty('baz'));
    _emberMetalProperties.defineProperty(obj, 'quzEmpty', _emberMetalComputed_macros.empty('quz'));

    equal(get(obj, 'fooEmpty'), true);
    set(obj, 'foo', [1]);
    equal(get(obj, 'fooEmpty'), false);
    equal(get(obj, 'barEmpty'), true);
    equal(get(obj, 'bazEmpty'), true);
    equal(get(obj, 'quzEmpty'), true);
    set(obj, 'quz', 'asdf');
    equal(get(obj, 'quzEmpty'), false);
  });

  _emberMetalTestsProps_helper.testBoth('computed.bool', function (get, set) {
    var obj = { foo: function () {}, bar: 'asdf', baz: null, quz: false };
    _emberMetalProperties.defineProperty(obj, 'fooBool', _emberMetalComputed_macros.bool('foo'));
    _emberMetalProperties.defineProperty(obj, 'barBool', _emberMetalComputed_macros.bool('bar'));
    _emberMetalProperties.defineProperty(obj, 'bazBool', _emberMetalComputed_macros.bool('baz'));
    _emberMetalProperties.defineProperty(obj, 'quzBool', _emberMetalComputed_macros.bool('quz'));
    equal(get(obj, 'fooBool'), true);
    equal(get(obj, 'barBool'), true);
    equal(get(obj, 'bazBool'), false);
    equal(get(obj, 'quzBool'), false);
  });

  _emberMetalTestsProps_helper.testBoth('computed.alias', function (get, set) {
    var obj = { bar: 'asdf', baz: null, quz: false };
    _emberMetalProperties.defineProperty(obj, 'bay', _emberMetalComputed.computed(function (key) {
      return 'apple';
    }));

    _emberMetalProperties.defineProperty(obj, 'barAlias', _emberMetalAlias.default('bar'));
    _emberMetalProperties.defineProperty(obj, 'bazAlias', _emberMetalAlias.default('baz'));
    _emberMetalProperties.defineProperty(obj, 'quzAlias', _emberMetalAlias.default('quz'));
    _emberMetalProperties.defineProperty(obj, 'bayAlias', _emberMetalAlias.default('bay'));

    equal(get(obj, 'barAlias'), 'asdf');
    equal(get(obj, 'bazAlias'), null);
    equal(get(obj, 'quzAlias'), false);
    equal(get(obj, 'bayAlias'), 'apple');

    set(obj, 'barAlias', 'newBar');
    set(obj, 'bazAlias', 'newBaz');
    set(obj, 'quzAlias', null);

    equal(get(obj, 'barAlias'), 'newBar');
    equal(get(obj, 'bazAlias'), 'newBaz');
    equal(get(obj, 'quzAlias'), null);

    equal(get(obj, 'bar'), 'newBar');
    equal(get(obj, 'baz'), 'newBaz');
    equal(get(obj, 'quz'), null);
  });

  _emberMetalTestsProps_helper.testBoth('computed.alias set', function (get, set) {
    var obj = {};
    var constantValue = 'always `a`';

    _emberMetalProperties.defineProperty(obj, 'original', _emberMetalComputed.computed({
      get: function (key) {
        return constantValue;
      },
      set: function (key, value) {
        return constantValue;
      }
    }));
    _emberMetalProperties.defineProperty(obj, 'aliased', _emberMetalAlias.default('original'));

    equal(get(obj, 'original'), constantValue);
    equal(get(obj, 'aliased'), constantValue);

    set(obj, 'aliased', 'should not set to this value');

    equal(get(obj, 'original'), constantValue);
    equal(get(obj, 'aliased'), constantValue);
  });

  _emberMetalTestsProps_helper.testBoth('computed.match', function (get, set) {
    var obj = { name: 'Paul' };
    _emberMetalProperties.defineProperty(obj, 'isPaul', _emberMetalComputed_macros.match('name', /Paul/));

    equal(get(obj, 'isPaul'), true, 'is Paul');

    set(obj, 'name', 'Pierre');

    equal(get(obj, 'isPaul'), false, 'is not Paul anymore');
  });

  _emberMetalTestsProps_helper.testBoth('computed.notEmpty', function (get, set) {
    var obj = { items: [1] };
    _emberMetalProperties.defineProperty(obj, 'hasItems', _emberMetalComputed_macros.notEmpty('items'));

    equal(get(obj, 'hasItems'), true, 'is not empty');

    set(obj, 'items', []);

    equal(get(obj, 'hasItems'), false, 'is empty');
  });

  _emberMetalTestsProps_helper.testBoth('computed.equal', function (get, set) {
    var obj = { name: 'Paul' };
    _emberMetalProperties.defineProperty(obj, 'isPaul', _emberMetalComputed_macros.equal('name', 'Paul'));

    equal(get(obj, 'isPaul'), true, 'is Paul');

    set(obj, 'name', 'Pierre');

    equal(get(obj, 'isPaul'), false, 'is not Paul anymore');
  });

  _emberMetalTestsProps_helper.testBoth('computed.gt', function (get, set) {
    var obj = { number: 2 };
    _emberMetalProperties.defineProperty(obj, 'isGreaterThenOne', _emberMetalComputed_macros.gt('number', 1));

    equal(get(obj, 'isGreaterThenOne'), true, 'is gt');

    set(obj, 'number', 1);

    equal(get(obj, 'isGreaterThenOne'), false, 'is not gt');

    set(obj, 'number', 0);

    equal(get(obj, 'isGreaterThenOne'), false, 'is not gt');
  });

  _emberMetalTestsProps_helper.testBoth('computed.gte', function (get, set) {
    var obj = { number: 2 };
    _emberMetalProperties.defineProperty(obj, 'isGreaterOrEqualThenOne', _emberMetalComputed_macros.gte('number', 1));

    equal(get(obj, 'isGreaterOrEqualThenOne'), true, 'is gte');

    set(obj, 'number', 1);

    equal(get(obj, 'isGreaterOrEqualThenOne'), true, 'is gte');

    set(obj, 'number', 0);

    equal(get(obj, 'isGreaterOrEqualThenOne'), false, 'is not gte');
  });

  _emberMetalTestsProps_helper.testBoth('computed.lt', function (get, set) {
    var obj = { number: 0 };
    _emberMetalProperties.defineProperty(obj, 'isLesserThenOne', _emberMetalComputed_macros.lt('number', 1));

    equal(get(obj, 'isLesserThenOne'), true, 'is lt');

    set(obj, 'number', 1);

    equal(get(obj, 'isLesserThenOne'), false, 'is not lt');

    set(obj, 'number', 2);

    equal(get(obj, 'isLesserThenOne'), false, 'is not lt');
  });

  _emberMetalTestsProps_helper.testBoth('computed.lte', function (get, set) {
    var obj = { number: 0 };
    _emberMetalProperties.defineProperty(obj, 'isLesserOrEqualThenOne', _emberMetalComputed_macros.lte('number', 1));

    equal(get(obj, 'isLesserOrEqualThenOne'), true, 'is lte');

    set(obj, 'number', 1);

    equal(get(obj, 'isLesserOrEqualThenOne'), true, 'is lte');

    set(obj, 'number', 2);

    equal(get(obj, 'isLesserOrEqualThenOne'), false, 'is not lte');
  });

  _emberMetalTestsProps_helper.testBoth('computed.and', function (get, set) {
    var obj = { one: true, two: true };
    _emberMetalProperties.defineProperty(obj, 'oneAndTwo', _emberMetalComputed_macros.and('one', 'two'));

    equal(get(obj, 'oneAndTwo'), true, 'one and two');

    set(obj, 'one', false);

    equal(get(obj, 'oneAndTwo'), false, 'one and not two');

    set(obj, 'one', true);
    set(obj, 'two', 2);

    equal(get(obj, 'oneAndTwo'), 2, 'returns truthy value as in &&');
  });

  _emberMetalTestsProps_helper.testBoth('computed.or', function (get, set) {
    var obj = { one: true, two: true };
    _emberMetalProperties.defineProperty(obj, 'oneOrTwo', _emberMetalComputed_macros.or('one', 'two'));

    equal(get(obj, 'oneOrTwo'), true, 'one or two');

    set(obj, 'one', false);

    equal(get(obj, 'oneOrTwo'), true, 'one or two');

    set(obj, 'two', false);

    equal(get(obj, 'oneOrTwo'), false, 'nore one nore two');

    set(obj, 'two', null);

    equal(get(obj, 'oneOrTwo'), null, 'returns last falsy value as in ||');

    set(obj, 'two', true);

    equal(get(obj, 'oneOrTwo'), true, 'one or two');

    set(obj, 'one', 1);

    equal(get(obj, 'oneOrTwo'), 1, 'returns truthy value as in ||');
  });

  _emberMetalTestsProps_helper.testBoth('computed.collect', function (get, set) {
    var obj = { one: 'foo', two: 'bar', three: null };
    _emberMetalProperties.defineProperty(obj, 'all', _emberMetalComputed_macros.collect('one', 'two', 'three', 'four'));

    deepEqual(get(obj, 'all'), ['foo', 'bar', null, null], 'have all of them');

    set(obj, 'four', true);

    deepEqual(get(obj, 'all'), ['foo', 'bar', null, true], 'have all of them');

    var a = [];
    set(obj, 'one', 0);
    set(obj, 'three', a);

    deepEqual(get(obj, 'all'), [0, 'bar', a, true], 'have all of them');
  });

  _emberMetalTestsProps_helper.testBoth('computed.oneWay', function (get, set) {
    var obj = {
      firstName: 'Teddy',
      lastName: 'Zeenny'
    };

    _emberMetalProperties.defineProperty(obj, 'nickName', _emberMetalComputed_macros.oneWay('firstName'));

    equal(get(obj, 'firstName'), 'Teddy');
    equal(get(obj, 'lastName'), 'Zeenny');
    equal(get(obj, 'nickName'), 'Teddy');

    set(obj, 'nickName', 'TeddyBear');

    equal(get(obj, 'firstName'), 'Teddy');
    equal(get(obj, 'lastName'), 'Zeenny');

    equal(get(obj, 'nickName'), 'TeddyBear');

    set(obj, 'firstName', 'TEDDDDDDDDYYY');

    equal(get(obj, 'nickName'), 'TeddyBear');
  });

  _emberMetalTestsProps_helper.testBoth('computed.readOnly', function (get, set) {
    var obj = {
      firstName: 'Teddy',
      lastName: 'Zeenny'
    };

    _emberMetalProperties.defineProperty(obj, 'nickName', _emberMetalComputed_macros.readOnly('firstName'));

    equal(get(obj, 'firstName'), 'Teddy');
    equal(get(obj, 'lastName'), 'Zeenny');
    equal(get(obj, 'nickName'), 'Teddy');

    throws(function () {
      set(obj, 'nickName', 'TeddyBear');
    }, / /);

    equal(get(obj, 'firstName'), 'Teddy');
    equal(get(obj, 'lastName'), 'Zeenny');

    equal(get(obj, 'nickName'), 'Teddy');

    set(obj, 'firstName', 'TEDDDDDDDDYYY');

    equal(get(obj, 'nickName'), 'TEDDDDDDDDYYY');
  });

  _emberMetalTestsProps_helper.testBoth('computed.deprecatingAlias', function (get, set) {
    var obj = { bar: 'asdf', baz: null, quz: false };
    _emberMetalProperties.defineProperty(obj, 'bay', _emberMetalComputed.computed(function (key) {
      return 'apple';
    }));

    _emberMetalProperties.defineProperty(obj, 'barAlias', _emberMetalComputed_macros.deprecatingAlias('bar'));
    _emberMetalProperties.defineProperty(obj, 'bazAlias', _emberMetalComputed_macros.deprecatingAlias('baz'));
    _emberMetalProperties.defineProperty(obj, 'quzAlias', _emberMetalComputed_macros.deprecatingAlias('quz'));
    _emberMetalProperties.defineProperty(obj, 'bayAlias', _emberMetalComputed_macros.deprecatingAlias('bay'));

    expectDeprecation(function () {
      equal(get(obj, 'barAlias'), 'asdf');
    }, 'Usage of `barAlias` is deprecated, use `bar` instead.');

    expectDeprecation(function () {
      equal(get(obj, 'bazAlias'), null);
    }, 'Usage of `bazAlias` is deprecated, use `baz` instead.');

    expectDeprecation(function () {
      equal(get(obj, 'quzAlias'), false);
    }, 'Usage of `quzAlias` is deprecated, use `quz` instead.');

    expectDeprecation(function () {
      equal(get(obj, 'bayAlias'), 'apple');
    }, 'Usage of `bayAlias` is deprecated, use `bay` instead.');

    expectDeprecation(function () {
      set(obj, 'barAlias', 'newBar');
    }, 'Usage of `barAlias` is deprecated, use `bar` instead.');

    expectDeprecation(function () {
      set(obj, 'bazAlias', 'newBaz');
    }, 'Usage of `bazAlias` is deprecated, use `baz` instead.');

    expectDeprecation(function () {
      set(obj, 'quzAlias', null);
    }, 'Usage of `quzAlias` is deprecated, use `quz` instead.');

    equal(get(obj, 'barAlias'), 'newBar');
    equal(get(obj, 'bazAlias'), 'newBaz');
    equal(get(obj, 'quzAlias'), null);

    equal(get(obj, 'bar'), 'newBar');
    equal(get(obj, 'baz'), 'newBaz');
    equal(get(obj, 'quz'), null);
  });
});
enifed('ember-runtime/tests/computed/computed_macros_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/computed');
  test('ember-runtime/tests/computed/computed_macros_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/computed/computed_macros_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/computed/computed_macros_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/computed');
  QUnit.test('ember-runtime/tests/computed/computed_macros_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/computed/computed_macros_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/computed/reduce_computed_macros_test', ['exports', 'ember-metal/core', 'ember-runtime/system/object', 'ember-metal/set_properties', 'ember-runtime/system/object_proxy', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/observer', 'ember-metal/mixin', 'ember-runtime/computed/reduce_computed_macros', 'ember-runtime/utils'], function (exports, _emberMetalCore, _emberRuntimeSystemObject, _emberMetalSet_properties, _emberRuntimeSystemObject_proxy, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalObserver, _emberMetalMixin, _emberRuntimeComputedReduce_computed_macros, _emberRuntimeUtils) {
  'use strict';

  var obj;
  QUnit.module('map', {
    setup: function () {
      obj = _emberRuntimeSystemObject.default.extend({
        mapped: _emberRuntimeComputedReduce_computed_macros.map('array.@each.v', function (item) {
          return item.v;
        }),
        mappedObjects: _emberRuntimeComputedReduce_computed_macros.map('arrayObjects.@each.v', function (item) {
          return { name: item.v.name };
        })
      }).create({
        arrayObjects: _emberMetalCore.default.A([{ v: { name: 'Robert' } }, { v: { name: 'Leanna' } }]),

        array: _emberMetalCore.default.A([{ v: 1 }, { v: 3 }, { v: 2 }, { v: 1 }])
      });
    },

    teardown: function () {
      _emberMetalCore.default.run(obj, 'destroy');
    }
  });

  QUnit.test('map is readOnly', function () {
    QUnit.throws(function () {
      obj.set('mapped', 1);
    }, /Cannot set read-only property "mapped" on object:/);
  });

  QUnit.test('it maps simple properties', function () {
    deepEqual(obj.get('mapped'), [1, 3, 2, 1]);

    obj.get('array').pushObject({ v: 5 });

    deepEqual(obj.get('mapped'), [1, 3, 2, 1, 5]);

    obj.get('array').removeAt(3);

    deepEqual(obj.get('mapped'), [1, 3, 2, 5]);
  });

  QUnit.test('it maps simple unshifted properties', function () {
    var array = _emberMetalCore.default.A();

    obj = _emberRuntimeSystemObject.default.extend({
      mapped: _emberRuntimeComputedReduce_computed_macros.map('array', function (item) {
        return item.toUpperCase();
      })
    }).create({
      array: array
    });

    array.unshiftObject('c');
    array.unshiftObject('b');
    array.unshiftObject('a');

    array.popObject();

    deepEqual(obj.get('mapped'), ['A', 'B'], 'properties unshifted in sequence are mapped correctly');
  });

  QUnit.test('it has the correct `this`', function () {
    obj = _emberRuntimeSystemObject.default.extend({
      mapped: _emberRuntimeComputedReduce_computed_macros.map('array', function (item) {
        equal(this, obj, 'should have correct context');
        return this.upperCase(item);
      }),
      upperCase: function (string) {
        return string.toUpperCase();
      }
    }).create({
      array: ['a', 'b', 'c']
    });

    deepEqual(obj.get('mapped'), ['A', 'B', 'C'], 'properties unshifted in sequence are mapped correctly');
  });

  QUnit.test('it passes the index to the callback', function () {
    var array = ['a', 'b', 'c'];

    obj = _emberRuntimeSystemObject.default.extend({
      mapped: _emberRuntimeComputedReduce_computed_macros.map('array', function (item, index) {
        return index;
      })
    }).create({
      array: array
    });

    deepEqual(obj.get('mapped'), [0, 1, 2], 'index is passed to callback correctly');
  });

  QUnit.test('it maps objects', function () {
    deepEqual(obj.get('mappedObjects'), [{ name: 'Robert' }, { name: 'Leanna' }]);

    obj.get('arrayObjects').pushObject({
      v: { name: 'Eddard' }
    });

    deepEqual(obj.get('mappedObjects'), [{ name: 'Robert' }, { name: 'Leanna' }, { name: 'Eddard' }]);

    obj.get('arrayObjects').removeAt(1);

    deepEqual(obj.get('mappedObjects'), [{ name: 'Robert' }, { name: 'Eddard' }]);

    _emberMetalProperty_set.set(obj.get('arrayObjects')[0], 'v', { name: 'Stannis' });

    deepEqual(obj.get('mappedObjects'), [{ name: 'Stannis' }, { name: 'Eddard' }]);
  });

  QUnit.test('it maps unshifted objects with property observers', function () {
    var array = _emberMetalCore.default.A();
    var cObj = { v: 'c' };

    obj = _emberRuntimeSystemObject.default.extend({
      mapped: _emberRuntimeComputedReduce_computed_macros.map('array.@each.v', function (item) {
        return _emberMetalProperty_get.get(item, 'v').toUpperCase();
      })
    }).create({
      array: array
    });

    array.unshiftObject(cObj);
    array.unshiftObject({ v: 'b' });
    array.unshiftObject({ v: 'a' });

    _emberMetalProperty_set.set(cObj, 'v', 'd');

    deepEqual(array.mapBy('v'), ['a', 'b', 'd'], 'precond - unmapped array is correct');
    deepEqual(obj.get('mapped'), ['A', 'B', 'D'], 'properties unshifted in sequence are mapped correctly');
  });

  QUnit.module('mapBy', {
    setup: function () {
      obj = _emberRuntimeSystemObject.default.extend({
        mapped: _emberRuntimeComputedReduce_computed_macros.mapBy('array', 'v')
      }).create({
        array: _emberMetalCore.default.A([{ v: 1 }, { v: 3 }, { v: 2 }, { v: 1 }])
      });
    },
    teardown: function () {
      _emberMetalCore.default.run(obj, 'destroy');
    }
  });

  QUnit.test('mapBy is readOnly', function () {
    QUnit.throws(function () {
      obj.set('mapped', 1);
    }, /Cannot set read-only property "mapped" on object:/);
  });

  QUnit.test('it maps properties', function () {
    deepEqual(obj.get('mapped'), [1, 3, 2, 1]);

    obj.get('array').pushObject({ v: 5 });

    deepEqual(obj.get('mapped'), [1, 3, 2, 1, 5]);

    obj.get('array').removeAt(3);

    deepEqual(obj.get('mapped'), [1, 3, 2, 5]);
  });

  QUnit.test('it is observable', function () {
    var calls = 0;

    deepEqual(obj.get('mapped'), [1, 3, 2, 1]);

    _emberMetalObserver.addObserver(obj, 'mapped.@each', function () {
      return calls++;
    });

    obj.get('array').pushObject({ v: 5 });

    equal(calls, 1, 'mapBy is observable');
  });

  QUnit.module('filter', {
    setup: function () {
      obj = _emberRuntimeSystemObject.default.extend({
        filtered: _emberRuntimeComputedReduce_computed_macros.filter('array', function (item) {
          return item % 2 === 0;
        })
      }).create({
        array: _emberMetalCore.default.A([1, 2, 3, 4, 5, 6, 7, 8])
      });
    },
    teardown: function () {
      _emberMetalCore.default.run(obj, 'destroy');
    }
  });

  QUnit.test('filter is readOnly', function () {
    QUnit.throws(function () {
      obj.set('filtered', 1);
    }, /Cannot set read-only property "filtered" on object:/);
  });

  QUnit.test('it filters according to the specified filter function', function () {
    deepEqual(obj.get('filtered'), [2, 4, 6, 8], 'filter filters by the specified function');
  });

  QUnit.test('it passes the index to the callback', function () {
    obj = _emberRuntimeSystemObject.default.extend({
      filtered: _emberRuntimeComputedReduce_computed_macros.filter('array', function (item, index) {
        return index === 1;
      })
    }).create({
      array: ['a', 'b', 'c']
    });

    deepEqual(_emberMetalProperty_get.get(obj, 'filtered'), ['b'], 'index is passed to callback correctly');
  });

  QUnit.test('it has the correct `this`', function () {
    obj = _emberRuntimeSystemObject.default.extend({
      filtered: _emberRuntimeComputedReduce_computed_macros.filter('array', function (item, index) {
        equal(this, obj);
        return this.isOne(index);
      }),
      isOne: function (value) {
        return value === 1;
      }
    }).create({
      array: ['a', 'b', 'c']
    });

    deepEqual(_emberMetalProperty_get.get(obj, 'filtered'), ['b'], 'index is passed to callback correctly');
  });

  QUnit.test('it passes the array to the callback', function () {
    obj = _emberRuntimeSystemObject.default.extend({
      filtered: _emberRuntimeComputedReduce_computed_macros.filter('array', function (item, index, array) {
        return index === _emberMetalProperty_get.get(array, 'length') - 2;
      })
    }).create({
      array: _emberMetalCore.default.A(['a', 'b', 'c'])
    });

    deepEqual(obj.get('filtered'), ['b'], 'array is passed to callback correctly');
  });

  QUnit.test('it caches properly', function () {
    var array = obj.get('array');

    var filtered = obj.get('filtered');
    ok(filtered === obj.get('filtered'));

    array.addObject(11);
    var newFiltered = obj.get('filtered');

    ok(filtered !== newFiltered);

    ok(obj.get('filtered') === newFiltered);
  });

  QUnit.test('it updates as the array is modified', function () {
    var array = obj.get('array');

    deepEqual(obj.get('filtered'), [2, 4, 6, 8], 'precond - filtered array is initially correct');

    array.addObject(11);
    deepEqual(obj.get('filtered'), [2, 4, 6, 8], 'objects not passing the filter are not added');

    array.addObject(12);
    deepEqual(obj.get('filtered'), [2, 4, 6, 8, 12], 'objects passing the filter are added');

    array.removeObject(3);
    array.removeObject(4);

    deepEqual(obj.get('filtered'), [2, 6, 8, 12], 'objects removed from the dependent array are removed from the computed array');
  });

  QUnit.test('the dependent array can be cleared one at a time', function () {
    var array = _emberMetalProperty_get.get(obj, 'array');

    deepEqual(obj.get('filtered'), [2, 4, 6, 8], 'precond - filtered array is initially correct');

    // clear 1-8 but in a random order
    array.removeObject(3);
    array.removeObject(1);
    array.removeObject(2);
    array.removeObject(4);
    array.removeObject(8);
    array.removeObject(6);
    array.removeObject(5);
    array.removeObject(7);

    deepEqual(obj.get('filtered'), [], 'filtered array cleared correctly');
  });

  QUnit.test('the dependent array can be `clear`ed directly (#3272)', function () {
    deepEqual(obj.get('filtered'), [2, 4, 6, 8], 'precond - filtered array is initially correct');

    obj.get('array').clear();

    deepEqual(obj.get('filtered'), [], 'filtered array cleared correctly');
  });

  QUnit.test('it updates as the array is replaced', function () {
    deepEqual(obj.get('filtered'), [2, 4, 6, 8], 'precond - filtered array is initially correct');

    obj.set('array', [20, 21, 22, 23, 24]);

    deepEqual(obj.get('filtered'), [20, 22, 24], 'computed array is updated when array is changed');
  });

  QUnit.module('filterBy', {
    setup: function () {
      obj = _emberRuntimeSystemObject.default.extend({
        a1s: _emberRuntimeComputedReduce_computed_macros.filterBy('array', 'a', 1),
        as: _emberRuntimeComputedReduce_computed_macros.filterBy('array', 'a'),
        bs: _emberRuntimeComputedReduce_computed_macros.filterBy('array', 'b')
      }).create({
        array: _emberMetalCore.default.A([{ name: 'one', a: 1, b: false }, { name: 'two', a: 2, b: false }, { name: 'three', a: 1, b: true }, { name: 'four', b: true }])
      });
    },
    teardown: function () {
      _emberMetalCore.default.run(obj, 'destroy');
    }
  });

  QUnit.test('filterBy is readOnly', function () {
    QUnit.throws(function () {
      obj.set('as', 1);
    }, /Cannot set read-only property "as" on object:/);
  });

  QUnit.test('properties can be filtered by truthiness', function () {
    deepEqual(obj.get('as').mapBy('name'), ['one', 'two', 'three'], 'properties can be filtered by existence');
    deepEqual(obj.get('bs').mapBy('name'), ['three', 'four'], 'booleans can be filtered');

    _emberMetalProperty_set.set(obj.get('array')[0], 'a', undefined);
    _emberMetalProperty_set.set(obj.get('array')[3], 'a', true);

    _emberMetalProperty_set.set(obj.get('array')[0], 'b', true);
    _emberMetalProperty_set.set(obj.get('array')[3], 'b', false);

    deepEqual(obj.get('as').mapBy('name'), ['two', 'three', 'four'], 'arrays computed by filter property respond to property changes');
    deepEqual(obj.get('bs').mapBy('name'), ['one', 'three'], 'arrays computed by filtered property respond to property changes');

    obj.get('array').pushObject({ name: 'five', a: 6, b: true });

    deepEqual(obj.get('as').mapBy('name'), ['two', 'three', 'four', 'five'], 'arrays computed by filter property respond to added objects');
    deepEqual(obj.get('bs').mapBy('name'), ['one', 'three', 'five'], 'arrays computed by filtered property respond to added objects');

    obj.get('array').popObject();

    deepEqual(obj.get('as').mapBy('name'), ['two', 'three', 'four'], 'arrays computed by filter property respond to removed objects');
    deepEqual(obj.get('bs').mapBy('name'), ['one', 'three'], 'arrays computed by filtered property respond to removed objects');

    obj.set('array', [{ name: 'six', a: 12, b: true }]);

    deepEqual(obj.get('as').mapBy('name'), ['six'], 'arrays computed by filter property respond to array changes');
    deepEqual(obj.get('bs').mapBy('name'), ['six'], 'arrays computed by filtered property respond to array changes');
  });

  QUnit.test('properties can be filtered by values', function () {
    deepEqual(obj.get('a1s').mapBy('name'), ['one', 'three'], 'properties can be filtered by matching value');

    obj.get('array').pushObject({ name: 'five', a: 1 });

    deepEqual(obj.get('a1s').mapBy('name'), ['one', 'three', 'five'], 'arrays computed by matching value respond to added objects');

    obj.get('array').popObject();

    deepEqual(obj.get('a1s').mapBy('name'), ['one', 'three'], 'arrays computed by matching value respond to removed objects');

    _emberMetalProperty_set.set(obj.get('array')[1], 'a', 1);
    _emberMetalProperty_set.set(obj.get('array')[2], 'a', 2);

    deepEqual(obj.get('a1s').mapBy('name'), ['one', 'two'], 'arrays computed by matching value respond to modified properties');
  });

  QUnit.test('properties values can be replaced', function () {
    obj = _emberRuntimeSystemObject.default.extend({
      a1s: _emberRuntimeComputedReduce_computed_macros.filterBy('array', 'a', 1),
      a1bs: _emberRuntimeComputedReduce_computed_macros.filterBy('a1s', 'b')
    }).create({
      array: []
    });

    deepEqual(obj.get('a1bs').mapBy('name'), [], 'properties can be filtered by matching value');

    _emberMetalProperty_set.set(obj, 'array', [{ name: 'item1', a: 1, b: true }]);

    deepEqual(obj.get('a1bs').mapBy('name'), ['item1'], 'properties can be filtered by matching value');
  });

  [['uniq', _emberRuntimeComputedReduce_computed_macros.uniq], ['union', _emberRuntimeComputedReduce_computed_macros.union]].forEach(function (tuple) {
    var name = tuple[0];
    var macro = tuple[1];

    QUnit.module('computed.' + name, {
      setup: function () {
        obj = _emberRuntimeSystemObject.default.extend({
          union: macro('array', 'array2', 'array3')
        }).create({
          array: _emberMetalCore.default.A([1, 2, 3, 4, 5, 6]),
          array2: _emberMetalCore.default.A([4, 5, 6, 7, 8, 9, 4, 5, 6, 7, 8, 9]),
          array3: _emberMetalCore.default.A([1, 8, 10])
        });
      },
      teardown: function () {
        _emberMetalCore.default.run(obj, 'destroy');
      }
    });

    QUnit.test(name + ' is readOnly', function () {
      QUnit.throws(function () {
        obj.set('union', 1);
      }, /Cannot set read-only property "union" on object:/);
    });

    QUnit.test('does not include duplicates', function () {
      var array = obj.get('array');
      var array2 = obj.get('array2');

      deepEqual(obj.get('union').sort(function (x, y) {
        return x - y;
      }), [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], name + ' does not include duplicates');

      array.pushObject(8);

      deepEqual(obj.get('union').sort(function (x, y) {
        return x - y;
      }), [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], name + ' does not add existing items');

      array.pushObject(11);

      deepEqual(obj.get('union').sort(function (x, y) {
        return x - y;
      }), [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], name + ' adds new items');

      array2.removeAt(6); // remove 7

      deepEqual(obj.get('union').sort(function (x, y) {
        return x - y;
      }), [1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11], name + ' does not remove items that are still in the dependent array');

      array2.removeObject(7);

      deepEqual(obj.get('union').sort(function (x, y) {
        return x - y;
      }), [1, 2, 3, 4, 5, 6, 8, 9, 10, 11], name + ' removes items when their last instance is gone');
    });

    QUnit.test('has set-union semantics', function () {
      var array = obj.get('array');

      deepEqual(obj.get('union').sort(function (x, y) {
        return x - y;
      }), [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], name + ' is initially correct');

      array.removeObject(6);

      deepEqual(obj.get('union').sort(function (x, y) {
        return x - y;
      }), [1, 2, 3, 4, 5, 6, 7, 8, 9, 10], 'objects are not removed if they exist in other dependent arrays');

      array.clear();

      deepEqual(obj.get('union').sort(function (x, y) {
        return x - y;
      }), [1, 4, 5, 6, 7, 8, 9, 10], 'objects are removed when they are no longer in any dependent array');
    });
  });

  QUnit.module('computed.intersect', {
    setup: function () {
      obj = _emberRuntimeSystemObject.default.extend({
        intersection: _emberRuntimeComputedReduce_computed_macros.intersect('array', 'array2', 'array3')
      }).create({
        array: _emberMetalCore.default.A([1, 2, 3, 4, 5, 6]),
        array2: _emberMetalCore.default.A([3, 3, 3, 4, 5]),
        array3: _emberMetalCore.default.A([3, 5, 6, 7, 8])
      });
    },
    teardown: function () {
      _emberMetalCore.default.run(obj, 'destroy');
    }
  });

  QUnit.test('intersect is readOnly', function () {
    QUnit.throws(function () {
      obj.set('intersection', 1);
    }, /Cannot set read-only property "intersection" on object:/);
  });

  QUnit.test('it has set-intersection semantics', function () {
    var array2 = obj.get('array2');
    var array3 = obj.get('array3');

    deepEqual(obj.get('intersection').sort(function (x, y) {
      return x - y;
    }), [3, 5], 'intersection is initially correct');

    array2.shiftObject();

    deepEqual(obj.get('intersection').sort(function (x, y) {
      return x - y;
    }), [3, 5], 'objects are not removed when they are still in all dependent arrays');

    array2.shiftObject();

    deepEqual(obj.get('intersection').sort(function (x, y) {
      return x - y;
    }), [3, 5], 'objects are not removed when they are still in all dependent arrays');

    array2.shiftObject();

    deepEqual(obj.get('intersection'), [5], 'objects are removed once they are gone from all dependent arrays');

    array2.pushObject(1);

    deepEqual(obj.get('intersection'), [5], 'objects are not added as long as they are missing from any dependent array');

    array3.pushObject(1);

    deepEqual(obj.get('intersection').sort(function (x, y) {
      return x - y;
    }), [1, 5], 'objects added once they belong to all dependent arrays');
  });

  QUnit.module('setDiff', {
    setup: function () {
      obj = _emberRuntimeSystemObject.default.extend({
        diff: _emberRuntimeComputedReduce_computed_macros.setDiff('array', 'array2')
      }).create({
        array: _emberMetalCore.default.A([1, 2, 3, 4, 5, 6, 7]),
        array2: _emberMetalCore.default.A([3, 4, 5, 10])
      });
    },
    teardown: function () {
      _emberMetalCore.default.run(obj, 'destroy');
    }
  });

  QUnit.test('setDiff is readOnly', function () {
    QUnit.throws(function () {
      obj.set('diff', 1);
    }, /Cannot set read-only property "diff" on object:/);
  });

  QUnit.test('it throws an error if given fewer or more than two dependent properties', function () {
    throws(function () {
      _emberRuntimeSystemObject.default.extend({
        diff: _emberRuntimeComputedReduce_computed_macros.setDiff('array')
      }).create({
        array: _emberMetalCore.default.A([1, 2, 3, 4, 5, 6, 7]),
        array2: _emberMetalCore.default.A([3, 4, 5])
      });
    }, /requires exactly two dependent arrays/, 'setDiff requires two dependent arrays');

    throws(function () {
      _emberRuntimeSystemObject.default.extend({
        diff: _emberRuntimeComputedReduce_computed_macros.setDiff('array', 'array2', 'array3')
      }).create({
        array: _emberMetalCore.default.A([1, 2, 3, 4, 5, 6, 7]),
        array2: _emberMetalCore.default.A([3, 4, 5]),
        array3: _emberMetalCore.default.A([7])
      });
    }, /requires exactly two dependent arrays/, 'setDiff requires two dependent arrays');
  });

  QUnit.test('it has set-diff semantics', function () {
    var array1 = obj.get('array');
    var array2 = obj.get('array2');

    deepEqual(obj.get('diff').sort(function (x, y) {
      return x - y;
    }), [1, 2, 6, 7], 'set-diff is initially correct');

    array2.popObject();

    deepEqual(obj.get('diff').sort(function (x, y) {
      return x - y;
    }), [1, 2, 6, 7], 'removing objects from the remove set has no effect if the object is not in the keep set');

    array2.shiftObject();

    deepEqual(obj.get('diff').sort(function (x, y) {
      return x - y;
    }), [1, 2, 3, 6, 7], 'removing objects from the remove set adds them if they\'re in the keep set');

    array1.removeObject(3);

    deepEqual(obj.get('diff').sort(function (x, y) {
      return x - y;
    }), [1, 2, 6, 7], 'removing objects from the keep array removes them from the computed array');

    array1.pushObject(5);

    deepEqual(obj.get('diff').sort(function (x, y) {
      return x - y;
    }), [1, 2, 6, 7], 'objects added to the keep array that are in the remove array are not added to the computed array');

    array1.pushObject(22);

    deepEqual(obj.get('diff').sort(function (x, y) {
      return x - y;
    }), [1, 2, 6, 7, 22], 'objects added to the keep array not in the remove array are added to the computed array');
  });

  function commonSortTests() {
    QUnit.test('arrays are initially sorted', function () {
      deepEqual(obj.get('sortedItems').mapBy('fname'), ['Cersei', 'Jaime', 'Bran', 'Robb'], 'array is initially sorted');
    });

    QUnit.test('default sort order is correct', function () {
      deepEqual(obj.get('sortedItems').mapBy('fname'), ['Cersei', 'Jaime', 'Bran', 'Robb'], 'array is initially sorted');
    });

    QUnit.test('changing the dependent array updates the sorted array', function () {
      deepEqual(obj.get('sortedItems').mapBy('fname'), ['Cersei', 'Jaime', 'Bran', 'Robb'], 'precond - array is initially sorted');

      obj.set('items', [{ fname: 'Roose', lname: 'Bolton' }, { fname: 'Theon', lname: 'Greyjoy' }, { fname: 'Ramsey', lname: 'Bolton' }, { fname: 'Stannis', lname: 'Baratheon' }]);

      deepEqual(obj.get('sortedItems').mapBy('fname'), ['Stannis', 'Ramsey', 'Roose', 'Theon'], 'changing dependent array updates sorted array');
    });

    QUnit.test('adding to the dependent array updates the sorted array', function () {
      var items = obj.get('items');

      deepEqual(obj.get('sortedItems').mapBy('fname'), ['Cersei', 'Jaime', 'Bran', 'Robb'], 'precond - array is initially sorted');

      items.pushObject({
        fname: 'Tyrion',
        lname: 'Lannister'
      });

      deepEqual(obj.get('sortedItems').mapBy('fname'), ['Cersei', 'Jaime', 'Tyrion', 'Bran', 'Robb'], 'Adding to the dependent array updates the sorted array');
    });

    QUnit.test('removing from the dependent array updates the sorted array', function () {
      deepEqual(obj.get('sortedItems').mapBy('fname'), ['Cersei', 'Jaime', 'Bran', 'Robb'], 'precond - array is initially sorted');

      obj.get('items').popObject();

      deepEqual(obj.get('sortedItems').mapBy('fname'), ['Cersei', 'Jaime', 'Robb'], 'Removing from the dependent array updates the sorted array');
    });

    QUnit.test('distinct items may be sort-equal, although their relative order will not be guaranteed', function () {
      // We recreate jaime and "Cersei" here only for test stability: we want
      // their guid-ordering to be deterministic
      var jaimeInDisguise = {
        fname: 'Cersei',
        lname: 'Lannister',
        age: 34
      };

      var jaime = {
        fname: 'Jaime',
        lname: 'Lannister',
        age: 34
      };

      var items = obj.get('items');

      items.replace(0, 1, jaime);
      items.replace(1, 1, jaimeInDisguise);

      deepEqual(obj.get('sortedItems').mapBy('fname'), ['Cersei', 'Jaime', 'Bran', 'Robb'], 'precond - array is initially sorted');

      _emberMetalProperty_set.set(jaimeInDisguise, 'fname', 'Jaime');

      deepEqual(obj.get('sortedItems').mapBy('fname'), ['Jaime', 'Jaime', 'Bran', 'Robb'], 'sorted array is updated');

      _emberMetalProperty_set.set(jaimeInDisguise, 'fname', 'Cersei');

      deepEqual(obj.get('sortedItems').mapBy('fname'), ['Cersei', 'Jaime', 'Bran', 'Robb'], 'sorted array is updated');
    });

    QUnit.test('guid sort-order fallback with a search proxy is not confused by non-search ObjectProxys', function () {
      var tyrion = {
        fname: 'Tyrion',
        lname: 'Lannister'
      };

      var tyrionInDisguise = _emberRuntimeSystemObject_proxy.default.create({
        fname: 'Yollo',
        lname: '',
        content: tyrion
      });

      var items = obj.get('items');

      items.pushObject(tyrion);

      deepEqual(obj.get('sortedItems').mapBy('fname'), ['Cersei', 'Jaime', 'Tyrion', 'Bran', 'Robb']);

      items.pushObject(tyrionInDisguise);

      deepEqual(obj.get('sortedItems').mapBy('fname'), ['Yollo', 'Cersei', 'Jaime', 'Tyrion', 'Bran', 'Robb']);
    });
  }

  QUnit.module('sort - sortProperties', {
    setup: function () {
      obj = _emberRuntimeSystemObject.default.extend({
        sortedItems: _emberRuntimeComputedReduce_computed_macros.sort('items', 'itemSorting')
      }).create({
        itemSorting: _emberMetalCore.default.A(['lname', 'fname']),
        items: _emberMetalCore.default.A([{ fname: 'Jaime', lname: 'Lannister', age: 34 }, { fname: 'Cersei', lname: 'Lannister', age: 34 }, { fname: 'Robb', lname: 'Stark', age: 16 }, { fname: 'Bran', lname: 'Stark', age: 8 }])
      });
    },
    teardown: function () {
      _emberMetalCore.default.run(obj, 'destroy');
    }
  });

  QUnit.test('sort is readOnly', function () {
    QUnit.throws(function () {
      obj.set('sortedItems', 1);
    }, /Cannot set read-only property "sortedItems" on object:/);
  });

  commonSortTests();

  QUnit.test('updating sort properties detaches observers for old sort properties', function () {
    var objectToRemove = obj.get('items')[3];

    deepEqual(obj.get('sortedItems').mapBy('fname'), ['Cersei', 'Jaime', 'Bran', 'Robb'], 'precond - array is initially sorted');

    obj.set('itemSorting', _emberMetalCore.default.A(['fname:desc']));

    deepEqual(obj.get('sortedItems').mapBy('fname'), ['Robb', 'Jaime', 'Cersei', 'Bran'], 'after updating sort properties array is updated');

    obj.get('items').removeObject(objectToRemove);

    deepEqual(obj.get('sortedItems').mapBy('fname'), ['Robb', 'Jaime', 'Cersei'], 'after removing item array is updated');

    _emberMetalProperty_set.set(objectToRemove, 'lname', 'Updated-Stark');

    deepEqual(obj.get('sortedItems').mapBy('fname'), ['Robb', 'Jaime', 'Cersei'], 'after changing removed item array is not updated');
  });

  QUnit.test('updating sort properties updates the sorted array', function () {
    deepEqual(obj.get('sortedItems').mapBy('fname'), ['Cersei', 'Jaime', 'Bran', 'Robb'], 'precond - array is initially sorted');

    obj.set('itemSorting', _emberMetalCore.default.A(['fname:desc']));

    deepEqual(obj.get('sortedItems').mapBy('fname'), ['Robb', 'Jaime', 'Cersei', 'Bran'], 'after updating sort properties array is updated');
  });

  QUnit.test('updating sort properties invalidates the sorted array', function () {
    var sortProps = obj.get('itemSorting');

    deepEqual(obj.get('sortedItems').mapBy('fname'), ['Cersei', 'Jaime', 'Bran', 'Robb'], 'precond - array is initially sorted');

    sortProps.clear();
    sortProps.pushObject('fname');

    deepEqual(obj.get('sortedItems').mapBy('fname'), ['Bran', 'Cersei', 'Jaime', 'Robb'], 'after updating sort properties array is updated');
  });

  QUnit.test('updating new sort properties invalidates the sorted array', function () {
    deepEqual(obj.get('sortedItems').mapBy('fname'), ['Cersei', 'Jaime', 'Bran', 'Robb'], 'precond - array is initially sorted');

    obj.set('itemSorting', _emberMetalCore.default.A(['age:desc', 'fname:asc']));

    deepEqual(obj.get('sortedItems').mapBy('fname'), ['Cersei', 'Jaime', 'Robb', 'Bran'], 'precond - array is correct after item sorting is changed');

    _emberMetalProperty_set.set(obj.get('items')[1], 'age', 29);

    deepEqual(obj.get('sortedItems').mapBy('fname'), ['Jaime', 'Cersei', 'Robb', 'Bran'], 'after updating sort properties array is updated');
  });

  QUnit.test('sort direction defaults to ascending', function () {
    deepEqual(obj.get('sortedItems').mapBy('fname'), ['Cersei', 'Jaime', 'Bran', 'Robb']);
  });

  QUnit.test('sort direction defaults to ascending (with sort property change)', function () {
    deepEqual(obj.get('sortedItems').mapBy('fname'), ['Cersei', 'Jaime', 'Bran', 'Robb'], 'precond - array is initially sorted');

    obj.set('itemSorting', _emberMetalCore.default.A(['fname']));

    deepEqual(obj.get('sortedItems').mapBy('fname'), ['Bran', 'Cersei', 'Jaime', 'Robb'], 'sort direction defaults to ascending');
  });

  QUnit.test('updating an item\'s sort properties updates the sorted array', function () {
    var tyrionInDisguise = obj.get('items')[1];

    deepEqual(obj.get('sortedItems').mapBy('fname'), ['Cersei', 'Jaime', 'Bran', 'Robb'], 'precond - array is initially sorted');

    _emberMetalProperty_set.set(tyrionInDisguise, 'fname', 'Tyrion');

    deepEqual(obj.get('sortedItems').mapBy('fname'), ['Jaime', 'Tyrion', 'Bran', 'Robb'], 'updating an item\'s sort properties updates the sorted array');
  });

  QUnit.test('updating several of an item\'s sort properties updated the sorted array', function () {
    var sansaInDisguise = obj.get('items')[1];

    deepEqual(obj.get('sortedItems').mapBy('fname'), ['Cersei', 'Jaime', 'Bran', 'Robb'], 'precond - array is initially sorted');

    _emberMetalSet_properties.default(sansaInDisguise, {
      fname: 'Sansa',
      lname: 'Stark'
    });

    deepEqual(obj.get('sortedItems').mapBy('fname'), ['Jaime', 'Bran', 'Robb', 'Sansa'], 'updating an item\'s sort properties updates the sorted array');
  });

  QUnit.test('updating an item\'s sort properties does not error when binary search does a self compare (#3273)', function () {
    var jaime = {
      name: 'Jaime',
      status: 1
    };

    var cersei = {
      name: 'Cersei',
      status: 2
    };

    var obj = _emberRuntimeSystemObject.default.extend({
      sortProps: ['status'],
      sortedPeople: _emberRuntimeComputedReduce_computed_macros.sort('people', 'sortProps')
    }).create({
      people: [jaime, cersei]
    });

    deepEqual(obj.get('sortedPeople'), [jaime, cersei], 'precond - array is initially sorted');

    _emberMetalProperty_set.set(cersei, 'status', 3);

    deepEqual(obj.get('sortedPeople'), [jaime, cersei], 'array is sorted correctly');

    _emberMetalProperty_set.set(cersei, 'status', 2);

    deepEqual(obj.get('sortedPeople'), [jaime, cersei], 'array is sorted correctly');
  });

  QUnit.test('array observers do not leak', function () {
    var daria = { name: 'Daria' };
    var jane = { name: 'Jane' };

    var sisters = [jane, daria];

    var sortProps = _emberMetalCore.default.A(['name']);
    var jaime = _emberRuntimeSystemObject.default.extend({
      sortedPeople: _emberRuntimeComputedReduce_computed_macros.sort('sisters', 'sortProps'),
      sortProps: sortProps
    }).create({
      sisters: sisters
    });

    jaime.get('sortedPeople');
    _emberMetalCore.default.run(jaime, 'destroy');

    try {
      sortProps.pushObject({
        name: 'Anna'
      });
      ok(true);
    } catch (e) {
      ok(false, e);
    }
  });

  QUnit.test('property paths in sort properties update the sorted array', function () {
    var jaime = {
      relatedObj: { status: 1, firstName: 'Jaime', lastName: 'Lannister' }
    };

    var cersei = {
      relatedObj: { status: 2, firstName: 'Cersei', lastName: 'Lannister' }
    };

    var sansa = _emberRuntimeSystemObject.default.create({
      relatedObj: { status: 3, firstName: 'Sansa', lastName: 'Stark' }
    });

    var obj = _emberRuntimeSystemObject.default.extend({
      sortProps: ['relatedObj.status'],
      sortedPeople: _emberRuntimeComputedReduce_computed_macros.sort('people', 'sortProps')
    }).create({
      people: [jaime, cersei, sansa]
    });

    deepEqual(obj.get('sortedPeople'), [jaime, cersei, sansa], 'precond - array is initially sorted');

    _emberMetalProperty_set.set(cersei, 'status', 3);

    deepEqual(obj.get('sortedPeople'), [jaime, cersei, sansa], 'array is sorted correctly');

    _emberMetalProperty_set.set(cersei, 'status', 1);

    deepEqual(obj.get('sortedPeople'), [jaime, cersei, sansa], 'array is sorted correctly');

    sansa.set('status', 1);

    deepEqual(obj.get('sortedPeople'), [jaime, cersei, sansa], 'array is sorted correctly');

    obj.set('sortProps', ['relatedObj.firstName']);

    deepEqual(obj.get('sortedPeople'), [cersei, jaime, sansa], 'array is sorted correctly');
  });

  QUnit.test('if the dependentKey is neither an array nor object, it will return an empty array', function () {
    _emberMetalProperty_set.set(obj, 'items', null);
    ok(_emberRuntimeUtils.isArray(obj.get('sortedItems')), 'returns an empty arrays');

    _emberMetalProperty_set.set(obj, 'array', undefined);
    ok(_emberRuntimeUtils.isArray(obj.get('sortedItems')), 'returns an empty arrays');

    _emberMetalProperty_set.set(obj, 'array', 'not an array');
    ok(_emberRuntimeUtils.isArray(obj.get('sortedItems')), 'returns an empty arrays');
  });

  function sortByLnameFname(a, b) {
    var lna = _emberMetalProperty_get.get(a, 'lname');
    var lnb = _emberMetalProperty_get.get(b, 'lname');

    if (lna !== lnb) {
      return lna > lnb ? 1 : -1;
    }

    return sortByFnameAsc(a, b);
  }

  function sortByFnameAsc(a, b) {
    var fna = _emberMetalProperty_get.get(a, 'fname');
    var fnb = _emberMetalProperty_get.get(b, 'fname');

    if (fna === fnb) {
      return 0;
    }
    return fna > fnb ? 1 : -1;
  }

  QUnit.module('sort - sort function', {
    setup: function () {
      obj = _emberRuntimeSystemObject.default.extend({
        sortedItems: _emberRuntimeComputedReduce_computed_macros.sort('items.@each.fname', sortByLnameFname)
      }).create({
        items: _emberMetalCore.default.A([{ fname: 'Jaime', lname: 'Lannister', age: 34 }, { fname: 'Cersei', lname: 'Lannister', age: 34 }, { fname: 'Robb', lname: 'Stark', age: 16 }, { fname: 'Bran', lname: 'Stark', age: 8 }])
      });
    },
    teardown: function () {
      _emberMetalCore.default.run(obj, 'destroy');
    }
  });

  QUnit.test('sort has correct `this`', function () {
    var obj = _emberRuntimeSystemObject.default.extend({
      sortedItems: _emberRuntimeComputedReduce_computed_macros.sort('items.@each.fname', function (a, b) {
        equal(this, obj, 'expected the object to be `this`');
        return this.sortByLastName(a, b);
      }),
      sortByLastName: function (a, b) {
        return sortByFnameAsc(a, b);
      }
    }).create({
      items: _emberMetalCore.default.A([{ fname: 'Jaime', lname: 'Lannister', age: 34 }, { fname: 'Cersei', lname: 'Lannister', age: 34 }, { fname: 'Robb', lname: 'Stark', age: 16 }, { fname: 'Bran', lname: 'Stark', age: 8 }])
    });

    obj.get('sortedItems');
  });

  QUnit.test('sort (with function) is readOnly', function () {
    QUnit.throws(function () {
      obj.set('sortedItems', 1);
    }, /Cannot set read-only property "sortedItems" on object:/);
  });

  commonSortTests();

  QUnit.test('changing item properties specified via @each triggers a resort of the modified item', function () {
    var items = _emberMetalProperty_get.get(obj, 'items');

    var tyrionInDisguise = items[1];

    deepEqual(obj.get('sortedItems').mapBy('fname'), ['Cersei', 'Jaime', 'Bran', 'Robb'], 'precond - array is initially sorted');

    _emberMetalProperty_set.set(tyrionInDisguise, 'fname', 'Tyrion');

    deepEqual(obj.get('sortedItems').mapBy('fname'), ['Jaime', 'Tyrion', 'Bran', 'Robb'], 'updating a specified property on an item resorts it');
  });

  QUnit.test('changing item properties not specified via @each does not trigger a resort', function () {
    var items = obj.get('items');
    var cersei = items[1];

    deepEqual(obj.get('sortedItems').mapBy('fname'), ['Cersei', 'Jaime', 'Bran', 'Robb'], 'precond - array is initially sorted');

    _emberMetalProperty_set.set(cersei, 'lname', 'Stark'); // plot twist! (possibly not canon)

    // The array has become unsorted.  If your sort function is sensitive to
    // properties, they *must* be specified as dependent item property keys or
    // we'll be doing binary searches on unsorted arrays.
    deepEqual(obj.get('sortedItems').mapBy('fname'), ['Cersei', 'Jaime', 'Bran', 'Robb'], 'updating an unspecified property on an item does not resort it');
  });

  QUnit.module('sort - stability', {
    setup: function () {
      obj = _emberRuntimeSystemObject.default.extend({
        sortProps: ['count', 'name'],
        sortedItems: _emberRuntimeComputedReduce_computed_macros.sort('items', 'sortProps')
      }).create({
        items: [{ name: 'A', count: 1 }, { name: 'B', count: 1 }, { name: 'C', count: 1 }, { name: 'D', count: 1 }]
      });
    },
    teardown: function () {
      _emberMetalCore.default.run(obj, 'destroy');
    }
  });

  QUnit.test('sorts correctly as only one property changes', function () {
    deepEqual(obj.get('sortedItems').mapBy('name'), ['A', 'B', 'C', 'D'], 'initial');

    _emberMetalProperty_set.set(obj.get('items')[3], 'count', 2);

    deepEqual(obj.get('sortedItems').mapBy('name'), ['A', 'B', 'C', 'D'], 'final');
  });

  QUnit.module('sort - concurrency', {
    setup: function () {
      obj = _emberRuntimeSystemObject.default.extend({
        sortProps: ['count'],
        sortedItems: _emberRuntimeComputedReduce_computed_macros.sort('items', 'sortProps'),
        customSortedItems: _emberRuntimeComputedReduce_computed_macros.sort('items.@each.count', function (a, b) {
          return a.count - b.count;
        })
      }).create({
        items: _emberMetalCore.default.A([{ name: 'A', count: 1 }, { name: 'B', count: 2 }, { name: 'C', count: 3 }, { name: 'D', count: 4 }])
      });
    },

    teardown: function () {
      _emberMetalCore.default.run(obj, 'destroy');
    }
  });

  QUnit.test('sorts correctly after mutation to the sort properties', function () {
    var sorted = obj.get('sortedItems');
    deepEqual(sorted.mapBy('name'), ['A', 'B', 'C', 'D'], 'initial');

    _emberMetalProperty_set.set(obj.get('items')[1], 'count', 5);
    _emberMetalProperty_set.set(obj.get('items')[2], 'count', 6);

    deepEqual(obj.get('sortedItems').mapBy('name'), ['A', 'D', 'B', 'C'], 'final');
  });

  QUnit.test('sort correctl after mutation to the sor ', function () {
    deepEqual(obj.get('customSortedItems').mapBy('name'), ['A', 'B', 'C', 'D'], 'initial');

    _emberMetalProperty_set.set(obj.get('items')[1], 'count', 5);
    _emberMetalProperty_set.set(obj.get('items')[2], 'count', 6);

    deepEqual(obj.get('customSortedItems').mapBy('name'), ['A', 'D', 'B', 'C'], 'final');

    deepEqual(obj.get('sortedItems').mapBy('name'), ['A', 'D', 'B', 'C'], 'final');
  });

  QUnit.module('max', {
    setup: function () {
      obj = _emberRuntimeSystemObject.default.extend({
        max: _emberRuntimeComputedReduce_computed_macros.max('items')
      }).create({
        items: _emberMetalCore.default.A([1, 2, 3])
      });
    },
    teardown: function () {
      _emberMetalCore.default.run(obj, 'destroy');
    }
  });

  QUnit.test('max is readOnly', function () {
    QUnit.throws(function () {
      obj.set('max', 1);
    }, /Cannot set read-only property "max" on object:/);
  });

  QUnit.test('max tracks the max number as objects are added', function () {
    equal(obj.get('max'), 3, 'precond - max is initially correct');

    var items = obj.get('items');

    items.pushObject(5);

    equal(obj.get('max'), 5, 'max updates when a larger number is added');

    items.pushObject(2);

    equal(obj.get('max'), 5, 'max does not update when a smaller number is added');
  });

  QUnit.test('max recomputes when the current max is removed', function () {
    equal(obj.get('max'), 3, 'precond - max is initially correct');

    obj.get('items').removeObject(2);

    equal(obj.get('max'), 3, 'max is unchanged when a non-max item is removed');

    obj.get('items').removeObject(3);

    equal(obj.get('max'), 1, 'max is recomputed when the current max is removed');
  });

  QUnit.module('min', {
    setup: function () {
      obj = _emberRuntimeSystemObject.default.extend({
        min: _emberRuntimeComputedReduce_computed_macros.min('items')
      }).create({
        items: _emberMetalCore.default.A([1, 2, 3])
      });
    },
    teardown: function () {
      _emberMetalCore.default.run(obj, 'destroy');
    }
  });

  QUnit.test('min is readOnly', function () {
    QUnit.throws(function () {
      obj.set('min', 1);
    }, /Cannot set read-only property "min" on object:/);
  });

  QUnit.test('min tracks the min number as objects are added', function () {
    equal(obj.get('min'), 1, 'precond - min is initially correct');

    obj.get('items').pushObject(-2);

    equal(obj.get('min'), -2, 'min updates when a smaller number is added');

    obj.get('items').pushObject(2);

    equal(obj.get('min'), -2, 'min does not update when a larger number is added');
  });

  QUnit.test('min recomputes when the current min is removed', function () {
    var items = obj.get('items');

    equal(obj.get('min'), 1, 'precond - min is initially correct');

    items.removeObject(2);

    equal(obj.get('min'), 1, 'min is unchanged when a non-min item is removed');

    items.removeObject(1);

    equal(obj.get('min'), 3, 'min is recomputed when the current min is removed');
  });

  QUnit.module('Ember.arrayComputed - mixed sugar', {
    setup: function () {
      obj = _emberRuntimeSystemObject.default.extend({
        lannisters: _emberRuntimeComputedReduce_computed_macros.filterBy('items', 'lname', 'Lannister'),
        lannisterSorting: _emberMetalCore.default.A(['fname']),
        sortedLannisters: _emberRuntimeComputedReduce_computed_macros.sort('lannisters', 'lannisterSorting'),

        starks: _emberRuntimeComputedReduce_computed_macros.filterBy('items', 'lname', 'Stark'),
        starkAges: _emberRuntimeComputedReduce_computed_macros.mapBy('starks', 'age'),
        oldestStarkAge: _emberRuntimeComputedReduce_computed_macros.max('starkAges')
      }).create({
        items: _emberMetalCore.default.A([{ fname: 'Jaime', lname: 'Lannister', age: 34 }, { fname: 'Cersei', lname: 'Lannister', age: 34 }, { fname: 'Robb', lname: 'Stark', age: 16 }, { fname: 'Bran', lname: 'Stark', age: 8 }])
      });
    },
    teardown: function () {
      _emberMetalCore.default.run(obj, 'destroy');
    }
  });

  QUnit.test('filtering and sorting can be combined', function () {
    var items = obj.get('items');

    deepEqual(obj.get('sortedLannisters').mapBy('fname'), ['Cersei', 'Jaime'], 'precond - array is initially filtered and sorted');

    items.pushObject({ fname: 'Tywin', lname: 'Lannister' });
    items.pushObject({ fname: 'Lyanna', lname: 'Stark' });
    items.pushObject({ fname: 'Gerion', lname: 'Lannister' });

    deepEqual(obj.get('sortedLannisters').mapBy('fname'), ['Cersei', 'Gerion', 'Jaime', 'Tywin'], 'updates propagate to array');
  });

  QUnit.test('filtering, sorting and reduce (max) can be combined', function () {
    var items = obj.get('items');

    equal(16, obj.get('oldestStarkAge'), 'precond - end of chain is initially correct');

    items.pushObject({ fname: 'Rickon', lname: 'Stark', age: 5 });

    equal(16, obj.get('oldestStarkAge'), 'chain is updated correctly');

    items.pushObject({ fname: 'Eddard', lname: 'Stark', age: 35 });

    equal(35, obj.get('oldestStarkAge'), 'chain is updated correctly');
  });

  function todo(name, priority) {
    return _emberRuntimeSystemObject.default.create({ name: name, priority: priority });
  }

  function priorityComparator(todoA, todoB) {
    var pa = parseInt(_emberMetalProperty_get.get(todoA, 'priority'), 10);
    var pb = parseInt(_emberMetalProperty_get.get(todoB, 'priority'), 10);

    return pa - pb;
  }

  function evenPriorities(todo) {
    var p = parseInt(_emberMetalProperty_get.get(todo, 'priority'), 10);

    return p % 2 === 0;
  }

  QUnit.module('Ember.arrayComputed - chains', {
    setup: function () {
      obj = _emberRuntimeSystemObject.default.extend({
        sorted: _emberRuntimeComputedReduce_computed_macros.sort('todos.@each.priority', priorityComparator),
        filtered: _emberRuntimeComputedReduce_computed_macros.filter('sorted.@each.priority', evenPriorities)
      }).create({
        todos: _emberMetalCore.default.A([todo('E', 4), todo('D', 3), todo('C', 2), todo('B', 1), todo('A', 0)])
      });
    },
    teardown: function () {
      _emberMetalCore.default.run(obj, 'destroy');
    }
  });

  QUnit.test('it can filter and sort when both depend on the same item property', function () {
    deepEqual(obj.get('todos').mapBy('name'), ['E', 'D', 'C', 'B', 'A'], 'precond - todos initially correct');
    deepEqual(obj.get('sorted').mapBy('name'), ['A', 'B', 'C', 'D', 'E'], 'precond - sorted initially correct');
    deepEqual(obj.get('filtered').mapBy('name'), ['A', 'C', 'E'], 'precond - filtered initially correct');

    _emberMetalProperty_set.set(obj.get('todos')[1], 'priority', 6);

    deepEqual(obj.get('todos').mapBy('name'), ['E', 'D', 'C', 'B', 'A'], 'precond - todos remain correct');
    deepEqual(obj.get('sorted').mapBy('name'), ['A', 'B', 'C', 'E', 'D'], 'precond - sorted updated correctly');
    deepEqual(obj.get('filtered').mapBy('name'), ['A', 'C', 'E', 'D'], 'filtered updated correctly');
  });

  var userFnCalls;
  QUnit.module('Chaining array and reduced CPs', {
    setup: function () {
      userFnCalls = 0;
      obj = _emberRuntimeSystemObject.default.extend({
        mapped: _emberRuntimeComputedReduce_computed_macros.mapBy('array', 'v'),
        max: _emberRuntimeComputedReduce_computed_macros.max('mapped'),
        maxDidChange: _emberMetalMixin.observer('max', function () {
          return userFnCalls++;
        })
      }).create({
        array: _emberMetalCore.default.A([{ v: 1 }, { v: 3 }, { v: 2 }, { v: 1 }])
      });
    },
    teardown: function () {
      _emberMetalCore.default.run(obj, 'destroy');
    }
  });

  QUnit.test('it computes interdependent array computed properties', function () {
    equal(obj.get('max'), 3, 'sanity - it properly computes the maximum value');

    var calls = 0;

    _emberMetalObserver.addObserver(obj, 'max', function () {
      return calls++;
    });

    obj.get('array').pushObject({ v: 5 });

    equal(obj.get('max'), 5, 'maximum value is updated correctly');
    equal(userFnCalls, 1, 'object defined observers fire');
    equal(calls, 1, 'runtime created observers fire');
  });

  QUnit.module('sum', {
    setup: function () {
      obj = _emberRuntimeSystemObject.default.extend({
        total: _emberRuntimeComputedReduce_computed_macros.sum('array')
      }).create({
        array: _emberMetalCore.default.A([1, 2, 3])
      });
    },

    teardown: function () {
      _emberMetalCore.default.run(obj, 'destroy');
    }
  });

  QUnit.test('sum is readOnly', function () {
    QUnit.throws(function () {
      obj.set('total', 1);
    }, /Cannot set read-only property "total" on object:/);
  });
  QUnit.test('sums the values in the dependentKey', function () {
    equal(obj.get('total'), 6, 'sums the values');
  });

  QUnit.test('if the dependentKey is neither an array nor object, it will return `0`', function () {
    _emberMetalProperty_set.set(obj, 'array', null);
    equal(_emberMetalProperty_get.get(obj, 'total'), 0, 'returns 0');

    _emberMetalProperty_set.set(obj, 'array', undefined);
    equal(_emberMetalProperty_get.get(obj, 'total'), 0, 'returns 0');

    _emberMetalProperty_set.set(obj, 'array', 'not an array');
    equal(_emberMetalProperty_get.get(obj, 'total'), 0, 'returns 0');
  });

  QUnit.test('updates when array is modified', function () {
    obj.get('array').pushObject(1);

    equal(obj.get('total'), 7, 'recomputed when elements are added');

    obj.get('array').popObject();

    equal(obj.get('total'), 6, 'recomputes when elements are removed');
  });
});
enifed('ember-runtime/tests/computed/reduce_computed_macros_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/computed');
  test('ember-runtime/tests/computed/reduce_computed_macros_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/computed/reduce_computed_macros_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/computed/reduce_computed_macros_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/computed');
  QUnit.test('ember-runtime/tests/computed/reduce_computed_macros_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/computed/reduce_computed_macros_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/controllers/controller_test', ['exports', 'ember-runtime/controllers/controller', 'ember-runtime/system/service', 'ember-metal/mixin', 'ember-runtime/system/object', 'ember-runtime/system/container', 'ember-runtime/inject', 'ember-metal/property_get'], function (exports, _emberRuntimeControllersController, _emberRuntimeSystemService, _emberMetalMixin, _emberRuntimeSystemObject, _emberRuntimeSystemContainer, _emberRuntimeInject, _emberMetalProperty_get) {
  /* global EmberDev */

  'use strict';

  QUnit.module('Controller event handling');

  QUnit.test('can access `actions` hash via `_actions` [DEPRECATED]', function () {
    expect(2);

    var controller = _emberRuntimeControllersController.default.extend({
      actions: {
        foo: function () {
          ok(true, 'called foo action');
        }
      }
    }).create();

    expectDeprecation(function () {
      controller._actions.foo();
    }, 'Usage of `_actions` is deprecated, use `actions` instead.');
  });

  QUnit.test('Action can be handled by a function on actions object', function () {
    expect(1);
    var TestController = _emberRuntimeControllersController.default.extend({
      actions: {
        poke: function () {
          ok(true, 'poked');
        }
      }
    });
    var controller = TestController.create({});
    controller.send('poke');
  });

  QUnit.test('A handled action can be bubbled to the target for continued processing', function () {
    expect(2);
    var TestController = _emberRuntimeControllersController.default.extend({
      actions: {
        poke: function () {
          ok(true, 'poked 1');
          return true;
        }
      }
    });

    var controller = TestController.create({
      target: _emberRuntimeControllersController.default.extend({
        actions: {
          poke: function () {
            ok(true, 'poked 2');
          }
        }
      }).create()
    });
    controller.send('poke');
  });

  QUnit.test('Action can be handled by a superclass\' actions object', function () {
    expect(4);

    var SuperController = _emberRuntimeControllersController.default.extend({
      actions: {
        foo: function () {
          ok(true, 'foo');
        },
        bar: function (msg) {
          equal(msg, 'HELLO');
        }
      }
    });

    var BarControllerMixin = _emberMetalMixin.default.create({
      actions: {
        bar: function (msg) {
          equal(msg, 'HELLO');
          this._super(msg);
        }
      }
    });

    var IndexController = SuperController.extend(BarControllerMixin, {
      actions: {
        baz: function () {
          ok(true, 'baz');
        }
      }
    });

    var controller = IndexController.create({});
    controller.send('foo');
    controller.send('bar', 'HELLO');
    controller.send('baz');
  });

  QUnit.module('Controller deprecations');

  QUnit.module('Controller Content -> Model Alias');

  QUnit.test('`model` is aliased as `content`', function () {
    expect(1);
    var controller = _emberRuntimeControllersController.default.extend({
      model: 'foo-bar'
    }).create();

    equal(controller.get('content'), 'foo-bar', 'content is an alias of model');
  });

  QUnit.test('`content` is moved to `model` when `model` is unset', function () {
    expect(2);
    var controller;

    ignoreDeprecation(function () {
      controller = _emberRuntimeControllersController.default.extend({
        content: 'foo-bar'
      }).create();
    });

    equal(controller.get('model'), 'foo-bar', 'model is set properly');
    equal(controller.get('content'), 'foo-bar', 'content is set properly');
  });

  QUnit.test('specifying `content` (without `model` specified) results in deprecation', function () {
    expect(1);
    var controller;

    expectDeprecation(function () {
      controller = _emberRuntimeControllersController.default.extend({
        content: 'foo-bar'
      }).create();
    }, 'Do not specify `content` on a Controller, use `model` instead.');
  });

  QUnit.test('specifying `content` (with `model` specified) does not result in deprecation', function () {
    expect(3);
    expectNoDeprecation();

    var controller = _emberRuntimeControllersController.default.extend({
      content: 'foo-bar',
      model: 'blammo'
    }).create();

    equal(_emberMetalProperty_get.get(controller, 'content'), 'foo-bar');
    equal(_emberMetalProperty_get.get(controller, 'model'), 'blammo');
  });

  QUnit.module('Controller injected properties');

  if (!EmberDev.runningProdBuild) {
    QUnit.test('defining a controller on a non-controller should fail assertion', function () {
      expectAssertion(function () {
        var registry = new _emberRuntimeSystemContainer.Registry();
        var container = registry.container();

        var AnObject = _emberRuntimeSystemObject.default.extend({
          container: container,
          foo: _emberRuntimeInject.default.controller('bar')
        });

        registry.register('foo:main', AnObject);

        container.lookupFactory('foo:main');
      }, /Defining an injected controller property on a non-controller is not allowed./);
    });
  }

  QUnit.test('controllers can be injected into controllers', function () {
    var registry = new _emberRuntimeSystemContainer.Registry();
    var container = registry.container();

    registry.register('controller:post', _emberRuntimeControllersController.default.extend({
      postsController: _emberRuntimeInject.default.controller('posts')
    }));

    registry.register('controller:posts', _emberRuntimeControllersController.default.extend());

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

    equal(postsController, postController.get('postsController'), 'controller.posts is injected');
  });

  QUnit.test('services can be injected into controllers', function () {
    var registry = new _emberRuntimeSystemContainer.Registry();
    var container = registry.container();

    registry.register('controller:application', _emberRuntimeControllersController.default.extend({
      authService: _emberRuntimeInject.default.service('auth')
    }));

    registry.register('service:auth', _emberRuntimeSystemService.default.extend());

    var appController = container.lookup('controller:application');
    var authService = container.lookup('service:auth');

    equal(authService, appController.get('authService'), 'service.auth is injected');
  });
});
enifed('ember-runtime/tests/controllers/controller_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/controllers');
  test('ember-runtime/tests/controllers/controller_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/controllers/controller_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/controllers/controller_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/controllers');
  QUnit.test('ember-runtime/tests/controllers/controller_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/controllers/controller_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/core/compare_test', ['exports', 'ember-runtime/utils', 'ember-runtime/system/object', 'ember-runtime/compare', 'ember-runtime/mixins/comparable'], function (exports, _emberRuntimeUtils, _emberRuntimeSystemObject, _emberRuntimeCompare, _emberRuntimeMixinsComparable) {
  'use strict';

  var data = [];
  var Comp = _emberRuntimeSystemObject.default.extend(_emberRuntimeMixinsComparable.default);

  Comp.reopenClass({
    compare: function (obj) {
      return obj.get('val');
    }
  });

  QUnit.module('Ember.compare()', {
    setup: function () {
      data[0] = null;
      data[1] = false;
      data[2] = true;
      data[3] = -12;
      data[4] = 3.5;
      data[5] = 'a string';
      data[6] = 'another string';
      data[7] = 'last string';
      data[8] = [1, 2];
      data[9] = [1, 2, 3];
      data[10] = [1, 3];
      data[11] = { a: 'hash' };
      data[12] = _emberRuntimeSystemObject.default.create();
      data[13] = function (a) {
        return a;
      };
      data[14] = new Date('2012/01/01');
      data[15] = new Date('2012/06/06');
    }
  });

  QUnit.test('ordering should work', function () {
    var suspect, comparable, failureMessage, suspectIndex, comparableIndex;

    for (suspectIndex = 0; suspectIndex < data.length; suspectIndex++) {
      suspect = data[suspectIndex];

      equal(_emberRuntimeCompare.default(suspect, suspect), 0, suspectIndex + ' should equal itself');

      for (comparableIndex = suspectIndex + 1; comparableIndex < data.length; comparableIndex++) {
        comparable = data[comparableIndex];

        failureMessage = 'data[' + suspectIndex + '] (' + _emberRuntimeUtils.typeOf(suspect) + ') should be smaller than data[' + comparableIndex + '] (' + _emberRuntimeUtils.typeOf(comparable) + ')';

        equal(_emberRuntimeCompare.default(suspect, comparable), -1, failureMessage);
      }
    }
  });

  QUnit.test('comparables should return values in the range of -1, 0, 1', function () {
    var negOne = Comp.create({
      val: -1
    });

    var zero = Comp.create({
      val: 0
    });

    var one = Comp.create({
      val: 1
    });

    equal(_emberRuntimeCompare.default(negOne, 'a'), -1, 'First item comparable - returns -1 (not negated)');
    equal(_emberRuntimeCompare.default(zero, 'b'), 0, 'First item comparable - returns  0 (not negated)');
    equal(_emberRuntimeCompare.default(one, 'c'), 1, 'First item comparable - returns  1 (not negated)');

    equal(_emberRuntimeCompare.default('a', negOne), 1, 'Second item comparable - returns -1 (negated)');
    equal(_emberRuntimeCompare.default('b', zero), 0, 'Second item comparable - returns  0 (negated)');
    equal(_emberRuntimeCompare.default('c', one), -1, 'Second item comparable - returns  1 (negated)');
  });
});
enifed('ember-runtime/tests/core/compare_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/core');
  test('ember-runtime/tests/core/compare_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/core/compare_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/core/compare_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/core');
  QUnit.test('ember-runtime/tests/core/compare_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/core/compare_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/core/copy_test', ['exports', 'ember-runtime/copy'], function (exports, _emberRuntimeCopy) {
  'use strict';

  QUnit.module('Ember Copy Method');

  QUnit.test('Ember.copy null', function () {
    var obj = { field: null };

    equal(_emberRuntimeCopy.default(obj, true).field, null, 'null should still be null');
  });

  QUnit.test('Ember.copy date', function () {
    var date = new Date(2014, 7, 22);
    var dateCopy = _emberRuntimeCopy.default(date);

    equal(date.getTime(), dateCopy.getTime(), 'dates should be equivalent');
  });

  QUnit.test('Ember.copy null prototype object', function () {
    var obj = Object.create(null);

    obj.foo = 'bar';

    equal(_emberRuntimeCopy.default(obj).foo, 'bar', 'bar should still be bar');
  });
});
enifed('ember-runtime/tests/core/copy_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/core');
  test('ember-runtime/tests/core/copy_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/core/copy_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/core/copy_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/core');
  QUnit.test('ember-runtime/tests/core/copy_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/core/copy_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/core/isEqual_test', ['exports', 'ember-runtime/core'], function (exports, _emberRuntimeCore) {
  'use strict';

  QUnit.module('isEqual');

  QUnit.test('undefined and null', function () {
    ok(_emberRuntimeCore.isEqual(undefined, undefined), 'undefined is equal to undefined');
    ok(!_emberRuntimeCore.isEqual(undefined, null), 'undefined is not equal to null');
    ok(_emberRuntimeCore.isEqual(null, null), 'null is equal to null');
    ok(!_emberRuntimeCore.isEqual(null, undefined), 'null is not equal to undefined');
  });

  QUnit.test('strings should be equal', function () {
    ok(!_emberRuntimeCore.isEqual('Hello', 'Hi'), 'different Strings are unequal');
    ok(_emberRuntimeCore.isEqual('Hello', 'Hello'), 'same Strings are equal');
  });

  QUnit.test('numericals should be equal', function () {
    ok(_emberRuntimeCore.isEqual(24, 24), 'same numbers are equal');
    ok(!_emberRuntimeCore.isEqual(24, 21), 'different numbers are inequal');
  });

  QUnit.test('dates should be equal', function () {
    ok(_emberRuntimeCore.isEqual(new Date(1985, 7, 22), new Date(1985, 7, 22)), 'same dates are equal');
    ok(!_emberRuntimeCore.isEqual(new Date(2014, 7, 22), new Date(1985, 7, 22)), 'different dates are not equal');
  });

  QUnit.test('array should be equal', function () {
    // NOTE: We don't test for array contents -- that would be too expensive.
    ok(!_emberRuntimeCore.isEqual([1, 2], [1, 2]), 'two array instances with the same values should not be equal');
    ok(!_emberRuntimeCore.isEqual([1, 2], [1]), 'two array instances with different values should not be equal');
  });

  QUnit.test('first object implements isEqual should use it', function () {
    ok(_emberRuntimeCore.isEqual({ isEqual: function () {
        return true;
      } }, null), 'should return true always');

    var obj = { isEqual: function () {
        return false;
      } };
    equal(_emberRuntimeCore.isEqual(obj, obj), false, 'should return false because isEqual returns false');
  });
});
enifed('ember-runtime/tests/core/isEqual_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/core');
  test('ember-runtime/tests/core/isEqual_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/core/isEqual_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/core/isEqual_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/core');
  QUnit.test('ember-runtime/tests/core/isEqual_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/core/isEqual_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/core/is_array_test', ['exports', 'ember-metal/core', 'ember-runtime/utils', 'ember-runtime/system/array_proxy'], function (exports, _emberMetalCore, _emberRuntimeUtils, _emberRuntimeSystemArray_proxy) {
  'use strict';

  QUnit.module('Ember Type Checking');

  var global = undefined;

  QUnit.test('Ember.isArray', function () {
    var numarray = [1, 2, 3];
    var number = 23;
    var strarray = ['Hello', 'Hi'];
    var string = 'Hello';
    var object = {};
    var length = { length: 12 };
    var fn = function () {};
    var arrayProxy = _emberRuntimeSystemArray_proxy.default.create({ content: _emberMetalCore.default.A() });

    equal(_emberRuntimeUtils.isArray(numarray), true, '[1,2,3]');
    equal(_emberRuntimeUtils.isArray(number), false, '23');
    equal(_emberRuntimeUtils.isArray(strarray), true, '["Hello", "Hi"]');
    equal(_emberRuntimeUtils.isArray(string), false, '"Hello"');
    equal(_emberRuntimeUtils.isArray(object), false, '{}');
    equal(_emberRuntimeUtils.isArray(length), true, '{ length: 12 }');
    equal(_emberRuntimeUtils.isArray(global), false, 'global');
    equal(_emberRuntimeUtils.isArray(fn), false, 'function() {}');
    equal(_emberRuntimeUtils.isArray(arrayProxy), true, '[]');
  });
});
enifed('ember-runtime/tests/core/is_array_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/core');
  test('ember-runtime/tests/core/is_array_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/core/is_array_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/core/is_array_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/core');
  QUnit.test('ember-runtime/tests/core/is_array_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/core/is_array_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/core/is_empty_test', ['exports', 'ember-metal/core', 'ember-metal/is_empty', 'ember-runtime/system/array_proxy'], function (exports, _emberMetalCore, _emberMetalIs_empty, _emberRuntimeSystemArray_proxy) {
  'use strict';

  QUnit.module('Ember.isEmpty');

  QUnit.test('Ember.isEmpty', function () {
    var arrayProxy = _emberRuntimeSystemArray_proxy.default.create({ content: _emberMetalCore.default.A() });

    equal(true, _emberMetalIs_empty.default(arrayProxy), 'for an ArrayProxy that has empty content');
  });
});
enifed('ember-runtime/tests/core/is_empty_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/core');
  test('ember-runtime/tests/core/is_empty_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/core/is_empty_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/core/is_empty_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/core');
  QUnit.test('ember-runtime/tests/core/is_empty_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/core/is_empty_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/core/type_of_test', ['exports', 'ember-runtime/utils', 'ember-runtime/system/object'], function (exports, _emberRuntimeUtils, _emberRuntimeSystemObject) {
  'use strict';

  QUnit.module('Ember Type Checking');

  QUnit.test('Ember.typeOf', function () {
    var MockedDate = function () {};
    MockedDate.prototype = new Date();

    var mockedDate = new MockedDate();
    var date = new Date();
    var error = new Error('boum');
    var object = { a: 'b' };
    var a = null;
    var arr = [1, 2, 3];
    var obj = {};
    var instance = _emberRuntimeSystemObject.default.create({ method: function () {} });

    equal(_emberRuntimeUtils.typeOf(), 'undefined', 'undefined');
    equal(_emberRuntimeUtils.typeOf(null), 'null', 'null');
    equal(_emberRuntimeUtils.typeOf('Cyril'), 'string', 'Cyril');
    equal(_emberRuntimeUtils.typeOf(101), 'number', '101');
    equal(_emberRuntimeUtils.typeOf(true), 'boolean', 'true');
    equal(_emberRuntimeUtils.typeOf([1, 2, 90]), 'array', '[1,2,90]');
    equal(_emberRuntimeUtils.typeOf(/abc/), 'regexp', '/abc/');
    equal(_emberRuntimeUtils.typeOf(date), 'date', 'new Date()');
    equal(_emberRuntimeUtils.typeOf(mockedDate), 'date', 'mocked date');
    equal(_emberRuntimeUtils.typeOf(error), 'error', 'error');
    equal(_emberRuntimeUtils.typeOf(object), 'object', 'object');
    equal(_emberRuntimeUtils.typeOf(undefined), 'undefined', 'item of type undefined');
    equal(_emberRuntimeUtils.typeOf(a), 'null', 'item of type null');
    equal(_emberRuntimeUtils.typeOf(arr), 'array', 'item of type array');
    equal(_emberRuntimeUtils.typeOf(obj), 'object', 'item of type object');
    equal(_emberRuntimeUtils.typeOf(instance), 'instance', 'item of type instance');
    equal(_emberRuntimeUtils.typeOf(instance.method), 'function', 'item of type function');
    equal(_emberRuntimeUtils.typeOf(_emberRuntimeSystemObject.default.extend()), 'class', 'item of type class');
    equal(_emberRuntimeUtils.typeOf(new Error()), 'error', 'item of type error');
  });
});
enifed('ember-runtime/tests/core/type_of_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/core');
  test('ember-runtime/tests/core/type_of_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/core/type_of_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/core/type_of_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/core');
  QUnit.test('ember-runtime/tests/core/type_of_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/core/type_of_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/ext/function_test', ['exports', 'ember-metal/core', 'ember-metal/tests/props_helper'], function (exports, _emberMetalCore, _emberMetalTestsProps_helper) {
  'use strict';

  QUnit.module('Function.prototype.observes() helper');

  _emberMetalTestsProps_helper.testBoth('global observer helper takes multiple params', function (get, set) {

    if (_emberMetalCore.default.EXTEND_PROTOTYPES === false) {
      ok('undefined' === typeof Function.prototype.observes, 'Function.prototype helper disabled');
      return;
    }

    var MyMixin = _emberMetalCore.default.Mixin.create({

      count: 0,

      foo: (function () {
        set(this, 'count', get(this, 'count') + 1);
      }).observes('bar', 'baz')

    });

    var obj = _emberMetalCore.default.mixin({}, MyMixin);
    equal(get(obj, 'count'), 0, 'should not invoke observer immediately');

    set(obj, 'bar', 'BAZ');
    set(obj, 'baz', 'BAZ');
    equal(get(obj, 'count'), 2, 'should invoke observer after change');
  });

  QUnit.module('Function.prototype.on() helper');

  _emberMetalTestsProps_helper.testBoth('sets up an event listener, and can trigger the function on multiple events', function (get, set) {

    if (_emberMetalCore.default.EXTEND_PROTOTYPES === false) {
      ok('undefined' === typeof Function.prototype.on, 'Function.prototype helper disabled');
      return;
    }

    var MyMixin = _emberMetalCore.default.Mixin.create({

      count: 0,

      foo: (function () {
        set(this, 'count', get(this, 'count') + 1);
      }).on('bar', 'baz')

    });

    var obj = _emberMetalCore.default.mixin({}, _emberMetalCore.default.Evented, MyMixin);
    equal(get(obj, 'count'), 0, 'should not invoke listener immediately');

    obj.trigger('bar');
    obj.trigger('baz');
    equal(get(obj, 'count'), 2, 'should invoke listeners when events trigger');
  });

  _emberMetalTestsProps_helper.testBoth('can be chained with observes', function (get, set) {

    if (_emberMetalCore.default.EXTEND_PROTOTYPES === false) {
      ok('Function.prototype helper disabled');
      return;
    }

    var MyMixin = _emberMetalCore.default.Mixin.create({

      count: 0,
      bay: 'bay',
      foo: (function () {
        set(this, 'count', get(this, 'count') + 1);
      }).observes('bay').on('bar')
    });

    var obj = _emberMetalCore.default.mixin({}, _emberMetalCore.default.Evented, MyMixin);
    equal(get(obj, 'count'), 0, 'should not invoke listener immediately');

    set(obj, 'bay', 'BAY');
    obj.trigger('bar');
    equal(get(obj, 'count'), 2, 'should invoke observer and listener');
  });

  QUnit.module('Function.prototype.property() helper');

  _emberMetalTestsProps_helper.testBoth('sets up a ComputedProperty', function (get, set) {

    if (_emberMetalCore.default.EXTEND_PROTOTYPES === false) {
      ok('undefined' === typeof Function.prototype.property, 'Function.prototype helper disabled');
      return;
    }

    var MyClass = _emberMetalCore.default.Object.extend({
      firstName: null,
      lastName: null,
      fullName: (function () {
        return get(this, 'firstName') + ' ' + get(this, 'lastName');
      }).property('firstName', 'lastName')
    });

    var obj = MyClass.create({ firstName: 'Fred', lastName: 'Flinstone' });
    equal(get(obj, 'fullName'), 'Fred Flinstone', 'should return the computed value');

    set(obj, 'firstName', 'Wilma');
    equal(get(obj, 'fullName'), 'Wilma Flinstone', 'should return the new computed value');

    set(obj, 'lastName', '');
    equal(get(obj, 'fullName'), 'Wilma ', 'should return the new computed value');
  });
});
enifed('ember-runtime/tests/ext/function_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/ext');
  test('ember-runtime/tests/ext/function_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/ext/function_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/ext/function_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/ext');
  QUnit.test('ember-runtime/tests/ext/function_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/ext/function_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/ext/mixin_test', ['exports', 'ember-metal/property_set', 'ember-metal/property_get', 'ember-metal/mixin', 'ember-metal/binding', 'ember-metal/run_loop'], function (exports, _emberMetalProperty_set, _emberMetalProperty_get, _emberMetalMixin, _emberMetalBinding, _emberMetalRun_loop) {
  'use strict';

  QUnit.module('system/mixin/binding_test');

  QUnit.test('Defining a property ending in Binding should setup binding when applied', function () {

    var MyMixin = _emberMetalMixin.Mixin.create({
      fooBinding: 'bar.baz'
    });

    var obj = { bar: { baz: 'BIFF' } };

    _emberMetalRun_loop.default(function () {
      MyMixin.apply(obj);
    });

    ok(_emberMetalProperty_get.get(obj, 'fooBinding') instanceof _emberMetalBinding.Binding, 'should be a binding object');
    equal(_emberMetalProperty_get.get(obj, 'foo'), 'BIFF', 'binding should be created and synced');
  });

  QUnit.test('Defining a property ending in Binding should apply to prototype children', function () {
    var MyMixin, obj, obj2;

    _emberMetalRun_loop.default(function () {
      MyMixin = _emberMetalMixin.Mixin.create({
        fooBinding: 'bar.baz'
      });
    });

    obj = { bar: { baz: 'BIFF' } };

    _emberMetalRun_loop.default(function () {
      MyMixin.apply(obj);
    });

    obj2 = Object.create(obj);
    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(_emberMetalProperty_get.get(obj2, 'bar'), 'baz', 'BARG');
    });

    ok(_emberMetalProperty_get.get(obj2, 'fooBinding') instanceof _emberMetalBinding.Binding, 'should be a binding object');
    equal(_emberMetalProperty_get.get(obj2, 'foo'), 'BARG', 'binding should be created and synced');
  });
});
enifed('ember-runtime/tests/ext/mixin_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/ext');
  test('ember-runtime/tests/ext/mixin_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/ext/mixin_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/ext/mixin_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/ext');
  QUnit.test('ember-runtime/tests/ext/mixin_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/ext/mixin_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/ext/rsvp_test', ['exports', 'ember-metal/core', 'ember-metal/run_loop', 'ember-runtime/ext/rsvp'], function (exports, _emberMetalCore, _emberMetalRun_loop, _emberRuntimeExtRsvp) {
  /* global Promise:true */
  'use strict';

  QUnit.module('Ember.RSVP');

  QUnit.test('Ensure that errors thrown from within a promise are sent to the console', function () {
    var error = new Error('Error thrown in a promise for testing purposes.');

    try {
      _emberMetalRun_loop.default(function () {
        new _emberRuntimeExtRsvp.default.Promise(function (resolve, reject) {
          throw error;
        });
      });
      ok(false, 'expected assertion to be thrown');
    } catch (e) {
      equal(e, error, 'error was re-thrown');
    }
  });

  var asyncStarted = 0;
  var asyncEnded = 0;
  var Promise = _emberRuntimeExtRsvp.default.Promise;

  var EmberTest;
  var EmberTesting;

  QUnit.module('Deferred RSVP\'s async + Testing', {
    setup: function () {
      EmberTest = _emberMetalCore.default.Test;
      EmberTesting = _emberMetalCore.default.testing;

      _emberMetalCore.default.Test = {
        adapter: {
          asyncStart: function () {
            asyncStarted++;
            QUnit.stop();
          },
          asyncEnd: function () {
            asyncEnded++;
            QUnit.start();
          }
        }
      };
    },
    teardown: function () {
      asyncStarted = 0;
      asyncEnded = 0;

      _emberMetalCore.default.testing = EmberTesting;
      _emberMetalCore.default.Test = EmberTest;
    }
  });

  QUnit.test('given `Ember.testing = true`, correctly informs the test suite about async steps', function () {
    expect(19);

    ok(!_emberMetalRun_loop.default.currentRunLoop, 'expect no run-loop');

    _emberMetalCore.default.testing = true;

    equal(asyncStarted, 0);
    equal(asyncEnded, 0);

    var user = Promise.resolve({
      name: 'tomster'
    });

    equal(asyncStarted, 0);
    equal(asyncEnded, 0);

    user.then(function (user) {
      equal(asyncStarted, 1);
      equal(asyncEnded, 1);

      equal(user.name, 'tomster');

      return Promise.resolve(1).then(function () {
        equal(asyncStarted, 1);
        equal(asyncEnded, 1);
      });
    }).then(function () {
      equal(asyncStarted, 1);
      equal(asyncEnded, 1);

      return new Promise(function (resolve) {
        QUnit.stop(); // raw async, we must inform the test framework manually
        setTimeout(function () {
          QUnit.start(); // raw async, we must inform the test framework manually

          equal(asyncStarted, 1);
          equal(asyncEnded, 1);

          resolve({
            name: 'async tomster'
          });

          equal(asyncStarted, 2);
          equal(asyncEnded, 1);
        }, 0);
      });
    }).then(function (user) {
      equal(user.name, 'async tomster');
      equal(asyncStarted, 2);
      equal(asyncEnded, 2);
    });
  });

  QUnit.test('TransitionAborted errors are not re-thrown', function () {
    expect(1);
    var fakeTransitionAbort = { name: 'TransitionAborted' };

    _emberMetalRun_loop.default(_emberRuntimeExtRsvp.default, 'reject', fakeTransitionAbort);

    ok(true, 'did not throw an error when dealing with TransitionAborted');
  });

  QUnit.test('rejections like jqXHR which have errorThrown property work', function () {
    expect(2);

    var wasEmberTesting = _emberMetalCore.default.testing;
    var wasOnError = _emberMetalCore.default.onerror;

    try {
      _emberMetalCore.default.testing = false;
      _emberMetalCore.default.onerror = function (error) {
        equal(error, actualError, 'expected the real error on the jqXHR');
        equal(error.__reason_with_error_thrown__, jqXHR, 'also retains a helpful reference to the rejection reason');
      };

      var actualError = new Error('OMG what really happened');
      var jqXHR = {
        errorThrown: actualError
      };

      _emberMetalRun_loop.default(_emberRuntimeExtRsvp.default, 'reject', jqXHR);
    } finally {
      _emberMetalCore.default.onerror = wasOnError;
      _emberMetalCore.default.testing = wasEmberTesting;
    }
  });

  QUnit.test('rejections where the errorThrown is a string should wrap the sting in an error object', function () {
    expect(2);

    var wasEmberTesting = _emberMetalCore.default.testing;
    var wasOnError = _emberMetalCore.default.onerror;

    try {
      _emberMetalCore.default.testing = false;
      _emberMetalCore.default.onerror = function (error) {
        equal(error.message, actualError, 'expected the real error on the jqXHR');
        equal(error.__reason_with_error_thrown__, jqXHR, 'also retains a helpful reference to the rejection reason');
      };

      var actualError = 'OMG what really happened';
      var jqXHR = {
        errorThrown: actualError
      };

      _emberMetalRun_loop.default(_emberRuntimeExtRsvp.default, 'reject', jqXHR);
    } finally {
      _emberMetalCore.default.onerror = wasOnError;
      _emberMetalCore.default.testing = wasEmberTesting;
    }
  });

  var wasTesting;
  var reason = 'i failed';
  QUnit.module('Ember.test: rejection assertions', {
    before: function () {
      wasTesting = _emberMetalCore.default.testing;
      _emberMetalCore.default.testing = true;
    },
    after: function () {
      _emberMetalCore.default.testing = wasTesting;
    }
  });

  function ajax(something) {
    return _emberRuntimeExtRsvp.default.Promise(function (resolve) {
      QUnit.stop();
      setTimeout(function () {
        QUnit.start();
        resolve();
      }, 0); // fake true / foreign async
    });
  }

  QUnit.test('unambigiously unhandled rejection', function () {
    QUnit.throws(function () {
      _emberMetalCore.default.run(function () {
        _emberRuntimeExtRsvp.default.Promise.reject(reason);
      }); // something is funky, we should likely assert
    }, reason);
  });

  QUnit.test('sync handled', function () {
    _emberMetalCore.default.run(function () {
      _emberRuntimeExtRsvp.default.Promise.reject(reason).catch(function () {});
    }); // handled, we shouldn't need to assert.
    ok(true, 'reached end of test');
  });

  QUnit.test('handled within the same micro-task (via Ember.RVP.Promise)', function () {
    _emberMetalCore.default.run(function () {
      var rejection = _emberRuntimeExtRsvp.default.Promise.reject(reason);
      _emberRuntimeExtRsvp.default.Promise.resolve(1).then(function () {
        return rejection.catch(function () {});
      });
    }); // handled, we shouldn't need to assert.
    ok(true, 'reached end of test');
  });

  QUnit.test('handled within the same micro-task (via direct run-loop)', function () {
    _emberMetalCore.default.run(function () {
      var rejection = _emberRuntimeExtRsvp.default.Promise.reject(reason);

      _emberMetalCore.default.run.schedule('afterRender', function () {
        return rejection.catch(function () {});
      });
    }); // handled, we shouldn't need to assert.
    ok(true, 'reached end of test');
  });

  QUnit.test('handled in the next microTask queue flush (Ember.run.next)', function () {
    expect(2);

    QUnit.throws(function () {
      _emberMetalCore.default.run(function () {
        var rejection = _emberRuntimeExtRsvp.default.Promise.reject(reason);

        QUnit.stop();
        _emberMetalCore.default.run.next(function () {
          QUnit.start();
          rejection.catch(function () {});
          ok(true, 'reached end of test');
        });
      });
    }, reason);

    // a promise rejection survived a full flush of the run-loop without being handled
    // this is very likely an issue.
  });

  QUnit.test('handled in the same microTask Queue flush do to data locality', function () {
    // an ambiguous scenario, this may or may not assert
    // it depends on the locality of `user#1`
    var store = {
      find: function () {
        return Promise.resolve(1);
      }
    };

    _emberMetalCore.default.run(function () {
      var rejection = _emberRuntimeExtRsvp.default.Promise.reject(reason);

      store.find('user', 1).then(function () {
        return rejection.catch(function () {});
      });
    });

    ok(true, 'reached end of test');
  });

  QUnit.test('handled in a different microTask Queue flush do to data locality', function () {
    // an ambiguous scenario, this may or may not assert
    // it depends on the locality of `user#1`
    var store = {
      find: function () {
        return ajax();
      }
    };

    QUnit.throws(function () {
      _emberMetalCore.default.run(function () {
        var rejection = _emberRuntimeExtRsvp.default.Promise.reject(reason);

        store.find('user', 1).then(function () {
          rejection.catch(function () {});
          ok(true, 'reached end of test');
        });
      });
    }, reason);
  });

  QUnit.test('handled in the next microTask queue flush (ajax example)', function () {
    QUnit.throws(function () {
      _emberMetalCore.default.run(function () {
        var rejection = _emberRuntimeExtRsvp.default.Promise.reject(reason);
        ajax('/something/').then(function () {
          rejection.catch(function () {});
          ok(true, 'reached end of test');
        });
      });
    }, reason);
  });
});
enifed('ember-runtime/tests/ext/rsvp_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/ext');
  test('ember-runtime/tests/ext/rsvp_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/ext/rsvp_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/ext/rsvp_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/ext');
  QUnit.test('ember-runtime/tests/ext/rsvp_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(false, 'ember-runtime/tests/ext/rsvp_test.js should pass jshint.\nember-runtime/tests/ext/rsvp_test.js: line 1, col 1, \'Promise\' is defined but never used.\n\n1 error');
  });
});
enifed('ember-runtime/tests/inject_test', ['exports', 'ember-metal/injected_property', 'ember-runtime/inject', 'ember-runtime/system/container', 'ember-runtime/system/object'], function (exports, _emberMetalInjected_property, _emberRuntimeInject, _emberRuntimeSystemContainer, _emberRuntimeSystemObject) {
  /* global EmberDev */

  'use strict';

  QUnit.module('inject');

  QUnit.test('calling `inject` directly should error', function () {
    expectAssertion(function () {
      _emberRuntimeInject.default('foo');
    }, /Injected properties must be created through helpers/);
  });

  if (!EmberDev.runningProdBuild) {
    // this check is done via an assertion which is stripped from
    // production builds
    QUnit.test('injection type validation is run when first looked up', function () {
      expect(1);

      _emberRuntimeInject.createInjectionHelper('foo', function () {
        ok(true, 'should call validation method');
      });

      var registry = new _emberRuntimeSystemContainer.Registry();
      var container = registry.container();

      var AnObject = _emberRuntimeSystemObject.default.extend({
        container: container,
        bar: _emberRuntimeInject.default.foo(),
        baz: _emberRuntimeInject.default.foo()
      });

      registry.register('foo:main', AnObject);
      container.lookupFactory('foo:main');
    });
  }

  QUnit.test('attempting to inject a nonexistent container key should error', function () {
    var registry = new _emberRuntimeSystemContainer.Registry();
    var container = registry.container();
    var AnObject = _emberRuntimeSystemObject.default.extend({
      container: container,
      foo: new _emberMetalInjected_property.default('bar', 'baz')
    });

    registry.register('foo:main', AnObject);

    throws(function () {
      container.lookup('foo:main');
    }, /Attempting to inject an unknown injection: `bar:baz`/);
  });

  QUnit.test('factories should return a list of lazy injection full names', function () {
    var AnObject = _emberRuntimeSystemObject.default.extend({
      foo: new _emberMetalInjected_property.default('foo', 'bar'),
      bar: new _emberMetalInjected_property.default('quux')
    });

    deepEqual(AnObject._lazyInjections(), { 'foo': 'foo:bar', 'bar': 'quux:bar' }, 'should return injected container keys');
  });
});
enifed('ember-runtime/tests/inject_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests');
  test('ember-runtime/tests/inject_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/inject_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/inject_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests');
  QUnit.test('ember-runtime/tests/inject_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/inject_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/legacy_1x/mixins/observable/chained_test', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/run_loop', 'ember-runtime/system/object', 'ember-metal/observer'], function (exports, _emberMetalCore, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalRun_loop, _emberRuntimeSystemObject, _emberMetalObserver) {
  'use strict';

  /*
    NOTE: This test is adapted from the 1.x series of unit tests.  The tests
    are the same except for places where we intend to break the API we instead
    validate that we warn the developer appropriately.
  
    CHANGES FROM 1.6:
  
    * changed obj.set() and obj.get() to Ember.set() and Ember.get()
    * changed obj.addObserver() to addObserver()
  */

  QUnit.module('Ember.Observable - Observing with @each');

  QUnit.test('chained observers on enumerable properties are triggered when the observed property of any item changes', function () {
    var family = _emberRuntimeSystemObject.default.create({ momma: null });
    var momma = _emberRuntimeSystemObject.default.create({ children: [] });

    var child1 = _emberRuntimeSystemObject.default.create({ name: 'Bartholomew' });
    var child2 = _emberRuntimeSystemObject.default.create({ name: 'Agnes' });
    var child3 = _emberRuntimeSystemObject.default.create({ name: 'Dan' });
    var child4 = _emberRuntimeSystemObject.default.create({ name: 'Nancy' });

    _emberMetalProperty_set.set(family, 'momma', momma);
    _emberMetalProperty_set.set(momma, 'children', _emberMetalCore.default.A([child1, child2, child3]));

    var observerFiredCount = 0;
    _emberMetalObserver.addObserver(family, 'momma.children.@each.name', this, function () {
      observerFiredCount++;
    });

    observerFiredCount = 0;
    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_get.get(momma, 'children').setEach('name', 'Juan');
    });
    equal(observerFiredCount, 3, 'observer fired after changing child names');

    observerFiredCount = 0;
    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_get.get(momma, 'children').pushObject(child4);
    });
    equal(observerFiredCount, 1, 'observer fired after adding a new item');

    observerFiredCount = 0;
    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(child4, 'name', 'Herbert');
    });
    equal(observerFiredCount, 1, 'observer fired after changing property on new object');

    _emberMetalProperty_set.set(momma, 'children', []);

    observerFiredCount = 0;
    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(child1, 'name', 'Hanna');
    });
    equal(observerFiredCount, 0, 'observer did not fire after removing changing property on a removed object');
  });
});
enifed('ember-runtime/tests/legacy_1x/mixins/observable/chained_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/legacy_1x/mixins/observable');
  test('ember-runtime/tests/legacy_1x/mixins/observable/chained_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/legacy_1x/mixins/observable/chained_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/legacy_1x/mixins/observable/chained_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/legacy_1x/mixins/observable');
  QUnit.test('ember-runtime/tests/legacy_1x/mixins/observable/chained_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/legacy_1x/mixins/observable/chained_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/legacy_1x/mixins/observable/observable_test', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-metal/computed', 'ember-metal/run_loop', 'ember-metal/mixin', 'ember-runtime/system/string', 'ember-runtime/system/object', 'ember-runtime/mixins/observable'], function (exports, _emberMetalCore, _emberMetalProperty_get, _emberMetalComputed, _emberMetalRun_loop, _emberMetalMixin, _emberRuntimeSystemString, _emberRuntimeSystemObject, _emberRuntimeMixinsObservable) {
  'use strict';

  /*
    NOTE: This test is adapted from the 1.x series of unit tests.  The tests
    are the same except for places where we intend to break the API we instead
    validate that we warn the developer appropriately.
  
    CHANGES FROM 1.6:
  
    * Added ObservableObject which applies the Ember.Observable mixin.
    * Changed reference to Ember.T_FUNCTION to 'function'
    * Changed all references to sc_super to this._super.apply(this, arguments)
    * Changed Ember.objectForPropertyPath() to Ember.getPath()
    * Removed allPropertiesDidChange test - no longer supported
    * Changed test that uses 'ObjectE' as path to 'objectE' to reflect new
      rule on using capital letters for property paths.
    * Removed test passing context to addObserver.  context param is no longer
      supported.
    * Changed calls to Ember.Binding.flushPendingChanges() -> run.sync()
    * removed test in observer around line 862 that expected key/value to be
      the last item in the chained path.  Should be root and chained path
  
  */

  // ========================================================================
  // Ember.Observable Tests
  // ========================================================================

  var object, ObjectC, ObjectD, objectA, objectB, lookup;

  var ObservableObject = _emberRuntimeSystemObject.default.extend(_emberRuntimeMixinsObservable.default);
  var originalLookup = _emberMetalCore.default.lookup;

  // ..........................................................
  // GET()
  //

  QUnit.module('object.get()', {

    setup: function () {
      object = ObservableObject.extend(_emberRuntimeMixinsObservable.default, {
        computed: _emberMetalComputed.computed(function () {
          return 'value';
        }).volatile(),
        method: function () {
          return 'value';
        },
        unknownProperty: function (key, value) {
          this.lastUnknownProperty = key;
          return 'unknown';
        }
      }).create({
        normal: 'value',
        numberVal: 24,
        toggleVal: true,
        nullProperty: null
      });
    }

  });

  QUnit.test('should get normal properties', function () {
    equal(object.get('normal'), 'value');
  });

  QUnit.test('should call computed properties and return their result', function () {
    equal(object.get('computed'), 'value');
  });

  QUnit.test('should return the function for a non-computed property', function () {
    var value = object.get('method');
    equal(typeof value, 'function');
  });

  QUnit.test('should return null when property value is null', function () {
    equal(object.get('nullProperty'), null);
  });

  QUnit.test('should call unknownProperty when value is undefined', function () {
    equal(object.get('unknown'), 'unknown');
    equal(object.lastUnknownProperty, 'unknown');
  });

  // ..........................................................
  // Ember.GET()
  //
  QUnit.module('Ember.get()', {
    setup: function () {
      objectA = ObservableObject.extend({
        computed: _emberMetalComputed.computed(function () {
          return 'value';
        }).volatile(),
        method: function () {
          return 'value';
        },
        unknownProperty: function (key, value) {
          this.lastUnknownProperty = key;
          return 'unknown';
        }
      }).create({
        normal: 'value',
        numberVal: 24,
        toggleVal: true,
        nullProperty: null
      });

      objectB = {
        normal: 'value',
        nullProperty: null
      };
    }
  });

  QUnit.test('should get normal properties on Ember.Observable', function () {
    equal(_emberMetalProperty_get.get(objectA, 'normal'), 'value');
  });

  QUnit.test('should call computed properties on Ember.Observable and return their result', function () {
    equal(_emberMetalProperty_get.get(objectA, 'computed'), 'value');
  });

  QUnit.test('should return the function for a non-computed property on Ember.Observable', function () {
    var value = _emberMetalProperty_get.get(objectA, 'method');
    equal(typeof value, 'function');
  });

  QUnit.test('should return null when property value is null on Ember.Observable', function () {
    equal(_emberMetalProperty_get.get(objectA, 'nullProperty'), null);
  });

  QUnit.test('should call unknownProperty when value is undefined on Ember.Observable', function () {
    equal(_emberMetalProperty_get.get(object, 'unknown'), 'unknown');
    equal(object.lastUnknownProperty, 'unknown');
  });

  QUnit.test('should get normal properties on standard objects', function () {
    equal(_emberMetalProperty_get.get(objectB, 'normal'), 'value');
  });

  QUnit.test('should return null when property is null on standard objects', function () {
    equal(_emberMetalProperty_get.get(objectB, 'nullProperty'), null);
  });

  /*
  QUnit.test("raise if the provided object is null", function() {
    throws(function() {
      get(null, 'key');
    });
  });
  */

  QUnit.test('raise if the provided object is undefined', function () {
    expectAssertion(function () {
      _emberMetalProperty_get.get(undefined, 'key');
    }, /Cannot call get with 'key' on an undefined object/i);
  });

  QUnit.test('should work when object is Ember (used in Ember.get)', function () {
    equal(_emberMetalProperty_get.get(_emberMetalCore.default, 'RunLoop'), _emberMetalCore.default.RunLoop, 'Ember.get(Ember, RunLoop)');
  });

  QUnit.module('Ember.get() with paths');

  QUnit.test('should return a property at a given path relative to the passed object', function () {
    var foo = ObservableObject.create({
      bar: ObservableObject.extend({
        baz: _emberMetalComputed.computed(function () {
          return 'blargh';
        }).volatile()
      }).create()
    });

    equal(_emberMetalProperty_get.get(foo, 'bar.baz'), 'blargh');
  });

  QUnit.test('should return a property at a given path relative to the passed object - JavaScript hash', function () {
    var foo = {
      bar: {
        baz: 'blargh'
      }
    };

    equal(_emberMetalProperty_get.get(foo, 'bar.baz'), 'blargh');
  });

  // ..........................................................
  // SET()
  //

  QUnit.module('object.set()', {

    setup: function () {
      object = ObservableObject.extend({
        computed: _emberMetalComputed.computed({
          get: function (key) {
            return this._computed;
          },
          set: function (key, value) {
            this._computed = value;
            return this._computed;
          }
        }).volatile(),

        method: function (key, value) {
          if (value !== undefined) {
            this._method = value;
          }
          return this._method;
        },

        unknownProperty: function (key) {
          return this._unknown;
        },

        setUnknownProperty: function (key, value) {
          this._unknown = value;
          return this._unknown;
        },

        // normal property
        normal: 'value',

        // computed property
        _computed: 'computed',
        // method, but not a property
        _method: 'method',
        // null property
        nullProperty: null,

        // unknown property
        _unknown: 'unknown'
      }).create();
    }

  });

  QUnit.test('should change normal properties and return the value', function () {
    var ret = object.set('normal', 'changed');
    equal(object.get('normal'), 'changed');
    equal(ret, 'changed');
  });

  QUnit.test('should call computed properties passing value and return the value', function () {
    var ret = object.set('computed', 'changed');
    equal(object.get('_computed'), 'changed');
    equal(ret, 'changed');
  });

  QUnit.test('should change normal properties when passing undefined', function () {
    var ret = object.set('normal', undefined);
    equal(object.get('normal'), undefined);
    equal(ret, undefined);
  });

  QUnit.test('should replace the function for a non-computed property and return the value', function () {
    var ret = object.set('method', 'changed');
    equal(object.get('_method'), 'method'); // make sure this was NOT run
    ok(typeof object.get('method') !== 'function');
    equal(ret, 'changed');
  });

  QUnit.test('should replace prover when property value is null', function () {
    var ret = object.set('nullProperty', 'changed');
    equal(object.get('nullProperty'), 'changed');
    equal(ret, 'changed');
  });

  QUnit.test('should call unknownProperty with value when property is undefined', function () {
    var ret = object.set('unknown', 'changed');
    equal(object.get('_unknown'), 'changed');
    equal(ret, 'changed');
  });

  // ..........................................................
  // COMPUTED PROPERTIES
  //

  QUnit.module('Computed properties', {
    setup: function () {
      lookup = _emberMetalCore.default.lookup = {};

      object = ObservableObject.extend({
        computed: _emberMetalComputed.computed({
          get: function () {
            this.computedCalls.push('getter-called');
            return 'computed';
          },
          set: function (key, value) {
            this.computedCalls.push(value);
          }
        }).volatile(),

        computedCached: _emberMetalComputed.computed({
          get: function () {
            this.computedCachedCalls.push('getter-called');
            return 'computedCached';
          },
          set: function (key, value) {
            this.computedCachedCalls.push(value);
          }
        }),

        dependent: _emberMetalComputed.computed({
          get: function () {
            this.dependentCalls.push('getter-called');
            return 'dependent';
          },
          set: function (key, value) {
            this.dependentCalls.push(value);
          }
        }).property('changer').volatile(),
        dependentFront: _emberMetalComputed.computed('changer', {
          get: function () {
            this.dependentFrontCalls.push('getter-called');
            return 'dependentFront';
          },
          set: function (key, value) {
            this.dependentFrontCalls.push(value);
          }
        }).volatile(),
        dependentCached: _emberMetalComputed.computed({
          get: function () {
            this.dependentCachedCalls.push('getter-called!');
            return 'dependentCached';
          },
          set: function (key, value) {
            this.dependentCachedCalls.push(value);
          }
        }).property('changer'),

        inc: _emberMetalComputed.computed('changer', function () {
          return this.incCallCount++;
        }),

        nestedInc: _emberMetalComputed.computed(function (key) {
          _emberMetalProperty_get.get(this, 'inc');
          return this.nestedIncCallCount++;
        }).property('inc'),

        isOn: _emberMetalComputed.computed({
          get: function () {
            return this.get('state') === 'on';
          },
          set: function (key, value) {
            this.set('state', 'on');
            return this.get('state') === 'on';
          }
        }).property('state').volatile(),

        isOff: _emberMetalComputed.computed({
          get: function () {
            return this.get('state') === 'off';
          },
          set: function (key, value) {
            this.set('state', 'off');
            return this.get('state') === 'off';
          }
        }).property('state').volatile()

      }).create({
        computedCalls: [],
        computedCachedCalls: [],
        changer: 'foo',
        dependentCalls: [],
        dependentFrontCalls: [],
        dependentCachedCalls: [],
        incCallCount: 0,
        nestedIncCallCount: 0,
        state: 'on'
      });
    },
    teardown: function () {
      _emberMetalCore.default.lookup = originalLookup;
    }
  });

  QUnit.test('getting values should call function return value', function () {

    // get each property twice. Verify return.
    var keys = _emberRuntimeSystemString.w('computed computedCached dependent dependentFront dependentCached');

    keys.forEach(function (key) {
      equal(object.get(key), key, 'Try #1: object.get(' + key + ') should run function');
      equal(object.get(key), key, 'Try #2: object.get(' + key + ') should run function');
    });

    // verify each call count.  cached should only be called once
    _emberRuntimeSystemString.w('computedCalls dependentFrontCalls dependentCalls').forEach(function (key) {
      equal(object[key].length, 2, 'non-cached property ' + key + ' should be called 2x');
    });

    _emberRuntimeSystemString.w('computedCachedCalls dependentCachedCalls').forEach(function (key) {
      equal(object[key].length, 1, 'non-cached property ' + key + ' should be called 1x');
    });
  });

  QUnit.test('setting values should call function return value', function () {

    // get each property twice. Verify return.
    var keys = _emberRuntimeSystemString.w('computed dependent dependentFront computedCached dependentCached');
    var values = _emberRuntimeSystemString.w('value1 value2');

    keys.forEach(function (key) {
      equal(object.set(key, values[0]), values[0], 'Try #1: object.set(' + key + ', ' + values[0] + ') should run function');

      equal(object.set(key, values[1]), values[1], 'Try #2: object.set(' + key + ', ' + values[1] + ') should run function');

      equal(object.set(key, values[1]), values[1], 'Try #3: object.set(' + key + ', ' + values[1] + ') should not run function since it is setting same value as before');
    });

    // verify each call count.  cached should only be called once
    keys.forEach(function (key) {
      var calls = object[key + 'Calls'];
      var idx, expectedLength;

      // Cached properties first check their cached value before setting the
      // property. Other properties blindly call set.
      expectedLength = 3;
      equal(calls.length, expectedLength, 'set(' + key + ') should be called the right amount of times');
      for (idx = 0; idx < 2; idx++) {
        equal(calls[idx], values[idx], 'call #' + (idx + 1) + ' to set(' + key + ') should have passed value ' + values[idx]);
      }
    });
  });

  QUnit.test('notify change should clear cache', function () {

    // call get several times to collect call count
    object.get('computedCached'); // should run func
    object.get('computedCached'); // should not run func

    object.propertyWillChange('computedCached').propertyDidChange('computedCached');

    object.get('computedCached'); // should run again
    equal(object.computedCachedCalls.length, 2, 'should have invoked method 2x');
  });

  QUnit.test('change dependent should clear cache', function () {

    // call get several times to collect call count
    var ret1 = object.get('inc'); // should run func
    equal(object.get('inc'), ret1, 'multiple calls should not run cached prop');

    object.set('changer', 'bar');

    equal(object.get('inc'), ret1 + 1, 'should increment after dependent key changes'); // should run again
  });

  QUnit.test('just notifying change of dependent should clear cache', function () {

    // call get several times to collect call count
    var ret1 = object.get('inc'); // should run func
    equal(object.get('inc'), ret1, 'multiple calls should not run cached prop');

    object.notifyPropertyChange('changer');

    equal(object.get('inc'), ret1 + 1, 'should increment after dependent key changes'); // should run again
  });

  QUnit.test('changing dependent should clear nested cache', function () {

    // call get several times to collect call count
    var ret1 = object.get('nestedInc'); // should run func
    equal(object.get('nestedInc'), ret1, 'multiple calls should not run cached prop');

    object.set('changer', 'bar');

    equal(object.get('nestedInc'), ret1 + 1, 'should increment after dependent key changes'); // should run again
  });

  QUnit.test('just notifying change of dependent should clear nested cache', function () {

    // call get several times to collect call count
    var ret1 = object.get('nestedInc'); // should run func
    equal(object.get('nestedInc'), ret1, 'multiple calls should not run cached prop');

    object.notifyPropertyChange('changer');

    equal(object.get('nestedInc'), ret1 + 1, 'should increment after dependent key changes'); // should run again
  });

  // This verifies a specific bug encountered where observers for computed
  // properties would fire before their prop caches were cleared.
  QUnit.test('change dependent should clear cache when observers of dependent are called', function () {

    // call get several times to collect call count
    var ret1 = object.get('inc'); // should run func
    equal(object.get('inc'), ret1, 'multiple calls should not run cached prop');

    // add observer to verify change...
    object.addObserver('inc', this, function () {
      equal(object.get('inc'), ret1 + 1, 'should increment after dependent key changes'); // should run again
    });

    // now run
    object.set('changer', 'bar');
  });

  QUnit.test('setting one of two computed properties that depend on a third property should clear the kvo cache', function () {
    // we have to call set twice to fill up the cache
    object.set('isOff', true);
    object.set('isOn', true);

    // setting isOff to true should clear the kvo cache
    object.set('isOff', true);
    equal(object.get('isOff'), true, 'object.isOff should be true');
    equal(object.get('isOn'), false, 'object.isOn should be false');
  });

  QUnit.test('dependent keys should be able to be specified as property paths', function () {
    var depObj = ObservableObject.extend({
      menuPrice: _emberMetalComputed.computed(function () {
        return this.get('menu.price');
      }).property('menu.price')
    }).create({
      menu: ObservableObject.create({
        price: 5
      })
    });

    equal(depObj.get('menuPrice'), 5, 'precond - initial value returns 5');

    depObj.set('menu.price', 6);

    equal(depObj.get('menuPrice'), 6, 'cache is properly invalidated after nested property changes');
  });

  QUnit.test('nested dependent keys should propagate after they update', function () {
    var bindObj;
    _emberMetalRun_loop.default(function () {
      lookup.DepObj = ObservableObject.extend({
        price: _emberMetalComputed.computed(function () {
          return this.get('restaurant.menu.price');
        }).property('restaurant.menu.price')
      }).create({
        restaurant: ObservableObject.create({
          menu: ObservableObject.create({
            price: 5
          })
        })
      });

      bindObj = ObservableObject.extend({
        priceBinding: 'DepObj.price'
      }).create();
    });

    equal(bindObj.get('price'), 5, 'precond - binding propagates');

    _emberMetalRun_loop.default(function () {
      lookup.DepObj.set('restaurant.menu.price', 10);
    });

    equal(bindObj.get('price'), 10, 'binding propagates after a nested dependent keys updates');

    _emberMetalRun_loop.default(function () {
      lookup.DepObj.set('restaurant.menu', ObservableObject.create({
        price: 15
      }));
    });

    equal(bindObj.get('price'), 15, 'binding propagates after a middle dependent keys updates');
  });

  QUnit.test('cacheable nested dependent keys should clear after their dependencies update', function () {
    ok(true);

    var DepObj;

    _emberMetalRun_loop.default(function () {
      lookup.DepObj = DepObj = ObservableObject.extend({
        price: _emberMetalComputed.computed('restaurant.menu.price', function () {
          return this.get('restaurant.menu.price');
        })
      }).create({
        restaurant: ObservableObject.create({
          menu: ObservableObject.create({
            price: 5
          })
        })
      });
    });

    equal(DepObj.get('price'), 5, 'precond - computed property is correct');

    _emberMetalRun_loop.default(function () {
      DepObj.set('restaurant.menu.price', 10);
    });
    equal(DepObj.get('price'), 10, 'cacheable computed properties are invalidated even if no run loop occurred');

    _emberMetalRun_loop.default(function () {
      DepObj.set('restaurant.menu.price', 20);
    });
    equal(DepObj.get('price'), 20, 'cacheable computed properties are invalidated after a second get before a run loop');
    equal(DepObj.get('price'), 20, 'precond - computed properties remain correct after a run loop');

    _emberMetalRun_loop.default(function () {
      DepObj.set('restaurant.menu', ObservableObject.create({
        price: 15
      }));
    });

    equal(DepObj.get('price'), 15, 'cacheable computed properties are invalidated after a middle property changes');

    _emberMetalRun_loop.default(function () {
      DepObj.set('restaurant.menu', ObservableObject.create({
        price: 25
      }));
    });

    equal(DepObj.get('price'), 25, 'cacheable computed properties are invalidated after a middle property changes again, before a run loop');
  });

  // ..........................................................
  // OBSERVABLE OBJECTS
  //

  QUnit.module('Observable objects & object properties ', {

    setup: function () {
      object = ObservableObject.extend({
        getEach: function () {
          var keys = ['normal', 'abnormal'];
          var ret = [];
          for (var idx = 0; idx < keys.length; idx++) {
            ret[ret.length] = this.get(keys[idx]);
          }
          return ret;
        },

        newObserver: function () {
          this.abnormal = 'changedValueObserved';
        },

        testObserver: _emberMetalMixin.observer('normal', function () {
          this.abnormal = 'removedObserver';
        }),

        testArrayObserver: _emberMetalMixin.observer('normalArray.[]', function () {
          this.abnormal = 'notifiedObserver';
        })
      }).create({
        normal: 'value',
        abnormal: 'zeroValue',
        numberVal: 24,
        toggleVal: true,
        observedProperty: 'beingWatched',
        testRemove: 'observerToBeRemoved',
        normalArray: _emberMetalCore.default.A([1, 2, 3, 4, 5])
      });
    }

  });

  QUnit.test('incrementProperty and decrementProperty', function () {
    var newValue = object.incrementProperty('numberVal');

    equal(25, newValue, 'numerical value incremented');
    object.numberVal = 24;
    newValue = object.decrementProperty('numberVal');
    equal(23, newValue, 'numerical value decremented');
    object.numberVal = 25;
    newValue = object.incrementProperty('numberVal', 5);
    equal(30, newValue, 'numerical value incremented by specified increment');
    object.numberVal = 25;
    newValue = object.incrementProperty('numberVal', -5);
    equal(20, newValue, 'minus numerical value incremented by specified increment');
    object.numberVal = 25;
    newValue = object.incrementProperty('numberVal', 0);
    equal(25, newValue, 'zero numerical value incremented by specified increment');

    expectAssertion(function () {
      newValue = object.incrementProperty('numberVal', 0 - void 0); // Increment by NaN
    }, /Must pass a numeric value to incrementProperty/i);

    expectAssertion(function () {
      newValue = object.incrementProperty('numberVal', 'Ember'); // Increment by non-numeric String
    }, /Must pass a numeric value to incrementProperty/i);

    expectAssertion(function () {
      newValue = object.incrementProperty('numberVal', 1 / 0); // Increment by Infinity
    }, /Must pass a numeric value to incrementProperty/i);

    equal(25, newValue, 'Attempting to increment by non-numeric values should not increment value');

    object.numberVal = 25;
    newValue = object.decrementProperty('numberVal', 5);
    equal(20, newValue, 'numerical value decremented by specified increment');
    object.numberVal = 25;
    newValue = object.decrementProperty('numberVal', -5);
    equal(30, newValue, 'minus numerical value decremented by specified increment');
    object.numberVal = 25;
    newValue = object.decrementProperty('numberVal', 0);
    equal(25, newValue, 'zero numerical value decremented by specified increment');

    expectAssertion(function () {
      newValue = object.decrementProperty('numberVal', 0 - void 0); // Decrement by NaN
    }, /Must pass a numeric value to decrementProperty/i);

    expectAssertion(function () {
      newValue = object.decrementProperty('numberVal', 'Ember'); // Decrement by non-numeric String
    }, /Must pass a numeric value to decrementProperty/i);

    expectAssertion(function () {
      newValue = object.decrementProperty('numberVal', 1 / 0); // Decrement by Infinity
    }, /Must pass a numeric value to decrementProperty/i);

    equal(25, newValue, 'Attempting to decrement by non-numeric values should not decrement value');
  });

  QUnit.test('toggle function, should be boolean', function () {
    equal(object.toggleProperty('toggleVal', true, false), object.get('toggleVal'));
    equal(object.toggleProperty('toggleVal', true, false), object.get('toggleVal'));
    equal(object.toggleProperty('toggleVal', undefined, undefined), object.get('toggleVal'));
  });

  QUnit.test('should notify array observer when array changes', function () {
    _emberMetalProperty_get.get(object, 'normalArray').replace(0, 0, 6);
    equal(object.abnormal, 'notifiedObserver', 'observer should be notified');
  });

  QUnit.module('object.addObserver()', {
    setup: function () {

      ObjectC = ObservableObject.create({

        objectE: ObservableObject.create({
          propertyVal: 'chainedProperty'
        }),

        normal: 'value',
        normal1: 'zeroValue',
        normal2: 'dependentValue',
        incrementor: 10,

        action: function () {
          this.normal1 = 'newZeroValue';
        },

        observeOnceAction: function () {
          this.incrementor = this.incrementor + 1;
        },

        chainedObserver: function () {
          this.normal2 = 'chainedPropertyObserved';
        }

      });
    }
  });

  QUnit.test('should register an observer for a property', function () {
    ObjectC.addObserver('normal', ObjectC, 'action');
    ObjectC.set('normal', 'newValue');
    equal(ObjectC.normal1, 'newZeroValue');
  });

  QUnit.test('should register an observer for a property - Special case of chained property', function () {
    ObjectC.addObserver('objectE.propertyVal', ObjectC, 'chainedObserver');
    ObjectC.objectE.set('propertyVal', 'chainedPropertyValue');
    equal('chainedPropertyObserved', ObjectC.normal2);
    ObjectC.normal2 = 'dependentValue';
    ObjectC.set('objectE', '');
    equal('chainedPropertyObserved', ObjectC.normal2);
  });

  QUnit.module('object.removeObserver()', {
    setup: function () {
      ObjectD = ObservableObject.create({

        objectF: ObservableObject.create({
          propertyVal: 'chainedProperty'
        }),

        normal: 'value',
        normal1: 'zeroValue',
        normal2: 'dependentValue',
        ArrayKeys: ['normal', 'normal1'],

        addAction: function () {
          this.normal1 = 'newZeroValue';
        },
        removeAction: function () {
          this.normal2 = 'newDependentValue';
        },
        removeChainedObserver: function () {
          this.normal2 = 'chainedPropertyObserved';
        },

        observableValue: 'hello world',

        observer1: function () {
          // Just an observer
        },
        observer2: function () {
          this.removeObserver('observableValue', null, 'observer1');
          this.removeObserver('observableValue', null, 'observer2');
          this.hasObserverFor('observableValue'); // Tickle 'getMembers()'
          this.removeObserver('observableValue', null, 'observer3');
        },
        observer3: function () {
          // Just an observer
        }
      });
    }
  });

  QUnit.test('should unregister an observer for a property', function () {
    ObjectD.addObserver('normal', ObjectD, 'addAction');
    ObjectD.set('normal', 'newValue');
    equal(ObjectD.normal1, 'newZeroValue');

    ObjectD.set('normal1', 'zeroValue');

    ObjectD.removeObserver('normal', ObjectD, 'addAction');
    ObjectD.set('normal', 'newValue');
    equal(ObjectD.normal1, 'zeroValue');
  });

  QUnit.test('should unregister an observer for a property - special case when key has a \'.\' in it.', function () {
    ObjectD.addObserver('objectF.propertyVal', ObjectD, 'removeChainedObserver');
    ObjectD.objectF.set('propertyVal', 'chainedPropertyValue');
    ObjectD.removeObserver('objectF.propertyVal', ObjectD, 'removeChainedObserver');
    ObjectD.normal2 = 'dependentValue';
    ObjectD.objectF.set('propertyVal', 'removedPropertyValue');
    equal('dependentValue', ObjectD.normal2);
    ObjectD.set('objectF', '');
    equal('dependentValue', ObjectD.normal2);
  });

  QUnit.test('removing an observer inside of an observer shouldn’t cause any problems', function () {
    // The observable system should be protected against clients removing
    // observers in the middle of observer notification.
    var encounteredError = false;
    try {
      ObjectD.addObserver('observableValue', null, 'observer1');
      ObjectD.addObserver('observableValue', null, 'observer2');
      ObjectD.addObserver('observableValue', null, 'observer3');
      _emberMetalRun_loop.default(function () {
        ObjectD.set('observableValue', 'hi world');
      });
    } catch (e) {
      encounteredError = true;
    }
    equal(encounteredError, false);
  });

  QUnit.module('Bind function ', {

    setup: function () {
      originalLookup = _emberMetalCore.default.lookup;
      objectA = ObservableObject.create({
        name: 'Sproutcore',
        location: 'Timbaktu'
      });

      objectB = ObservableObject.create({
        normal: 'value',
        computed: function () {
          this.normal = 'newValue';
        }
      });

      lookup = _emberMetalCore.default.lookup = {
        'Namespace': {
          objectA: objectA,
          objectB: objectB
        }
      };
    },

    teardown: function () {
      _emberMetalCore.default.lookup = originalLookup;
    }
  });

  QUnit.test('should bind property with method parameter as undefined', function () {
    // creating binding
    _emberMetalRun_loop.default(function () {
      objectA.bind('name', 'Namespace.objectB.normal', undefined);
    });

    // now make a change to see if the binding triggers.
    _emberMetalRun_loop.default(function () {
      objectB.set('normal', 'changedValue');
    });

    // support new-style bindings if available
    equal('changedValue', objectA.get('name'), 'objectA.name is bound');
  });

  // ..........................................................
  // SPECIAL CASES
  //

  QUnit.test('changing chained observer object to null should not raise exception', function () {

    var obj = ObservableObject.create({
      foo: ObservableObject.create({
        bar: ObservableObject.create({ bat: 'BAT' })
      })
    });

    var callCount = 0;
    obj.foo.addObserver('bar.bat', obj, function (target, key, value) {
      callCount++;
    });

    _emberMetalRun_loop.default(function () {
      obj.foo.set('bar', null);
    });

    equal(callCount, 1, 'changing bar should trigger observer');
    expect(1);
  });
});
enifed('ember-runtime/tests/legacy_1x/mixins/observable/observable_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/legacy_1x/mixins/observable');
  test('ember-runtime/tests/legacy_1x/mixins/observable/observable_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/legacy_1x/mixins/observable/observable_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/legacy_1x/mixins/observable/observable_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/legacy_1x/mixins/observable');
  QUnit.test('ember-runtime/tests/legacy_1x/mixins/observable/observable_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/legacy_1x/mixins/observable/observable_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/legacy_1x/mixins/observable/observersForKey_test', ['exports', 'ember-metal/property_get', 'ember-runtime/system/object', 'ember-runtime/mixins/observable'], function (exports, _emberMetalProperty_get, _emberRuntimeSystemObject, _emberRuntimeMixinsObservable) {
  /*
    NOTE: This test is adapted from the 1.x series of unit tests.  The tests
    are the same except for places where we intend to break the API we instead
    validate that we warn the developer appropriately.
  
    CHANGES FROM 1.6:
  
    * Create ObservableObject which includes Ember.Observable
  */

  // ========================================================================
  // Ember.Observable Tests
  // ========================================================================

  'use strict';

  var ObservableObject = _emberRuntimeSystemObject.default.extend(_emberRuntimeMixinsObservable.default);

  // ..........................................................
  // GET()
  //

  QUnit.module('object.observesForKey()');

  QUnit.test('should get observers', function () {
    var o1 = ObservableObject.create({ foo: 100 });
    var o2 = ObservableObject.create({ func: function () {} });
    var o3 = ObservableObject.create({ func: function () {} });
    var observers = null;

    equal(_emberMetalProperty_get.get(o1.observersForKey('foo'), 'length'), 0, 'o1.observersForKey should return empty array');

    o1.addObserver('foo', o2, o2.func);
    o1.addObserver('foo', o3, o3.func);

    observers = o1.observersForKey('foo');

    equal(_emberMetalProperty_get.get(observers, 'length'), 2, 'o2.observersForKey should return an array with length 2');
    equal(observers[0][0], o2, 'first item in observers array should be o2');
    equal(observers[1][0], o3, 'second item in observers array should be o3');
  });
});
enifed('ember-runtime/tests/legacy_1x/mixins/observable/observersForKey_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/legacy_1x/mixins/observable');
  test('ember-runtime/tests/legacy_1x/mixins/observable/observersForKey_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/legacy_1x/mixins/observable/observersForKey_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/legacy_1x/mixins/observable/observersForKey_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/legacy_1x/mixins/observable');
  QUnit.test('ember-runtime/tests/legacy_1x/mixins/observable/observersForKey_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/legacy_1x/mixins/observable/observersForKey_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/legacy_1x/mixins/observable/propertyChanges_test', ['exports', 'ember-runtime/system/object', 'ember-runtime/mixins/observable', 'ember-metal/computed', 'ember-metal/mixin'], function (exports, _emberRuntimeSystemObject, _emberRuntimeMixinsObservable, _emberMetalComputed, _emberMetalMixin) {
  /*
    NOTE: This test is adapted from the 1.x series of unit tests.  The tests
    are the same except for places where we intend to break the API we instead
    validate that we warn the developer appropriately.
  
    CHANGES FROM 1.6:
  
    * Create ObservableObject which includes Ember.Observable
    * Remove test that tests internal _kvo_changeLevel property.  This is an
      implementation detail.
    * Remove test for allPropertiesDidChange
    * Removed star observer test.  no longer supported
    * Removed property revision test.  no longer supported
  */

  // ========================================================================
  // Ember.Observable Tests
  // ========================================================================

  'use strict';

  var ObservableObject = _emberRuntimeSystemObject.default.extend(_emberRuntimeMixinsObservable.default);

  var revMatches = false;
  var ObjectA;

  QUnit.module('object.propertyChanges', {
    setup: function () {
      ObjectA = ObservableObject.extend({
        action: _emberMetalMixin.observer('foo', function () {
          this.set('prop', 'changedPropValue');
        }),
        notifyAction: _emberMetalMixin.observer('newFoo', function () {
          this.set('newProp', 'changedNewPropValue');
        }),

        notifyAllAction: _emberMetalMixin.observer('prop', function () {
          this.set('newFoo', 'changedNewFooValue');
        }),

        starObserver: function (target, key, value, rev) {
          revMatches = rev === target.propertyRevision;
          this.starProp = key;
        }
      }).create({
        starProp: null,

        foo: 'fooValue',
        prop: 'propValue',

        newFoo: 'newFooValue',
        newProp: 'newPropValue'
      });
    }
  });

  QUnit.test('should observe the changes within the nested begin / end property changes', function () {

    //start the outer nest
    ObjectA.beginPropertyChanges();

    // Inner nest
    ObjectA.beginPropertyChanges();
    ObjectA.set('foo', 'changeFooValue');

    equal(ObjectA.prop, 'propValue');
    ObjectA.endPropertyChanges();

    //end inner nest
    ObjectA.set('prop', 'changePropValue');
    equal(ObjectA.newFoo, 'newFooValue');

    //close the outer nest
    ObjectA.endPropertyChanges();

    equal(ObjectA.prop, 'changedPropValue');
    equal(ObjectA.newFoo, 'changedNewFooValue');
  });

  QUnit.test('should observe the changes within the begin and end property changes', function () {

    ObjectA.beginPropertyChanges();
    ObjectA.set('foo', 'changeFooValue');

    equal(ObjectA.prop, 'propValue');
    ObjectA.endPropertyChanges();

    equal(ObjectA.prop, 'changedPropValue');
  });

  QUnit.test('should indicate that the property of an object has just changed', function () {
    // indicate that property of foo will change to its subscribers
    ObjectA.propertyWillChange('foo');

    //Value of the prop is unchanged yet as this will be changed when foo changes
    equal(ObjectA.prop, 'propValue');

    //change the value of foo.
    ObjectA.set('foo', 'changeFooValue');

    // Indicate the subscribers of foo that the value has just changed
    ObjectA.propertyDidChange('foo', null);

    // Values of prop has just changed
    equal(ObjectA.prop, 'changedPropValue');
  });

  QUnit.test('should notify that the property of an object has changed', function () {
    // Notify to its subscriber that the values of 'newFoo' will be changed. In this
    // case the observer is "newProp". Therefore this will call the notifyAction function
    // and value of "newProp" will be changed.
    ObjectA.notifyPropertyChange('newFoo', 'fooValue');

    //value of newProp changed.
    equal(ObjectA.newProp, 'changedNewPropValue');
  });

  QUnit.test('should invalidate function property cache when notifyPropertyChange is called', function () {

    var a = ObservableObject.extend({
      b: _emberMetalComputed.computed({
        get: function () {
          return this._b;
        },
        set: function (key, value) {
          this._b = value;
          return this;
        }
      }).volatile()
    }).create({
      _b: null
    });

    a.set('b', 'foo');
    equal(a.get('b'), 'foo', 'should have set the correct value for property b');

    a._b = 'bar';
    a.notifyPropertyChange('b');
    a.set('b', 'foo');
    equal(a.get('b'), 'foo', 'should have invalidated the cache so that the newly set value is actually set');
  });
});
enifed('ember-runtime/tests/legacy_1x/mixins/observable/propertyChanges_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/legacy_1x/mixins/observable');
  test('ember-runtime/tests/legacy_1x/mixins/observable/propertyChanges_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/legacy_1x/mixins/observable/propertyChanges_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/legacy_1x/mixins/observable/propertyChanges_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/legacy_1x/mixins/observable');
  QUnit.test('ember-runtime/tests/legacy_1x/mixins/observable/propertyChanges_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/legacy_1x/mixins/observable/propertyChanges_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/legacy_1x/system/binding_test', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/run_loop', 'ember-metal/binding', 'ember-metal/mixin', 'ember-runtime/system/object'], function (exports, _emberMetalCore, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalRun_loop, _emberMetalBinding, _emberMetalMixin, _emberRuntimeSystemObject) {
  'use strict';

  /*
    NOTE: This test is adapted from the 1.x series of unit tests.  The tests
    are the same except for places where we intend to break the API we instead
    validate that we warn the developer appropriately.
  
    CHANGES FROM 1.6:
  
    * All calls to run.sync() were changed to
      run.sync()
  
    * Bindings no longer accept a root object as their second param.  Instead
      our test binding objects were put under a single object they could
      originate from.
  
    * tests that inspected internal properties were removed.
  
    * converted foo.get/foo.set to use get/Ember.set
  
    * Removed tests for Binding.isConnected.  Since binding instances are now
      shared this property no longer makes sense.
  
    * Changed call calls for obj.bind(...) to bind(obj, ...);
  
    * Changed all calls to sc_super() to this._super.apply(this, arguments)
  
    * Changed all calls to disconnect() to pass the root object.
  
    * removed calls to Binding.destroy() as that method is no longer useful
      (or defined)
  
    * changed use of T_STRING to 'string'
  */

  // ========================================================================
  // Binding Tests
  // ========================================================================

  var TestNamespace, fromObject, toObject, binding, Bon1, bon2, root; // global variables
  var originalLookup, lookup;

  QUnit.module('basic object binding', {
    setup: function () {
      fromObject = _emberRuntimeSystemObject.default.create({ value: 'start' });
      toObject = _emberRuntimeSystemObject.default.create({ value: 'end' });
      root = { fromObject: fromObject, toObject: toObject };
      _emberMetalRun_loop.default(function () {
        binding = _emberMetalBinding.bind(root, 'toObject.value', 'fromObject.value');
      });
    }
  });

  QUnit.test('binding should have synced on connect', function () {
    equal(_emberMetalProperty_get.get(toObject, 'value'), 'start', 'toObject.value should match fromObject.value');
  });

  QUnit.test('fromObject change should propagate to toObject only after flush', function () {
    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(fromObject, 'value', 'change');
      equal(_emberMetalProperty_get.get(toObject, 'value'), 'start');
    });
    equal(_emberMetalProperty_get.get(toObject, 'value'), 'change');
  });

  QUnit.test('toObject change should propagate to fromObject only after flush', function () {
    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(toObject, 'value', 'change');
      equal(_emberMetalProperty_get.get(fromObject, 'value'), 'start');
    });
    equal(_emberMetalProperty_get.get(fromObject, 'value'), 'change');
  });

  QUnit.test('deferred observing during bindings', function () {

    // setup special binding
    fromObject = _emberRuntimeSystemObject.default.create({
      value1: 'value1',
      value2: 'value2'
    });

    toObject = _emberRuntimeSystemObject.default.extend({
      observer: _emberMetalMixin.observer('value1', 'value2', function () {
        equal(_emberMetalProperty_get.get(this, 'value1'), 'CHANGED', 'value1 when observer fires');
        equal(_emberMetalProperty_get.get(this, 'value2'), 'CHANGED', 'value2 when observer fires');
        this.callCount++;
      })
    }).create({
      value1: 'value1',
      value2: 'value2',

      callCount: 0
    });

    var root = { fromObject: fromObject, toObject: toObject };
    _emberMetalRun_loop.default(function () {
      _emberMetalBinding.bind(root, 'toObject.value1', 'fromObject.value1');
      _emberMetalBinding.bind(root, 'toObject.value2', 'fromObject.value2');

      // change both value1 + value2, then  flush bindings.  observer should only
      // fire after bindings are done flushing.
      _emberMetalProperty_set.set(fromObject, 'value1', 'CHANGED');
      _emberMetalProperty_set.set(fromObject, 'value2', 'CHANGED');
    });

    equal(toObject.callCount, 2, 'should call observer twice');
  });

  QUnit.test('binding disconnection actually works', function () {
    binding.disconnect(root);
    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(fromObject, 'value', 'change');
    });
    equal(_emberMetalProperty_get.get(toObject, 'value'), 'start');
  });

  var first, second, third, binding1, binding2; // global variables

  // ..........................................................
  // chained binding
  //

  QUnit.module('chained binding', {

    setup: function () {
      _emberMetalRun_loop.default(function () {
        first = _emberRuntimeSystemObject.default.create({ output: 'first' });

        second = _emberRuntimeSystemObject.default.extend({
          inputDidChange: _emberMetalMixin.observer('input', function () {
            _emberMetalProperty_set.set(this, 'output', _emberMetalProperty_get.get(this, 'input'));
          })
        }).create({
          input: 'second',
          output: 'second'
        });

        third = _emberRuntimeSystemObject.default.create({ input: 'third' });

        root = { first: first, second: second, third: third };
        binding1 = _emberMetalBinding.bind(root, 'second.input', 'first.output');
        binding2 = _emberMetalBinding.bind(root, 'second.output', 'third.input');
      });
    },
    teardown: function () {
      _emberMetalRun_loop.default.cancelTimers();
    }
  });

  QUnit.test('changing first output should propagate to third after flush', function () {
    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(first, 'output', 'change');
      equal('change', _emberMetalProperty_get.get(first, 'output'), 'first.output');
      ok('change' !== _emberMetalProperty_get.get(third, 'input'), 'third.input');
    });

    equal('change', _emberMetalProperty_get.get(first, 'output'), 'first.output');
    equal('change', _emberMetalProperty_get.get(second, 'input'), 'second.input');
    equal('change', _emberMetalProperty_get.get(second, 'output'), 'second.output');
    equal('change', _emberMetalProperty_get.get(third, 'input'), 'third.input');
  });

  // ..........................................................
  // Custom Binding
  //

  QUnit.module('Custom Binding', {
    setup: function () {
      originalLookup = _emberMetalCore.default.lookup;
      _emberMetalCore.default.lookup = lookup = {};

      Bon1 = _emberRuntimeSystemObject.default.extend({
        value1: 'hi',
        value2: 83,
        array1: []
      });

      bon2 = _emberRuntimeSystemObject.default.create({
        val1: 'hello',
        val2: 25,
        arr: [1, 2, 3, 4]
      });

      _emberMetalCore.default.lookup['TestNamespace'] = TestNamespace = {
        bon2: bon2,
        Bon1: Bon1
      };
    },
    teardown: function () {
      _emberMetalCore.default.lookup = originalLookup;
      Bon1 = bon2 = TestNamespace = null;
      _emberMetalRun_loop.default.cancelTimers();
    }
  });

  QUnit.test('two bindings to the same value should sync in the order they are initialized', function () {

    _emberMetalRun_loop.default.begin();

    var a = _emberRuntimeSystemObject.default.create({
      foo: 'bar'
    });

    var b = _emberRuntimeSystemObject.default.extend({
      C: _emberRuntimeSystemObject.default.extend({
        foo: 'bee',
        fooBinding: 'owner.foo'
      }),

      init: function () {
        this._super.apply(this, arguments);
        _emberMetalProperty_set.set(this, 'c', this.C.create({ owner: this }));
      }
    }).create({
      foo: 'baz',
      fooBinding: 'a.foo',
      a: a
    });

    _emberMetalRun_loop.default.end();

    equal(_emberMetalProperty_get.get(a, 'foo'), 'bar', 'a.foo should not change');
    equal(_emberMetalProperty_get.get(b, 'foo'), 'bar', 'a.foo should propagate up to b.foo');
    equal(_emberMetalProperty_get.get(b.c, 'foo'), 'bar', 'a.foo should propagate up to b.c.foo');
  });

  // ..........................................................
  // propertyNameBinding with longhand
  //

  QUnit.module('propertyNameBinding with longhand', {
    setup: function () {
      originalLookup = _emberMetalCore.default.lookup;
      _emberMetalCore.default.lookup = lookup = {};

      _emberMetalCore.default.lookup['TestNamespace'] = TestNamespace = {};
      _emberMetalRun_loop.default(function () {
        TestNamespace.fromObject = _emberRuntimeSystemObject.default.create({
          value: 'originalValue'
        });

        TestNamespace.toObject = _emberRuntimeSystemObject.default.extend({
          valueBinding: _emberMetalBinding.Binding.from('TestNamespace.fromObject.value'),
          relativeBinding: _emberMetalBinding.Binding.from('localValue')
        }).create({
          localValue: 'originalLocal'
        });
      });
    },
    teardown: function () {
      TestNamespace = undefined;
      _emberMetalCore.default.lookup = originalLookup;
    }
  });

  QUnit.test('works with full path', function () {
    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(TestNamespace.fromObject, 'value', 'updatedValue');
    });

    equal(_emberMetalProperty_get.get(TestNamespace.toObject, 'value'), 'updatedValue');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(TestNamespace.fromObject, 'value', 'newerValue');
    });

    equal(_emberMetalProperty_get.get(TestNamespace.toObject, 'value'), 'newerValue');
  });

  QUnit.test('works with local path', function () {
    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(TestNamespace.toObject, 'localValue', 'updatedValue');
    });

    equal(_emberMetalProperty_get.get(TestNamespace.toObject, 'relative'), 'updatedValue');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(TestNamespace.toObject, 'localValue', 'newerValue');
    });

    equal(_emberMetalProperty_get.get(TestNamespace.toObject, 'relative'), 'newerValue');
  });
});
enifed('ember-runtime/tests/legacy_1x/system/binding_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/legacy_1x/system');
  test('ember-runtime/tests/legacy_1x/system/binding_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/legacy_1x/system/binding_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/legacy_1x/system/binding_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/legacy_1x/system');
  QUnit.test('ember-runtime/tests/legacy_1x/system/binding_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/legacy_1x/system/binding_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/legacy_1x/system/object/base_test', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/mixin', 'ember-runtime/system/object'], function (exports, _emberMetalCore, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalMixin, _emberRuntimeSystemObject) {
  'use strict';

  /*
    NOTE: This test is adapted from the 1.x series of unit tests.  The tests
    are the same except for places where we intend to break the API we instead
    validate that we warn the developer appropriately.
  
    CHANGES FROM 1.6:
  
    * Changed get(obj, ) and set(obj, ) to Ember.get() and Ember.set()
    * Removed obj.instanceOf() and obj.kindOf() tests.  use obj instanceof Foo
      instead
    * Removed respondsTo() and tryToPerform() tests.  Can be brought back in a
      utils package.
    * Removed destroy() test.  You can impl yourself but not built in
    * Changed Class.subclassOf() test to Class.detect()
    * Remove broken test for 'superclass' property.
    * Removed obj.didChangeFor()
  */

  // ========================================================================
  // EmberObject Base Tests
  // ========================================================================

  var obj, obj1, don; // global variables
  var TestNamespace, originalLookup, lookup;

  QUnit.module('A new EmberObject instance', {

    setup: function () {
      obj = _emberRuntimeSystemObject.default.create({
        foo: 'bar',
        total: 12345,
        aMethodThatExists: function () {},
        aMethodThatReturnsTrue: function () {
          return true;
        },
        aMethodThatReturnsFoobar: function () {
          return 'Foobar';
        },
        aMethodThatReturnsFalse: function () {
          return false;
        }
      });
    },

    teardown: function () {
      obj = undefined;
    }

  });

  QUnit.test('Should return its properties when requested using EmberObject#get', function () {
    equal(_emberMetalProperty_get.get(obj, 'foo'), 'bar');
    equal(_emberMetalProperty_get.get(obj, 'total'), 12345);
  });

  QUnit.test('Should allow changing of those properties by calling EmberObject#set', function () {
    equal(_emberMetalProperty_get.get(obj, 'foo'), 'bar');
    equal(_emberMetalProperty_get.get(obj, 'total'), 12345);

    _emberMetalProperty_set.set(obj, 'foo', 'Chunky Bacon');
    _emberMetalProperty_set.set(obj, 'total', 12);

    equal(_emberMetalProperty_get.get(obj, 'foo'), 'Chunky Bacon');
    equal(_emberMetalProperty_get.get(obj, 'total'), 12);
  });

  QUnit.module('EmberObject observers', {
    setup: function () {
      originalLookup = _emberMetalCore.default.lookup;
      _emberMetalCore.default.lookup = lookup = {};

      // create a namespace
      lookup['TestNamespace'] = TestNamespace = {
        obj: _emberRuntimeSystemObject.default.create({
          value: 'test'
        })
      };

      // create an object
      obj = _emberRuntimeSystemObject.default.extend({
        // normal observer
        observer: _emberMetalMixin.observer('prop1', function () {
          this._normal = true;
        }),

        globalObserver: _emberMetalMixin.observer('TestNamespace.obj.value', function () {
          this._global = true;
        }),

        bothObserver: _emberMetalMixin.observer('prop1', 'TestNamespace.obj.value', function () {
          this._both = true;
        })
      }).create({
        prop1: null
      });
    },

    teardown: function () {
      _emberMetalCore.default.lookup = originalLookup;
    }
  });

  QUnit.test('Local observers work', function () {
    obj._normal = false;
    _emberMetalProperty_set.set(obj, 'prop1', false);
    equal(obj._normal, true, 'Normal observer did change.');
  });

  QUnit.test('Global observers work', function () {
    obj._global = false;
    _emberMetalProperty_set.set(TestNamespace.obj, 'value', 'test2');
    equal(obj._global, true, 'Global observer did change.');
  });

  QUnit.test('Global+Local observer works', function () {
    obj._both = false;
    _emberMetalProperty_set.set(obj, 'prop1', false);
    equal(obj._both, true, 'Both observer did change.');
  });

  QUnit.module('EmberObject superclass and subclasses', {
    setup: function () {
      obj = _emberRuntimeSystemObject.default.extend({
        method1: function () {
          return 'hello';
        }
      });
      obj1 = obj.extend();
      don = obj1.create({
        method2: function () {
          return this.superclass();
        }
      });
    },

    teardown: function () {
      obj = undefined;
      obj1 = undefined;
      don = undefined;
    }
  });

  QUnit.test('Checking the detect() function on an object and its subclass', function () {
    equal(obj.detect(obj1), true);
    equal(obj1.detect(obj), false);
  });

  QUnit.test('Checking the detectInstance() function on an object and its subclass', function () {
    ok(_emberRuntimeSystemObject.default.detectInstance(obj.create()));
    ok(obj.detectInstance(obj.create()));
  });
});
enifed('ember-runtime/tests/legacy_1x/system/object/base_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/legacy_1x/system/object');
  test('ember-runtime/tests/legacy_1x/system/object/base_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/legacy_1x/system/object/base_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/legacy_1x/system/object/base_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/legacy_1x/system/object');
  QUnit.test('ember-runtime/tests/legacy_1x/system/object/base_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/legacy_1x/system/object/base_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/legacy_1x/system/object/bindings_test', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/run_loop', 'ember-metal/watching', 'ember-runtime/system/object'], function (exports, _emberMetalCore, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalRun_loop, _emberMetalWatching, _emberRuntimeSystemObject) {
  'use strict';

  /*
    NOTE: This test is adapted from the 1.x series of unit tests.  The tests
    are the same except for places where we intend to break the API we instead
    validate that we warn the developer appropriately.
  
    CHANGES FROM 1.6:
  
    * changed Ember.Bending.flushPendingChanges() -> run.sync();
    * changes obj.set() and obj.get() to Ember.set() and Ember.get()
    * Fixed an actual bug in unit tests around line 133
    * fixed 'bindings should disconnect on destroy' test to use destroy.
  */

  // ========================================================================
  // EmberObject bindings Tests
  // ========================================================================

  var testObject, fromObject, extraObject, TestObject;
  var TestNamespace, originalLookup, lookup;

  var bindModuleOpts = {

    setup: function () {
      originalLookup = _emberMetalCore.default.lookup;
      _emberMetalCore.default.lookup = lookup = {};

      testObject = _emberRuntimeSystemObject.default.create({
        foo: 'bar',
        bar: 'foo',
        extraObject: null
      });

      fromObject = _emberRuntimeSystemObject.default.create({
        bar: 'foo',
        extraObject: null
      });

      extraObject = _emberRuntimeSystemObject.default.create({
        foo: 'extraObjectValue'
      });

      lookup['TestNamespace'] = TestNamespace = {
        fromObject: fromObject,
        testObject: testObject
      };
    },

    teardown: function () {
      testObject = fromObject = extraObject = null;
      _emberMetalCore.default.lookup = originalLookup;
    }

  };

  QUnit.module('bind() method', bindModuleOpts);

  QUnit.test('bind(TestNamespace.fromObject.bar) should follow absolute path', function () {
    _emberMetalRun_loop.default(function () {
      // create binding
      testObject.bind('foo', 'TestNamespace.fromObject.bar');

      // now make a change to see if the binding triggers.
      _emberMetalProperty_set.set(fromObject, 'bar', 'changedValue');
    });

    equal('changedValue', _emberMetalProperty_get.get(testObject, 'foo'), 'testObject.foo');
  });

  QUnit.test('bind(.bar) should bind to relative path', function () {
    _emberMetalRun_loop.default(function () {
      // create binding
      testObject.bind('foo', 'bar');

      // now make a change to see if the binding triggers.
      _emberMetalProperty_set.set(testObject, 'bar', 'changedValue');
    });

    equal('changedValue', _emberMetalProperty_get.get(testObject, 'foo'), 'testObject.foo');
  });

  var fooBindingModuleOpts = {

    setup: function () {
      originalLookup = _emberMetalCore.default.lookup;
      _emberMetalCore.default.lookup = lookup = {};

      TestObject = _emberRuntimeSystemObject.default.extend({
        foo: 'bar',
        bar: 'foo',
        extraObject: null
      });

      fromObject = _emberRuntimeSystemObject.default.create({
        bar: 'foo',
        extraObject: null
      });

      extraObject = _emberRuntimeSystemObject.default.create({
        foo: 'extraObjectValue'
      });

      lookup['TestNamespace'] = TestNamespace = {
        fromObject: fromObject,
        testObject: TestObject
      };
    },

    teardown: function () {
      _emberMetalCore.default.lookup = originalLookup;
      TestObject = fromObject = extraObject = null;
      //  delete TestNamespace;
    }

  };

  QUnit.module('fooBinding method', fooBindingModuleOpts);

  QUnit.test('fooBinding: TestNamespace.fromObject.bar should follow absolute path', function () {
    // create binding
    _emberMetalRun_loop.default(function () {
      testObject = TestObject.extend({
        fooBinding: 'TestNamespace.fromObject.bar'
      }).create();

      // now make a change to see if the binding triggers.
      _emberMetalProperty_set.set(fromObject, 'bar', 'changedValue');
    });

    equal('changedValue', _emberMetalProperty_get.get(testObject, 'foo'), 'testObject.foo');
  });

  QUnit.test('fooBinding: .bar should bind to relative path', function () {
    _emberMetalRun_loop.default(function () {
      testObject = TestObject.extend({
        fooBinding: 'bar'
      }).create();
      // now make a change to see if the binding triggers.
      _emberMetalProperty_set.set(testObject, 'bar', 'changedValue');
    });

    equal('changedValue', _emberMetalProperty_get.get(testObject, 'foo'), 'testObject.foo');
  });

  QUnit.test('fooBinding: should disconnect bindings when destroyed', function () {
    _emberMetalRun_loop.default(function () {
      testObject = TestObject.extend({
        fooBinding: 'TestNamespace.fromObject.bar'
      }).create();

      _emberMetalProperty_set.set(TestNamespace.fromObject, 'bar', 'BAZ');
    });

    equal(_emberMetalProperty_get.get(testObject, 'foo'), 'BAZ', 'binding should have synced');

    _emberMetalWatching.destroy(testObject);

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(TestNamespace.fromObject, 'bar', 'BIFF');
    });

    ok(_emberMetalProperty_get.get(testObject, 'foo') !== 'bar', 'binding should not have synced');
  });
});
enifed('ember-runtime/tests/legacy_1x/system/object/bindings_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/legacy_1x/system/object');
  test('ember-runtime/tests/legacy_1x/system/object/bindings_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/legacy_1x/system/object/bindings_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/legacy_1x/system/object/bindings_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/legacy_1x/system/object');
  QUnit.test('ember-runtime/tests/legacy_1x/system/object/bindings_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/legacy_1x/system/object/bindings_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/legacy_1x/system/object/concatenated_test', ['exports', 'ember-metal/property_get', 'ember-runtime/system/object'], function (exports, _emberMetalProperty_get, _emberRuntimeSystemObject) {
  'use strict';

  /*
    NOTE: This test is adapted from the 1.x series of unit tests.  The tests
    are the same except for places where we intend to break the API we instead
    validate that we warn the developer appropriately.
  
    CHANGES FROM 1.6:
  
    * changed get(obj, ) and set(obj, ) to Ember.get() and Ember.set()
    * converted uses of obj.isEqual() to use deepEqual() test since isEqual is not
      always defined
  */

  function K() {
    return this;
  }

  var klass;

  QUnit.module('EmberObject Concatenated Properties', {
    setup: function () {
      klass = _emberRuntimeSystemObject.default.extend({
        concatenatedProperties: ['values', 'functions'],
        values: ['a', 'b', 'c'],
        functions: [K]
      });
    }
  });

  QUnit.test('concatenates instances', function () {
    var obj = klass.create({
      values: ['d', 'e', 'f']
    });

    var values = _emberMetalProperty_get.get(obj, 'values');
    var expected = ['a', 'b', 'c', 'd', 'e', 'f'];

    deepEqual(values, expected, 'should concatenate values property (expected: ' + expected + ', got: ' + values + ')');
  });

  QUnit.test('concatenates subclasses', function () {
    var subKlass = klass.extend({
      values: ['d', 'e', 'f']
    });
    var obj = subKlass.create();

    var values = _emberMetalProperty_get.get(obj, 'values');
    var expected = ['a', 'b', 'c', 'd', 'e', 'f'];

    deepEqual(values, expected, 'should concatenate values property (expected: ' + expected + ', got: ' + values + ')');
  });

  QUnit.test('concatenates reopen', function () {
    klass.reopen({
      values: ['d', 'e', 'f']
    });
    var obj = klass.create();

    var values = _emberMetalProperty_get.get(obj, 'values');
    var expected = ['a', 'b', 'c', 'd', 'e', 'f'];

    deepEqual(values, expected, 'should concatenate values property (expected: ' + expected + ', got: ' + values + ')');
  });

  QUnit.test('concatenates mixin', function () {
    var mixin = {
      values: ['d', 'e']
    };
    var subKlass = klass.extend(mixin, {
      values: ['f']
    });
    var obj = subKlass.create();

    var values = _emberMetalProperty_get.get(obj, 'values');
    var expected = ['a', 'b', 'c', 'd', 'e', 'f'];

    deepEqual(values, expected, 'should concatenate values property (expected: ' + expected + ', got: ' + values + ')');
  });

  QUnit.test('concatenates reopen, subclass, and instance', function () {
    klass.reopen({ values: ['d'] });
    var subKlass = klass.extend({ values: ['e'] });
    var obj = subKlass.create({ values: ['f'] });

    var values = _emberMetalProperty_get.get(obj, 'values');
    var expected = ['a', 'b', 'c', 'd', 'e', 'f'];

    deepEqual(values, expected, 'should concatenate values property (expected: ' + expected + ', got: ' + values + ')');
  });

  QUnit.test('concatenates subclasses when the values are functions', function () {
    var subKlass = klass.extend({
      functions: K
    });
    var obj = subKlass.create();

    var values = _emberMetalProperty_get.get(obj, 'functions');
    var expected = [K, K];

    deepEqual(values, expected, 'should concatenate functions property (expected: ' + expected + ', got: ' + values + ')');
  });
});
enifed('ember-runtime/tests/legacy_1x/system/object/concatenated_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/legacy_1x/system/object');
  test('ember-runtime/tests/legacy_1x/system/object/concatenated_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/legacy_1x/system/object/concatenated_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/legacy_1x/system/object/concatenated_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/legacy_1x/system/object');
  QUnit.test('ember-runtime/tests/legacy_1x/system/object/concatenated_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/legacy_1x/system/object/concatenated_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/legacy_1x/system/run_loop_test', ['exports', 'ember-metal/mixin', 'ember-metal/run_loop', 'ember-metal/binding', 'ember-runtime/mixins/observable', 'ember-runtime/system/object'], function (exports, _emberMetalMixin, _emberMetalRun_loop, _emberMetalBinding, _emberRuntimeMixinsObservable, _emberRuntimeSystemObject) {
  'use strict';

  /*
    NOTE: This test is adapted from the 1.x series of unit tests.  The tests
    are the same except for places where we intend to break the API we instead
    validate that we warn the developer appropriately.
  
    CHANGES FROM 1.6:
  
    * Updated the API usage for setting up and syncing Binding since these
      are not the APIs this file is testing.
  
    * Disabled a call to invokeOnce() around line 127 because it appeared to be
      broken anyway.  I don't think it ever even worked.
  */

  var MyApp, binding1, binding2;

  QUnit.module('System:run_loop() - chained binding', {
    setup: function () {
      MyApp = {};
      MyApp.first = _emberRuntimeSystemObject.default.extend(_emberRuntimeMixinsObservable.default).create({
        output: 'MyApp.first'
      });

      MyApp.second = _emberRuntimeSystemObject.default.extend(_emberRuntimeMixinsObservable.default, {
        inputDidChange: _emberMetalMixin.observer('input', function () {
          this.set('output', this.get('input'));
        })
      }).create({
        input: 'MyApp.second',
        output: 'MyApp.second'
      });

      MyApp.third = _emberRuntimeSystemObject.default.extend(_emberRuntimeMixinsObservable.default).create({
        input: 'MyApp.third'
      });
    }
  });

  QUnit.test('Should propagate bindings after the RunLoop completes (using Ember.RunLoop)', function () {
    _emberMetalRun_loop.default(function () {

      //Binding of output of MyApp.first object to input of MyApp.second object
      binding1 = _emberMetalBinding.Binding.from('first.output').to('second.input').connect(MyApp);

      //Binding of output of MyApp.second object to input of MyApp.third object
      binding2 = _emberMetalBinding.Binding.from('second.output').to('third.input').connect(MyApp);
    });

    _emberMetalRun_loop.default(function () {
      // Based on the above binding if you change the output of MyApp.first
      // object it should change the all the variable of
      //  MyApp.first,MyApp.second and MyApp.third object
      MyApp.first.set('output', 'change');

      //Changes the output of the MyApp.first object
      equal(MyApp.first.get('output'), 'change');

      //since binding has not taken into effect the value still remains as change.
      equal(MyApp.second.get('output'), 'MyApp.first');
    }); // allows bindings to trigger...

    //Value of the output variable changed to 'change'
    equal(MyApp.first.get('output'), 'change');

    //Since binding triggered after the end loop the value changed to 'change'.
    equal(MyApp.second.get('output'), 'change');
  });

  QUnit.test('Should propagate bindings after the RunLoop completes', function () {
    _emberMetalRun_loop.default(function () {
      //Binding of output of MyApp.first object to input of MyApp.second object
      binding1 = _emberMetalBinding.Binding.from('first.output').to('second.input').connect(MyApp);

      //Binding of output of MyApp.second object to input of MyApp.third object
      binding2 = _emberMetalBinding.Binding.from('second.output').to('third.input').connect(MyApp);
    });

    _emberMetalRun_loop.default(function () {
      //Based on the above binding if you change the output of MyApp.first object it should
      //change the all the variable of MyApp.first,MyApp.second and MyApp.third object
      MyApp.first.set('output', 'change');

      //Changes the output of the MyApp.first object
      equal(MyApp.first.get('output'), 'change');

      //since binding has not taken into effect the value still remains as change.
      equal(MyApp.second.get('output'), 'MyApp.first');
    });

    //Value of the output variable changed to 'change'
    equal(MyApp.first.get('output'), 'change');

    //Since binding triggered after the end loop the value changed to 'change'.
    equal(MyApp.second.get('output'), 'change');
  });
});
enifed('ember-runtime/tests/legacy_1x/system/run_loop_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/legacy_1x/system');
  test('ember-runtime/tests/legacy_1x/system/run_loop_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/legacy_1x/system/run_loop_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/legacy_1x/system/run_loop_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/legacy_1x/system');
  QUnit.test('ember-runtime/tests/legacy_1x/system/run_loop_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/legacy_1x/system/run_loop_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/mixins/array_test', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/observer', 'ember-metal/mixin', 'ember-metal/computed', 'ember-metal/tests/props_helper', 'ember-runtime/tests/suites/array', 'ember-runtime/system/object', 'ember-runtime/mixins/array'], function (exports, _emberMetalCore, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalObserver, _emberMetalMixin, _emberMetalComputed, _emberMetalTestsProps_helper, _emberRuntimeTestsSuitesArray, _emberRuntimeSystemObject, _emberRuntimeMixinsArray) {
  'use strict';

  /*
    Implement a basic fake mutable array.  This validates that any non-native
    enumerable can impl this API.
  */
  var TestArray = _emberRuntimeSystemObject.default.extend(_emberRuntimeMixinsArray.default, {

    _content: null,

    init: function (ary) {
      this._content = ary || [];
    },

    // some methods to modify the array so we can test changes.  Note that
    // arrays can be modified even if they don't implement MutableArray.  The
    // MutableArray is just a standard API for mutation but not required.
    addObject: function (obj) {
      var idx = this._content.length;
      this.arrayContentWillChange(idx, 0, 1);
      this._content.push(obj);
      this.arrayContentDidChange(idx, 0, 1);
    },

    removeFirst: function (idx) {
      this.arrayContentWillChange(0, 1, 0);
      this._content.shift();
      this.arrayContentDidChange(0, 1, 0);
    },

    objectAt: function (idx) {
      return this._content[idx];
    },

    length: _emberMetalComputed.computed(function () {
      return this._content.length;
    })
  });

  _emberRuntimeTestsSuitesArray.ArrayTests.extend({

    name: 'Basic Mutable Array',

    newObject: function (ary) {
      ary = ary ? ary.slice() : this.newFixture(3);
      return new TestArray(ary);
    },

    // allows for testing of the basic enumerable after an internal mutation
    mutate: function (obj) {
      obj.addObject(this.getFixture(1)[0]);
    },

    toArray: function (obj) {
      return obj.slice();
    }

  }).run();

  QUnit.test('the return value of slice has Ember.Array applied', function () {
    var x = _emberRuntimeSystemObject.default.extend(_emberRuntimeMixinsArray.default).create({
      length: 0
    });
    var y = x.slice(1);
    equal(_emberRuntimeMixinsArray.default.detect(y), true, 'mixin should be applied');
  });

  QUnit.test('slice supports negative index arguments', function () {
    var testArray = new TestArray([1, 2, 3, 4]);

    deepEqual(testArray.slice(-2), [3, 4], 'slice(-2)');
    deepEqual(testArray.slice(-2, -1), [3], 'slice(-2, -1');
    deepEqual(testArray.slice(-2, -2), [], 'slice(-2, -2)');
    deepEqual(testArray.slice(-1, -2), [], 'slice(-1, -2)');

    deepEqual(testArray.slice(-4, 1), [1], 'slice(-4, 1)');
    deepEqual(testArray.slice(-4, 5), [1, 2, 3, 4], 'slice(-4, 5)');
    deepEqual(testArray.slice(-4), [1, 2, 3, 4], 'slice(-4)');

    deepEqual(testArray.slice(0, -1), [1, 2, 3], 'slice(0, -1)');
    deepEqual(testArray.slice(0, -4), [], 'slice(0, -4)');
    deepEqual(testArray.slice(0, -3), [1], 'slice(0, -3)');
  });

  // ..........................................................
  // CONTENT DID CHANGE
  //

  var DummyArray = _emberRuntimeSystemObject.default.extend(_emberRuntimeMixinsArray.default, {
    nextObject: function () {},
    length: 0,
    objectAt: function (idx) {
      return 'ITEM-' + idx;
    }
  });

  var obj, observer;

  // ..........................................................
  // NOTIFY ARRAY OBSERVERS
  //

  QUnit.module('mixins/array/arrayContent[Will|Did]Change');

  QUnit.test('should notify observers of []', function () {

    obj = DummyArray.extend({
      enumerablePropertyDidChange: _emberMetalMixin.observer('[]', function () {
        this._count++;
      })
    }).create({
      _count: 0
    });

    equal(obj._count, 0, 'should not have invoked yet');

    obj.arrayContentWillChange(0, 1, 1);
    obj.arrayContentDidChange(0, 1, 1);

    equal(obj._count, 1, 'should have invoked');
  });

  // ..........................................................
  // NOTIFY CHANGES TO LENGTH
  //

  QUnit.module('notify observers of length', {
    setup: function () {
      obj = DummyArray.extend({
        lengthDidChange: _emberMetalMixin.observer('length', function () {
          this._after++;
        })
      }).create({
        _after: 0
      });

      equal(obj._after, 0, 'should not have fired yet');
    },

    teardown: function () {
      obj = null;
    }
  });

  QUnit.test('should notify observers when call with no params', function () {
    obj.arrayContentWillChange();
    equal(obj._after, 0);

    obj.arrayContentDidChange();
    equal(obj._after, 1);
  });

  // API variation that included items only
  QUnit.test('should not notify when passed lengths are same', function () {
    obj.arrayContentWillChange(0, 1, 1);
    equal(obj._after, 0);

    obj.arrayContentDidChange(0, 1, 1);
    equal(obj._after, 0);
  });

  QUnit.test('should notify when passed lengths are different', function () {
    obj.arrayContentWillChange(0, 1, 2);
    equal(obj._after, 0);

    obj.arrayContentDidChange(0, 1, 2);
    equal(obj._after, 1);
  });

  // ..........................................................
  // NOTIFY ARRAY OBSERVER
  //

  QUnit.module('notify array observers', {
    setup: function () {
      obj = DummyArray.create();

      observer = _emberRuntimeSystemObject.default.extend({
        arrayWillChange: function () {
          equal(this._before, null); // should only call once
          this._before = Array.prototype.slice.call(arguments);
        },

        arrayDidChange: function () {
          equal(this._after, null); // should only call once
          this._after = Array.prototype.slice.call(arguments);
        }
      }).create({
        _before: null,
        _after: null
      });

      obj.addArrayObserver(observer);
    },

    teardown: function () {
      obj = observer = null;
    }
  });

  QUnit.test('should notify enumerable observers when called with no params', function () {
    obj.arrayContentWillChange();
    deepEqual(observer._before, [obj, 0, -1, -1]);

    obj.arrayContentDidChange();
    deepEqual(observer._after, [obj, 0, -1, -1]);
  });

  // API variation that included items only
  QUnit.test('should notify when called with same length items', function () {
    obj.arrayContentWillChange(0, 1, 1);
    deepEqual(observer._before, [obj, 0, 1, 1]);

    obj.arrayContentDidChange(0, 1, 1);
    deepEqual(observer._after, [obj, 0, 1, 1]);
  });

  QUnit.test('should notify when called with diff length items', function () {
    obj.arrayContentWillChange(0, 2, 1);
    deepEqual(observer._before, [obj, 0, 2, 1]);

    obj.arrayContentDidChange(0, 2, 1);
    deepEqual(observer._after, [obj, 0, 2, 1]);
  });

  QUnit.test('removing enumerable observer should disable', function () {
    obj.removeArrayObserver(observer);
    obj.arrayContentWillChange();
    deepEqual(observer._before, null);

    obj.arrayContentDidChange();
    deepEqual(observer._after, null);
  });

  // ..........................................................
  // NOTIFY ENUMERABLE OBSERVER
  //

  QUnit.module('notify enumerable observers as well', {
    setup: function () {
      obj = DummyArray.create();

      observer = _emberRuntimeSystemObject.default.extend({
        enumerableWillChange: function () {
          equal(this._before, null); // should only call once
          this._before = Array.prototype.slice.call(arguments);
        },

        enumerableDidChange: function () {
          equal(this._after, null); // should only call once
          this._after = Array.prototype.slice.call(arguments);
        }
      }).create({
        _before: null,
        _after: null
      });

      obj.addEnumerableObserver(observer);
    },

    teardown: function () {
      obj = observer = null;
    }
  });

  QUnit.test('should notify enumerable observers when called with no params', function () {
    obj.arrayContentWillChange();
    deepEqual(observer._before, [obj, null, null], 'before');

    obj.arrayContentDidChange();
    deepEqual(observer._after, [obj, null, null], 'after');
  });

  // API variation that included items only
  QUnit.test('should notify when called with same length items', function () {
    obj.arrayContentWillChange(0, 1, 1);
    deepEqual(observer._before, [obj, ['ITEM-0'], 1], 'before');

    obj.arrayContentDidChange(0, 1, 1);
    deepEqual(observer._after, [obj, 1, ['ITEM-0']], 'after');
  });

  QUnit.test('should notify when called with diff length items', function () {
    obj.arrayContentWillChange(0, 2, 1);
    deepEqual(observer._before, [obj, ['ITEM-0', 'ITEM-1'], 1], 'before');

    obj.arrayContentDidChange(0, 2, 1);
    deepEqual(observer._after, [obj, 2, ['ITEM-0']], 'after');
  });

  QUnit.test('removing enumerable observer should disable', function () {
    obj.removeEnumerableObserver(observer);
    obj.arrayContentWillChange();
    deepEqual(observer._before, null, 'before');

    obj.arrayContentDidChange();
    deepEqual(observer._after, null, 'after');
  });

  // ..........................................................
  // @each
  //

  var ary;

  QUnit.module('EmberArray.@each support', {
    setup: function () {
      ary = new TestArray([{ isDone: true, desc: 'Todo 1' }, { isDone: false, desc: 'Todo 2' }, { isDone: true, desc: 'Todo 3' }, { isDone: false, desc: 'Todo 4' }]);
    },

    teardown: function () {
      ary = null;
    }
  });

  QUnit.test('adding an object should notify (@each.isDone)', function () {

    var called = 0;

    var observerObject = _emberRuntimeSystemObject.default.create({
      wasCalled: function () {
        called++;
      }
    });

    _emberMetalObserver.addObserver(ary, '@each.isDone', observerObject, 'wasCalled');

    ary.addObject(_emberRuntimeSystemObject.default.create({
      desc: 'foo',
      isDone: false
    }));

    equal(called, 1, 'calls observer when object is pushed');
  });

  QUnit.test('using @each to observe arrays that does not return objects raise error', function () {

    var called = 0;

    var observerObject = _emberRuntimeSystemObject.default.create({
      wasCalled: function () {
        called++;
      }
    });

    ary = TestArray.create({
      objectAt: function (idx) {
        return _emberMetalProperty_get.get(this._content[idx], 'desc');
      }
    });

    _emberMetalObserver.addObserver(ary, '@each.isDone', observerObject, 'wasCalled');

    expectAssertion(function () {
      ary.addObject(_emberRuntimeSystemObject.default.create({
        desc: 'foo',
        isDone: false
      }));
    }, /When using @each to observe the array/);

    equal(called, 0, 'not calls observer when object is pushed');
  });

  QUnit.test('modifying the array should also indicate the isDone prop itself has changed', function () {
    // NOTE: we never actually get the '@each.isDone' property here.  This is
    // important because it tests the case where we don't have an isDone
    // EachArray materialized but just want to know when the property has
    // changed.

    var each = _emberMetalProperty_get.get(ary, '@each');
    var count = 0;

    _emberMetalObserver.addObserver(each, 'isDone', function () {
      count++;
    });

    count = 0;
    var item = ary.objectAt(2);
    _emberMetalProperty_set.set(item, 'isDone', !_emberMetalProperty_get.get(item, 'isDone'));
    equal(count, 1, '@each.isDone should have notified');
  });

  _emberMetalTestsProps_helper.testBoth('should be clear caches for computed properties that have dependent keys on arrays that are changed after object initialization', function (get, set) {
    var obj = _emberRuntimeSystemObject.default.extend({
      init: function () {
        this._super.apply(this, arguments);
        set(this, 'resources', _emberMetalCore.default.A());
      },

      common: _emberMetalComputed.computed('resources.@each.common', function () {
        return get(get(this, 'resources').objectAt(0), 'common');
      })
    }).create();

    get(obj, 'resources').pushObject(_emberRuntimeSystemObject.default.create({ common: 'HI!' }));
    equal('HI!', get(obj, 'common'));

    set(get(obj, 'resources').objectAt(0), 'common', 'BYE!');
    equal('BYE!', get(obj, 'common'));
  });

  _emberMetalTestsProps_helper.testBoth('observers that contain @each in the path should fire only once the first time they are accessed', function (get, set) {
    var count = 0;

    var obj = _emberRuntimeSystemObject.default.extend({
      init: function () {
        this._super.apply(this, arguments);
        // Observer does not fire on init
        set(this, 'resources', _emberMetalCore.default.A());
      },

      commonDidChange: _emberMetalMixin.observer('resources.@each.common', function () {
        count++;
      })
    }).create();

    // Observer fires second time when new object is added
    get(obj, 'resources').pushObject(_emberRuntimeSystemObject.default.create({ common: 'HI!' }));
    // Observer fires third time when property on an object is changed
    set(get(obj, 'resources').objectAt(0), 'common', 'BYE!');

    equal(count, 2, 'observers should only be called once');
  });
});
// Ember.A
enifed('ember-runtime/tests/mixins/array_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/mixins');
  test('ember-runtime/tests/mixins/array_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/mixins/array_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/mixins/array_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/mixins');
  QUnit.test('ember-runtime/tests/mixins/array_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/mixins/array_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/mixins/comparable_test', ['exports', 'ember-metal/property_get', 'ember-runtime/system/object', 'ember-runtime/compare', 'ember-runtime/mixins/comparable'], function (exports, _emberMetalProperty_get, _emberRuntimeSystemObject, _emberRuntimeCompare, _emberRuntimeMixinsComparable) {
  'use strict';

  var Rectangle = _emberRuntimeSystemObject.default.extend(_emberRuntimeMixinsComparable.default, {
    length: 0,
    width: 0,

    area: function () {
      return _emberMetalProperty_get.get(this, 'length') * _emberMetalProperty_get.get(this, 'width');
    },

    compare: function (a, b) {
      return _emberRuntimeCompare.default(a.area(), b.area());
    }

  });

  var r1, r2;

  QUnit.module('Comparable', {

    setup: function () {
      r1 = Rectangle.create({ length: 6, width: 12 });
      r2 = Rectangle.create({ length: 6, width: 13 });
    },

    teardown: function () {}

  });

  QUnit.test('should be comparable and return the correct result', function () {
    equal(_emberRuntimeMixinsComparable.default.detect(r1), true);
    equal(_emberRuntimeCompare.default(r1, r1), 0);
    equal(_emberRuntimeCompare.default(r1, r2), -1);
    equal(_emberRuntimeCompare.default(r2, r1), 1);
  });
});
enifed('ember-runtime/tests/mixins/comparable_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/mixins');
  test('ember-runtime/tests/mixins/comparable_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/mixins/comparable_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/mixins/comparable_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/mixins');
  QUnit.test('ember-runtime/tests/mixins/comparable_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/mixins/comparable_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/mixins/copyable_test', ['exports', 'ember-runtime/tests/suites/copyable', 'ember-runtime/mixins/copyable', 'ember-runtime/system/object', 'ember-metal/utils', 'ember-metal/property_set', 'ember-metal/property_get'], function (exports, _emberRuntimeTestsSuitesCopyable, _emberRuntimeMixinsCopyable, _emberRuntimeSystemObject, _emberMetalUtils, _emberMetalProperty_set, _emberMetalProperty_get) {
  'use strict';

  var CopyableObject = _emberRuntimeSystemObject.default.extend(_emberRuntimeMixinsCopyable.default, {

    id: null,

    init: function () {
      this._super.apply(this, arguments);
      _emberMetalProperty_set.set(this, 'id', _emberMetalUtils.generateGuid());
    },

    copy: function () {
      var ret = new CopyableObject();
      _emberMetalProperty_set.set(ret, 'id', _emberMetalProperty_get.get(this, 'id'));
      return ret;
    }
  });

  _emberRuntimeTestsSuitesCopyable.default.extend({

    name: 'Copyable Basic Test',

    newObject: function () {
      return new CopyableObject();
    },

    isEqual: function (a, b) {
      if (!(a instanceof CopyableObject) || !(b instanceof CopyableObject)) {
        return false;
      }

      return _emberMetalProperty_get.get(a, 'id') === _emberMetalProperty_get.get(b, 'id');
    }
  }).run();
});
enifed('ember-runtime/tests/mixins/copyable_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/mixins');
  test('ember-runtime/tests/mixins/copyable_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/mixins/copyable_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/mixins/copyable_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/mixins');
  QUnit.test('ember-runtime/tests/mixins/copyable_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/mixins/copyable_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/mixins/enumerable_test', ['exports', 'ember-metal/core', 'ember-runtime/tests/suites/enumerable', 'ember-runtime/system/object', 'ember-runtime/mixins/enumerable', 'ember-runtime/mixins/array', 'ember-metal/property_get', 'ember-metal/computed', 'ember-metal/mixin'], function (exports, _emberMetalCore, _emberRuntimeTestsSuitesEnumerable, _emberRuntimeSystemObject, _emberRuntimeMixinsEnumerable, _emberRuntimeMixinsArray, _emberMetalProperty_get, _emberMetalComputed, _emberMetalMixin) {
  'use strict';

  function K() {
    return this;
  }

  /*
    Implement a basic fake enumerable.  This validates that any non-native
    enumerable can impl this API.
  */
  var TestEnumerable = _emberRuntimeSystemObject.default.extend(_emberRuntimeMixinsEnumerable.default, {

    _content: null,

    init: function (ary) {
      this._content = ary || [];
    },

    addObject: function (obj) {
      if (this._content.indexOf(obj) >= 0) {
        return this;
      }

      this._content.push(obj);
      this.enumerableContentDidChange();
    },

    nextObject: function (idx) {
      return idx >= _emberMetalProperty_get.get(this, 'length') ? undefined : this._content[idx];
    },

    length: _emberMetalComputed.computed(function () {
      return this._content.length;
    }),

    slice: function () {
      return this._content.slice();
    }

  });

  _emberRuntimeTestsSuitesEnumerable.default.extend({

    name: 'Basic Enumerable',

    newObject: function (ary) {
      ary = ary ? ary.slice() : this.newFixture(3);
      return new TestEnumerable(ary);
    },

    // allows for testing of the basic enumerable after an internal mutation
    mutate: function (obj) {
      obj.addObject(obj._content.length + 1);
    },

    toArray: function (obj) {
      return obj.slice();
    }

  }).run();

  QUnit.module('Ember.Enumerable');

  QUnit.test('should apply Ember.Array to return value of map', function () {
    var x = _emberRuntimeSystemObject.default.extend(_emberRuntimeMixinsEnumerable.default).create();
    var y = x.map(K);
    equal(_emberRuntimeMixinsArray.default.detect(y), true, 'should have mixin applied');
  });

  QUnit.test('should apply Ember.Array to return value of filter', function () {
    var x = _emberRuntimeSystemObject.default.extend(_emberRuntimeMixinsEnumerable.default).create();
    var y = x.filter(K);
    equal(_emberRuntimeMixinsArray.default.detect(y), true, 'should have mixin applied');
  });

  QUnit.test('should apply Ember.Array to return value of invoke', function () {
    var x = _emberRuntimeSystemObject.default.extend(_emberRuntimeMixinsEnumerable.default).create();
    var y = x.invoke(K);
    equal(_emberRuntimeMixinsArray.default.detect(y), true, 'should have mixin applied');
  });

  QUnit.test('should apply Ember.Array to return value of toArray', function () {
    var x = _emberRuntimeSystemObject.default.extend(_emberRuntimeMixinsEnumerable.default).create();
    var y = x.toArray(K);
    equal(_emberRuntimeMixinsArray.default.detect(y), true, 'should have mixin applied');
  });

  QUnit.test('should apply Ember.Array to return value of without', function () {
    var x = _emberRuntimeSystemObject.default.extend(_emberRuntimeMixinsEnumerable.default, {
      contains: function () {
        return true;
      }
    }).create();
    var y = x.without(K);
    equal(_emberRuntimeMixinsArray.default.detect(y), true, 'should have mixin applied');
  });

  QUnit.test('should apply Ember.Array to return value of uniq', function () {
    var x = _emberRuntimeSystemObject.default.extend(_emberRuntimeMixinsEnumerable.default).create();
    var y = x.uniq(K);
    equal(_emberRuntimeMixinsArray.default.detect(y), true, 'should have mixin applied');
  });

  QUnit.test('any', function () {
    var kittens = _emberMetalCore.default.A([{
      color: 'white'
    }, {
      color: 'black'
    }, {
      color: 'white'
    }]);
    var foundWhite = kittens.any(function (kitten) {
      return kitten.color === 'white';
    });
    var foundWhite2 = kittens.isAny('color', 'white');

    equal(foundWhite, true);
    equal(foundWhite2, true);
  });

  QUnit.test('any with NaN', function () {
    var numbers = _emberMetalCore.default.A([1, 2, NaN, 4]);

    var hasNaN = numbers.any(function (n) {
      return isNaN(n);
    });

    equal(hasNaN, true, 'works when matching NaN');
  });

  QUnit.test('every', function () {
    var allColorsKittens = _emberMetalCore.default.A([{
      color: 'white'
    }, {
      color: 'black'
    }, {
      color: 'white'
    }]);
    var allWhiteKittens = _emberMetalCore.default.A([{
      color: 'white'
    }, {
      color: 'white'
    }, {
      color: 'white'
    }]);
    var allWhite = false;
    var whiteKittenPredicate = function (kitten) {
      return kitten.color === 'white';
    };

    allWhite = allColorsKittens.every(whiteKittenPredicate);
    equal(allWhite, false);

    allWhite = allWhiteKittens.every(whiteKittenPredicate);
    equal(allWhite, true);

    allWhite = allColorsKittens.isEvery('color', 'white');
    equal(allWhite, false);

    allWhite = allWhiteKittens.isEvery('color', 'white');
    equal(allWhite, true);
  });

  // ..........................................................
  // CONTENT DID CHANGE
  //

  var DummyEnum = _emberRuntimeSystemObject.default.extend(_emberRuntimeMixinsEnumerable.default, {
    nextObject: function () {},
    length: 0
  });

  var obj, observer;

  // ..........................................................
  // NOTIFY ENUMERABLE PROPERTY
  //

  QUnit.module('mixins/enumerable/enumerableContentDidChange');

  QUnit.test('should notify observers of []', function () {

    var obj = _emberRuntimeSystemObject.default.extend(_emberRuntimeMixinsEnumerable.default, {
      nextObject: function () {}, // avoid exceptions

      enumerablePropertyDidChange: _emberMetalMixin.observer('[]', function () {
        this._count++;
      })
    }).create({
      _count: 0
    });

    equal(obj._count, 0, 'should not have invoked yet');
    obj.enumerableContentWillChange();
    obj.enumerableContentDidChange();
    equal(obj._count, 1, 'should have invoked');
  });

  // ..........................................................
  // NOTIFY CHANGES TO LENGTH
  //

  QUnit.module('notify observers of length', {
    setup: function () {
      obj = DummyEnum.extend({
        lengthDidChange: _emberMetalMixin.observer('length', function () {
          this._after++;
        })
      }).create({
        _after: 0
      });

      equal(obj._after, 0, 'should not have fired yet');
    },

    teardown: function () {
      obj = null;
    }
  });

  QUnit.test('should notify observers when call with no params', function () {
    obj.enumerableContentWillChange();
    equal(obj._after, 0);

    obj.enumerableContentDidChange();
    equal(obj._after, 1);
  });

  // API variation that included items only
  QUnit.test('should not notify when passed arrays of same length', function () {
    var added = ['foo'];
    var removed = ['bar'];

    obj.enumerableContentWillChange(removed, added);
    equal(obj._after, 0);

    obj.enumerableContentDidChange(removed, added);
    equal(obj._after, 0);
  });

  QUnit.test('should notify when passed arrays of different length', function () {
    var added = ['foo'];
    var removed = ['bar', 'baz'];

    obj.enumerableContentWillChange(removed, added);
    equal(obj._after, 0);

    obj.enumerableContentDidChange(removed, added);
    equal(obj._after, 1);
  });

  // API variation passes indexes only
  QUnit.test('should not notify when passed with indexes', function () {
    obj.enumerableContentWillChange(1, 1);
    equal(obj._after, 0);

    obj.enumerableContentDidChange(1, 1);
    equal(obj._after, 0);
  });

  QUnit.test('should notify when passed old index API with delta', function () {
    obj.enumerableContentWillChange(1, 2);
    equal(obj._after, 0);

    obj.enumerableContentDidChange(1, 2);
    equal(obj._after, 1);
  });

  // ..........................................................
  // NOTIFY ENUMERABLE OBSERVER
  //

  QUnit.module('notify enumerable observers', {
    setup: function () {
      obj = DummyEnum.create();

      observer = _emberRuntimeSystemObject.default.extend({
        enumerableWillChange: function () {
          equal(this._before, null); // should only call once
          this._before = Array.prototype.slice.call(arguments);
        },

        enumerableDidChange: function () {
          equal(this._after, null); // should only call once
          this._after = Array.prototype.slice.call(arguments);
        }
      }).create({
        _before: null,
        _after: null
      });

      obj.addEnumerableObserver(observer);
    },

    teardown: function () {
      obj = observer = null;
    }
  });

  QUnit.test('should notify enumerable observers when called with no params', function () {
    obj.enumerableContentWillChange();
    deepEqual(observer._before, [obj, null, null]);

    obj.enumerableContentDidChange();
    deepEqual(observer._after, [obj, null, null]);
  });

  // API variation that included items only
  QUnit.test('should notify when called with same length items', function () {
    var added = ['foo'];
    var removed = ['bar'];

    obj.enumerableContentWillChange(removed, added);
    deepEqual(observer._before, [obj, removed, added]);

    obj.enumerableContentDidChange(removed, added);
    deepEqual(observer._after, [obj, removed, added]);
  });

  QUnit.test('should notify when called with diff length items', function () {
    var added = ['foo', 'baz'];
    var removed = ['bar'];

    obj.enumerableContentWillChange(removed, added);
    deepEqual(observer._before, [obj, removed, added]);

    obj.enumerableContentDidChange(removed, added);
    deepEqual(observer._after, [obj, removed, added]);
  });

  QUnit.test('should not notify when passed with indexes only', function () {
    obj.enumerableContentWillChange(1, 2);
    deepEqual(observer._before, [obj, 1, 2]);

    obj.enumerableContentDidChange(1, 2);
    deepEqual(observer._after, [obj, 1, 2]);
  });

  QUnit.test('removing enumerable observer should disable', function () {
    obj.removeEnumerableObserver(observer);
    obj.enumerableContentWillChange();
    deepEqual(observer._before, null);

    obj.enumerableContentDidChange();
    deepEqual(observer._after, null);
  });
});
// for Ember.A
enifed('ember-runtime/tests/mixins/enumerable_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/mixins');
  test('ember-runtime/tests/mixins/enumerable_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/mixins/enumerable_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/mixins/enumerable_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/mixins');
  QUnit.test('ember-runtime/tests/mixins/enumerable_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/mixins/enumerable_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/mixins/freezable_test', ['exports', 'ember-runtime/system/object', 'ember-runtime/mixins/freezable'], function (exports, _emberRuntimeSystemObject, _emberRuntimeMixinsFreezable) {
  'use strict';

  QUnit.module('Ember.Freezable');

  QUnit.test('should be deprecated', function () {
    expectDeprecation('`Ember.Freezable` is deprecated, use `Object.freeze` instead.');
    _emberRuntimeSystemObject.default.extend(_emberRuntimeMixinsFreezable.Freezable).create();
  });
});
enifed('ember-runtime/tests/mixins/freezable_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/mixins');
  test('ember-runtime/tests/mixins/freezable_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/mixins/freezable_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/mixins/freezable_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/mixins');
  QUnit.test('ember-runtime/tests/mixins/freezable_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/mixins/freezable_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/mixins/mutable_array_test', ['exports', 'ember-metal/core', 'ember-metal/computed', 'ember-runtime/tests/suites/mutable_array', 'ember-runtime/mixins/mutable_array', 'ember-runtime/system/object'], function (exports, _emberMetalCore, _emberMetalComputed, _emberRuntimeTestsSuitesMutable_array, _emberRuntimeMixinsMutable_array, _emberRuntimeSystemObject) {
  'use strict';

  /*
    Implement a basic fake mutable array.  This validates that any non-native
    enumerable can impl this API.
  */
  var TestMutableArray = _emberRuntimeSystemObject.default.extend(_emberRuntimeMixinsMutable_array.default, {

    _content: null,

    init: function (ary) {
      this._content = _emberMetalCore.default.A(ary || []);
    },

    replace: function (idx, amt, objects) {

      var args = objects ? objects.slice() : [];
      var removeAmt = amt;
      var addAmt = args.length;

      this.arrayContentWillChange(idx, removeAmt, addAmt);

      args.unshift(amt);
      args.unshift(idx);
      this._content.splice.apply(this._content, args);
      this.arrayContentDidChange(idx, removeAmt, addAmt);
      return this;
    },

    objectAt: function (idx) {
      return this._content[idx];
    },

    length: _emberMetalComputed.computed(function () {
      return this._content.length;
    }),

    slice: function () {
      return this._content.slice();
    }

  });

  _emberRuntimeTestsSuitesMutable_array.default.extend({

    name: 'Basic Mutable Array',

    newObject: function (ary) {
      ary = ary ? ary.slice() : this.newFixture(3);
      return new TestMutableArray(ary);
    },

    // allows for testing of the basic enumerable after an internal mutation
    mutate: function (obj) {
      obj.addObject(this.getFixture(1)[0]);
    },

    toArray: function (obj) {
      return obj.slice();
    }

  }).run();
});
enifed('ember-runtime/tests/mixins/mutable_array_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/mixins');
  test('ember-runtime/tests/mixins/mutable_array_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/mixins/mutable_array_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/mixins/mutable_array_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/mixins');
  QUnit.test('ember-runtime/tests/mixins/mutable_array_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/mixins/mutable_array_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/mixins/mutable_enumerable_test', ['exports', 'ember-runtime/tests/suites/mutable_enumerable', 'ember-runtime/mixins/mutable_enumerable', 'ember-runtime/system/object', 'ember-metal/computed', 'ember-metal/property_get'], function (exports, _emberRuntimeTestsSuitesMutable_enumerable, _emberRuntimeMixinsMutable_enumerable, _emberRuntimeSystemObject, _emberMetalComputed, _emberMetalProperty_get) {
  'use strict';

  /*
    Implement a basic fake mutable array.  This validates that any non-native
    enumerable can impl this API.
  */
  var TestMutableEnumerable = _emberRuntimeSystemObject.default.extend(_emberRuntimeMixinsMutable_enumerable.default, {

    _content: null,

    addObject: function (obj) {
      if (this._content.indexOf(obj) >= 0) {
        return this;
      }

      this.enumerableContentWillChange(null, [obj]);
      this._content.push(obj);
      this.enumerableContentDidChange(null, [obj]);
    },

    removeObject: function (obj) {
      var idx = this._content.indexOf(obj);
      if (idx < 0) {
        return this;
      }

      this.enumerableContentWillChange([obj], null);
      this._content.splice(idx, 1);
      this.enumerableContentDidChange([obj], null);
      return this;
    },

    init: function (ary) {
      this._content = ary || [];
    },

    nextObject: function (idx) {
      return idx >= _emberMetalProperty_get.get(this, 'length') ? undefined : this._content[idx];
    },

    length: _emberMetalComputed.computed(function () {
      return this._content.length;
    }),

    slice: function () {
      return this._content.slice();
    }
  });

  _emberRuntimeTestsSuitesMutable_enumerable.default.extend({

    name: 'Basic Mutable Array',

    newObject: function (ary) {
      ary = ary ? ary.slice() : this.newFixture(3);
      return new TestMutableEnumerable(ary);
    },

    // allows for testing of the basic enumerable after an internal mutation
    mutate: function (obj) {
      obj.addObject(this.getFixture(1)[0]);
    },

    toArray: function (obj) {
      return obj.slice();
    }

  }).run();
});
enifed('ember-runtime/tests/mixins/mutable_enumerable_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/mixins');
  test('ember-runtime/tests/mixins/mutable_enumerable_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/mixins/mutable_enumerable_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/mixins/mutable_enumerable_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/mixins');
  QUnit.test('ember-runtime/tests/mixins/mutable_enumerable_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/mixins/mutable_enumerable_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/mixins/observable_test', ['exports', 'ember-metal/computed', 'ember-metal/observer', 'ember-runtime/system/object', 'ember-metal/tests/props_helper'], function (exports, _emberMetalComputed, _emberMetalObserver, _emberRuntimeSystemObject, _emberMetalTestsProps_helper) {
  'use strict';

  QUnit.module('mixins/observable');

  QUnit.test('should be able to use getProperties to get a POJO of provided keys', function () {
    var obj = _emberRuntimeSystemObject.default.create({
      firstName: 'Steve',
      lastName: 'Jobs',
      companyName: 'Apple, Inc.'
    });

    var pojo = obj.getProperties('firstName', 'lastName');
    equal('Steve', pojo.firstName);
    equal('Jobs', pojo.lastName);
  });

  QUnit.test('should be able to use getProperties with array parameter to get a POJO of provided keys', function () {
    var obj = _emberRuntimeSystemObject.default.create({
      firstName: 'Steve',
      lastName: 'Jobs',
      companyName: 'Apple, Inc.'
    });

    var pojo = obj.getProperties(['firstName', 'lastName']);
    equal('Steve', pojo.firstName);
    equal('Jobs', pojo.lastName);
  });

  QUnit.test('should be able to use setProperties to set multiple properties at once', function () {
    var obj = _emberRuntimeSystemObject.default.create({
      firstName: 'Steve',
      lastName: 'Jobs',
      companyName: 'Apple, Inc.'
    });

    obj.setProperties({ firstName: 'Tim', lastName: 'Cook' });
    equal('Tim', obj.get('firstName'));
    equal('Cook', obj.get('lastName'));
  });

  _emberMetalTestsProps_helper.testBoth('calling setProperties completes safely despite exceptions', function (get, set) {
    var exc = new Error('Something unexpected happened!');
    var obj = _emberRuntimeSystemObject.default.extend({
      companyName: _emberMetalComputed.computed({
        get: function () {
          return 'Apple, Inc.';
        },
        set: function (key, value) {
          throw exc;
        }
      })
    }).create({
      firstName: 'Steve',
      lastName: 'Jobs'
    });

    var firstNameChangedCount = 0;

    _emberMetalObserver.addObserver(obj, 'firstName', function () {
      firstNameChangedCount++;
    });

    try {
      obj.setProperties({
        firstName: 'Tim',
        lastName: 'Cook',
        companyName: 'Fruit Co., Inc.'
      });
    } catch (err) {
      if (err !== exc) {
        throw err;
      }
    }

    equal(firstNameChangedCount, 1, 'firstName should have fired once');
  });

  _emberMetalTestsProps_helper.testBoth('should be able to retrieve cached values of computed properties without invoking the computed property', function (get) {
    var obj = _emberRuntimeSystemObject.default.extend({
      foo: _emberMetalComputed.computed(function () {
        return 'foo';
      })
    }).create({
      bar: 'bar'
    });

    equal(obj.cacheFor('foo'), undefined, 'should return undefined if no value has been cached');
    get(obj, 'foo');

    equal(get(obj, 'foo'), 'foo', 'precond - should cache the value');
    equal(obj.cacheFor('foo'), 'foo', 'should return the cached value after it is invoked');

    equal(obj.cacheFor('bar'), undefined, 'returns undefined if the value is not a computed property');
  });

  QUnit.test('incrementProperty should work even if value is number in string', function () {
    var obj = _emberRuntimeSystemObject.default.create({
      age: '24'
    });
    obj.incrementProperty('age');
    equal(25, obj.get('age'));
  });
});
enifed('ember-runtime/tests/mixins/observable_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/mixins');
  test('ember-runtime/tests/mixins/observable_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/mixins/observable_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/mixins/observable_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/mixins');
  QUnit.test('ember-runtime/tests/mixins/observable_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/mixins/observable_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/mixins/promise_proxy_test', ['exports', 'ember-metal/property_get', 'ember-metal/run_loop', 'ember-runtime/system/object_proxy', 'ember-runtime/mixins/promise_proxy', 'ember-runtime/ext/rsvp', 'rsvp'], function (exports, _emberMetalProperty_get, _emberMetalRun_loop, _emberRuntimeSystemObject_proxy, _emberRuntimeMixinsPromise_proxy, _emberRuntimeExtRsvp, _rsvp) {
  'use strict';

  var ObjectPromiseProxy;

  QUnit.test('present on ember namespace', function () {
    ok(_emberRuntimeMixinsPromise_proxy.default, 'expected PromiseProxyMixin to exist');
  });

  QUnit.module('Ember.PromiseProxy - ObjectProxy', {
    setup: function () {
      ObjectPromiseProxy = _emberRuntimeSystemObject_proxy.default.extend(_emberRuntimeMixinsPromise_proxy.default);
    }
  });

  QUnit.test('no promise, invoking then should raise', function () {
    var proxy = ObjectPromiseProxy.create();

    throws(function () {
      proxy.then(function () {
        return this;
      }, function () {
        return this;
      });
    }, new RegExp('PromiseProxy\'s promise must be set'));
  });

  QUnit.test('fulfillment', function () {
    var value = {
      firstName: 'stef',
      lastName: 'penner'
    };

    var deferred = _rsvp.defer();

    var proxy = ObjectPromiseProxy.create({
      promise: deferred.promise
    });

    var didFulfillCount = 0;
    var didRejectCount = 0;

    proxy.then(function () {
      didFulfillCount++;
    }, function () {
      didRejectCount++;
    });

    equal(_emberMetalProperty_get.get(proxy, 'content'), undefined, 'expects the proxy to have no content');
    equal(_emberMetalProperty_get.get(proxy, 'reason'), undefined, 'expects the proxy to have no reason');
    equal(_emberMetalProperty_get.get(proxy, 'isPending'), true, 'expects the proxy to indicate that it is loading');
    equal(_emberMetalProperty_get.get(proxy, 'isSettled'), false, 'expects the proxy to indicate that it is not settled');
    equal(_emberMetalProperty_get.get(proxy, 'isRejected'), false, 'expects the proxy to indicate that it is not rejected');
    equal(_emberMetalProperty_get.get(proxy, 'isFulfilled'), false, 'expects the proxy to indicate that it is not fulfilled');

    equal(didFulfillCount, 0, 'should not yet have been fulfilled');
    equal(didRejectCount, 0, 'should not yet have been rejected');

    _emberMetalRun_loop.default(deferred, 'resolve', value);

    equal(didFulfillCount, 1, 'should have been fulfilled');
    equal(didRejectCount, 0, 'should not have been rejected');

    equal(_emberMetalProperty_get.get(proxy, 'content'), value, 'expects the proxy to have content');
    equal(_emberMetalProperty_get.get(proxy, 'reason'), undefined, 'expects the proxy to still have no reason');
    equal(_emberMetalProperty_get.get(proxy, 'isPending'), false, 'expects the proxy to indicate that it is no longer loading');
    equal(_emberMetalProperty_get.get(proxy, 'isSettled'), true, 'expects the proxy to indicate that it is settled');
    equal(_emberMetalProperty_get.get(proxy, 'isRejected'), false, 'expects the proxy to indicate that it is not rejected');
    equal(_emberMetalProperty_get.get(proxy, 'isFulfilled'), true, 'expects the proxy to indicate that it is fulfilled');

    _emberMetalRun_loop.default(deferred, 'resolve', value);

    equal(didFulfillCount, 1, 'should still have been only fulfilled once');
    equal(didRejectCount, 0, 'should still not have been rejected');

    _emberMetalRun_loop.default(deferred, 'reject', value);

    equal(didFulfillCount, 1, 'should still have been only fulfilled once');
    equal(didRejectCount, 0, 'should still not have been rejected');

    equal(_emberMetalProperty_get.get(proxy, 'content'), value, 'expects the proxy to have still have same content');
    equal(_emberMetalProperty_get.get(proxy, 'reason'), undefined, 'expects the proxy still to have no reason');
    equal(_emberMetalProperty_get.get(proxy, 'isPending'), false, 'expects the proxy to indicate that it is no longer loading');
    equal(_emberMetalProperty_get.get(proxy, 'isSettled'), true, 'expects the proxy to indicate that it is settled');
    equal(_emberMetalProperty_get.get(proxy, 'isRejected'), false, 'expects the proxy to indicate that it is not rejected');
    equal(_emberMetalProperty_get.get(proxy, 'isFulfilled'), true, 'expects the proxy to indicate that it is fulfilled');

    // rest of the promise semantics are tested in directly in RSVP
  });

  QUnit.test('rejection', function () {
    var reason = new Error('failure');
    var deferred = _rsvp.defer();
    var proxy = ObjectPromiseProxy.create({
      promise: deferred.promise
    });

    var didFulfillCount = 0;
    var didRejectCount = 0;

    proxy.then(function () {
      didFulfillCount++;
    }, function () {
      didRejectCount++;
    });

    equal(_emberMetalProperty_get.get(proxy, 'content'), undefined, 'expects the proxy to have no content');
    equal(_emberMetalProperty_get.get(proxy, 'reason'), undefined, 'expects the proxy to have no reason');
    equal(_emberMetalProperty_get.get(proxy, 'isPending'), true, 'expects the proxy to indicate that it is loading');
    equal(_emberMetalProperty_get.get(proxy, 'isSettled'), false, 'expects the proxy to indicate that it is not settled');
    equal(_emberMetalProperty_get.get(proxy, 'isRejected'), false, 'expects the proxy to indicate that it is not rejected');
    equal(_emberMetalProperty_get.get(proxy, 'isFulfilled'), false, 'expects the proxy to indicate that it is not fulfilled');

    equal(didFulfillCount, 0, 'should not yet have been fulfilled');
    equal(didRejectCount, 0, 'should not yet have been rejected');

    _emberMetalRun_loop.default(deferred, 'reject', reason);

    equal(didFulfillCount, 0, 'should not yet have been fulfilled');
    equal(didRejectCount, 1, 'should have been rejected');

    equal(_emberMetalProperty_get.get(proxy, 'content'), undefined, 'expects the proxy to have no content');
    equal(_emberMetalProperty_get.get(proxy, 'reason'), reason, 'expects the proxy to have a reason');
    equal(_emberMetalProperty_get.get(proxy, 'isPending'), false, 'expects the proxy to indicate that it is not longer loading');
    equal(_emberMetalProperty_get.get(proxy, 'isSettled'), true, 'expects the proxy to indicate that it is settled');
    equal(_emberMetalProperty_get.get(proxy, 'isRejected'), true, 'expects the proxy to indicate that it is  rejected');
    equal(_emberMetalProperty_get.get(proxy, 'isFulfilled'), false, 'expects the proxy to indicate that it is not fulfilled');

    _emberMetalRun_loop.default(deferred, 'reject', reason);

    equal(didFulfillCount, 0, 'should stll not yet have been fulfilled');
    equal(didRejectCount, 1, 'should still remain rejected');

    _emberMetalRun_loop.default(deferred, 'resolve', 1);

    equal(didFulfillCount, 0, 'should stll not yet have been fulfilled');
    equal(didRejectCount, 1, 'should still remain rejected');

    equal(_emberMetalProperty_get.get(proxy, 'content'), undefined, 'expects the proxy to have no content');
    equal(_emberMetalProperty_get.get(proxy, 'reason'), reason, 'expects the proxy to have a reason');
    equal(_emberMetalProperty_get.get(proxy, 'isPending'), false, 'expects the proxy to indicate that it is not longer loading');
    equal(_emberMetalProperty_get.get(proxy, 'isSettled'), true, 'expects the proxy to indicate that it is settled');
    equal(_emberMetalProperty_get.get(proxy, 'isRejected'), true, 'expects the proxy to indicate that it is  rejected');
    equal(_emberMetalProperty_get.get(proxy, 'isFulfilled'), false, 'expects the proxy to indicate that it is not fulfilled');
  });

  QUnit.test('unhandled rejects still propagate to RSVP.on(\'error\', ...) ', function () {
    expect(1);

    _rsvp.on('error', onerror);
    _rsvp.off('error', _emberRuntimeExtRsvp.onerrorDefault);

    var expectedReason = new Error('failure');
    var deferred = _rsvp.defer();

    var proxy = ObjectPromiseProxy.create({
      promise: deferred.promise
    });

    proxy.get('promise');

    function onerror(reason) {
      equal(reason, expectedReason, 'expected reason');
    }

    _rsvp.on('error', onerror);
    _rsvp.off('error', _emberRuntimeExtRsvp.onerrorDefault);

    _emberMetalRun_loop.default(deferred, 'reject', expectedReason);

    _rsvp.on('error', _emberRuntimeExtRsvp.onerrorDefault);
    _rsvp.off('error', onerror);

    _emberMetalRun_loop.default(deferred, 'reject', expectedReason);

    _rsvp.on('error', _emberRuntimeExtRsvp.onerrorDefault);
    _rsvp.off('error', onerror);
  });

  QUnit.test('should work with promise inheritance', function () {
    function PromiseSubclass() {
      _rsvp.Promise.apply(this, arguments);
    }

    PromiseSubclass.prototype = Object.create(_rsvp.Promise.prototype);
    PromiseSubclass.prototype.constructor = PromiseSubclass;
    PromiseSubclass.cast = _rsvp.Promise.cast;

    var proxy = ObjectPromiseProxy.create({
      promise: new PromiseSubclass(function () {})
    });

    ok(proxy.then() instanceof PromiseSubclass, 'promise proxy respected inheritance');
  });

  QUnit.test('should reset isFulfilled and isRejected when promise is reset', function () {
    var deferred = _emberRuntimeExtRsvp.default.defer();

    var proxy = ObjectPromiseProxy.create({
      promise: deferred.promise
    });

    equal(_emberMetalProperty_get.get(proxy, 'isPending'), true, 'expects the proxy to indicate that it is loading');
    equal(_emberMetalProperty_get.get(proxy, 'isSettled'), false, 'expects the proxy to indicate that it is not settled');
    equal(_emberMetalProperty_get.get(proxy, 'isRejected'), false, 'expects the proxy to indicate that it is not rejected');
    equal(_emberMetalProperty_get.get(proxy, 'isFulfilled'), false, 'expects the proxy to indicate that it is not fulfilled');

    _emberMetalRun_loop.default(deferred, 'resolve');

    equal(_emberMetalProperty_get.get(proxy, 'isPending'), false, 'expects the proxy to indicate that it is no longer loading');
    equal(_emberMetalProperty_get.get(proxy, 'isSettled'), true, 'expects the proxy to indicate that it is settled');
    equal(_emberMetalProperty_get.get(proxy, 'isRejected'), false, 'expects the proxy to indicate that it is not rejected');
    equal(_emberMetalProperty_get.get(proxy, 'isFulfilled'), true, 'expects the proxy to indicate that it is fulfilled');

    var anotherDeferred = _emberRuntimeExtRsvp.default.defer();
    proxy.set('promise', anotherDeferred.promise);

    equal(_emberMetalProperty_get.get(proxy, 'isPending'), true, 'expects the proxy to indicate that it is loading');
    equal(_emberMetalProperty_get.get(proxy, 'isSettled'), false, 'expects the proxy to indicate that it is not settled');
    equal(_emberMetalProperty_get.get(proxy, 'isRejected'), false, 'expects the proxy to indicate that it is not rejected');
    equal(_emberMetalProperty_get.get(proxy, 'isFulfilled'), false, 'expects the proxy to indicate that it is not fulfilled');

    _emberMetalRun_loop.default(anotherDeferred, 'reject');

    equal(_emberMetalProperty_get.get(proxy, 'isPending'), false, 'expects the proxy to indicate that it is not longer loading');
    equal(_emberMetalProperty_get.get(proxy, 'isSettled'), true, 'expects the proxy to indicate that it is settled');
    equal(_emberMetalProperty_get.get(proxy, 'isRejected'), true, 'expects the proxy to indicate that it is  rejected');
    equal(_emberMetalProperty_get.get(proxy, 'isFulfilled'), false, 'expects the proxy to indicate that it is not fulfilled');
  });

  QUnit.test('should have content when isFulfilled is set', function () {
    var deferred = _emberRuntimeExtRsvp.default.defer();

    var proxy = ObjectPromiseProxy.create({
      promise: deferred.promise
    });

    proxy.addObserver('isFulfilled', function () {
      equal(_emberMetalProperty_get.get(proxy, 'content'), true);
    });

    _emberMetalRun_loop.default(deferred, 'resolve', true);
  });

  QUnit.test('should have reason when isRejected is set', function () {
    var error = new Error('Y U REJECT?!?');
    var deferred = _emberRuntimeExtRsvp.default.defer();

    var proxy = ObjectPromiseProxy.create({
      promise: deferred.promise
    });

    proxy.addObserver('isRejected', function () {
      equal(_emberMetalProperty_get.get(proxy, 'reason'), error);
    });

    try {
      _emberMetalRun_loop.default(deferred, 'reject', error);
    } catch (e) {
      equal(e, error);
    }
  });
});
enifed('ember-runtime/tests/mixins/promise_proxy_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/mixins');
  test('ember-runtime/tests/mixins/promise_proxy_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/mixins/promise_proxy_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/mixins/promise_proxy_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/mixins');
  QUnit.test('ember-runtime/tests/mixins/promise_proxy_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/mixins/promise_proxy_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/mixins/target_action_support_test', ['exports', 'ember-metal/core', 'ember-runtime/system/object', 'ember-runtime/mixins/target_action_support'], function (exports, _emberMetalCore, _emberRuntimeSystemObject, _emberRuntimeMixinsTarget_action_support) {
  'use strict';

  var originalLookup;

  QUnit.module('TargetActionSupport', {
    setup: function () {
      originalLookup = _emberMetalCore.default.lookup;
    },
    teardown: function () {
      _emberMetalCore.default.lookup = originalLookup;
    }
  });

  QUnit.test('it should return false if no target or action are specified', function () {
    expect(1);

    var obj = _emberRuntimeSystemObject.default.extend(_emberRuntimeMixinsTarget_action_support.default).create();

    ok(false === obj.triggerAction(), 'no target or action was specified');
  });

  QUnit.test('it should support actions specified as strings', function () {
    expect(2);

    var obj = _emberRuntimeSystemObject.default.extend(_emberRuntimeMixinsTarget_action_support.default).create({
      target: _emberRuntimeSystemObject.default.create({
        anEvent: function () {
          ok(true, 'anEvent method was called');
        }
      }),

      action: 'anEvent'
    });

    ok(true === obj.triggerAction(), 'a valid target and action were specified');
  });

  QUnit.test('it should invoke the send() method on objects that implement it', function () {
    expect(3);

    var obj = _emberRuntimeSystemObject.default.extend(_emberRuntimeMixinsTarget_action_support.default).create({
      target: _emberRuntimeSystemObject.default.create({
        send: function (evt, context) {
          equal(evt, 'anEvent', 'send() method was invoked with correct event name');
          equal(context, obj, 'send() method was invoked with correct context');
        }
      }),

      action: 'anEvent'
    });

    ok(true === obj.triggerAction(), 'a valid target and action were specified');
  });

  QUnit.test('it should find targets specified using a property path', function () {
    expect(2);

    var Test = {};
    _emberMetalCore.default.lookup = { Test: Test };

    Test.targetObj = _emberRuntimeSystemObject.default.create({
      anEvent: function () {
        ok(true, 'anEvent method was called on global object');
      }
    });

    var myObj = _emberRuntimeSystemObject.default.extend(_emberRuntimeMixinsTarget_action_support.default).create({
      target: 'Test.targetObj',
      action: 'anEvent'
    });

    ok(true === myObj.triggerAction(), 'a valid target and action were specified');
  });

  QUnit.test('it should use an actionContext object specified as a property on the object', function () {
    expect(2);
    var obj = _emberRuntimeSystemObject.default.extend(_emberRuntimeMixinsTarget_action_support.default).create({
      action: 'anEvent',
      actionContext: {},
      target: _emberRuntimeSystemObject.default.create({
        anEvent: function (ctx) {
          ok(obj.actionContext === ctx, 'anEvent method was called with the expected context');
        }
      })
    });
    ok(true === obj.triggerAction(), 'a valid target and action were specified');
  });

  QUnit.test('it should find an actionContext specified as a property path', function () {
    expect(2);

    var Test = {};
    _emberMetalCore.default.lookup = { Test: Test };
    Test.aContext = {};

    var obj = _emberRuntimeSystemObject.default.extend(_emberRuntimeMixinsTarget_action_support.default).create({
      action: 'anEvent',
      actionContext: 'Test.aContext',
      target: _emberRuntimeSystemObject.default.create({
        anEvent: function (ctx) {
          ok(Test.aContext === ctx, 'anEvent method was called with the expected context');
        }
      })
    });

    ok(true === obj.triggerAction(), 'a valid target and action were specified');
  });

  QUnit.test('it should use the target specified in the argument', function () {
    expect(2);
    var targetObj = _emberRuntimeSystemObject.default.create({
      anEvent: function () {
        ok(true, 'anEvent method was called');
      }
    });
    var obj = _emberRuntimeSystemObject.default.extend(_emberRuntimeMixinsTarget_action_support.default).create({
      action: 'anEvent'
    });

    ok(true === obj.triggerAction({ target: targetObj }), 'a valid target and action were specified');
  });

  QUnit.test('it should use the action specified in the argument', function () {
    expect(2);

    var obj = _emberRuntimeSystemObject.default.extend(_emberRuntimeMixinsTarget_action_support.default).create({
      target: _emberRuntimeSystemObject.default.create({
        anEvent: function () {
          ok(true, 'anEvent method was called');
        }
      })
    });
    ok(true === obj.triggerAction({ action: 'anEvent' }), 'a valid target and action were specified');
  });

  QUnit.test('it should use the actionContext specified in the argument', function () {
    expect(2);
    var context = {};
    var obj = _emberRuntimeSystemObject.default.extend(_emberRuntimeMixinsTarget_action_support.default).create({
      target: _emberRuntimeSystemObject.default.create({
        anEvent: function (ctx) {
          ok(context === ctx, 'anEvent method was called with the expected context');
        }
      }),
      action: 'anEvent'
    });

    ok(true === obj.triggerAction({ actionContext: context }), 'a valid target and action were specified');
  });

  QUnit.test('it should allow multiple arguments from actionContext', function () {
    expect(3);
    var param1 = 'someParam';
    var param2 = 'someOtherParam';
    var obj = _emberRuntimeSystemObject.default.extend(_emberRuntimeMixinsTarget_action_support.default).create({
      target: _emberRuntimeSystemObject.default.create({
        anEvent: function (first, second) {
          ok(first === param1, 'anEvent method was called with the expected first argument');
          ok(second === param2, 'anEvent method was called with the expected second argument');
        }
      }),
      action: 'anEvent'
    });

    ok(true === obj.triggerAction({ actionContext: [param1, param2] }), 'a valid target and action were specified');
  });

  QUnit.test('it should use a null value specified in the actionContext argument', function () {
    expect(2);
    var obj = _emberRuntimeSystemObject.default.extend(_emberRuntimeMixinsTarget_action_support.default).create({
      target: _emberRuntimeSystemObject.default.create({
        anEvent: function (ctx) {
          ok(null === ctx, 'anEvent method was called with the expected context (null)');
        }
      }),
      action: 'anEvent'
    });
    ok(true === obj.triggerAction({ actionContext: null }), 'a valid target and action were specified');
  });
});
enifed('ember-runtime/tests/mixins/target_action_support_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/mixins');
  test('ember-runtime/tests/mixins/target_action_support_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/mixins/target_action_support_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/mixins/target_action_support_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/mixins');
  QUnit.test('ember-runtime/tests/mixins/target_action_support_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/mixins/target_action_support_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/array', ['exports', 'ember-runtime/tests/suites/enumerable', 'ember-runtime/tests/suites/array/indexOf', 'ember-runtime/tests/suites/array/lastIndexOf', 'ember-runtime/tests/suites/array/objectAt'], function (exports, _emberRuntimeTestsSuitesEnumerable, _emberRuntimeTestsSuitesArrayIndexOf, _emberRuntimeTestsSuitesArrayLastIndexOf, _emberRuntimeTestsSuitesArrayObjectAt) {
  'use strict';

  var ObserverClass = _emberRuntimeTestsSuitesEnumerable.ObserverClass.extend({

    observeArray: function (obj) {
      obj.addArrayObserver(this);
      return this;
    },

    stopObserveArray: function (obj) {
      obj.removeArrayObserver(this);
      return this;
    },

    arrayWillChange: function () {
      equal(this._before, null, 'should only call once');
      this._before = Array.prototype.slice.call(arguments);
    },

    arrayDidChange: function () {
      equal(this._after, null, 'should only call once');
      this._after = Array.prototype.slice.call(arguments);
    }

  });

  var ArrayTests = _emberRuntimeTestsSuitesEnumerable.EnumerableTests.extend({

    observerClass: ObserverClass

  });

  ArrayTests.ObserverClass = ObserverClass;

  ArrayTests.importModuleTests(_emberRuntimeTestsSuitesArrayIndexOf.default);
  ArrayTests.importModuleTests(_emberRuntimeTestsSuitesArrayLastIndexOf.default);
  ArrayTests.importModuleTests(_emberRuntimeTestsSuitesArrayObjectAt.default);

  exports.ArrayTests = ArrayTests;
  exports.ObserverClass = ObserverClass;
});
enifed('ember-runtime/tests/suites/array.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites');
  test('ember-runtime/tests/suites/array.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/array.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/array.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites');
  QUnit.test('ember-runtime/tests/suites/array.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/array.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/array/indexOf', ['exports', 'ember-runtime/tests/suites/suite'], function (exports, _emberRuntimeTestsSuitesSuite) {
  'use strict';

  var suite = _emberRuntimeTestsSuitesSuite.SuiteModuleBuilder.create();

  suite.module('indexOf');

  suite.test('should return index of object', function () {
    var expected = this.newFixture(3);
    var obj = this.newObject(expected);
    var len = 3;
    var idx;

    for (idx = 0; idx < len; idx++) {
      equal(obj.indexOf(expected[idx]), idx, 'obj.indexOf(' + expected[idx] + ') should match idx');
    }
  });

  suite.test('should return -1 when requesting object not in index', function () {
    var obj = this.newObject(this.newFixture(3));
    var foo = {};

    equal(obj.indexOf(foo), -1, 'obj.indexOf(foo) should be < 0');
  });

  exports.default = suite;
});
enifed('ember-runtime/tests/suites/array/indexOf.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites/array');
  test('ember-runtime/tests/suites/array/indexOf.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/array/indexOf.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/array/indexOf.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites/array');
  QUnit.test('ember-runtime/tests/suites/array/indexOf.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/array/indexOf.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/array/lastIndexOf', ['exports', 'ember-runtime/tests/suites/suite'], function (exports, _emberRuntimeTestsSuitesSuite) {
  'use strict';

  var suite = _emberRuntimeTestsSuitesSuite.SuiteModuleBuilder.create();

  suite.module('lastIndexOf');

  suite.test('should return index of object\'s last occurrence', function () {
    var expected = this.newFixture(3);
    var obj = this.newObject(expected);
    var len = 3;
    var idx;

    for (idx = 0; idx < len; idx++) {
      equal(obj.lastIndexOf(expected[idx]), idx, 'obj.lastIndexOf(' + expected[idx] + ') should match idx');
    }
  });

  suite.test('should return index of object\'s last occurrence even startAt search location is equal to length', function () {
    var expected = this.newFixture(3);
    var obj = this.newObject(expected);
    var len = 3;
    var idx;

    for (idx = 0; idx < len; idx++) {
      equal(obj.lastIndexOf(expected[idx], len), idx, 'obj.lastIndexOfs(' + expected[idx] + ') should match idx');
    }
  });

  suite.test('should return index of object\'s last occurrence even startAt search location is greater than length', function () {
    var expected = this.newFixture(3);
    var obj = this.newObject(expected);
    var len = 3;
    var idx;

    for (idx = 0; idx < len; idx++) {
      equal(obj.lastIndexOf(expected[idx], len + 1), idx, 'obj.lastIndexOf(' + expected[idx] + ') should match idx');
    }
  });

  suite.test('should return -1 when no match is found', function () {
    var obj = this.newObject(this.newFixture(3));
    var foo = {};

    equal(obj.lastIndexOf(foo), -1, 'obj.lastIndexOf(foo) should be -1');
  });

  suite.test('should return -1 when no match is found even startAt search location is equal to length', function () {
    var obj = this.newObject(this.newFixture(3));
    var foo = {};

    equal(obj.lastIndexOf(foo, obj.length), -1, 'obj.lastIndexOf(foo) should be -1');
  });

  suite.test('should return -1 when no match is found even startAt search location is greater than length', function () {
    var obj = this.newObject(this.newFixture(3));
    var foo = {};

    equal(obj.lastIndexOf(foo, obj.length + 1), -1, 'obj.lastIndexOf(foo) should be -1');
  });

  exports.default = suite;
});
enifed('ember-runtime/tests/suites/array/lastIndexOf.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites/array');
  test('ember-runtime/tests/suites/array/lastIndexOf.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/array/lastIndexOf.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/array/lastIndexOf.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites/array');
  QUnit.test('ember-runtime/tests/suites/array/lastIndexOf.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/array/lastIndexOf.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/array/objectAt', ['exports', 'ember-runtime/tests/suites/suite'], function (exports, _emberRuntimeTestsSuitesSuite) {
  'use strict';

  var suite = _emberRuntimeTestsSuitesSuite.SuiteModuleBuilder.create();

  suite.module('objectAt');

  suite.test('should return object at specified index', function () {
    var expected = this.newFixture(3);
    var obj = this.newObject(expected);
    var len = expected.length;
    var idx;

    for (idx = 0; idx < len; idx++) {
      equal(obj.objectAt(idx), expected[idx], 'obj.objectAt(' + idx + ') should match');
    }
  });

  suite.test('should return undefined when requesting objects beyond index', function () {
    var obj;

    obj = this.newObject(this.newFixture(3));
    equal(obj.objectAt(5), undefined, 'should return undefined for obj.objectAt(5) when len = 3');

    obj = this.newObject([]);
    equal(obj.objectAt(0), undefined, 'should return undefined for obj.objectAt(0) when len = 0');
  });

  exports.default = suite;
});
enifed('ember-runtime/tests/suites/array/objectAt.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites/array');
  test('ember-runtime/tests/suites/array/objectAt.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/array/objectAt.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/array/objectAt.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites/array');
  QUnit.test('ember-runtime/tests/suites/array/objectAt.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/array/objectAt.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/copyable', ['exports', 'ember-runtime/tests/suites/suite', 'ember-runtime/tests/suites/copyable/copy', 'ember-runtime/tests/suites/copyable/frozenCopy'], function (exports, _emberRuntimeTestsSuitesSuite, _emberRuntimeTestsSuitesCopyableCopy, _emberRuntimeTestsSuitesCopyableFrozenCopy) {
  'use strict';

  var CopyableTests = _emberRuntimeTestsSuitesSuite.Suite.extend({

    /*
      __Required.__ You must implement this method to apply this mixin.
       Must be able to create a new object for testing.
       @returns {Object} object
    */
    newObject: null,

    /*
      __Required.__ You must implement this method to apply this mixin.
       Compares the two passed in objects.  Returns true if the two objects
      are logically equivalent.
       @param {Object} a
        First object
       @param {Object} b
        Second object
       @returns {Boolean}
    */
    isEqual: null,

    /*
      Set this to true if you expect the objects you test to be freezable.
      The suite will verify that your objects actually match this.  (i.e. if
      you say you can't test freezable it will verify that your objects really
      aren't freezable.)
       @type Boolean
    */
    shouldBeFreezable: false

  });

  CopyableTests.importModuleTests(_emberRuntimeTestsSuitesCopyableCopy.default);
  CopyableTests.importModuleTests(_emberRuntimeTestsSuitesCopyableFrozenCopy.default);

  exports.default = CopyableTests;
});
enifed('ember-runtime/tests/suites/copyable.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites');
  test('ember-runtime/tests/suites/copyable.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/copyable.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/copyable.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites');
  QUnit.test('ember-runtime/tests/suites/copyable.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/copyable.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/copyable/copy', ['exports', 'ember-runtime/tests/suites/suite'], function (exports, _emberRuntimeTestsSuitesSuite) {
  'use strict';

  var suite = _emberRuntimeTestsSuitesSuite.SuiteModuleBuilder.create();

  suite.module('copy');

  suite.test('should return an equivalent copy', function () {
    var obj = this.newObject();
    var copy = obj.copy();
    ok(this.isEqual(obj, copy), 'old object and new object should be equivalent');
  });

  exports.default = suite;
});
enifed('ember-runtime/tests/suites/copyable/copy.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites/copyable');
  test('ember-runtime/tests/suites/copyable/copy.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/copyable/copy.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/copyable/copy.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites/copyable');
  QUnit.test('ember-runtime/tests/suites/copyable/copy.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/copyable/copy.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/copyable/frozenCopy', ['exports', 'ember-runtime/tests/suites/suite', 'ember-runtime/mixins/freezable', 'ember-metal/property_get'], function (exports, _emberRuntimeTestsSuitesSuite, _emberRuntimeMixinsFreezable, _emberMetalProperty_get) {
  'use strict';

  var suite = _emberRuntimeTestsSuitesSuite.SuiteModuleBuilder.create();

  suite.module('frozenCopy');

  suite.test('frozen objects should return same instance', function () {
    var obj, copy;

    obj = this.newObject();
    if (_emberMetalProperty_get.get(this, 'shouldBeFreezable')) {
      expectDeprecation('`frozenCopy` is deprecated, use Object.freeze instead.');

      ok(!_emberRuntimeMixinsFreezable.Freezable || _emberRuntimeMixinsFreezable.Freezable.detect(obj), 'object should be freezable');

      copy = obj.frozenCopy();
      ok(this.isEqual(obj, copy), 'new copy should be equal');
      ok(_emberMetalProperty_get.get(copy, 'isFrozen'), 'returned value should be frozen');

      copy = obj.freeze().frozenCopy();
      equal(copy, obj, 'returns frozen object should be same');
      ok(_emberMetalProperty_get.get(copy, 'isFrozen'), 'returned object should be frozen');
    } else {
      ok(!_emberRuntimeMixinsFreezable.Freezable || !_emberRuntimeMixinsFreezable.Freezable.detect(obj), 'object should not be freezable');
    }
  });

  exports.default = suite;
});
enifed('ember-runtime/tests/suites/copyable/frozenCopy.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites/copyable');
  test('ember-runtime/tests/suites/copyable/frozenCopy.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/copyable/frozenCopy.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/copyable/frozenCopy.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites/copyable');
  QUnit.test('ember-runtime/tests/suites/copyable/frozenCopy.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/copyable/frozenCopy.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/enumerable', ['exports', 'ember-runtime/tests/suites/suite', 'ember-runtime/system/object', 'ember-metal/utils', 'ember-metal/computed', 'ember-metal/property_get', 'ember-metal/observer', 'ember-runtime/tests/suites/enumerable/any', 'ember-runtime/tests/suites/enumerable/is_any', 'ember-runtime/tests/suites/enumerable/compact', 'ember-runtime/tests/suites/enumerable/contains', 'ember-runtime/tests/suites/enumerable/every', 'ember-runtime/tests/suites/enumerable/filter', 'ember-runtime/tests/suites/enumerable/find', 'ember-runtime/tests/suites/enumerable/firstObject', 'ember-runtime/tests/suites/enumerable/forEach', 'ember-runtime/tests/suites/enumerable/mapBy', 'ember-runtime/tests/suites/enumerable/invoke', 'ember-runtime/tests/suites/enumerable/lastObject', 'ember-runtime/tests/suites/enumerable/map', 'ember-runtime/tests/suites/enumerable/reduce', 'ember-runtime/tests/suites/enumerable/reject', 'ember-runtime/tests/suites/enumerable/sortBy', 'ember-runtime/tests/suites/enumerable/toArray', 'ember-runtime/tests/suites/enumerable/uniq', 'ember-runtime/tests/suites/enumerable/without'], function (exports, _emberRuntimeTestsSuitesSuite, _emberRuntimeSystemObject, _emberMetalUtils, _emberMetalComputed, _emberMetalProperty_get, _emberMetalObserver, _emberRuntimeTestsSuitesEnumerableAny, _emberRuntimeTestsSuitesEnumerableIs_any, _emberRuntimeTestsSuitesEnumerableCompact, _emberRuntimeTestsSuitesEnumerableContains, _emberRuntimeTestsSuitesEnumerableEvery, _emberRuntimeTestsSuitesEnumerableFilter, _emberRuntimeTestsSuitesEnumerableFind, _emberRuntimeTestsSuitesEnumerableFirstObject, _emberRuntimeTestsSuitesEnumerableForEach, _emberRuntimeTestsSuitesEnumerableMapBy, _emberRuntimeTestsSuitesEnumerableInvoke, _emberRuntimeTestsSuitesEnumerableLastObject, _emberRuntimeTestsSuitesEnumerableMap, _emberRuntimeTestsSuitesEnumerableReduce, _emberRuntimeTestsSuitesEnumerableReject, _emberRuntimeTestsSuitesEnumerableSortBy, _emberRuntimeTestsSuitesEnumerableToArray, _emberRuntimeTestsSuitesEnumerableUniq, _emberRuntimeTestsSuitesEnumerableWithout) {
  'use strict';

  var ObserverClass = _emberRuntimeSystemObject.default.extend({

    _keysBefore: null,
    _keys: null,
    _values: null,
    _before: null,
    _after: null,

    isEnabled: true,

    init: function () {
      this._super.apply(this, arguments);
      this.reset();
    },

    propertyWillChange: function (target, key) {
      if (this._keysBefore[key] === undefined) {
        this._keysBefore[key] = 0;
      }
      this._keysBefore[key]++;
    },

    /*
      Invoked when the property changes.  Just records the parameters for
      later analysis.
    */
    propertyDidChange: function (target, key, value) {
      if (this._keys[key] === undefined) {
        this._keys[key] = 0;
      }
      this._keys[key]++;
      this._values[key] = value;
    },

    /*
      Resets the recorded results for another run.
       @returns {Object} receiver
    */
    reset: function () {
      this._keysBefore = {};
      this._keys = {};
      this._values = {};
      this._before = null;
      this._after = null;
      return this;
    },

    observeBefore: function (obj) {
      var keys = Array.prototype.slice.call(arguments, 1);
      var loc = keys.length;
      while (--loc >= 0) {
        _emberMetalObserver._addBeforeObserver(obj, keys[loc], this, 'propertyWillChange');
      }

      return this;
    },

    /*
      Begins observing the passed key names on the passed object.  Any changes
      on the named properties will be recorded.
       @param {Ember.Enumerable} obj
        The enumerable to observe.
       @returns {Object} receiver
    */
    observe: function (obj) {
      if (obj.addObserver) {
        var keys = Array.prototype.slice.call(arguments, 1);
        var loc = keys.length;

        while (--loc >= 0) {
          obj.addObserver(keys[loc], this, 'propertyDidChange');
        }
      } else {
        this.isEnabled = false;
      }
      return this;
    },

    /*
      Returns true if the passed key was invoked.  If you pass a value as
      well then validates that the values match.
       @param {String} key
        Key to validate
       @param {Object} value
        (Optional) value
       @returns {Boolean}
    */
    validate: function (key, value) {
      if (!this.isEnabled) {
        return true;
      }

      if (!this._keys[key]) {
        return false;
      }

      if (arguments.length > 1) {
        return this._values[key] === value;
      } else {
        return true;
      }
    },

    /*
      Returns times the before observer as invoked.
       @param {String} key
        Key to check
    */
    timesCalledBefore: function (key) {
      return this._keysBefore[key] || 0;
    },

    /*
      Returns times the observer as invoked.
       @param {String} key
        Key to check
    */
    timesCalled: function (key) {
      return this._keys[key] || 0;
    },

    /*
      begins acting as an enumerable observer.
    */
    observeEnumerable: function (obj) {
      obj.addEnumerableObserver(this);
      return this;
    },

    stopObserveEnumerable: function (obj) {
      obj.removeEnumerableObserver(this);
      return this;
    },

    enumerableWillChange: function () {
      equal(this._before, null, 'should only call once');
      this._before = Array.prototype.slice.call(arguments);
    },

    enumerableDidChange: function () {
      equal(this._after, null, 'should only call once');
      this._after = Array.prototype.slice.call(arguments);
    }

  });

  var EnumerableTests = _emberRuntimeTestsSuitesSuite.Suite.extend({
    /*
      __Required.__ You must implement this method to apply this mixin.
       Implement to return a new enumerable object for testing.  Should accept
      either no parameters, a single number (indicating the desired length of
      the collection) or an array of objects.
       @param {Array} content
        An array of items to include in the enumerable optionally.
       @returns {Ember.Enumerable} a new enumerable
    */
    newObject: null,

    /*
      Implement to return a set of new fixture strings that can be applied to
      the enumerable.  This may be passed into the newObject method.
       @param {Number} count
        The number of items required.
       @returns {Array} array of strings
    */
    newFixture: function (cnt) {
      var ret = [];
      while (--cnt >= 0) {
        ret.push(_emberMetalUtils.generateGuid());
      }

      return ret;
    },

    /*
      Implement to return a set of new fixture objects that can be applied to
      the enumerable.  This may be passed into the newObject method.
       @param {Number} cnt
        The number of items required.
       @returns {Array} array of objects
    */
    newObjectsFixture: function (cnt) {
      var ret = [];
      var item;
      while (--cnt >= 0) {
        item = {};
        _emberMetalUtils.guidFor(item);
        ret.push(item);
      }
      return ret;
    },

    /*
      __Required.__ You must implement this method to apply this mixin.
       Implement accept an instance of the enumerable and return an array
      containing the objects in the enumerable.  This is used only for testing
      so performance is not important.
       @param {Ember.Enumerable} enumerable
        The enumerable to convert.
       @returns {Array} array of items
    */
    toArray: null,

    /*
      Implement this method if your object can mutate internally (even if it
      does not support the MutableEnumerable API).  The method should accept
      an object of your desired type and modify it somehow.  Suite tests will
      use this to ensure that all appropriate caches, etc. clear when the
      mutation occurs.
       If you do not define this optional method, then mutation-related tests
      will be skipped.
       @param {Ember.Enumerable} enumerable
        The enumerable to mutate
       @returns {void}
    */
    mutate: function () {},

    /*
      Becomes true when you define a new mutate() method, indicating that
      mutation tests should run.  This is calculated automatically.
       @type Boolean
    */
    canTestMutation: _emberMetalComputed.computed(function () {
      return this.mutate !== EnumerableTests.prototype.mutate;
    }),

    /*
      Invoked to actually run the test - overridden by mixins
    */
    run: function () {},

    /*
      Creates a new observer object for testing.  You can add this object as an
      observer on an array and it will record results anytime it is invoked.
      After running the test, call the validate() method on the observer to
      validate the results.
    */
    newObserver: function (obj) {
      var ret = _emberMetalProperty_get.get(this, 'observerClass').create();
      if (arguments.length > 0) {
        ret.observeBefore.apply(ret, arguments);
      }

      if (arguments.length > 0) {
        ret.observe.apply(ret, arguments);
      }

      return ret;
    },

    observerClass: ObserverClass
  });

  EnumerableTests.importModuleTests(_emberRuntimeTestsSuitesEnumerableAny.default);
  EnumerableTests.importModuleTests(_emberRuntimeTestsSuitesEnumerableIs_any.default);
  EnumerableTests.importModuleTests(_emberRuntimeTestsSuitesEnumerableCompact.default);
  EnumerableTests.importModuleTests(_emberRuntimeTestsSuitesEnumerableContains.default);
  EnumerableTests.importModuleTests(_emberRuntimeTestsSuitesEnumerableEvery.default);
  EnumerableTests.importModuleTests(_emberRuntimeTestsSuitesEnumerableFilter.default);
  EnumerableTests.importModuleTests(_emberRuntimeTestsSuitesEnumerableFind.default);
  EnumerableTests.importModuleTests(_emberRuntimeTestsSuitesEnumerableFirstObject.default);
  EnumerableTests.importModuleTests(_emberRuntimeTestsSuitesEnumerableForEach.default);
  EnumerableTests.importModuleTests(_emberRuntimeTestsSuitesEnumerableMapBy.default);
  EnumerableTests.importModuleTests(_emberRuntimeTestsSuitesEnumerableInvoke.default);
  EnumerableTests.importModuleTests(_emberRuntimeTestsSuitesEnumerableLastObject.default);
  EnumerableTests.importModuleTests(_emberRuntimeTestsSuitesEnumerableMap.default);
  EnumerableTests.importModuleTests(_emberRuntimeTestsSuitesEnumerableReduce.default);
  EnumerableTests.importModuleTests(_emberRuntimeTestsSuitesEnumerableReject.default);
  EnumerableTests.importModuleTests(_emberRuntimeTestsSuitesEnumerableSortBy.default);
  EnumerableTests.importModuleTests(_emberRuntimeTestsSuitesEnumerableToArray.default);
  EnumerableTests.importModuleTests(_emberRuntimeTestsSuitesEnumerableUniq.default);
  EnumerableTests.importModuleTests(_emberRuntimeTestsSuitesEnumerableWithout.default);

  exports.default = EnumerableTests;
  exports.EnumerableTests = EnumerableTests;
  exports.ObserverClass = ObserverClass;
});
enifed('ember-runtime/tests/suites/enumerable.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites');
  test('ember-runtime/tests/suites/enumerable.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/enumerable.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/enumerable.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites');
  QUnit.test('ember-runtime/tests/suites/enumerable.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/enumerable.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/enumerable/any', ['exports', 'ember-metal/core', 'ember-runtime/tests/suites/suite'], function (exports, _emberMetalCore, _emberRuntimeTestsSuitesSuite) {
  'use strict';

  var suite = _emberRuntimeTestsSuitesSuite.SuiteModuleBuilder.create();

  // ..........................................................
  // any()
  //

  suite.module('any');

  suite.test('any should should invoke callback on each item as long as you return false', function () {
    var obj = this.newObject();
    var ary = this.toArray(obj);
    var found = [];
    var result;

    result = obj.any(function (i) {
      found.push(i);
      return false;
    });
    equal(result, false, 'return value of obj.any');
    deepEqual(found, ary, 'items passed during any() should match');
  });

  suite.test('any should stop invoking when you return true', function () {
    var obj = this.newObject();
    var ary = this.toArray(obj);
    var cnt = ary.length - 2;
    var exp = cnt;
    var found = [];
    var result;

    result = obj.any(function (i) {
      found.push(i);
      return --cnt <= 0;
    });
    equal(result, true, 'return value of obj.any');
    equal(found.length, exp, 'should invoke proper number of times');
    deepEqual(found, ary.slice(0, -2), 'items passed during any() should match');
  });

  suite.test('any should return true if any object matches the callback', function () {
    var obj = _emberMetalCore.default.A([0, 1, 2]);
    var result;

    result = obj.any(function (i) {
      return !!i;
    });
    equal(result, true, 'return value of obj.any');
  });

  suite.test('any should return false if no object matches the callback', function () {
    var obj = _emberMetalCore.default.A([0, null, false]);
    var result;

    result = obj.any(function (i) {
      return !!i;
    });
    equal(result, false, 'return value of obj.any');
  });

  suite.test('any should produce correct results even if the matching element is undefined', function () {
    var obj = _emberMetalCore.default.A([undefined]);
    var result;

    result = obj.any(function (i) {
      return true;
    });
    equal(result, true, 'return value of obj.any');
  });

  exports.default = suite;
});
enifed('ember-runtime/tests/suites/enumerable/any.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites/enumerable');
  test('ember-runtime/tests/suites/enumerable/any.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/enumerable/any.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/enumerable/any.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites/enumerable');
  QUnit.test('ember-runtime/tests/suites/enumerable/any.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/enumerable/any.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/enumerable/compact', ['exports', 'ember-runtime/tests/suites/suite'], function (exports, _emberRuntimeTestsSuitesSuite) {
  'use strict';

  var suite = _emberRuntimeTestsSuitesSuite.SuiteModuleBuilder.create();

  suite.module('compact');

  suite.test('removes null and undefined values from enumerable', function () {
    var obj = this.newObject([null, 1, false, '', undefined, 0, null]);
    var ary = obj.compact();
    deepEqual(ary, [1, false, '', 0]);
  });

  exports.default = suite;
});
enifed('ember-runtime/tests/suites/enumerable/compact.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites/enumerable');
  test('ember-runtime/tests/suites/enumerable/compact.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/enumerable/compact.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/enumerable/compact.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites/enumerable');
  QUnit.test('ember-runtime/tests/suites/enumerable/compact.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/enumerable/compact.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/enumerable/contains', ['exports', 'ember-runtime/tests/suites/suite'], function (exports, _emberRuntimeTestsSuitesSuite) {
  'use strict';

  var suite = _emberRuntimeTestsSuitesSuite.SuiteModuleBuilder.create();

  suite.module('contains');

  suite.test('contains returns true if items is in enumerable', function () {
    var data = this.newFixture(3);
    var obj = this.newObject(data);
    equal(obj.contains(data[1]), true, 'should return true if contained');
  });

  suite.test('contains returns false if item is not in enumerable', function () {
    var data = this.newFixture(1);
    var obj = this.newObject(this.newFixture(3));
    equal(obj.contains(data[0]), false, 'should return false if not contained');
  });

  exports.default = suite;
});
enifed('ember-runtime/tests/suites/enumerable/contains.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites/enumerable');
  test('ember-runtime/tests/suites/enumerable/contains.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/enumerable/contains.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/enumerable/contains.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites/enumerable');
  QUnit.test('ember-runtime/tests/suites/enumerable/contains.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/enumerable/contains.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/enumerable/every', ['exports', 'ember-runtime/system/object', 'ember-runtime/tests/suites/suite'], function (exports, _emberRuntimeSystemObject, _emberRuntimeTestsSuitesSuite) {
  'use strict';

  var suite = _emberRuntimeTestsSuitesSuite.SuiteModuleBuilder.create();

  // ..........................................................
  // every()
  //

  suite.module('every');

  suite.test('every should should invoke callback on each item as long as you return true', function () {
    var obj = this.newObject();
    var ary = this.toArray(obj);
    var found = [];
    var result;

    result = obj.every(function (i) {
      found.push(i);
      return true;
    });
    equal(result, true, 'return value of obj.every');
    deepEqual(found, ary, 'items passed during every() should match');
  });

  suite.test('every should stop invoking when you return false', function () {
    var obj = this.newObject();
    var ary = this.toArray(obj);
    var cnt = ary.length - 2;
    var exp = cnt;
    var found = [];
    var result;

    result = obj.every(function (i) {
      found.push(i);
      return --cnt > 0;
    });
    equal(result, false, 'return value of obj.every');
    equal(found.length, exp, 'should invoke proper number of times');
    deepEqual(found, ary.slice(0, -2), 'items passed during every() should match');
  });

  // ..........................................................
  // isEvery()
  //

  suite.module('isEvery');

  suite.test('should return true of every property matches', function () {
    var obj = this.newObject([{ foo: 'foo', bar: 'BAZ' }, _emberRuntimeSystemObject.default.create({ foo: 'foo', bar: 'bar' })]);

    equal(obj.isEvery('foo', 'foo'), true, 'isEvery(foo)');
    equal(obj.isEvery('bar', 'bar'), false, 'isEvery(bar)');
  });

  suite.test('should return true of every property is true', function () {
    var obj = this.newObject([{ foo: 'foo', bar: true }, _emberRuntimeSystemObject.default.create({ foo: 'bar', bar: false })]);

    // different values - all eval to true
    equal(obj.isEvery('foo'), true, 'isEvery(foo)');
    equal(obj.isEvery('bar'), false, 'isEvery(bar)');
  });

  suite.test('should return true if every property matches null', function () {
    var obj = this.newObject([{ foo: null, bar: 'BAZ' }, _emberRuntimeSystemObject.default.create({ foo: null, bar: null })]);

    equal(obj.isEvery('foo', null), true, 'isEvery(\'foo\', null)');
    equal(obj.isEvery('bar', null), false, 'isEvery(\'bar\', null)');
  });

  suite.test('should return true if every property is undefined', function () {
    var obj = this.newObject([{ foo: undefined, bar: 'BAZ' }, _emberRuntimeSystemObject.default.create({ bar: undefined })]);

    equal(obj.isEvery('foo', undefined), true, 'isEvery(\'foo\', undefined)');
    equal(obj.isEvery('bar', undefined), false, 'isEvery(\'bar\', undefined)');
  });

  exports.default = suite;
});
enifed('ember-runtime/tests/suites/enumerable/every.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites/enumerable');
  test('ember-runtime/tests/suites/enumerable/every.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/enumerable/every.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/enumerable/every.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites/enumerable');
  QUnit.test('ember-runtime/tests/suites/enumerable/every.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/enumerable/every.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/enumerable/filter', ['exports', 'ember-runtime/system/object', 'ember-runtime/tests/suites/suite'], function (exports, _emberRuntimeSystemObject, _emberRuntimeTestsSuitesSuite) {
  'use strict';

  var suite = _emberRuntimeTestsSuitesSuite.SuiteModuleBuilder.create();

  // ..........................................................
  // filter()
  //

  suite.module('filter');

  suite.test('filter should invoke on each item', function () {
    var obj = this.newObject();
    var ary = this.toArray(obj);
    var cnt = ary.length - 2;
    var found = [];
    var result;

    // return true on all but the last two
    result = obj.filter(function (i) {
      found.push(i);
      return --cnt >= 0;
    });
    deepEqual(found, ary, 'should have invoked on each item');
    deepEqual(result, ary.slice(0, -2), 'filtered array should exclude items');
  });

  // ..........................................................
  // filterBy()
  //

  suite.module('filterBy');

  suite.test('should filter based on object', function () {
    var obj, ary;

    ary = [{ foo: 'foo', bar: 'BAZ' }, _emberRuntimeSystemObject.default.create({ foo: 'foo', bar: 'bar' })];

    obj = this.newObject(ary);

    deepEqual(obj.filterBy('foo', 'foo'), ary, 'filterBy(foo)');
    deepEqual(obj.filterBy('bar', 'bar'), [ary[1]], 'filterBy(bar)');
  });

  suite.test('should include in result if property is true', function () {
    var obj, ary;

    ary = [{ foo: 'foo', bar: true }, _emberRuntimeSystemObject.default.create({ foo: 'bar', bar: false })];

    obj = this.newObject(ary);

    // different values - all eval to true
    deepEqual(obj.filterBy('foo'), ary, 'filterBy(foo)');
    deepEqual(obj.filterBy('bar'), [ary[0]], 'filterBy(bar)');
  });

  suite.test('should filter on second argument if provided', function () {
    var obj, ary;

    ary = [{ name: 'obj1', foo: 3 }, _emberRuntimeSystemObject.default.create({ name: 'obj2', foo: 2 }), { name: 'obj3', foo: 2 }, _emberRuntimeSystemObject.default.create({ name: 'obj4', foo: 3 })];

    obj = this.newObject(ary);

    deepEqual(obj.filterBy('foo', 3), [ary[0], ary[3]], 'filterBy(\'foo\', 3)\')');
  });

  suite.test('should correctly filter null second argument', function () {
    var obj, ary;

    ary = [{ name: 'obj1', foo: 3 }, _emberRuntimeSystemObject.default.create({ name: 'obj2', foo: null }), { name: 'obj3', foo: null }, _emberRuntimeSystemObject.default.create({ name: 'obj4', foo: 3 })];

    obj = this.newObject(ary);

    deepEqual(obj.filterBy('foo', null), [ary[1], ary[2]], 'filterBy(\'foo\', 3)\')');
  });

  suite.test('should not return all objects on undefined second argument', function () {
    var obj, ary;

    ary = [{ name: 'obj1', foo: 3 }, _emberRuntimeSystemObject.default.create({ name: 'obj2', foo: 2 })];

    obj = this.newObject(ary);

    deepEqual(obj.filterBy('foo', undefined), [], 'filterBy(\'foo\', 3)\')');
  });

  suite.test('should correctly filter explicit undefined second argument', function () {
    var obj, ary;

    ary = [{ name: 'obj1', foo: 3 }, _emberRuntimeSystemObject.default.create({ name: 'obj2', foo: 3 }), { name: 'obj3', foo: undefined }, _emberRuntimeSystemObject.default.create({ name: 'obj4', foo: undefined }), { name: 'obj5' }, _emberRuntimeSystemObject.default.create({ name: 'obj6' })];

    obj = this.newObject(ary);

    deepEqual(obj.filterBy('foo', undefined), ary.slice(2), 'filterBy(\'foo\', 3)\')');
  });

  suite.test('should not match undefined properties without second argument', function () {
    var obj, ary;

    ary = [{ name: 'obj1', foo: 3 }, _emberRuntimeSystemObject.default.create({ name: 'obj2', foo: 3 }), { name: 'obj3', foo: undefined }, _emberRuntimeSystemObject.default.create({ name: 'obj4', foo: undefined }), { name: 'obj5' }, _emberRuntimeSystemObject.default.create({ name: 'obj6' })];

    obj = this.newObject(ary);

    deepEqual(obj.filterBy('foo'), ary.slice(0, 2), 'filterBy(\'foo\', 3)\')');
  });

  exports.default = suite;
});
enifed('ember-runtime/tests/suites/enumerable/filter.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites/enumerable');
  test('ember-runtime/tests/suites/enumerable/filter.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/enumerable/filter.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/enumerable/filter.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites/enumerable');
  QUnit.test('ember-runtime/tests/suites/enumerable/filter.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/enumerable/filter.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/enumerable/find', ['exports', 'ember-runtime/system/object', 'ember-runtime/tests/suites/suite'], function (exports, _emberRuntimeSystemObject, _emberRuntimeTestsSuitesSuite) {
  'use strict';

  var suite = _emberRuntimeTestsSuitesSuite.SuiteModuleBuilder.create();
  // ..........................................................
  // find()
  //

  suite.module('find');

  suite.test('find should invoke callback on each item as long as you return false', function () {
    var obj = this.newObject();
    var ary = this.toArray(obj);
    var found = [];
    var result;

    result = obj.find(function (i) {
      found.push(i);
      return false;
    });
    equal(result, undefined, 'return value of obj.find');
    deepEqual(found, ary, 'items passed during find() should match');
  });

  suite.test('every should stop invoking when you return true', function () {
    var obj = this.newObject();
    var ary = this.toArray(obj);
    var cnt = ary.length - 2;
    var exp = cnt;
    var found = [];
    var result;

    result = obj.find(function (i) {
      found.push(i);
      return --cnt >= 0;
    });
    equal(result, ary[exp - 1], 'return value of obj.find');
    equal(found.length, exp, 'should invoke proper number of times');
    deepEqual(found, ary.slice(0, -2), 'items passed during find() should match');
  });

  // ..........................................................
  // findBy()
  //

  suite.module('findBy');

  suite.test('should return first object of property matches', function () {
    var ary, obj;

    ary = [{ foo: 'foo', bar: 'BAZ' }, _emberRuntimeSystemObject.default.create({ foo: 'foo', bar: 'bar' })];

    obj = this.newObject(ary);

    equal(obj.findBy('foo', 'foo'), ary[0], 'findBy(foo)');
    equal(obj.findBy('bar', 'bar'), ary[1], 'findBy(bar)');
  });

  suite.test('should return first object with truthy prop', function () {
    var ary, obj;

    ary = [{ foo: 'foo', bar: false }, _emberRuntimeSystemObject.default.create({ foo: 'bar', bar: true })];

    obj = this.newObject(ary);

    // different values - all eval to true
    equal(obj.findBy('foo'), ary[0], 'findBy(foo)');
    equal(obj.findBy('bar'), ary[1], 'findBy(bar)');
  });

  suite.test('should return first null property match', function () {
    var ary, obj;

    ary = [{ foo: null, bar: 'BAZ' }, _emberRuntimeSystemObject.default.create({ foo: null, bar: null })];

    obj = this.newObject(ary);

    equal(obj.findBy('foo', null), ary[0], 'findBy(\'foo\', null)');
    equal(obj.findBy('bar', null), ary[1], 'findBy(\'bar\', null)');
  });

  suite.test('should return first undefined property match', function () {
    var ary, obj;

    ary = [{ foo: undefined, bar: 'BAZ' }, _emberRuntimeSystemObject.default.create({})];

    obj = this.newObject(ary);

    equal(obj.findBy('foo', undefined), ary[0], 'findBy(\'foo\', undefined)');
    equal(obj.findBy('bar', undefined), ary[1], 'findBy(\'bar\', undefined)');
  });

  exports.default = suite;
});
enifed('ember-runtime/tests/suites/enumerable/find.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites/enumerable');
  test('ember-runtime/tests/suites/enumerable/find.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/enumerable/find.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/enumerable/find.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites/enumerable');
  QUnit.test('ember-runtime/tests/suites/enumerable/find.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/enumerable/find.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/enumerable/firstObject', ['exports', 'ember-runtime/tests/suites/suite', 'ember-metal/property_get'], function (exports, _emberRuntimeTestsSuitesSuite, _emberMetalProperty_get) {
  'use strict';

  var suite = _emberRuntimeTestsSuitesSuite.SuiteModuleBuilder.create();

  suite.module('firstObject');

  suite.test('returns first item in enumerable', function () {
    var obj = this.newObject();
    equal(_emberMetalProperty_get.get(obj, 'firstObject'), this.toArray(obj)[0]);
  });

  suite.test('returns undefined if enumerable is empty', function () {
    var obj = this.newObject([]);
    equal(_emberMetalProperty_get.get(obj, 'firstObject'), undefined);
  });

  exports.default = suite;
});
enifed('ember-runtime/tests/suites/enumerable/firstObject.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites/enumerable');
  test('ember-runtime/tests/suites/enumerable/firstObject.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/enumerable/firstObject.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/enumerable/firstObject.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites/enumerable');
  QUnit.test('ember-runtime/tests/suites/enumerable/firstObject.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/enumerable/firstObject.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/enumerable/forEach', ['exports', 'ember-runtime/tests/suites/suite', 'ember-metal/property_get', 'ember-metal/utils'], function (exports, _emberRuntimeTestsSuitesSuite, _emberMetalProperty_get, _emberMetalUtils) {
  'use strict';

  var suite = _emberRuntimeTestsSuitesSuite.SuiteModuleBuilder.create();

  suite.module('forEach');

  suite.test('forEach should iterate over list', function () {
    var obj = this.newObject();
    var ary = this.toArray(obj);
    var found = [];

    obj.forEach(function (i) {
      found.push(i);
    });
    deepEqual(found, ary, 'items passed during forEach should match');
  });

  suite.test('forEach should iterate over list after mutation', function () {
    if (_emberMetalProperty_get.get(this, 'canTestMutation')) {
      expect(0);
      return;
    }

    var obj = this.newObject();
    var ary = this.toArray(obj);
    var found = [];

    obj.forEach(function (i) {
      found.push(i);
    });
    deepEqual(found, ary, 'items passed during forEach should match');

    this.mutate(obj);
    ary = this.toArray(obj);
    found = [];

    obj.forEach(function (i) {
      found.push(i);
    });
    deepEqual(found, ary, 'items passed during forEach should match');
  });

  suite.test('2nd target parameter', function () {
    var obj = this.newObject();
    var target = this;

    obj.forEach(function () {
      // ES6TODO: When transpiled we will end up with "use strict" which disables automatically binding to the global context.
      // Therefore, the following test can never pass in strict mode unless we modify the `map` function implementation to
      // use `Ember.lookup` if target is not specified.
      //
      // equal(guidFor(this), guidFor(global), 'should pass the global object as this if no context');
    });

    obj.forEach(function () {
      equal(_emberMetalUtils.guidFor(this), _emberMetalUtils.guidFor(target), 'should pass target as this if context');
    }, target);
  });

  suite.test('callback params', function () {
    var obj = this.newObject();
    var ary = this.toArray(obj);
    var loc = 0;

    obj.forEach(function (item, idx, enumerable) {
      equal(item, ary[loc], 'item param');
      equal(idx, loc, 'idx param');
      equal(_emberMetalUtils.guidFor(enumerable), _emberMetalUtils.guidFor(obj), 'enumerable param');
      loc++;
    });
  });

  exports.default = suite;
});
enifed('ember-runtime/tests/suites/enumerable/forEach.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites/enumerable');
  test('ember-runtime/tests/suites/enumerable/forEach.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/enumerable/forEach.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/enumerable/forEach.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites/enumerable');
  QUnit.test('ember-runtime/tests/suites/enumerable/forEach.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/enumerable/forEach.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/enumerable/invoke', ['exports', 'ember-runtime/system/object', 'ember-runtime/tests/suites/suite'], function (exports, _emberRuntimeSystemObject, _emberRuntimeTestsSuitesSuite) {
  'use strict';

  var suite = _emberRuntimeTestsSuitesSuite.SuiteModuleBuilder.create();

  suite.module('invoke');

  suite.test('invoke should call on each object that implements', function () {
    var cnt, ary, obj;

    function F(amt) {
      cnt += amt === undefined ? 1 : amt;
    }
    cnt = 0;
    ary = [{ foo: F }, _emberRuntimeSystemObject.default.create({ foo: F }),

    // NOTE: does not impl foo - invoke should just skip
    _emberRuntimeSystemObject.default.create({ bar: F }), { foo: F }];

    obj = this.newObject(ary);
    obj.invoke('foo');
    equal(cnt, 3, 'should have invoked 3 times');

    cnt = 0;
    obj.invoke('foo', 2);
    equal(cnt, 6, 'should have invoked 3 times, passing param');
  });

  exports.default = suite;
});
enifed('ember-runtime/tests/suites/enumerable/invoke.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites/enumerable');
  test('ember-runtime/tests/suites/enumerable/invoke.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/enumerable/invoke.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/enumerable/invoke.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites/enumerable');
  QUnit.test('ember-runtime/tests/suites/enumerable/invoke.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/enumerable/invoke.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/enumerable/is_any', ['exports', 'ember-runtime/system/object', 'ember-runtime/tests/suites/suite'], function (exports, _emberRuntimeSystemObject, _emberRuntimeTestsSuitesSuite) {
  'use strict';

  var suite = _emberRuntimeTestsSuitesSuite.SuiteModuleBuilder.create();

  // ..........................................................
  // isAny()
  //

  suite.module('isAny');

  suite.test('should return true of any property matches', function () {
    var obj = this.newObject([{ foo: 'foo', bar: 'BAZ' }, _emberRuntimeSystemObject.default.create({ foo: 'foo', bar: 'bar' })]);

    equal(obj.isAny('foo', 'foo'), true, 'isAny(foo)');
    equal(obj.isAny('bar', 'bar'), true, 'isAny(bar)');
    equal(obj.isAny('bar', 'BIFF'), false, 'isAny(BIFF)');
  });

  suite.test('should return true of any property is true', function () {
    var obj = this.newObject([{ foo: 'foo', bar: true }, _emberRuntimeSystemObject.default.create({ foo: 'bar', bar: false })]);

    // different values - all eval to true
    equal(obj.isAny('foo'), true, 'isAny(foo)');
    equal(obj.isAny('bar'), true, 'isAny(bar)');
    equal(obj.isAny('BIFF'), false, 'isAny(biff)');
  });

  suite.test('should return true if any property matches null', function () {
    var obj = this.newObject([{ foo: null, bar: 'bar' }, _emberRuntimeSystemObject.default.create({ foo: 'foo', bar: null })]);

    equal(obj.isAny('foo', null), true, 'isAny(\'foo\', null)');
    equal(obj.isAny('bar', null), true, 'isAny(\'bar\', null)');
  });

  suite.test('should return true if any property is undefined', function () {
    var obj = this.newObject([{ foo: undefined, bar: 'bar' }, _emberRuntimeSystemObject.default.create({ foo: 'foo' })]);

    equal(obj.isAny('foo', undefined), true, 'isAny(\'foo\', undefined)');
    equal(obj.isAny('bar', undefined), true, 'isAny(\'bar\', undefined)');
  });

  suite.test('should not match undefined properties without second argument', function () {
    var obj = this.newObject([{ foo: undefined }, _emberRuntimeSystemObject.default.create({})]);

    equal(obj.isAny('foo'), false, 'isAny(\'foo\', undefined)');
  });

  exports.default = suite;
});
enifed('ember-runtime/tests/suites/enumerable/is_any.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites/enumerable');
  test('ember-runtime/tests/suites/enumerable/is_any.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/enumerable/is_any.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/enumerable/is_any.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites/enumerable');
  QUnit.test('ember-runtime/tests/suites/enumerable/is_any.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/enumerable/is_any.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/enumerable/lastObject', ['exports', 'ember-runtime/tests/suites/suite', 'ember-metal/property_get'], function (exports, _emberRuntimeTestsSuitesSuite, _emberMetalProperty_get) {
  'use strict';

  var suite = _emberRuntimeTestsSuitesSuite.SuiteModuleBuilder.create();

  suite.module('lastObject');

  suite.test('returns last item in enumerable', function () {
    var obj = this.newObject();
    var ary = this.toArray(obj);

    equal(_emberMetalProperty_get.get(obj, 'lastObject'), ary[ary.length - 1]);
  });

  suite.test('returns undefined if enumerable is empty', function () {
    var obj = this.newObject([]);

    equal(_emberMetalProperty_get.get(obj, 'lastObject'), undefined);
  });

  exports.default = suite;
});
enifed('ember-runtime/tests/suites/enumerable/lastObject.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites/enumerable');
  test('ember-runtime/tests/suites/enumerable/lastObject.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/enumerable/lastObject.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/enumerable/lastObject.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites/enumerable');
  QUnit.test('ember-runtime/tests/suites/enumerable/lastObject.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/enumerable/lastObject.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/enumerable/map', ['exports', 'ember-runtime/tests/suites/suite', 'ember-metal/property_get', 'ember-metal/utils'], function (exports, _emberRuntimeTestsSuitesSuite, _emberMetalProperty_get, _emberMetalUtils) {
  'use strict';

  var suite = _emberRuntimeTestsSuitesSuite.SuiteModuleBuilder.create();

  suite.module('map');

  function mapFunc(item) {
    return item ? item.toString() : null;
  }

  suite.test('map should iterate over list', function () {
    var obj = this.newObject();
    var ary = this.toArray(obj).map(mapFunc);
    var found = [];

    found = obj.map(mapFunc);
    deepEqual(found, ary, 'mapped arrays should match');
  });

  suite.test('map should iterate over list after mutation', function () {
    if (_emberMetalProperty_get.get(this, 'canTestMutation')) {
      expect(0);
      return;
    }

    var obj = this.newObject();
    var ary = this.toArray(obj).map(mapFunc);
    var found;

    found = obj.map(mapFunc);
    deepEqual(found, ary, 'items passed during forEach should match');

    this.mutate(obj);
    ary = this.toArray(obj).map(mapFunc);
    found = obj.map(mapFunc);
    deepEqual(found, ary, 'items passed during forEach should match');
  });

  suite.test('2nd target parameter', function () {
    var obj = this.newObject();
    var target = this;

    obj.map(function () {
      // ES6TODO: When transpiled we will end up with "use strict" which disables automatically binding to the global context.
      // Therefore, the following test can never pass in strict mode unless we modify the `map` function implementation to
      // use `Ember.lookup` if target is not specified.
      //
      // equal(guidFor(this), guidFor(global), 'should pass the global object as this if no context');
    });

    obj.map(function () {
      equal(_emberMetalUtils.guidFor(this), _emberMetalUtils.guidFor(target), 'should pass target as this if context');
    }, target);
  });

  suite.test('callback params', function () {
    var obj = this.newObject();
    var ary = this.toArray(obj);
    var loc = 0;

    obj.map(function (item, idx, enumerable) {
      equal(item, ary[loc], 'item param');
      equal(idx, loc, 'idx param');
      equal(_emberMetalUtils.guidFor(enumerable), _emberMetalUtils.guidFor(obj), 'enumerable param');
      loc++;
    });
  });

  exports.default = suite;
});
enifed('ember-runtime/tests/suites/enumerable/map.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites/enumerable');
  test('ember-runtime/tests/suites/enumerable/map.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/enumerable/map.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/enumerable/map.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites/enumerable');
  QUnit.test('ember-runtime/tests/suites/enumerable/map.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/enumerable/map.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/enumerable/mapBy', ['exports', 'ember-runtime/tests/suites/suite'], function (exports, _emberRuntimeTestsSuitesSuite) {
  'use strict';

  var suite = _emberRuntimeTestsSuitesSuite.SuiteModuleBuilder.create();

  suite.module('mapBy');

  suite.test('get value of each property', function () {
    var obj = this.newObject([{ a: 1 }, { a: 2 }]);
    equal(obj.mapBy('a').join(''), '12');
  });

  suite.test('should work also through getEach alias', function () {
    var obj = this.newObject([{ a: 1 }, { a: 2 }]);
    equal(obj.getEach('a').join(''), '12');
  });

  exports.default = suite;
});
enifed('ember-runtime/tests/suites/enumerable/mapBy.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites/enumerable');
  test('ember-runtime/tests/suites/enumerable/mapBy.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/enumerable/mapBy.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/enumerable/mapBy.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites/enumerable');
  QUnit.test('ember-runtime/tests/suites/enumerable/mapBy.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/enumerable/mapBy.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/enumerable/reduce', ['exports', 'ember-runtime/tests/suites/suite'], function (exports, _emberRuntimeTestsSuitesSuite) {
  'use strict';

  var suite = _emberRuntimeTestsSuitesSuite.SuiteModuleBuilder.create();

  suite.module('reduce');

  suite.test('collects a summary value from an enumeration', function () {
    var obj = this.newObject([1, 2, 3]);
    var res = obj.reduce(function (previousValue, item, index, enumerable) {
      return previousValue + item;
    }, 0);
    equal(res, 6);
  });

  suite.test('passes index of item to callback', function () {
    var obj = this.newObject([1, 2, 3]);
    var res = obj.reduce(function (previousValue, item, index, enumerable) {
      return previousValue + index;
    }, 0);
    equal(res, 3);
  });

  suite.test('passes enumerable object to callback', function () {
    var obj = this.newObject([1, 2, 3]);
    var res = obj.reduce(function (previousValue, item, index, enumerable) {
      return enumerable;
    }, 0);
    equal(res, obj);
  });

  exports.default = suite;
});
enifed('ember-runtime/tests/suites/enumerable/reduce.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites/enumerable');
  test('ember-runtime/tests/suites/enumerable/reduce.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/enumerable/reduce.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/enumerable/reduce.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites/enumerable');
  QUnit.test('ember-runtime/tests/suites/enumerable/reduce.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/enumerable/reduce.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/enumerable/reject', ['exports', 'ember-runtime/system/object', 'ember-runtime/tests/suites/suite'], function (exports, _emberRuntimeSystemObject, _emberRuntimeTestsSuitesSuite) {
  'use strict';

  var suite = _emberRuntimeTestsSuitesSuite.SuiteModuleBuilder.create();

  // ..........................................................
  // reject()
  //

  suite.module('reject');

  suite.test('should reject any item that does not meet the condition', function () {
    var obj = this.newObject([1, 2, 3, 4]);
    var result;

    result = obj.reject(function (i) {
      return i < 3;
    });
    deepEqual(result, [3, 4], 'reject the correct items');
  });

  suite.test('should be the inverse of filter', function () {
    var obj = this.newObject([1, 2, 3, 4]);
    var isEven = function (i) {
      return i % 2 === 0;
    };
    var filtered, rejected;

    filtered = obj.filter(isEven);
    rejected = obj.reject(isEven);

    deepEqual(filtered, [2, 4], 'filtered evens');
    deepEqual(rejected, [1, 3], 'rejected evens');
  });

  // ..........................................................
  // rejectBy()
  //

  suite.module('rejectBy');

  suite.test('should reject based on object', function () {
    var obj, ary;

    ary = [{ foo: 'foo', bar: 'BAZ' }, _emberRuntimeSystemObject.default.create({ foo: 'foo', bar: 'bar' })];

    obj = this.newObject(ary);

    deepEqual(obj.rejectBy('foo', 'foo'), [], 'rejectBy(foo)');
    deepEqual(obj.rejectBy('bar', 'bar'), [ary[0]], 'rejectBy(bar)');
  });

  suite.test('should include in result if property is false', function () {
    var obj, ary;

    ary = [{ foo: false, bar: true }, _emberRuntimeSystemObject.default.create({ foo: false, bar: false })];

    obj = this.newObject(ary);

    deepEqual(obj.rejectBy('foo'), ary, 'rejectBy(foo)');
    deepEqual(obj.rejectBy('bar'), [ary[1]], 'rejectBy(bar)');
  });

  suite.test('should reject on second argument if provided', function () {
    var obj, ary;

    ary = [{ name: 'obj1', foo: 3 }, _emberRuntimeSystemObject.default.create({ name: 'obj2', foo: 2 }), { name: 'obj3', foo: 2 }, _emberRuntimeSystemObject.default.create({ name: 'obj4', foo: 3 })];

    obj = this.newObject(ary);

    deepEqual(obj.rejectBy('foo', 3), [ary[1], ary[2]], 'rejectBy(\'foo\', 3)\')');
  });

  suite.test('should correctly reject null second argument', function () {
    var obj, ary;

    ary = [{ name: 'obj1', foo: 3 }, _emberRuntimeSystemObject.default.create({ name: 'obj2', foo: null }), { name: 'obj3', foo: null }, _emberRuntimeSystemObject.default.create({ name: 'obj4', foo: 3 })];

    obj = this.newObject(ary);

    deepEqual(obj.rejectBy('foo', null), [ary[0], ary[3]], 'rejectBy(\'foo\', null)\')');
  });

  suite.test('should correctly reject undefined second argument', function () {
    var obj, ary;

    ary = [{ name: 'obj1', foo: 3 }, _emberRuntimeSystemObject.default.create({ name: 'obj2', foo: 2 })];

    obj = this.newObject(ary);

    deepEqual(obj.rejectBy('bar', undefined), [], 'rejectBy(\'bar\', undefined)\')');
  });

  suite.test('should correctly reject explicit undefined second argument', function () {
    var obj, ary;

    ary = [{ name: 'obj1', foo: 3 }, _emberRuntimeSystemObject.default.create({ name: 'obj2', foo: 3 }), { name: 'obj3', foo: undefined }, _emberRuntimeSystemObject.default.create({ name: 'obj4', foo: undefined }), { name: 'obj5' }, _emberRuntimeSystemObject.default.create({ name: 'obj6' })];

    obj = this.newObject(ary);

    deepEqual(obj.rejectBy('foo', undefined), ary.slice(0, 2), 'rejectBy(\'foo\', undefined)\')');
  });

  suite.test('should match undefined, null, or false properties without second argument', function () {
    var obj, ary;

    ary = [{ name: 'obj1', foo: 3 }, _emberRuntimeSystemObject.default.create({ name: 'obj2', foo: 3 }), { name: 'obj3', foo: undefined }, _emberRuntimeSystemObject.default.create({ name: 'obj4', foo: undefined }), { name: 'obj5' }, _emberRuntimeSystemObject.default.create({ name: 'obj6' }), { name: 'obj7', foo: null }, _emberRuntimeSystemObject.default.create({ name: 'obj8', foo: null }), { name: 'obj9', foo: false }, _emberRuntimeSystemObject.default.create({ name: 'obj10', foo: false })];

    obj = this.newObject(ary);

    deepEqual(obj.rejectBy('foo'), ary.slice(2), 'rejectBy(\'foo\')\')');
  });

  exports.default = suite;
});
enifed('ember-runtime/tests/suites/enumerable/reject.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites/enumerable');
  test('ember-runtime/tests/suites/enumerable/reject.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/enumerable/reject.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/enumerable/reject.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites/enumerable');
  QUnit.test('ember-runtime/tests/suites/enumerable/reject.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/enumerable/reject.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/enumerable/sortBy', ['exports', 'ember-runtime/tests/suites/suite', 'ember-metal/property_get'], function (exports, _emberRuntimeTestsSuitesSuite, _emberMetalProperty_get) {
  'use strict';

  var suite = _emberRuntimeTestsSuitesSuite.SuiteModuleBuilder.create();

  suite.module('sortBy');

  suite.test('sort by value of property', function () {
    var obj = this.newObject([{ a: 2 }, { a: 1 }]);
    var sorted = obj.sortBy('a');

    equal(_emberMetalProperty_get.get(sorted[0], 'a'), 1);
    equal(_emberMetalProperty_get.get(sorted[1], 'a'), 2);
  });

  suite.test('supports multiple propertyNames', function () {
    var obj = this.newObject([{ a: 1, b: 2 }, { a: 1, b: 1 }]);
    var sorted = obj.sortBy('a', 'b');

    equal(_emberMetalProperty_get.get(sorted[0], 'b'), 1);
    equal(_emberMetalProperty_get.get(sorted[1], 'b'), 2);
  });

  exports.default = suite;
});
enifed('ember-runtime/tests/suites/enumerable/sortBy.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites/enumerable');
  test('ember-runtime/tests/suites/enumerable/sortBy.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/enumerable/sortBy.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/enumerable/sortBy.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites/enumerable');
  QUnit.test('ember-runtime/tests/suites/enumerable/sortBy.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/enumerable/sortBy.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/enumerable/toArray', ['exports', 'ember-runtime/tests/suites/suite'], function (exports, _emberRuntimeTestsSuitesSuite) {
  'use strict';

  var suite = _emberRuntimeTestsSuitesSuite.SuiteModuleBuilder.create();

  suite.module('toArray');

  suite.test('toArray should convert to an array', function () {
    var obj = this.newObject();
    deepEqual(obj.toArray(), this.toArray(obj));
  });

  exports.default = suite;
});
enifed('ember-runtime/tests/suites/enumerable/toArray.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites/enumerable');
  test('ember-runtime/tests/suites/enumerable/toArray.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/enumerable/toArray.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/enumerable/toArray.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites/enumerable');
  QUnit.test('ember-runtime/tests/suites/enumerable/toArray.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/enumerable/toArray.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/enumerable/uniq', ['exports', 'ember-runtime/tests/suites/suite'], function (exports, _emberRuntimeTestsSuitesSuite) {
  'use strict';

  var suite = _emberRuntimeTestsSuitesSuite.SuiteModuleBuilder.create();

  suite.module('uniq');

  suite.test('should return new instance with duplicates removed', function () {
    var before, after, obj, ret;

    after = this.newFixture(3);
    before = [after[0], after[1], after[2], after[1], after[0]];
    obj = this.newObject(before);
    before = obj.toArray(); // in case of set before will be different...

    ret = obj.uniq();
    deepEqual(this.toArray(ret), after, 'should have removed item');
    deepEqual(this.toArray(obj), before, 'should not have changed original');
  });

  suite.test('should return duplicate of same content if no duplicates found', function () {
    var item, obj, ret;
    obj = this.newObject(this.newFixture(3));
    ret = obj.uniq(item);
    ok(ret !== obj, 'should not be same object');
    deepEqual(this.toArray(ret), this.toArray(obj), 'should be the same content');
  });

  exports.default = suite;
});
enifed('ember-runtime/tests/suites/enumerable/uniq.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites/enumerable');
  test('ember-runtime/tests/suites/enumerable/uniq.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/enumerable/uniq.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/enumerable/uniq.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites/enumerable');
  QUnit.test('ember-runtime/tests/suites/enumerable/uniq.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/enumerable/uniq.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/enumerable/without', ['exports', 'ember-runtime/tests/suites/suite'], function (exports, _emberRuntimeTestsSuitesSuite) {
  'use strict';

  var suite = _emberRuntimeTestsSuitesSuite.SuiteModuleBuilder.create();

  suite.module('without');

  suite.test('should return new instance with item removed', function () {
    var before, after, obj, ret;

    before = this.newFixture(3);
    after = [before[0], before[2]];
    obj = this.newObject(before);

    ret = obj.without(before[1]);
    deepEqual(this.toArray(ret), after, 'should have removed item');
    deepEqual(this.toArray(obj), before, 'should not have changed original');
  });

  suite.test('should return same instance if object not found', function () {
    var item, obj, ret;

    item = this.newFixture(1)[0];
    obj = this.newObject(this.newFixture(3));

    ret = obj.without(item);
    equal(ret, obj, 'should be same instance');
  });

  exports.default = suite;
});
enifed('ember-runtime/tests/suites/enumerable/without.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites/enumerable');
  test('ember-runtime/tests/suites/enumerable/without.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/enumerable/without.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/enumerable/without.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites/enumerable');
  QUnit.test('ember-runtime/tests/suites/enumerable/without.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/enumerable/without.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/mutable_array', ['exports', 'ember-runtime/tests/suites/array', 'ember-runtime/tests/suites/mutable_array/insertAt', 'ember-runtime/tests/suites/mutable_array/popObject', 'ember-runtime/tests/suites/mutable_array/pushObject', 'ember-runtime/tests/suites/mutable_array/pushObjects', 'ember-runtime/tests/suites/mutable_array/removeAt', 'ember-runtime/tests/suites/mutable_array/replace', 'ember-runtime/tests/suites/mutable_array/shiftObject', 'ember-runtime/tests/suites/mutable_array/unshiftObject', 'ember-runtime/tests/suites/mutable_array/reverseObjects'], function (exports, _emberRuntimeTestsSuitesArray, _emberRuntimeTestsSuitesMutable_arrayInsertAt, _emberRuntimeTestsSuitesMutable_arrayPopObject, _emberRuntimeTestsSuitesMutable_arrayPushObject, _emberRuntimeTestsSuitesMutable_arrayPushObjects, _emberRuntimeTestsSuitesMutable_arrayRemoveAt, _emberRuntimeTestsSuitesMutable_arrayReplace, _emberRuntimeTestsSuitesMutable_arrayShiftObject, _emberRuntimeTestsSuitesMutable_arrayUnshiftObject, _emberRuntimeTestsSuitesMutable_arrayReverseObjects) {
  'use strict';

  var MutableArrayTests = _emberRuntimeTestsSuitesArray.ArrayTests.extend();
  MutableArrayTests.importModuleTests(_emberRuntimeTestsSuitesMutable_arrayInsertAt.default);
  MutableArrayTests.importModuleTests(_emberRuntimeTestsSuitesMutable_arrayPopObject.default);
  MutableArrayTests.importModuleTests(_emberRuntimeTestsSuitesMutable_arrayPushObject.default);
  MutableArrayTests.importModuleTests(_emberRuntimeTestsSuitesMutable_arrayPushObjects.default);
  MutableArrayTests.importModuleTests(_emberRuntimeTestsSuitesMutable_arrayRemoveAt.default);
  MutableArrayTests.importModuleTests(_emberRuntimeTestsSuitesMutable_arrayReplace.default);
  MutableArrayTests.importModuleTests(_emberRuntimeTestsSuitesMutable_arrayShiftObject.default);
  MutableArrayTests.importModuleTests(_emberRuntimeTestsSuitesMutable_arrayUnshiftObject.default);
  MutableArrayTests.importModuleTests(_emberRuntimeTestsSuitesMutable_arrayReverseObjects.default);

  exports.default = MutableArrayTests;
});
enifed('ember-runtime/tests/suites/mutable_array.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites');
  test('ember-runtime/tests/suites/mutable_array.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/mutable_array.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/mutable_array.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites');
  QUnit.test('ember-runtime/tests/suites/mutable_array.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/mutable_array.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/mutable_array/addObject', ['exports', 'ember-metal/core', 'ember-runtime/tests/suites/suite'], function (exports, _emberMetalCore, _emberRuntimeTestsSuitesSuite) {
  'use strict';

  var suite = _emberRuntimeTestsSuitesSuite.SuiteModuleBuilder.create();

  suite.module('addObject');

  suite.test('should return receiver', function () {
    var before, obj;
    before = this.newFixture(3);
    obj = this.newObject(before);
    equal(obj.addObject(before[1]), obj, 'should return receiver');
  });

  suite.test('[A,B].addObject(C) => [A,B,C] + notify', function () {
    var obj, before, after, observer, item;

    before = this.newFixture(2);
    item = this.newFixture(1)[0];
    after = [before[0], before[1], item];
    obj = this.newObject(before);
    observer = this.newObserver(obj, '[]', '@each', 'length', 'firstObject', 'lastObject');
    obj.getProperties('firstObject', 'lastObject'); /* Prime the cache */

    obj.addObject(item);

    deepEqual(this.toArray(obj), after, 'post item results');
    equal(_emberMetalCore.default.get(obj, 'length'), after.length, 'length');

    if (observer.isEnabled) {
      equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
      equal(observer.timesCalled('@each'), 0, 'should not have notified @each once');
      equal(observer.timesCalled('length'), 1, 'should have notified length once');
      equal(observer.timesCalled('lastObject'), 1, 'should have notified lastObject once');

      equal(observer.validate('firstObject'), false, 'should NOT have notified firstObject once');
    }
  });

  suite.test('[A,B,C].addObject(A) => [A,B,C] + NO notify', function () {
    var obj, before, after, observer, item;

    before = this.newFixture(3);
    after = before;
    item = before[0];
    obj = this.newObject(before);
    observer = this.newObserver(obj, '[]', '@each', 'length', 'firstObject', 'lastObject');
    obj.getProperties('firstObject', 'lastObject'); /* Prime the cache */

    obj.addObject(item); // note: item in set

    deepEqual(this.toArray(obj), after, 'post item results');
    equal(_emberMetalCore.default.get(obj, 'length'), after.length, 'length');

    if (observer.isEnabled) {
      equal(observer.validate('[]'), false, 'should NOT have notified []');
      equal(observer.validate('@each'), false, 'should NOT have notified @each');
      equal(observer.validate('length'), false, 'should NOT have notified length');
      equal(observer.validate('firstObject'), false, 'should NOT have notified firstObject once');
      equal(observer.validate('lastObject'), false, 'should NOT have notified lastObject once');
    }
  });

  exports.default = suite;
});
enifed('ember-runtime/tests/suites/mutable_array/addObject.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites/mutable_array');
  test('ember-runtime/tests/suites/mutable_array/addObject.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/mutable_array/addObject.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/mutable_array/addObject.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites/mutable_array');
  QUnit.test('ember-runtime/tests/suites/mutable_array/addObject.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/mutable_array/addObject.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/mutable_array/clear', ['exports', 'ember-metal/core', 'ember-runtime/tests/suites/suite'], function (exports, _emberMetalCore, _emberRuntimeTestsSuitesSuite) {
  'use strict';

  var suite = _emberRuntimeTestsSuitesSuite.SuiteModuleBuilder.create();

  suite.module('clear');

  suite.test('[].clear() => [] + notify', function () {
    var obj, before, after, observer;

    before = [];
    after = [];
    obj = this.newObject(before);
    observer = this.newObserver(obj, '[]', '@each', 'length', 'firstObject', 'lastObject');
    obj.getProperties('firstObject', 'lastObject'); /* Prime the cache */

    equal(obj.clear(), obj, 'return self');

    deepEqual(this.toArray(obj), after, 'post item results');
    equal(_emberMetalCore.default.get(obj, 'length'), after.length, 'length');

    equal(observer.validate('[]'), false, 'should NOT have notified [] once');
    equal(observer.validate('@each'), false, 'should NOT have notified @each once');
    equal(observer.validate('length'), false, 'should NOT have notified length once');
    equal(observer.validate('firstObject'), false, 'should NOT have notified firstObject once');
    equal(observer.validate('lastObject'), false, 'should NOT have notified lastObject once');
  });

  suite.test('[X].clear() => [] + notify', function () {
    var obj, before, after, observer;

    before = this.newFixture(1);
    after = [];
    obj = this.newObject(before);
    observer = this.newObserver(obj, '[]', '@each', 'length', 'firstObject', 'lastObject');
    obj.getProperties('firstObject', 'lastObject'); /* Prime the cache */

    equal(obj.clear(), obj, 'return self');

    deepEqual(this.toArray(obj), after, 'post item results');
    equal(_emberMetalCore.default.get(obj, 'length'), after.length, 'length');

    equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
    equal(observer.timesCalled('@each'), 0, 'should not have notified @each once');
    equal(observer.timesCalled('length'), 1, 'should have notified length once');
    equal(observer.timesCalled('firstObject'), 1, 'should have notified firstObject once');
    equal(observer.timesCalled('lastObject'), 1, 'should have notified lastObject once');
  });

  exports.default = suite;
});
enifed('ember-runtime/tests/suites/mutable_array/clear.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites/mutable_array');
  test('ember-runtime/tests/suites/mutable_array/clear.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/mutable_array/clear.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/mutable_array/clear.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites/mutable_array');
  QUnit.test('ember-runtime/tests/suites/mutable_array/clear.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/mutable_array/clear.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/mutable_array/insertAt', ['exports', 'ember-runtime/tests/suites/suite', 'ember-metal/property_get'], function (exports, _emberRuntimeTestsSuitesSuite, _emberMetalProperty_get) {
  'use strict';

  var suite = _emberRuntimeTestsSuitesSuite.SuiteModuleBuilder.create();

  suite.module('insertAt');

  suite.test('[].insertAt(0, X) => [X] + notify', function () {
    var obj, after, observer;

    after = this.newFixture(1);
    obj = this.newObject([]);
    observer = this.newObserver(obj, '[]', '@each', 'length', 'firstObject', 'lastObject');

    obj.getProperties('firstObject', 'lastObject'); /* Prime the cache */

    obj.insertAt(0, after[0]);

    deepEqual(this.toArray(obj), after, 'post item results');
    equal(_emberMetalProperty_get.get(obj, 'length'), after.length, 'length');

    equal(observer.timesCalledBefore('[]'), 1, 'should have notified [] will change once');
    equal(observer.timesCalledBefore('@each'), 0, 'should not have notified @each will change once');
    equal(observer.timesCalledBefore('length'), 1, 'should have notified length will change once');
    equal(observer.timesCalledBefore('firstObject'), 1, 'should have notified firstObject will change once');
    equal(observer.timesCalledBefore('lastObject'), 1, 'should have notified lastObject will change once');

    equal(observer.timesCalled('[]'), 1, 'should have notified [] did change once');
    equal(observer.timesCalled('@each'), 0, 'should not have notified @each did change once');
    equal(observer.timesCalled('length'), 1, 'should have notified length did change once');
    equal(observer.timesCalled('firstObject'), 1, 'should have notified firstObject did change once');
    equal(observer.timesCalled('lastObject'), 1, 'should have notified lastObject did change once');
  });

  suite.test('[].insertAt(200,X) => OUT_OF_RANGE_EXCEPTION exception', function () {
    var obj = this.newObject([]);
    var that = this;

    throws(function () {
      obj.insertAt(200, that.newFixture(1)[0]);
    }, Error);
  });

  suite.test('[A].insertAt(0, X) => [X,A] + notify', function () {
    var obj, item, after, before, observer;

    item = this.newFixture(1)[0];
    before = this.newFixture(1);
    after = [item, before[0]];
    obj = this.newObject(before);
    observer = this.newObserver(obj, '[]', '@each', 'length', 'firstObject', 'lastObject');

    obj.getProperties('firstObject', 'lastObject'); /* Prime the cache */

    obj.insertAt(0, item);

    deepEqual(this.toArray(obj), after, 'post item results');
    equal(_emberMetalProperty_get.get(obj, 'length'), after.length, 'length');

    equal(observer.timesCalledBefore('[]'), 1, 'should have notified [] will change once');
    equal(observer.timesCalledBefore('@each'), 0, 'should not have notified @each will change once');
    equal(observer.timesCalledBefore('length'), 1, 'should have notified length will change once');
    equal(observer.timesCalledBefore('firstObject'), 1, 'should have notified firstObject will change once');
    equal(observer.timesCalledBefore('lastObject'), 0, 'should NOT have notified lastObject will change once');

    equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
    equal(observer.timesCalled('@each'), 0, 'should not have notified @each once');
    equal(observer.timesCalled('length'), 1, 'should have notified length once');
    equal(observer.timesCalled('firstObject'), 1, 'should have notified firstObject once');

    equal(observer.validate('lastObject'), false, 'should NOT have notified lastObject');
  });

  suite.test('[A].insertAt(1, X) => [A,X] + notify', function () {
    var obj, item, after, before, observer;

    item = this.newFixture(1)[0];
    before = this.newFixture(1);
    after = [before[0], item];
    obj = this.newObject(before);
    observer = this.newObserver(obj, '[]', '@each', 'length', 'firstObject', 'lastObject');

    obj.getProperties('firstObject', 'lastObject'); /* Prime the cache */

    obj.insertAt(1, item);

    deepEqual(this.toArray(obj), after, 'post item results');
    equal(_emberMetalProperty_get.get(obj, 'length'), after.length, 'length');

    equal(observer.timesCalledBefore('[]'), 1, 'should have notified [] will change once');
    equal(observer.timesCalledBefore('@each'), 0, 'should not have notified @each will change once');
    equal(observer.timesCalledBefore('length'), 1, 'should have notified length will change once');
    equal(observer.timesCalledBefore('firstObject'), 0, 'should NOT have notified firstObject will change once');
    equal(observer.timesCalledBefore('lastObject'), 1, 'should have notified lastObject will change once');

    equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
    equal(observer.timesCalled('@each'), 0, 'should not have notified @each once');
    equal(observer.timesCalled('length'), 1, 'should have notified length once');
    equal(observer.timesCalled('lastObject'), 1, 'should have notified lastObject once');

    equal(observer.validate('firstObject'), false, 'should NOT have notified firstObject');
  });

  suite.test('[A].insertAt(200,X) => OUT_OF_RANGE exception', function () {
    var obj = this.newObject(this.newFixture(1));
    var that = this;

    throws(function () {
      obj.insertAt(200, that.newFixture(1)[0]);
    }, Error);
  });

  suite.test('[A,B,C].insertAt(0,X) => [X,A,B,C] + notify', function () {
    var obj, item, after, before, observer;

    item = this.newFixture(1)[0];
    before = this.newFixture(3);
    after = [item, before[0], before[1], before[2]];
    obj = this.newObject(before);
    observer = this.newObserver(obj, '[]', '@each', 'length', 'firstObject', 'lastObject');

    obj.getProperties('firstObject', 'lastObject'); /* Prime the cache */

    obj.insertAt(0, item);

    deepEqual(this.toArray(obj), after, 'post item results');
    equal(_emberMetalProperty_get.get(obj, 'length'), after.length, 'length');

    equal(observer.timesCalledBefore('[]'), 1, 'should have notified [] will change once');
    equal(observer.timesCalledBefore('@each'), 0, 'should not have notified @each will change once');
    equal(observer.timesCalledBefore('length'), 1, 'should have notified length will change once');
    equal(observer.timesCalledBefore('firstObject'), 1, 'should have notified firstObject will change once');
    equal(observer.timesCalledBefore('lastObject'), 0, 'should NOT have notified lastObject will change once');

    equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
    equal(observer.timesCalled('@each'), 0, 'should not have notified @each once');
    equal(observer.timesCalled('length'), 1, 'should have notified length once');
    equal(observer.timesCalled('firstObject'), 1, 'should have notified firstObject once');

    equal(observer.validate('lastObject'), false, 'should NOT have notified lastObject');
  });

  suite.test('[A,B,C].insertAt(1,X) => [A,X,B,C] + notify', function () {
    var obj, item, after, before, observer;

    item = this.newFixture(1)[0];
    before = this.newFixture(3);
    after = [before[0], item, before[1], before[2]];
    obj = this.newObject(before);
    observer = this.newObserver(obj, '[]', '@each', 'length', 'firstObject', 'lastObject');

    obj.getProperties('firstObject', 'lastObject'); /* Prime the cache */

    obj.insertAt(1, item);

    deepEqual(this.toArray(obj), after, 'post item results');
    equal(_emberMetalProperty_get.get(obj, 'length'), after.length, 'length');

    equal(observer.timesCalledBefore('[]'), 1, 'should have notified [] will change once');
    equal(observer.timesCalledBefore('@each'), 0, 'should not have notified @each will change once');
    equal(observer.timesCalledBefore('length'), 1, 'should have notified length will change once');
    equal(observer.timesCalledBefore('firstObject'), 0, 'should NOT have notified firstObject will change once');
    equal(observer.timesCalledBefore('lastObject'), 0, 'should NOT have notified lastObject will change once');

    equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
    equal(observer.timesCalled('@each'), 0, 'should not have notified @each once');
    equal(observer.timesCalled('length'), 1, 'should have notified length once');

    equal(observer.validate('firstObject'), false, 'should NOT have notified firstObject');
    equal(observer.validate('lastObject'), false, 'should NOT have notified lastObject');
  });

  suite.test('[A,B,C].insertAt(3,X) => [A,B,C,X] + notify', function () {
    var obj, item, after, before, observer;

    item = this.newFixture(1)[0];
    before = this.newFixture(3);
    after = [before[0], before[1], before[2], item];
    obj = this.newObject(before);
    observer = this.newObserver(obj, '[]', '@each', 'length', 'firstObject', 'lastObject');

    obj.getProperties('firstObject', 'lastObject'); /* Prime the cache */

    obj.insertAt(3, item);

    deepEqual(this.toArray(obj), after, 'post item results');
    equal(_emberMetalProperty_get.get(obj, 'length'), after.length, 'length');

    equal(observer.timesCalledBefore('[]'), 1, 'should have notified [] will change once');
    equal(observer.timesCalledBefore('@each'), 0, 'should not have notified @each will change once');
    equal(observer.timesCalledBefore('length'), 1, 'should have notified length will change once');
    equal(observer.timesCalledBefore('firstObject'), 0, 'should NOT have notified firstObject will change once');
    equal(observer.timesCalledBefore('lastObject'), 1, 'should have notified lastObject will change once');

    equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
    equal(observer.timesCalled('@each'), 0, 'should not have notified @each once');
    equal(observer.timesCalled('length'), 1, 'should have notified length once');
    equal(observer.timesCalled('lastObject'), 1, 'should have notified lastObject once');

    equal(observer.validate('firstObject'), false, 'should NOT have notified firstObject');
  });

  exports.default = suite;
});
enifed('ember-runtime/tests/suites/mutable_array/insertAt.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites/mutable_array');
  test('ember-runtime/tests/suites/mutable_array/insertAt.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/mutable_array/insertAt.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/mutable_array/insertAt.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites/mutable_array');
  QUnit.test('ember-runtime/tests/suites/mutable_array/insertAt.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/mutable_array/insertAt.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/mutable_array/popObject', ['exports', 'ember-runtime/tests/suites/suite', 'ember-metal/property_get'], function (exports, _emberRuntimeTestsSuitesSuite, _emberMetalProperty_get) {
  'use strict';

  var suite = _emberRuntimeTestsSuitesSuite.SuiteModuleBuilder.create();

  suite.module('popObject');

  suite.test('[].popObject() => [] + returns undefined + NO notify', function () {
    var obj, observer;

    obj = this.newObject([]);
    observer = this.newObserver(obj, '[]', '@each', 'length', 'firstObject', 'lastObject');
    obj.getProperties('firstObject', 'lastObject'); /* Prime the cache */

    equal(obj.popObject(), undefined, 'popObject results');

    deepEqual(this.toArray(obj), [], 'post item results');

    equal(observer.validate('[]'), false, 'should NOT have notified []');
    equal(observer.validate('@each'), false, 'should NOT have notified @each');
    equal(observer.validate('length'), false, 'should NOT have notified length');
    equal(observer.validate('firstObject'), false, 'should NOT have notified firstObject');
    equal(observer.validate('lastObject'), false, 'should NOT have notified lastObject');
  });

  suite.test('[X].popObject() => [] + notify', function () {
    var obj, before, after, observer, ret;

    before = this.newFixture(1);
    after = [];
    obj = this.newObject(before);
    observer = this.newObserver(obj, '[]', '@each', 'length', 'firstObject', 'lastObject');
    obj.getProperties('firstObject', 'lastObject'); /* Prime the cache */

    ret = obj.popObject();

    equal(ret, before[0], 'return object');
    deepEqual(this.toArray(obj), after, 'post item results');
    equal(_emberMetalProperty_get.get(obj, 'length'), after.length, 'length');

    equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
    equal(observer.timesCalled('@each'), 0, 'should not have notified @each once');
    equal(observer.timesCalled('length'), 1, 'should have notified length once');
    equal(observer.timesCalled('firstObject'), 1, 'should have notified firstObject once');
    equal(observer.timesCalled('lastObject'), 1, 'should have notified lastObject once');
  });

  suite.test('[A,B,C].popObject() => [A,B] + notify', function () {
    var obj, before, after, observer, ret;

    before = this.newFixture(3);
    after = [before[0], before[1]];
    obj = this.newObject(before);
    observer = this.newObserver(obj, '[]', '@each', 'length', 'firstObject', 'lastObject');
    obj.getProperties('firstObject', 'lastObject'); /* Prime the cache */

    ret = obj.popObject();

    equal(ret, before[2], 'return object');
    deepEqual(this.toArray(obj), after, 'post item results');
    equal(_emberMetalProperty_get.get(obj, 'length'), after.length, 'length');

    equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
    equal(observer.timesCalled('@each'), 0, 'should not have notified @each once');
    equal(observer.timesCalled('length'), 1, 'should have notified length once');
    equal(observer.timesCalled('lastObject'), 1, 'should have notified lastObject once');

    equal(observer.validate('firstObject'), false, 'should NOT have notified firstObject');
  });

  exports.default = suite;
});
enifed('ember-runtime/tests/suites/mutable_array/popObject.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites/mutable_array');
  test('ember-runtime/tests/suites/mutable_array/popObject.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/mutable_array/popObject.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/mutable_array/popObject.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites/mutable_array');
  QUnit.test('ember-runtime/tests/suites/mutable_array/popObject.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/mutable_array/popObject.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/mutable_array/pushObject', ['exports', 'ember-runtime/tests/suites/suite', 'ember-metal/property_get'], function (exports, _emberRuntimeTestsSuitesSuite, _emberMetalProperty_get) {
  'use strict';

  var suite = _emberRuntimeTestsSuitesSuite.SuiteModuleBuilder.create();

  suite.module('pushObject');

  suite.test('returns pushed object', function () {
    var exp = this.newFixture(1)[0];
    var obj = this.newObject([]);
    equal(obj.pushObject(exp), exp, 'should return pushed object');
  });

  suite.test('[].pushObject(X) => [X] + notify', function () {
    var obj, before, after, observer;

    before = [];
    after = this.newFixture(1);
    obj = this.newObject(before);
    observer = this.newObserver(obj, '[]', '@each', 'length', 'firstObject', 'lastObject');
    obj.getProperties('firstObject', 'lastObject'); /* Prime the cache */

    obj.pushObject(after[0]);

    deepEqual(this.toArray(obj), after, 'post item results');
    equal(_emberMetalProperty_get.get(obj, 'length'), after.length, 'length');

    equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
    equal(observer.timesCalled('@each'), 0, 'should not have notified @each once');
    equal(observer.timesCalled('length'), 1, 'should have notified length once');
    equal(observer.timesCalled('firstObject'), 1, 'should have notified firstObject once');
    equal(observer.timesCalled('lastObject'), 1, 'should have notified lastObject once');
  });

  suite.test('[A,B,C].pushObject(X) => [A,B,C,X] + notify', function () {
    var obj, before, after, item, observer;

    before = this.newFixture(3);
    item = this.newFixture(1)[0];
    after = [before[0], before[1], before[2], item];
    obj = this.newObject(before);
    observer = this.newObserver(obj, '[]', '@each', 'length', 'firstObject', 'lastObject');
    obj.getProperties('firstObject', 'lastObject'); /* Prime the cache */

    obj.pushObject(item);

    deepEqual(this.toArray(obj), after, 'post item results');
    equal(_emberMetalProperty_get.get(obj, 'length'), after.length, 'length');

    equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
    equal(observer.timesCalled('@each'), 0, 'should not have notified @each once');
    equal(observer.timesCalled('length'), 1, 'should have notified length once');
    equal(observer.timesCalled('lastObject'), 1, 'should have notified lastObject once');

    equal(observer.validate('firstObject'), false, 'should NOT have notified firstObject');
  });

  exports.default = suite;
});
enifed('ember-runtime/tests/suites/mutable_array/pushObject.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites/mutable_array');
  test('ember-runtime/tests/suites/mutable_array/pushObject.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/mutable_array/pushObject.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/mutable_array/pushObject.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites/mutable_array');
  QUnit.test('ember-runtime/tests/suites/mutable_array/pushObject.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/mutable_array/pushObject.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/mutable_array/pushObjects', ['exports', 'ember-runtime/tests/suites/suite'], function (exports, _emberRuntimeTestsSuitesSuite) {
  'use strict';

  var suite = _emberRuntimeTestsSuitesSuite.SuiteModuleBuilder.create();

  suite.module('pushObjects');

  suite.test('should raise exception if not Ember.Enumerable is passed to pushObjects', function () {
    var obj = this.newObject([]);

    throws(function () {
      obj.pushObjects('string');
    });
  });

  exports.default = suite;
});
enifed('ember-runtime/tests/suites/mutable_array/pushObjects.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites/mutable_array');
  test('ember-runtime/tests/suites/mutable_array/pushObjects.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/mutable_array/pushObjects.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/mutable_array/pushObjects.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites/mutable_array');
  QUnit.test('ember-runtime/tests/suites/mutable_array/pushObjects.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/mutable_array/pushObjects.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/mutable_array/removeAt', ['exports', 'ember-runtime/tests/suites/suite', 'ember-metal/property_get'], function (exports, _emberRuntimeTestsSuitesSuite, _emberMetalProperty_get) {
  'use strict';

  var suite = _emberRuntimeTestsSuitesSuite.SuiteModuleBuilder.create();

  suite.module('removeAt');

  suite.test('[X].removeAt(0) => [] + notify', function () {
    var obj, before, after, observer;

    before = this.newFixture(1);
    after = [];
    obj = this.newObject(before);
    observer = this.newObserver(obj, '[]', '@each', 'length', 'firstObject', 'lastObject');
    obj.getProperties('firstObject', 'lastObject'); /* Prime the cache */

    equal(obj.removeAt(0), obj, 'return self');

    deepEqual(this.toArray(obj), after, 'post item results');
    equal(_emberMetalProperty_get.get(obj, 'length'), after.length, 'length');

    equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
    equal(observer.timesCalled('@each'), 0, 'should not have notified @each once');
    equal(observer.timesCalled('length'), 1, 'should have notified length once');
    equal(observer.timesCalled('firstObject'), 1, 'should have notified firstObject once');
    equal(observer.timesCalled('lastObject'), 1, 'should have notified lastObject once');
  });

  suite.test('[].removeAt(200) => OUT_OF_RANGE_EXCEPTION exception', function () {
    var obj = this.newObject([]);
    throws(function () {
      obj.removeAt(200);
    }, Error);
  });

  suite.test('[A,B].removeAt(0) => [B] + notify', function () {
    var obj, before, after, observer;

    before = this.newFixture(2);
    after = [before[1]];
    obj = this.newObject(before);
    observer = this.newObserver(obj, '[]', '@each', 'length', 'firstObject', 'lastObject');
    obj.getProperties('firstObject', 'lastObject'); /* Prime the cache */

    equal(obj.removeAt(0), obj, 'return self');

    deepEqual(this.toArray(obj), after, 'post item results');
    equal(_emberMetalProperty_get.get(obj, 'length'), after.length, 'length');

    equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
    equal(observer.timesCalled('@each'), 0, 'should not have notified @each once');
    equal(observer.timesCalled('length'), 1, 'should have notified length once');
    equal(observer.timesCalled('firstObject'), 1, 'should have notified firstObject once');

    equal(observer.validate('lastObject'), false, 'should NOT have notified lastObject');
  });

  suite.test('[A,B].removeAt(1) => [A] + notify', function () {
    var obj, before, after, observer;

    before = this.newFixture(2);
    after = [before[0]];
    obj = this.newObject(before);
    observer = this.newObserver(obj, '[]', '@each', 'length', 'firstObject', 'lastObject');
    obj.getProperties('firstObject', 'lastObject'); /* Prime the cache */

    equal(obj.removeAt(1), obj, 'return self');

    deepEqual(this.toArray(obj), after, 'post item results');
    equal(_emberMetalProperty_get.get(obj, 'length'), after.length, 'length');

    equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
    equal(observer.timesCalled('@each'), 0, 'should not have notified @each once');
    equal(observer.timesCalled('length'), 1, 'should have notified length once');
    equal(observer.timesCalled('lastObject'), 1, 'should have notified lastObject once');

    equal(observer.validate('firstObject'), false, 'should NOT have notified firstObject once');
  });

  suite.test('[A,B,C].removeAt(1) => [A,C] + notify', function () {
    var obj, before, after, observer;

    before = this.newFixture(3);
    after = [before[0], before[2]];
    obj = this.newObject(before);
    observer = this.newObserver(obj, '[]', '@each', 'length', 'firstObject', 'lastObject');
    obj.getProperties('firstObject', 'lastObject'); /* Prime the cache */

    equal(obj.removeAt(1), obj, 'return self');

    deepEqual(this.toArray(obj), after, 'post item results');
    equal(_emberMetalProperty_get.get(obj, 'length'), after.length, 'length');

    equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
    equal(observer.timesCalled('@each'), 0, 'should not have notified @each once');
    equal(observer.timesCalled('length'), 1, 'should have notified length once');

    equal(observer.validate('firstObject'), false, 'should NOT have notified firstObject once');
    equal(observer.validate('lastObject'), false, 'should NOT have notified lastObject once');
  });

  suite.test('[A,B,C,D].removeAt(1,2) => [A,D] + notify', function () {
    var obj, before, after, observer;

    before = this.newFixture(4);
    after = [before[0], before[3]];
    obj = this.newObject(before);
    observer = this.newObserver(obj, '[]', '@each', 'length', 'firstObject', 'lastObject');
    obj.getProperties('firstObject', 'lastObject'); /* Prime the cache */

    equal(obj.removeAt(1, 2), obj, 'return self');

    deepEqual(this.toArray(obj), after, 'post item results');
    equal(_emberMetalProperty_get.get(obj, 'length'), after.length, 'length');

    equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
    equal(observer.timesCalled('@each'), 0, 'should not have notified @each once');
    equal(observer.timesCalled('length'), 1, 'should have notified length once');

    equal(observer.validate('firstObject'), false, 'should NOT have notified firstObject once');
    equal(observer.validate('lastObject'), false, 'should NOT have notified lastObject once');
  });

  exports.default = suite;
});
enifed('ember-runtime/tests/suites/mutable_array/removeAt.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites/mutable_array');
  test('ember-runtime/tests/suites/mutable_array/removeAt.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/mutable_array/removeAt.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/mutable_array/removeAt.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites/mutable_array');
  QUnit.test('ember-runtime/tests/suites/mutable_array/removeAt.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/mutable_array/removeAt.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/mutable_array/removeObject', ['exports', 'ember-metal/core', 'ember-runtime/tests/suites/suite'], function (exports, _emberMetalCore, _emberRuntimeTestsSuitesSuite) {
  'use strict';

  var suite = _emberRuntimeTestsSuitesSuite.SuiteModuleBuilder.create();

  suite.module('removeObject');

  suite.test('should return receiver', function () {
    var before, obj;
    before = this.newFixture(3);
    obj = this.newObject(before);
    equal(obj.removeObject(before[1]), obj, 'should return receiver');
  });

  suite.test('[A,B,C].removeObject(B) => [A,C] + notify', function () {
    var obj, before, after, observer;

    before = this.newFixture(3);
    after = [before[0], before[2]];
    obj = this.newObject(before);
    observer = this.newObserver(obj, '[]', '@each', 'length', 'firstObject', 'lastObject');
    obj.getProperties('firstObject', 'lastObject'); /* Prime the cache */

    obj.removeObject(before[1]);

    deepEqual(this.toArray(obj), after, 'post item results');
    equal(_emberMetalCore.default.get(obj, 'length'), after.length, 'length');

    if (observer.isEnabled) {
      equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
      equal(observer.timesCalled('@each'), 0, 'should not have notified @each once');
      equal(observer.timesCalled('length'), 1, 'should have notified length once');

      equal(observer.validate('firstObject'), false, 'should NOT have notified firstObject once');
      equal(observer.validate('lastObject'), false, 'should NOT have notified lastObject once');
    }
  });

  suite.test('[A,B,C].removeObject(D) => [A,B,C]', function () {
    var obj, before, after, observer, item;

    before = this.newFixture(3);
    after = before;
    item = this.newFixture(1)[0];
    obj = this.newObject(before);
    observer = this.newObserver(obj, '[]', '@each', 'length', 'firstObject', 'lastObject');
    obj.getProperties('firstObject', 'lastObject'); /* Prime the cache */

    obj.removeObject(item); // note: item not in set

    deepEqual(this.toArray(obj), after, 'post item results');
    equal(_emberMetalCore.default.get(obj, 'length'), after.length, 'length');

    if (observer.isEnabled) {
      equal(observer.validate('[]'), false, 'should NOT have notified []');
      equal(observer.validate('@each'), false, 'should NOT have notified @each');
      equal(observer.validate('length'), false, 'should NOT have notified length');

      equal(observer.validate('firstObject'), false, 'should NOT have notified firstObject once');
      equal(observer.validate('lastObject'), false, 'should NOT have notified lastObject once');
    }
  });

  exports.default = suite;
});
enifed('ember-runtime/tests/suites/mutable_array/removeObject.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites/mutable_array');
  test('ember-runtime/tests/suites/mutable_array/removeObject.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/mutable_array/removeObject.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/mutable_array/removeObject.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites/mutable_array');
  QUnit.test('ember-runtime/tests/suites/mutable_array/removeObject.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/mutable_array/removeObject.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/mutable_array/replace', ['exports', 'ember-runtime/tests/suites/suite'], function (exports, _emberRuntimeTestsSuitesSuite) {
  'use strict';

  var suite = _emberRuntimeTestsSuitesSuite.SuiteModuleBuilder.create();

  suite.module('replace');

  suite.test('[].replace(0,0,\'X\') => [\'X\'] + notify', function () {

    var obj, exp, observer;
    exp = this.newFixture(1);
    obj = this.newObject([]);
    observer = this.newObserver(obj, '[]', '@each', 'length', 'firstObject', 'lastObject');
    obj.getProperties('firstObject', 'lastObject'); /* Prime the cache */

    obj.replace(0, 0, exp);

    deepEqual(this.toArray(obj), exp, 'post item results');

    equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
    equal(observer.timesCalled('@each'), 0, 'should not have notified @each once');
    equal(observer.timesCalled('length'), 1, 'should have notified length once');
    equal(observer.timesCalled('firstObject'), 1, 'should have notified firstObject once');
    equal(observer.timesCalled('lastObject'), 1, 'should have notified lastObject once');
  });

  suite.test('[A,B,C,D].replace(1,2,X) => [A,X,D] + notify', function () {
    var obj, observer, before, replace, after;

    before = this.newFixture(4);
    replace = this.newFixture(1);
    after = [before[0], replace[0], before[3]];

    obj = this.newObject(before);
    observer = this.newObserver(obj, '[]', '@each', 'length', 'firstObject', 'lastObject');
    obj.getProperties('firstObject', 'lastObject'); /* Prime the cache */

    obj.replace(1, 2, replace);

    deepEqual(this.toArray(obj), after, 'post item results');

    equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
    equal(observer.timesCalled('@each'), 0, 'should not have notified @each once');
    equal(observer.timesCalled('length'), 1, 'should have notified length once');

    equal(observer.validate('firstObject'), false, 'should NOT have notified firstObject once');
    equal(observer.validate('lastObject'), false, 'should NOT have notified lastObject once');
  });

  suite.test('[A,B,C,D].replace(1,2,[X,Y]) => [A,X,Y,D] + notify', function () {
    var obj, observer, before, replace, after;

    before = this.newFixture(4);
    replace = this.newFixture(2);
    after = [before[0], replace[0], replace[1], before[3]];

    obj = this.newObject(before);
    observer = this.newObserver(obj, '[]', '@each', 'length', 'firstObject', 'lastObject');
    obj.getProperties('firstObject', 'lastObject'); /* Prime the cache */

    obj.replace(1, 2, replace);

    deepEqual(this.toArray(obj), after, 'post item results');

    equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
    equal(observer.timesCalled('@each'), 0, 'should not have notified @each once');
    equal(observer.validate('length'), false, 'should NOT have notified length');

    equal(observer.validate('firstObject'), false, 'should NOT have notified firstObject once');
    equal(observer.validate('lastObject'), false, 'should NOT have notified lastObject once');
  });

  suite.test('[A,B].replace(1,0,[X,Y]) => [A,X,Y,B] + notify', function () {
    var obj, observer, before, replace, after;

    before = this.newFixture(2);
    replace = this.newFixture(2);
    after = [before[0], replace[0], replace[1], before[1]];

    obj = this.newObject(before);
    observer = this.newObserver(obj, '[]', '@each', 'length', 'firstObject', 'lastObject');
    obj.getProperties('firstObject', 'lastObject'); /* Prime the cache */

    obj.replace(1, 0, replace);

    deepEqual(this.toArray(obj), after, 'post item results');

    equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
    equal(observer.timesCalled('@each'), 0, 'should not have notified @each once');
    equal(observer.timesCalled('length'), 1, 'should have notified length once');

    equal(observer.validate('firstObject'), false, 'should NOT have notified firstObject once');
    equal(observer.validate('lastObject'), false, 'should NOT have notified lastObject once');
  });

  suite.test('[A,B,C,D].replace(2,2) => [A,B] + notify', function () {
    var obj, observer, before, after;

    before = this.newFixture(4);
    after = [before[0], before[1]];

    obj = this.newObject(before);
    observer = this.newObserver(obj, '[]', '@each', 'length', 'firstObject', 'lastObject');
    obj.getProperties('firstObject', 'lastObject'); /* Prime the cache */

    obj.replace(2, 2);

    deepEqual(this.toArray(obj), after, 'post item results');

    equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
    equal(observer.timesCalled('@each'), 0, 'should not have notified @each once');
    equal(observer.timesCalled('length'), 1, 'should have notified length once');
    equal(observer.timesCalled('lastObject'), 1, 'should have notified lastObject once');

    equal(observer.validate('firstObject'), false, 'should NOT have notified firstObject once');
  });

  suite.test('Adding object should notify enumerable observer', function () {

    var fixtures = this.newFixture(4);
    var obj = this.newObject(fixtures);
    var observer = this.newObserver(obj).observeEnumerable(obj);
    var item = this.newFixture(1)[0];

    obj.replace(2, 2, [item]);

    deepEqual(observer._before, [obj, [fixtures[2], fixtures[3]], 1], 'before');
    deepEqual(observer._after, [obj, 2, [item]], 'after');
  });

  suite.test('Adding object should notify array observer', function () {

    var fixtures = this.newFixture(4);
    var obj = this.newObject(fixtures);
    var observer = this.newObserver(obj).observeArray(obj);
    var item = this.newFixture(1)[0];

    obj.replace(2, 2, [item]);

    deepEqual(observer._before, [obj, 2, 2, 1], 'before');
    deepEqual(observer._after, [obj, 2, 2, 1], 'after');
  });

  exports.default = suite;
});
enifed('ember-runtime/tests/suites/mutable_array/replace.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites/mutable_array');
  test('ember-runtime/tests/suites/mutable_array/replace.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/mutable_array/replace.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/mutable_array/replace.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites/mutable_array');
  QUnit.test('ember-runtime/tests/suites/mutable_array/replace.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/mutable_array/replace.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/mutable_array/reverseObjects', ['exports', 'ember-runtime/tests/suites/suite', 'ember-metal/property_get'], function (exports, _emberRuntimeTestsSuitesSuite, _emberMetalProperty_get) {
  'use strict';

  var suite = _emberRuntimeTestsSuitesSuite.SuiteModuleBuilder.create();

  suite.module('reverseObjects');

  suite.test('[A,B,C].reverseObjects() => [] + notify', function () {
    var obj, before, after, observer;

    before = this.newFixture(3);
    after = [before[2], before[1], before[0]];
    obj = this.newObject(before);
    observer = this.newObserver(obj, '[]', '@each', 'length', 'firstObject', 'lastObject');
    obj.getProperties('firstObject', 'lastObject'); /* Prime the cache */

    equal(obj.reverseObjects(), obj, 'return self');

    deepEqual(this.toArray(obj), after, 'post item results');
    equal(_emberMetalProperty_get.get(obj, 'length'), after.length, 'length');

    equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
    equal(observer.timesCalled('@each'), 0, 'should not have notified @each once');
    equal(observer.timesCalled('length'), 0, 'should have notified length once');
    equal(observer.timesCalled('firstObject'), 1, 'should have notified firstObject once');
    equal(observer.timesCalled('lastObject'), 1, 'should have notified lastObject once');
  });

  exports.default = suite;
});
enifed('ember-runtime/tests/suites/mutable_array/reverseObjects.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites/mutable_array');
  test('ember-runtime/tests/suites/mutable_array/reverseObjects.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/mutable_array/reverseObjects.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/mutable_array/reverseObjects.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites/mutable_array');
  QUnit.test('ember-runtime/tests/suites/mutable_array/reverseObjects.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/mutable_array/reverseObjects.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/mutable_array/setObjects', ['exports', 'ember-metal/core', 'ember-runtime/tests/suites/suite'], function (exports, _emberMetalCore, _emberRuntimeTestsSuitesSuite) {
  'use strict';

  var suite = _emberRuntimeTestsSuitesSuite.SuiteModuleBuilder.create();

  suite.module('setObjects');

  suite.test('[A,B,C].setObjects([]) = > [] + notify', function () {
    var obj, before, after, observer;

    before = this.newFixture(3);
    after = [];
    obj = this.newObject(before);
    observer = this.newObserver(obj, '[]', '@each', 'length', 'firstObject', 'lastObject');
    obj.getProperties('firstObject', 'lastObject'); /* Prime the cache */

    equal(obj.setObjects(after), obj, 'return self');

    deepEqual(this.toArray(obj), after, 'post item results');
    equal(_emberMetalCore.default.get(obj, 'length'), after.length, 'length');

    equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
    equal(observer.timesCalled('@each'), 0, 'should not have notified @each once');
    equal(observer.timesCalled('length'), 1, 'should have notified length once');
    equal(observer.timesCalled('firstObject'), 1, 'should have notified firstObject once');
    equal(observer.timesCalled('lastObject'), 1, 'should have notified lastObject once');
  });

  suite.test('[A,B,C].setObjects([D, E, F, G]) = > [D, E, F, G] + notify', function () {
    var obj, before, after, observer;

    before = this.newFixture(3);
    after = this.newFixture(4);
    obj = this.newObject(before);
    observer = this.newObserver(obj, '[]', '@each', 'length', 'firstObject', 'lastObject');
    obj.getProperties('firstObject', 'lastObject'); /* Prime the cache */

    equal(obj.setObjects(after), obj, 'return self');

    deepEqual(this.toArray(obj), after, 'post item results');
    equal(_emberMetalCore.default.get(obj, 'length'), after.length, 'length');

    equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
    equal(observer.timesCalled('@each'), 0, 'should not have notified @each once');
    equal(observer.timesCalled('length'), 1, 'should have notified length once');
    equal(observer.timesCalled('firstObject'), 1, 'should have notified firstObject once');
    equal(observer.timesCalled('lastObject'), 1, 'should have notified lastObject once');
  });

  exports.default = suite;
});
enifed('ember-runtime/tests/suites/mutable_array/setObjects.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites/mutable_array');
  test('ember-runtime/tests/suites/mutable_array/setObjects.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/mutable_array/setObjects.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/mutable_array/setObjects.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites/mutable_array');
  QUnit.test('ember-runtime/tests/suites/mutable_array/setObjects.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/mutable_array/setObjects.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/mutable_array/shiftObject', ['exports', 'ember-runtime/tests/suites/suite', 'ember-metal/property_get'], function (exports, _emberRuntimeTestsSuitesSuite, _emberMetalProperty_get) {
  'use strict';

  var suite = _emberRuntimeTestsSuitesSuite.SuiteModuleBuilder.create();

  suite.module('shiftObject');

  suite.test('[].shiftObject() => [] + returns undefined + NO notify', function () {
    var obj, before, after, observer;

    before = [];
    after = [];
    obj = this.newObject(before);
    observer = this.newObserver(obj, '[]', '@each', 'length', 'firstObject', 'lastObject');
    obj.getProperties('firstObject', 'lastObject'); /* Prime the cache */

    equal(obj.shiftObject(), undefined);

    deepEqual(this.toArray(obj), after, 'post item results');
    equal(_emberMetalProperty_get.get(obj, 'length'), after.length, 'length');

    equal(observer.validate('[]', undefined, 1), false, 'should NOT have notified [] once');
    equal(observer.validate('@each', undefined, 1), false, 'should NOT have notified @each once');
    equal(observer.validate('length', undefined, 1), false, 'should NOT have notified length once');

    equal(observer.validate('firstObject'), false, 'should NOT have notified firstObject once');
    equal(observer.validate('lastObject'), false, 'should NOT have notified lastObject once');
  });

  suite.test('[X].shiftObject() => [] + notify', function () {
    var obj, before, after, observer;

    before = this.newFixture(1);
    after = [];
    obj = this.newObject(before);
    observer = this.newObserver(obj, '[]', '@each', 'length', 'firstObject', 'lastObject');
    obj.getProperties('firstObject', 'lastObject'); /* Prime the cache */

    equal(obj.shiftObject(), before[0], 'should return object');

    deepEqual(this.toArray(obj), after, 'post item results');
    equal(_emberMetalProperty_get.get(obj, 'length'), after.length, 'length');

    equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
    equal(observer.timesCalled('@each'), 0, 'should not have notified @each once');
    equal(observer.timesCalled('length'), 1, 'should have notified length once');
    equal(observer.timesCalled('firstObject'), 1, 'should have notified firstObject once');
    equal(observer.timesCalled('lastObject'), 1, 'should have notified lastObject once');
  });

  suite.test('[A,B,C].shiftObject() => [B,C] + notify', function () {
    var obj, before, after, observer;

    before = this.newFixture(3);
    after = [before[1], before[2]];
    obj = this.newObject(before);
    observer = this.newObserver(obj, '[]', '@each', 'length', 'firstObject', 'lastObject');
    obj.getProperties('firstObject', 'lastObject'); /* Prime the cache */

    equal(obj.shiftObject(), before[0], 'should return object');

    deepEqual(this.toArray(obj), after, 'post item results');
    equal(_emberMetalProperty_get.get(obj, 'length'), after.length, 'length');

    equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
    equal(observer.timesCalled('@each'), 0, 'should not have notified @each once');
    equal(observer.timesCalled('length'), 1, 'should have notified length once');
    equal(observer.timesCalled('firstObject'), 1, 'should have notified firstObject once');

    equal(observer.validate('lastObject'), false, 'should NOT have notified lastObject once');
  });

  exports.default = suite;
});
enifed('ember-runtime/tests/suites/mutable_array/shiftObject.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites/mutable_array');
  test('ember-runtime/tests/suites/mutable_array/shiftObject.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/mutable_array/shiftObject.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/mutable_array/shiftObject.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites/mutable_array');
  QUnit.test('ember-runtime/tests/suites/mutable_array/shiftObject.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/mutable_array/shiftObject.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/mutable_array/unshiftObject', ['exports', 'ember-runtime/tests/suites/suite', 'ember-metal/property_get'], function (exports, _emberRuntimeTestsSuitesSuite, _emberMetalProperty_get) {
  'use strict';

  var suite = _emberRuntimeTestsSuitesSuite.SuiteModuleBuilder.create();

  suite.module('unshiftObject');

  suite.test('returns unshifted object', function () {
    var obj = this.newObject([]);
    var item = this.newFixture(1)[0];
    equal(obj.unshiftObject(item), item, 'should return unshifted object');
  });

  suite.test('[].unshiftObject(X) => [X] + notify', function () {
    var obj, before, after, item, observer;

    before = [];
    item = this.newFixture(1)[0];
    after = [item];
    obj = this.newObject(before);
    observer = this.newObserver(obj, '[]', '@each', 'length', 'firstObject', 'lastObject');
    obj.getProperties('firstObject', 'lastObject'); /* Prime the cache */

    obj.unshiftObject(item);

    deepEqual(this.toArray(obj), after, 'post item results');
    equal(_emberMetalProperty_get.get(obj, 'length'), after.length, 'length');

    equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
    equal(observer.timesCalled('@each'), 0, 'should not have notified @each once');
    equal(observer.timesCalled('length'), 1, 'should have notified length once');
    equal(observer.timesCalled('firstObject'), 1, 'should have notified firstObject once');
    equal(observer.timesCalled('lastObject'), 1, 'should have notified lastObject once');
  });

  suite.test('[A,B,C].unshiftObject(X) => [X,A,B,C] + notify', function () {
    var obj, before, after, item, observer;

    before = this.newFixture(3);
    item = this.newFixture(1)[0];
    after = [item, before[0], before[1], before[2]];
    obj = this.newObject(before);
    observer = this.newObserver(obj, '[]', '@each', 'length', 'firstObject', 'lastObject');
    obj.getProperties('firstObject', 'lastObject'); /* Prime the cache */

    obj.unshiftObject(item);

    deepEqual(this.toArray(obj), after, 'post item results');
    equal(_emberMetalProperty_get.get(obj, 'length'), after.length, 'length');

    equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
    equal(observer.timesCalled('@each'), 0, 'should not have notified @each once');
    equal(observer.timesCalled('length'), 1, 'should have notified length once');
    equal(observer.timesCalled('firstObject'), 1, 'should have notified firstObject once');

    equal(observer.validate('lastObject'), false, 'should NOT have notified lastObject');
  });

  suite.test('[A,B,C].unshiftObject(A) => [A,A,B,C] + notify', function () {
    var obj, before, after, item, observer;

    before = this.newFixture(3);
    item = before[0]; // note same object as current head. should end up twice
    after = [item, before[0], before[1], before[2]];
    obj = this.newObject(before);
    observer = this.newObserver(obj, '[]', '@each', 'length', 'firstObject', 'lastObject');
    obj.getProperties('firstObject', 'lastObject'); /* Prime the cache */

    obj.unshiftObject(item);

    deepEqual(this.toArray(obj), after, 'post item results');
    equal(_emberMetalProperty_get.get(obj, 'length'), after.length, 'length');

    equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
    equal(observer.timesCalled('@each'), 0, 'should not have notified @each once');
    equal(observer.timesCalled('length'), 1, 'should have notified length once');

    equal(observer.validate('firstObject'), false, 'should NOT have notified firstObject');
    equal(observer.validate('lastObject'), false, 'should NOT have notified lastObject');
  });

  exports.default = suite;
});
enifed('ember-runtime/tests/suites/mutable_array/unshiftObject.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites/mutable_array');
  test('ember-runtime/tests/suites/mutable_array/unshiftObject.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/mutable_array/unshiftObject.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/mutable_array/unshiftObject.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites/mutable_array');
  QUnit.test('ember-runtime/tests/suites/mutable_array/unshiftObject.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/mutable_array/unshiftObject.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/mutable_array/unshiftObjects', ['exports', 'ember-metal/core', 'ember-runtime/tests/suites/suite'], function (exports, _emberMetalCore, _emberRuntimeTestsSuitesSuite) {
  'use strict';

  var suite = _emberRuntimeTestsSuitesSuite.SuiteModuleBuilder.create();

  suite.module('unshiftObjects');

  suite.test('returns receiver', function () {
    var obj = this.newObject([]);
    var items = this.newFixture(3);
    equal(obj.unshiftObjects(items), obj, 'should return receiver');
  });

  suite.test('[].unshiftObjects([A,B,C]) => [A,B,C] + notify', function () {
    var obj, before, items, observer;

    before = [];
    items = this.newFixture(3);
    obj = this.newObject(before);
    observer = this.newObserver(obj, '[]', '@each', 'length', 'firstObject', 'lastObject');
    obj.getProperties('firstObject', 'lastObject'); /* Prime the cache */

    obj.unshiftObjects(items);

    deepEqual(this.toArray(obj), items, 'post item results');
    equal(_emberMetalCore.default.get(obj, 'length'), items.length, 'length');

    equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
    equal(observer.timesCalled('@each'), 0, 'should not have notified @each once');
    equal(observer.timesCalled('length'), 1, 'should have notified length once');
    equal(observer.timesCalled('firstObject'), 1, 'should have notified firstObject once');
    equal(observer.timesCalled('lastObject'), 1, 'should have notified lastObject once');
  });

  suite.test('[A,B,C].unshiftObjects([X,Y]) => [X,Y,A,B,C] + notify', function () {
    var obj, before, items, after, observer;

    before = this.newFixture(3);
    items = this.newFixture(2);
    after = items.concat(before);
    obj = this.newObject(before);
    observer = this.newObserver(obj, '[]', '@each', 'length', 'firstObject', 'lastObject');
    obj.getProperties('firstObject', 'lastObject'); /* Prime the cache */

    obj.unshiftObjects(items);

    deepEqual(this.toArray(obj), after, 'post item results');
    equal(_emberMetalCore.default.get(obj, 'length'), after.length, 'length');

    equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
    equal(observer.timesCalled('@each'), 0, 'should not have notified @each once');
    equal(observer.timesCalled('length'), 1, 'should have notified length once');
    equal(observer.timesCalled('firstObject'), 1, 'should have notified firstObject once');

    equal(observer.validate('lastObject'), false, 'should NOT have notified lastObject');
  });

  suite.test('[A,B,C].unshiftObjects([A,B]) => [A,B,A,B,C] + notify', function () {
    var obj, before, after, items, observer;

    before = this.newFixture(3);
    items = [before[0], before[1]]; // note same object as current head. should end up twice
    after = items.concat(before);
    obj = this.newObject(before);
    observer = this.newObserver(obj, '[]', '@each', 'length', 'firstObject', 'lastObject');
    obj.getProperties('firstObject', 'lastObject'); /* Prime the cache */

    obj.unshiftObjects(items);

    deepEqual(this.toArray(obj), after, 'post item results');
    equal(_emberMetalCore.default.get(obj, 'length'), after.length, 'length');

    equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
    equal(observer.timesCalled('@each'), 0, 'should not have notified @each once');
    equal(observer.timesCalled('length'), 1, 'should have notified length once');

    equal(observer.validate('firstObject'), false, 'should NOT have notified firstObject');
    equal(observer.validate('lastObject'), false, 'should NOT have notified lastObject');
  });

  exports.default = suite;
});
enifed('ember-runtime/tests/suites/mutable_array/unshiftObjects.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites/mutable_array');
  test('ember-runtime/tests/suites/mutable_array/unshiftObjects.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/mutable_array/unshiftObjects.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/mutable_array/unshiftObjects.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites/mutable_array');
  QUnit.test('ember-runtime/tests/suites/mutable_array/unshiftObjects.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/mutable_array/unshiftObjects.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/mutable_enumerable', ['exports', 'ember-runtime/tests/suites/enumerable', 'ember-runtime/tests/suites/mutable_enumerable/addObject', 'ember-runtime/tests/suites/mutable_enumerable/removeObject', 'ember-runtime/tests/suites/mutable_enumerable/removeObjects'], function (exports, _emberRuntimeTestsSuitesEnumerable, _emberRuntimeTestsSuitesMutable_enumerableAddObject, _emberRuntimeTestsSuitesMutable_enumerableRemoveObject, _emberRuntimeTestsSuitesMutable_enumerableRemoveObjects) {
  'use strict';

  var MutableEnumerableTests = _emberRuntimeTestsSuitesEnumerable.EnumerableTests.extend();
  MutableEnumerableTests.importModuleTests(_emberRuntimeTestsSuitesMutable_enumerableAddObject.default);
  MutableEnumerableTests.importModuleTests(_emberRuntimeTestsSuitesMutable_enumerableRemoveObject.default);
  MutableEnumerableTests.importModuleTests(_emberRuntimeTestsSuitesMutable_enumerableRemoveObjects.default);

  exports.default = MutableEnumerableTests;
});
enifed('ember-runtime/tests/suites/mutable_enumerable.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites');
  test('ember-runtime/tests/suites/mutable_enumerable.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/mutable_enumerable.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/mutable_enumerable.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites');
  QUnit.test('ember-runtime/tests/suites/mutable_enumerable.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/mutable_enumerable.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/mutable_enumerable/addObject', ['exports', 'ember-runtime/tests/suites/suite', 'ember-metal/property_get'], function (exports, _emberRuntimeTestsSuitesSuite, _emberMetalProperty_get) {
  'use strict';

  var suite = _emberRuntimeTestsSuitesSuite.SuiteModuleBuilder.create();

  suite.module('addObject');

  suite.test('should return receiver', function () {
    var before, obj;
    before = this.newFixture(3);
    obj = this.newObject(before);
    equal(obj.addObject(before[1]), obj, 'should return receiver');
  });

  suite.test('[A,B].addObject(C) => [A,B,C] + notify', function () {
    var obj, before, after, observer, item;

    before = this.newFixture(2);
    item = this.newFixture(1)[0];
    after = [before[0], before[1], item];
    obj = this.newObject(before);
    observer = this.newObserver(obj, '[]', 'length', 'firstObject', 'lastObject');
    _emberMetalProperty_get.get(obj, 'firstObject');
    _emberMetalProperty_get.get(obj, 'lastObject');

    obj.addObject(item);

    deepEqual(this.toArray(obj), after, 'post item results');
    equal(_emberMetalProperty_get.get(obj, 'length'), after.length, 'length');

    if (observer.isEnabled) {
      equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
      equal(observer.timesCalled('length'), 1, 'should have notified length once');
      equal(observer.timesCalled('lastObject'), 1, 'should have notified lastObject once');
      // This gets called since MutableEnumerable is naive about changes
      equal(observer.timesCalled('firstObject'), 1, 'should have notified firstObject once');
    }
  });

  suite.test('[A,B,C].addObject(A) => [A,B,C] + NO notify', function () {
    var obj, before, after, observer, item;

    before = this.newFixture(3);
    after = before;
    item = before[0];
    obj = this.newObject(before);
    observer = this.newObserver(obj, '[]', 'length', 'firstObject', 'lastObject');

    obj.addObject(item); // note: item in set

    deepEqual(this.toArray(obj), after, 'post item results');
    equal(_emberMetalProperty_get.get(obj, 'length'), after.length, 'length');

    if (observer.isEnabled) {
      equal(observer.validate('[]'), false, 'should NOT have notified []');
      equal(observer.validate('length'), false, 'should NOT have notified length');
      equal(observer.validate('firstObject'), false, 'should NOT have notified firstObject');
      equal(observer.validate('lastObject'), false, 'should NOT have notified lastObject');
    }
  });

  suite.test('Adding object should notify enumerable observer', function () {
    var obj = this.newObject(this.newFixture(3));
    var observer = this.newObserver(obj).observeEnumerable(obj);
    var item = this.newFixture(1)[0];

    obj.addObject(item);

    deepEqual(observer._before, [obj, null, [item]]);
    deepEqual(observer._after, [obj, null, [item]]);
  });

  exports.default = suite;
});
enifed('ember-runtime/tests/suites/mutable_enumerable/addObject.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites/mutable_enumerable');
  test('ember-runtime/tests/suites/mutable_enumerable/addObject.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/mutable_enumerable/addObject.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/mutable_enumerable/addObject.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites/mutable_enumerable');
  QUnit.test('ember-runtime/tests/suites/mutable_enumerable/addObject.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/mutable_enumerable/addObject.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/mutable_enumerable/removeObject', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-runtime/tests/suites/suite'], function (exports, _emberMetalCore, _emberMetalProperty_get, _emberRuntimeTestsSuitesSuite) {
  'use strict';

  var suite = _emberRuntimeTestsSuitesSuite.SuiteModuleBuilder.create();

  suite.module('removeObject');

  suite.test('should return receiver', function () {
    var before, obj;
    before = this.newFixture(3);
    obj = this.newObject(before);
    equal(obj.removeObject(before[1]), obj, 'should return receiver');
  });

  suite.test('[A,B,C].removeObject(B) => [A,C] + notify', function () {
    var obj, before, after, observer;

    before = _emberMetalCore.default.A(this.newFixture(3));
    after = [before[0], before[2]];
    obj = before;
    observer = this.newObserver(obj, '[]', 'length', 'firstObject', 'lastObject');
    obj.getProperties('firstObject', 'lastObject'); // Prime the cache

    obj.removeObject(before[1]);

    deepEqual(this.toArray(obj), after, 'post item results');
    equal(_emberMetalProperty_get.get(obj, 'length'), after.length, 'length');

    if (observer.isEnabled) {
      equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
      equal(observer.timesCalled('length'), 1, 'should have notified length once');

      equal(observer.validate('firstObject'), false, 'should NOT have notified firstObject');
      equal(observer.validate('lastObject'), false, 'should NOT have notified lastObject');
    }
  });

  suite.test('[A,B,C].removeObject(D) => [A,B,C]', function () {
    var obj, before, after, observer, item;

    before = _emberMetalCore.default.A(this.newFixture(3));
    after = before;
    item = this.newFixture(1)[0];
    obj = before;
    observer = this.newObserver(obj, '[]', 'length', 'firstObject', 'lastObject');
    obj.getProperties('firstObject', 'lastObject'); // Prime the cache

    obj.removeObject(item); // Note: item not in set

    deepEqual(this.toArray(obj), after, 'post item results');
    equal(_emberMetalProperty_get.get(obj, 'length'), after.length, 'length');

    if (observer.isEnabled) {
      equal(observer.validate('[]'), false, 'should NOT have notified []');
      equal(observer.validate('length'), false, 'should NOT have notified length');

      equal(observer.validate('firstObject'), false, 'should NOT have notified firstObject');
      equal(observer.validate('lastObject'), false, 'should NOT have notified lastObject');
    }
  });

  suite.test('Removing object should notify enumerable observer', function () {
    var fixtures = this.newFixture(3);
    var obj = this.newObject(fixtures);
    var observer = this.newObserver(obj).observeEnumerable(obj);
    var item = fixtures[1];

    obj.removeObject(item);

    deepEqual(observer._before, [obj, [item], null]);
    deepEqual(observer._after, [obj, [item], null]);
  });

  exports.default = suite;
});
enifed('ember-runtime/tests/suites/mutable_enumerable/removeObject.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites/mutable_enumerable');
  test('ember-runtime/tests/suites/mutable_enumerable/removeObject.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/mutable_enumerable/removeObject.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/mutable_enumerable/removeObject.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites/mutable_enumerable');
  QUnit.test('ember-runtime/tests/suites/mutable_enumerable/removeObject.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/mutable_enumerable/removeObject.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/mutable_enumerable/removeObjects', ['exports', 'ember-runtime/tests/suites/suite', 'ember-metal/property_get', 'ember-metal/core'], function (exports, _emberRuntimeTestsSuitesSuite, _emberMetalProperty_get, _emberMetalCore) {
  'use strict';

  var suite = _emberRuntimeTestsSuitesSuite.SuiteModuleBuilder.create();

  suite.module('removeObjects');

  suite.test('should return receiver', function () {
    var before, obj;
    before = _emberMetalCore.default.A(this.newFixture(3));
    obj = before;
    equal(obj.removeObjects(before[1]), obj, 'should return receiver');
  });

  suite.test('[A,B,C].removeObjects([B]) => [A,C] + notify', function () {
    var obj, before, after, observer;

    before = _emberMetalCore.default.A(this.newFixture(3));
    after = [before[0], before[2]];
    obj = before;
    observer = this.newObserver(obj, '[]', 'length', 'firstObject', 'lastObject');
    obj.getProperties('firstObject', 'lastObject'); // Prime the cache

    obj.removeObjects([before[1]]);

    deepEqual(this.toArray(obj), after, 'post item results');
    equal(_emberMetalProperty_get.get(obj, 'length'), after.length, 'length');

    if (observer.isEnabled) {
      equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
      equal(observer.timesCalled('length'), 1, 'should have notified length once');

      equal(observer.validate('firstObject'), false, 'should NOT have notified firstObject');
      equal(observer.validate('lastObject'), false, 'should NOT have notified lastObject');
    }
  });

  suite.test('[{A},{B},{C}].removeObjects([{B}]) => [{A},{C}] + notify', function () {
    var obj, before, after, observer;

    before = _emberMetalCore.default.A(this.newObjectsFixture(3));
    after = [before[0], before[2]];
    obj = before;
    observer = this.newObserver(obj, '[]', 'length', 'firstObject', 'lastObject');
    obj.getProperties('firstObject', 'lastObject'); // Prime the cache

    obj.removeObjects([before[1]]);

    deepEqual(this.toArray(obj), after, 'post item results');
    equal(_emberMetalProperty_get.get(obj, 'length'), after.length, 'length');

    if (observer.isEnabled) {
      equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
      equal(observer.timesCalled('length'), 1, 'should have notified length once');

      equal(observer.validate('firstObject'), false, 'should NOT have notified firstObject');
      equal(observer.validate('lastObject'), false, 'should NOT have notified lastObject');
    }
  });

  suite.test('[A,B,C].removeObjects([A,B]) => [C] + notify', function () {
    var obj, before, after, observer;

    before = _emberMetalCore.default.A(this.newFixture(3));
    after = [before[2]];
    obj = before;
    observer = this.newObserver(obj, '[]', 'length', 'firstObject', 'lastObject');
    obj.getProperties('firstObject', 'lastObject'); // Prime the cache

    obj.removeObjects([before[0], before[1]]);

    deepEqual(this.toArray(obj), after, 'post item results');
    equal(_emberMetalProperty_get.get(obj, 'length'), after.length, 'length');

    if (observer.isEnabled) {
      equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
      equal(observer.timesCalled('length'), 1, 'should have notified length once');

      equal(observer.timesCalled('firstObject'), 1, 'should have notified firstObject');
      equal(observer.validate('lastObject'), false, 'should NOT have notified lastObject');
    }
  });

  suite.test('[{A},{B},{C}].removeObjects([{A},{B}]) => [{C}] + notify', function () {
    var obj, before, after, observer;

    before = _emberMetalCore.default.A(this.newObjectsFixture(3));
    after = [before[2]];
    obj = before;
    observer = this.newObserver(obj, '[]', 'length', 'firstObject', 'lastObject');
    obj.getProperties('firstObject', 'lastObject'); // Prime the cache

    obj.removeObjects([before[0], before[1]]);

    deepEqual(this.toArray(obj), after, 'post item results');
    equal(_emberMetalProperty_get.get(obj, 'length'), after.length, 'length');

    if (observer.isEnabled) {
      equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
      equal(observer.timesCalled('length'), 1, 'should have notified length once');

      equal(observer.timesCalled('firstObject'), 1, 'should have notified firstObject');
      equal(observer.validate('lastObject'), false, 'should NOT have notified lastObject');
    }
  });

  suite.test('[A,B,C].removeObjects([A,B,C]) => [] + notify', function () {
    var obj, before, after, observer;

    before = _emberMetalCore.default.A(this.newFixture(3));
    after = [];
    obj = before;
    observer = this.newObserver(obj, '[]', 'length', 'firstObject', 'lastObject');
    obj.getProperties('firstObject', 'lastObject'); // Prime the cache

    obj.removeObjects([before[0], before[1], before[2]]);

    deepEqual(this.toArray(obj), after, 'post item results');
    equal(_emberMetalProperty_get.get(obj, 'length'), after.length, 'length');

    if (observer.isEnabled) {
      equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
      equal(observer.timesCalled('length'), 1, 'should have notified length once');

      equal(observer.timesCalled('firstObject'), 1, 'should have notified firstObject');
      equal(observer.timesCalled('lastObject'), 1, 'should have notified lastObject');
    }
  });

  suite.test('[{A},{B},{C}].removeObjects([{A},{B},{C}]) => [] + notify', function () {
    var obj, before, after, observer;

    before = _emberMetalCore.default.A(this.newObjectsFixture(3));
    after = [];
    obj = before;
    observer = this.newObserver(obj, '[]', 'length', 'firstObject', 'lastObject');
    obj.getProperties('firstObject', 'lastObject'); // Prime the cache

    obj.removeObjects(before);

    deepEqual(this.toArray(obj), after, 'post item results');
    equal(_emberMetalProperty_get.get(obj, 'length'), after.length, 'length');

    if (observer.isEnabled) {
      equal(observer.timesCalled('[]'), 1, 'should have notified [] once');
      equal(observer.timesCalled('length'), 1, 'should have notified length once');

      equal(observer.timesCalled('firstObject'), 1, 'should have notified firstObject');
      equal(observer.validate('lastObject'), 1, 'should have notified lastObject');
    }
  });

  suite.test('[A,B,C].removeObjects([D]) => [A,B,C]', function () {
    var obj, before, after, observer, item;

    before = _emberMetalCore.default.A(this.newFixture(3));
    after = before;
    item = this.newFixture(1)[0];
    obj = before;
    observer = this.newObserver(obj, '[]', 'length', 'firstObject', 'lastObject');
    obj.getProperties('firstObject', 'lastObject'); // Prime the cache

    obj.removeObjects([item]); // Note: item not in set

    deepEqual(this.toArray(obj), after, 'post item results');
    equal(_emberMetalProperty_get.get(obj, 'length'), after.length, 'length');

    if (observer.isEnabled) {
      equal(observer.validate('[]'), false, 'should NOT have notified []');
      equal(observer.validate('length'), false, 'should NOT have notified length');

      equal(observer.validate('firstObject'), false, 'should NOT have notified firstObject');
      equal(observer.validate('lastObject'), false, 'should NOT have notified lastObject');
    }
  });

  suite.test('Removing objects should notify enumerable observer', function () {
    var fixtures = this.newFixture(3);
    var obj = this.newObject(fixtures);
    var observer = this.newObserver(obj).observeEnumerable(obj);
    var item = fixtures[1];

    obj.removeObjects([item]);

    deepEqual(observer._before, [obj, [item], null]);
    deepEqual(observer._after, [obj, [item], null]);
  });

  exports.default = suite;
});
enifed('ember-runtime/tests/suites/mutable_enumerable/removeObjects.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites/mutable_enumerable');
  test('ember-runtime/tests/suites/mutable_enumerable/removeObjects.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/mutable_enumerable/removeObjects.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/mutable_enumerable/removeObjects.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites/mutable_enumerable');
  QUnit.test('ember-runtime/tests/suites/mutable_enumerable/removeObjects.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/mutable_enumerable/removeObjects.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/suites/suite', ['exports', 'ember-runtime/system/object', 'ember-metal/utils', 'ember-metal/property_get'], function (exports, _emberRuntimeSystemObject, _emberMetalUtils, _emberMetalProperty_get) {
  'use strict';

  /*
    @class
    A Suite can be used to define a reusable set of unit tests that can be
    applied to any object.  Suites are most useful for defining tests that
    work against a mixin or plugin API.  Developers implementing objects that
    use the mixin or support the API can then run these tests against their
    own code to verify compliance.
  
    To define a suite, you need to define the tests themselves as well as a
    callback API implementers can use to tie your tests to their specific class.
  
    ## Defining a Callback API
  
    To define the callback API, just extend this class and add your properties
    or methods that must be provided.
  
    ## Defining Unit Tests
  
    To add unit tests, use the suite.module() or suite.test() methods instead
    of a regular module() or test() method when defining your tests.  This will
    add the tests to the suite.
  
    ## Using a Suite
  
    To use a Suite to test your own objects, extend the suite subclass and
    define any required methods.  Then call run() on the new subclass.  This
    will create an instance of your class and then defining the unit tests.
  
    @extends Ember.Object
    @private
  */
  var Suite = _emberRuntimeSystemObject.default.extend({

    /*
      __Required.__ You must implement this method to apply this mixin.
       Define a name for these tests - all modules are prefixed w/ it.
       @type String
    */
    name: null,

    /*
      Invoked to actually run the test - overridden by mixins
    */
    run: function () {}

  });

  Suite.reopenClass({

    plan: null,

    run: function () {
      var C = this;
      return new C().run();
    },

    module: function (desc, opts) {
      if (!opts) {
        opts = {};
      }

      var setup = opts.setup;
      var teardown = opts.teardown;
      this.reopen({
        run: function () {
          this._super.apply(this, arguments);
          var title = _emberMetalProperty_get.get(this, 'name') + ': ' + desc;
          var ctx = this;
          QUnit.module(title, {
            setup: function () {
              if (setup) {
                setup.call(ctx);
              }
            },

            teardown: function () {
              if (teardown) {
                teardown.call(ctx);
              }
            }
          });
        }
      });
    },

    test: function (name, func) {
      this.reopen({
        run: function () {
          this._super.apply(this, arguments);
          var ctx = this;

          if (!func) {
            QUnit.test(name); // output warning
          } else {
              QUnit.test(name, function () {
                func.call(ctx);
              });
            }
        }
      });
    },

    // convert to guids to minimize logging.
    same: function (actual, exp, message) {
      actual = actual && actual.map ? actual.map(function (x) {
        return _emberMetalUtils.guidFor(x);
      }) : actual;
      exp = exp && exp.map ? exp.map(function (x) {
        return _emberMetalUtils.guidFor(x);
      }) : exp;
      return deepEqual(actual, exp, message);
    },

    // easy way to disable tests
    notest: function () {},

    importModuleTests: function (builder) {
      var _this = this;

      this.module(builder._module);

      builder._tests.forEach(function (descAndFunc) {
        _this.test.apply(_this, descAndFunc);
      });
    }
  });

  var SuiteModuleBuilder = _emberRuntimeSystemObject.default.extend({
    _module: null,
    _tests: null,

    init: function () {
      this._tests = [];
    },

    module: function (name) {
      this._module = name;
    },

    test: function (name, func) {
      this._tests.push([name, func]);
    }
  });

  exports.SuiteModuleBuilder = SuiteModuleBuilder;
  exports.Suite = Suite;
  exports.default = Suite;
});
enifed('ember-runtime/tests/suites/suite.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/suites');
  test('ember-runtime/tests/suites/suite.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/suites/suite.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/suites/suite.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/suites');
  QUnit.test('ember-runtime/tests/suites/suite.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/suites/suite.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/system/application/base_test', ['exports', 'ember-runtime/system/namespace', 'ember-runtime/system/application'], function (exports, _emberRuntimeSystemNamespace, _emberRuntimeSystemApplication) {
  'use strict';

  QUnit.module('Ember.Application');

  QUnit.test('Ember.Application should be a subclass of Ember.Namespace', function () {

    ok(_emberRuntimeSystemNamespace.default.detect(_emberRuntimeSystemApplication.default), 'Ember.Application subclass of Ember.Namespace');
  });
});
enifed('ember-runtime/tests/system/application/base_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/system/application');
  test('ember-runtime/tests/system/application/base_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/system/application/base_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/system/application/base_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/system/application');
  QUnit.test('ember-runtime/tests/system/application/base_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/system/application/base_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/system/array_proxy/arranged_content_test', ['exports', 'ember-metal/core', 'ember-metal/run_loop', 'ember-metal/computed', 'ember-runtime/system/array_proxy'], function (exports, _emberMetalCore, _emberMetalRun_loop, _emberMetalComputed, _emberRuntimeSystemArray_proxy) {
  'use strict';

  var array;

  QUnit.module('ArrayProxy - arrangedContent', {
    setup: function () {
      _emberMetalRun_loop.default(function () {
        array = _emberRuntimeSystemArray_proxy.default.extend({
          arrangedContent: _emberMetalComputed.computed('content.[]', function () {
            var content = this.get('content');
            return content && _emberMetalCore.default.A(content.slice().sort(function (a, b) {
              if (a == null) {
                a = -1;
              }
              if (b == null) {
                b = -1;
              }
              return b - a;
            }));
          })
        }).create({
          content: _emberMetalCore.default.A([1, 2, 4, 5])
        });
      });
    },
    teardown: function () {
      _emberMetalRun_loop.default(function () {
        array.destroy();
      });
    }
  });

  QUnit.test('addObject - adds to end of \'content\' if not present', function () {
    _emberMetalRun_loop.default(function () {
      array.addObject(3);
    });
    deepEqual(array.get('content'), [1, 2, 4, 5, 3], 'adds to end of content');
    deepEqual(array.get('arrangedContent'), [5, 4, 3, 2, 1], 'arrangedContent stays sorted');

    _emberMetalRun_loop.default(function () {
      array.addObject(1);
    });
    deepEqual(array.get('content'), [1, 2, 4, 5, 3], 'does not add existing number to content');
  });

  QUnit.test('addObjects - adds to end of \'content\' if not present', function () {
    _emberMetalRun_loop.default(function () {
      array.addObjects([1, 3, 6]);
    });
    deepEqual(array.get('content'), [1, 2, 4, 5, 3, 6], 'adds to end of content');
    deepEqual(array.get('arrangedContent'), [6, 5, 4, 3, 2, 1], 'arrangedContent stays sorted');
  });

  QUnit.test('compact - returns arrangedContent without nulls and undefined', function () {
    _emberMetalRun_loop.default(function () {
      array.set('content', _emberMetalCore.default.A([1, 3, null, 2, undefined]));
    });
    deepEqual(array.compact(), [3, 2, 1]);
  });

  QUnit.test('indexOf - returns index of object in arrangedContent', function () {
    equal(array.indexOf(4), 1, 'returns arranged index');
  });

  QUnit.test('insertAt - raises, indeterminate behavior', function () {
    throws(function () {
      _emberMetalRun_loop.default(function () {
        array.insertAt(2, 3);
      });
    });
  });

  QUnit.test('lastIndexOf - returns last index of object in arrangedContent', function () {
    _emberMetalRun_loop.default(function () {
      array.pushObject(4);
    });
    equal(array.lastIndexOf(4), 2, 'returns last arranged index');
  });

  QUnit.test('nextObject - returns object at index in arrangedContent', function () {
    equal(array.nextObject(1), 4, 'returns object at index');
  });

  QUnit.test('objectAt - returns object at index in arrangedContent', function () {
    equal(array.objectAt(1), 4, 'returns object at index');
  });

  // Not sure if we need a specific test for it, since it's internal
  QUnit.test('objectAtContent - returns object at index in arrangedContent', function () {
    equal(array.objectAtContent(1), 4, 'returns object at index');
  });

  QUnit.test('objectsAt - returns objects at indices in arrangedContent', function () {
    deepEqual(array.objectsAt([0, 2, 4]), [5, 2, undefined], 'returns objects at indices');
  });

  QUnit.test('popObject - removes last object in arrangedContent', function () {
    var popped;
    _emberMetalRun_loop.default(function () {
      popped = array.popObject();
    });
    equal(popped, 1, 'returns last object');
    deepEqual(array.get('content'), [2, 4, 5], 'removes from content');
  });

  QUnit.test('pushObject - adds to end of content even if it already exists', function () {
    _emberMetalRun_loop.default(function () {
      array.pushObject(1);
    });
    deepEqual(array.get('content'), [1, 2, 4, 5, 1], 'adds to end of content');
  });

  QUnit.test('pushObjects - adds multiple to end of content even if it already exists', function () {
    _emberMetalRun_loop.default(function () {
      array.pushObjects([1, 2, 4]);
    });
    deepEqual(array.get('content'), [1, 2, 4, 5, 1, 2, 4], 'adds to end of content');
  });

  QUnit.test('removeAt - removes from index in arrangedContent', function () {
    _emberMetalRun_loop.default(function () {
      array.removeAt(1, 2);
    });
    deepEqual(array.get('content'), [1, 5]);
  });

  QUnit.test('removeObject - removes object from content', function () {
    _emberMetalRun_loop.default(function () {
      array.removeObject(2);
    });
    deepEqual(array.get('content'), [1, 4, 5]);
  });

  QUnit.test('removeObjects - removes objects from content', function () {
    _emberMetalRun_loop.default(function () {
      array.removeObjects([2, 4, 6]);
    });
    deepEqual(array.get('content'), [1, 5]);
  });

  QUnit.test('replace - raises, indeterminate behavior', function () {
    throws(function () {
      _emberMetalRun_loop.default(function () {
        array.replace(1, 2, [3]);
      });
    });
  });

  QUnit.test('replaceContent - does a standard array replace on content', function () {
    _emberMetalRun_loop.default(function () {
      array.replaceContent(1, 2, [3]);
    });
    deepEqual(array.get('content'), [1, 3, 5]);
  });

  QUnit.test('reverseObjects - raises, use Sortable#sortAscending', function () {
    throws(function () {
      _emberMetalRun_loop.default(function () {
        array.reverseObjects();
      });
    });
  });

  QUnit.test('setObjects - replaces entire content', function () {
    _emberMetalRun_loop.default(function () {
      array.setObjects([6, 7, 8]);
    });
    deepEqual(array.get('content'), [6, 7, 8], 'replaces content');
  });

  QUnit.test('shiftObject - removes from start of arrangedContent', function () {
    var shifted;
    _emberMetalRun_loop.default(function () {
      shifted = array.shiftObject();
    });
    equal(shifted, 5, 'returns first object');
    deepEqual(array.get('content'), [1, 2, 4], 'removes object from content');
  });

  QUnit.test('slice - returns a slice of the arrangedContent', function () {
    deepEqual(array.slice(1, 3), [4, 2], 'returns sliced arrangedContent');
  });

  QUnit.test('toArray - returns copy of arrangedContent', function () {
    deepEqual(array.toArray(), [5, 4, 2, 1]);
  });

  QUnit.test('unshiftObject - adds to start of content', function () {
    _emberMetalRun_loop.default(function () {
      array.unshiftObject(6);
    });
    deepEqual(array.get('content'), [6, 1, 2, 4, 5], 'adds to start of content');
  });

  QUnit.test('unshiftObjects - adds to start of content', function () {
    _emberMetalRun_loop.default(function () {
      array.unshiftObjects([6, 7]);
    });
    deepEqual(array.get('content'), [6, 7, 1, 2, 4, 5], 'adds to start of content');
  });

  QUnit.test('without - returns arrangedContent without object', function () {
    deepEqual(array.without(2), [5, 4, 1], 'returns arranged without object');
  });

  QUnit.test('lastObject - returns last arranged object', function () {
    equal(array.get('lastObject'), 1, 'returns last arranged object');
  });

  QUnit.test('firstObject - returns first arranged object', function () {
    equal(array.get('firstObject'), 5, 'returns first arranged object');
  });

  QUnit.module('ArrayProxy - arrangedContent matching content', {
    setup: function () {
      _emberMetalRun_loop.default(function () {
        array = _emberRuntimeSystemArray_proxy.default.create({
          content: _emberMetalCore.default.A([1, 2, 4, 5])
        });
      });
    },
    teardown: function () {
      _emberMetalRun_loop.default(function () {
        array.destroy();
      });
    }
  });

  QUnit.test('insertAt - inserts object at specified index', function () {
    _emberMetalRun_loop.default(function () {
      array.insertAt(2, 3);
    });
    deepEqual(array.get('content'), [1, 2, 3, 4, 5]);
  });

  QUnit.test('replace - does a standard array replace', function () {
    _emberMetalRun_loop.default(function () {
      array.replace(1, 2, [3]);
    });
    deepEqual(array.get('content'), [1, 3, 5]);
  });

  QUnit.test('reverseObjects - reverses content', function () {
    _emberMetalRun_loop.default(function () {
      array.reverseObjects();
    });
    deepEqual(array.get('content'), [5, 4, 2, 1]);
  });

  QUnit.module('ArrayProxy - arrangedContent with transforms', {
    setup: function () {
      _emberMetalRun_loop.default(function () {
        array = _emberRuntimeSystemArray_proxy.default.extend({
          arrangedContent: _emberMetalComputed.computed(function () {
            var content = this.get('content');
            return content && _emberMetalCore.default.A(content.slice().sort(function (a, b) {
              if (a == null) {
                a = -1;
              }
              if (b == null) {
                b = -1;
              }
              return b - a;
            }));
          }).property('content.[]'),

          objectAtContent: function (idx) {
            var obj = this.get('arrangedContent').objectAt(idx);
            return obj && obj.toString();
          }
        }).create({
          content: _emberMetalCore.default.A([1, 2, 4, 5])
        });
      });
    },
    teardown: function () {
      _emberMetalRun_loop.default(function () {
        array.destroy();
      });
    }
  });

  QUnit.test('indexOf - returns index of object in arrangedContent', function () {
    equal(array.indexOf('4'), 1, 'returns arranged index');
  });

  QUnit.test('lastIndexOf - returns last index of object in arrangedContent', function () {
    _emberMetalRun_loop.default(function () {
      array.pushObject(4);
    });
    equal(array.lastIndexOf('4'), 2, 'returns last arranged index');
  });

  QUnit.test('nextObject - returns object at index in arrangedContent', function () {
    equal(array.nextObject(1), '4', 'returns object at index');
  });

  QUnit.test('objectAt - returns object at index in arrangedContent', function () {
    equal(array.objectAt(1), '4', 'returns object at index');
  });

  // Not sure if we need a specific test for it, since it's internal
  QUnit.test('objectAtContent - returns object at index in arrangedContent', function () {
    equal(array.objectAtContent(1), '4', 'returns object at index');
  });

  QUnit.test('objectsAt - returns objects at indices in arrangedContent', function () {
    deepEqual(array.objectsAt([0, 2, 4]), ['5', '2', undefined], 'returns objects at indices');
  });

  QUnit.test('popObject - removes last object in arrangedContent', function () {
    var popped;
    _emberMetalRun_loop.default(function () {
      popped = array.popObject();
    });
    equal(popped, '1', 'returns last object');
    deepEqual(array.get('content'), [2, 4, 5], 'removes from content');
  });

  QUnit.test('removeObject - removes object from content', function () {
    _emberMetalRun_loop.default(function () {
      array.removeObject('2');
    });
    deepEqual(array.get('content'), [1, 4, 5]);
  });

  QUnit.test('removeObjects - removes objects from content', function () {
    _emberMetalRun_loop.default(function () {
      array.removeObjects(['2', '4', '6']);
    });
    deepEqual(array.get('content'), [1, 5]);
  });

  QUnit.test('shiftObject - removes from start of arrangedContent', function () {
    var shifted;
    _emberMetalRun_loop.default(function () {
      shifted = array.shiftObject();
    });
    equal(shifted, '5', 'returns first object');
    deepEqual(array.get('content'), [1, 2, 4], 'removes object from content');
  });

  QUnit.test('slice - returns a slice of the arrangedContent', function () {
    deepEqual(array.slice(1, 3), ['4', '2'], 'returns sliced arrangedContent');
  });

  QUnit.test('toArray - returns copy of arrangedContent', function () {
    deepEqual(array.toArray(), ['5', '4', '2', '1']);
  });

  QUnit.test('without - returns arrangedContent without object', function () {
    deepEqual(array.without('2'), ['5', '4', '1'], 'returns arranged without object');
  });

  QUnit.test('lastObject - returns last arranged object', function () {
    equal(array.get('lastObject'), '1', 'returns last arranged object');
  });

  QUnit.test('firstObject - returns first arranged object', function () {
    equal(array.get('firstObject'), '5', 'returns first arranged object');
  });
});
enifed('ember-runtime/tests/system/array_proxy/arranged_content_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/system/array_proxy');
  test('ember-runtime/tests/system/array_proxy/arranged_content_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/system/array_proxy/arranged_content_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/system/array_proxy/arranged_content_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/system/array_proxy');
  QUnit.test('ember-runtime/tests/system/array_proxy/arranged_content_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/system/array_proxy/arranged_content_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/system/array_proxy/content_change_test', ['exports', 'ember-metal/core', 'ember-metal/property_set', 'ember-metal/run_loop', 'ember-runtime/system/array_proxy'], function (exports, _emberMetalCore, _emberMetalProperty_set, _emberMetalRun_loop, _emberRuntimeSystemArray_proxy) {
  'use strict';

  QUnit.module('ArrayProxy - content change');

  QUnit.test('should update length for null content', function () {
    var proxy = _emberRuntimeSystemArray_proxy.default.create({
      content: _emberMetalCore.default.A([1, 2, 3])
    });

    equal(proxy.get('length'), 3, 'precond - length is 3');

    proxy.set('content', null);

    equal(proxy.get('length'), 0, 'length updates');
  });

  QUnit.test('The `arrangedContentWillChange` method is invoked before `content` is changed.', function () {
    var callCount = 0;
    var expectedLength;

    var proxy = _emberRuntimeSystemArray_proxy.default.extend({
      content: _emberMetalCore.default.A([1, 2, 3]),

      arrangedContentWillChange: function () {
        equal(this.get('arrangedContent.length'), expectedLength, 'hook should be invoked before array has changed');
        callCount++;
      }
    }).create();

    proxy.pushObject(4);
    equal(callCount, 0, 'pushing content onto the array doesn\'t trigger it');

    proxy.get('content').pushObject(5);
    equal(callCount, 0, 'pushing content onto the content array doesn\'t trigger it');

    expectedLength = 5;
    proxy.set('content', _emberMetalCore.default.A(['a', 'b']));
    equal(callCount, 1, 'replacing the content array triggers the hook');
  });

  QUnit.test('The `arrangedContentDidChange` method is invoked after `content` is changed.', function () {
    var callCount = 0;
    var expectedLength;

    var proxy = _emberRuntimeSystemArray_proxy.default.extend({
      content: _emberMetalCore.default.A([1, 2, 3]),

      arrangedContentDidChange: function () {
        equal(this.get('arrangedContent.length'), expectedLength, 'hook should be invoked after array has changed');
        callCount++;
      }
    }).create();

    equal(callCount, 0, 'hook is not called after creating the object');

    proxy.pushObject(4);
    equal(callCount, 0, 'pushing content onto the array doesn\'t trigger it');

    proxy.get('content').pushObject(5);
    equal(callCount, 0, 'pushing content onto the content array doesn\'t trigger it');

    expectedLength = 2;
    proxy.set('content', _emberMetalCore.default.A(['a', 'b']));
    equal(callCount, 1, 'replacing the content array triggers the hook');
  });

  QUnit.test('The ArrayProxy doesn\'t explode when assigned a destroyed object', function () {
    var proxy1 = _emberRuntimeSystemArray_proxy.default.create();
    var proxy2 = _emberRuntimeSystemArray_proxy.default.create();

    _emberMetalRun_loop.default(function () {
      proxy1.destroy();
    });

    _emberMetalProperty_set.set(proxy2, 'content', proxy1);

    ok(true, 'No exception was raised');
  });
});
enifed('ember-runtime/tests/system/array_proxy/content_change_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/system/array_proxy');
  test('ember-runtime/tests/system/array_proxy/content_change_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/system/array_proxy/content_change_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/system/array_proxy/content_change_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/system/array_proxy');
  QUnit.test('ember-runtime/tests/system/array_proxy/content_change_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/system/array_proxy/content_change_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/system/array_proxy/content_update_test', ['exports', 'ember-metal/core', 'ember-metal/computed', 'ember-runtime/system/array_proxy'], function (exports, _emberMetalCore, _emberMetalComputed, _emberRuntimeSystemArray_proxy) {
  'use strict';

  QUnit.module('Ember.ArrayProxy - content update');

  QUnit.test('The `contentArrayDidChange` method is invoked after `content` is updated.', function () {

    var proxy;
    var observerCalled = false;

    proxy = _emberRuntimeSystemArray_proxy.default.extend({
      arrangedContent: _emberMetalComputed.computed('content', function (key) {
        return _emberMetalCore.default.A(this.get('content').slice());
      }),

      contentArrayDidChange: function (array, idx, removedCount, addedCount) {
        observerCalled = true;
        return this._super(array, idx, removedCount, addedCount);
      }
    }).create({
      content: _emberMetalCore.default.A()
    });

    proxy.pushObject(1);

    ok(observerCalled, 'contentArrayDidChange is invoked');
  });
});
enifed('ember-runtime/tests/system/array_proxy/content_update_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/system/array_proxy');
  test('ember-runtime/tests/system/array_proxy/content_update_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/system/array_proxy/content_update_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/system/array_proxy/content_update_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/system/array_proxy');
  QUnit.test('ember-runtime/tests/system/array_proxy/content_update_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/system/array_proxy/content_update_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/system/array_proxy/length_test', ['exports', 'ember-runtime/system/array_proxy', 'ember-runtime/system/object', 'ember-metal/mixin', 'ember-metal/computed', 'ember-runtime/system/native_array'], function (exports, _emberRuntimeSystemArray_proxy, _emberRuntimeSystemObject, _emberMetalMixin, _emberMetalComputed, _emberRuntimeSystemNative_array) {
  'use strict';

  QUnit.module('Ember.ArrayProxy - content change (length)');

  QUnit.test('array proxy + aliasedProperty complex test', function () {
    var aCalled, bCalled, cCalled, dCalled, eCalled;

    aCalled = bCalled = cCalled = dCalled = eCalled = 0;

    var obj = _emberRuntimeSystemObject.default.extend({
      colors: _emberMetalComputed.computed.reads('model'),
      length: _emberMetalComputed.computed.reads('colors.length'),

      a: _emberMetalMixin.observer('length', function () {
        aCalled++;
      }),

      b: _emberMetalMixin.observer('colors.length', function () {
        bCalled++;
      }),

      c: _emberMetalMixin.observer('colors.content.length', function () {
        cCalled++;
      }),

      d: _emberMetalMixin.observer('colors.[]', function () {
        dCalled++;
      }),

      e: _emberMetalMixin.observer('colors.content.[]', function () {
        eCalled++;
      })
    }).create();

    obj.set('model', _emberRuntimeSystemArray_proxy.default.create({
      content: _emberRuntimeSystemNative_array.A(['red', 'yellow', 'blue'])
    }));

    equal(obj.get('colors.content.length'), 3);
    equal(obj.get('colors.length'), 3);
    equal(obj.get('length'), 3);

    equal(aCalled, 1, 'expected observer `length` to be called ONCE');
    equal(bCalled, 1, 'expected observer `colors.length` to be called ONCE');
    equal(cCalled, 1, 'expected observer `colors.content.length` to be called ONCE');
    equal(dCalled, 1, 'expected observer `colors.[]` to be called ONCE');
    equal(eCalled, 1, 'expected observer `colors.content.[]` to be called ONCE');

    obj.get('colors').pushObjects(['green', 'red']);

    equal(obj.get('colors.content.length'), 5);
    equal(obj.get('colors.length'), 5);
    equal(obj.get('length'), 5);

    equal(aCalled, 2, 'expected observer `length` to be called TWICE');
    equal(bCalled, 2, 'expected observer `colors.length` to be called TWICE');
    equal(cCalled, 2, 'expected observer `colors.content.length` to be called TWICE');
    equal(dCalled, 2, 'expected observer `colors.[]` to be called TWICE');
    equal(eCalled, 2, 'expected observer `colors.content.[]` to be called TWICE');
  });
});
enifed('ember-runtime/tests/system/array_proxy/length_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/system/array_proxy');
  test('ember-runtime/tests/system/array_proxy/length_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/system/array_proxy/length_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/system/array_proxy/length_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/system/array_proxy');
  QUnit.test('ember-runtime/tests/system/array_proxy/length_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/system/array_proxy/length_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/system/array_proxy/suite_test', ['exports', 'ember-metal/core', 'ember-runtime/tests/suites/mutable_array', 'ember-runtime/system/array_proxy', 'ember-metal/property_get'], function (exports, _emberMetalCore, _emberRuntimeTestsSuitesMutable_array, _emberRuntimeSystemArray_proxy, _emberMetalProperty_get) {
  'use strict';

  _emberRuntimeTestsSuitesMutable_array.default.extend({

    name: 'Ember.ArrayProxy',

    newObject: function (ary) {
      var ret = ary ? ary.slice() : this.newFixture(3);
      return _emberRuntimeSystemArray_proxy.default.create({ content: _emberMetalCore.default.A(ret) });
    },

    mutate: function (obj) {
      obj.pushObject(_emberMetalProperty_get.get(obj, 'length') + 1);
    },

    toArray: function (obj) {
      return obj.toArray ? obj.toArray() : obj.slice();
    }

  }).run();
});
enifed('ember-runtime/tests/system/array_proxy/suite_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/system/array_proxy');
  test('ember-runtime/tests/system/array_proxy/suite_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/system/array_proxy/suite_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/system/array_proxy/suite_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/system/array_proxy');
  QUnit.test('ember-runtime/tests/system/array_proxy/suite_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/system/array_proxy/suite_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/system/lazy_load_test', ['exports', 'ember-metal/run_loop', 'ember-runtime/system/lazy_load'], function (exports, _emberMetalRun_loop, _emberRuntimeSystemLazy_load) {
  'use strict';

  QUnit.module('Lazy Loading');

  QUnit.test('if a load hook is registered, it is executed when runLoadHooks are exected', function () {
    var count = 0;

    _emberMetalRun_loop.default(function () {
      _emberRuntimeSystemLazy_load.onLoad('__test_hook__', function (object) {
        count += object;
      });
    });

    _emberMetalRun_loop.default(function () {
      _emberRuntimeSystemLazy_load.runLoadHooks('__test_hook__', 1);
    });

    equal(count, 1, 'the object was passed into the load hook');
  });

  QUnit.test('if runLoadHooks was already run, it executes newly added hooks immediately', function () {
    var count = 0;
    _emberMetalRun_loop.default(function () {
      _emberRuntimeSystemLazy_load.onLoad('__test_hook__', function (object) {
        count += object;
      });
    });

    _emberMetalRun_loop.default(function () {
      _emberRuntimeSystemLazy_load.runLoadHooks('__test_hook__', 1);
    });

    count = 0;
    _emberMetalRun_loop.default(function () {
      _emberRuntimeSystemLazy_load.onLoad('__test_hook__', function (object) {
        count += object;
      });
    });

    equal(count, 1, 'the original object was passed into the load hook');
  });

  QUnit.test('hooks in ENV.EMBER_LOAD_HOOKS[\'hookName\'] get executed', function () {

    // Note that the necessary code to perform this test is run before
    // the Ember lib is loaded in tests/index.html

    _emberMetalRun_loop.default(function () {
      _emberRuntimeSystemLazy_load.runLoadHooks('__before_ember_test_hook__', 1);
    });

    equal(window.ENV.__test_hook_count__, 1, 'the object was passed into the load hook');
  });

  if (typeof window === 'object' && typeof window.dispatchEvent === 'function' && typeof CustomEvent === 'function') {
    QUnit.test('load hooks trigger a custom event', function () {
      var eventObject = 'super duper awesome events';

      window.addEventListener('__test_hook_for_events__', function (e) {
        ok(true, 'custom event was fired');
        equal(e.detail, eventObject, 'event details are provided properly');
      });

      _emberMetalRun_loop.default(function () {
        _emberRuntimeSystemLazy_load.runLoadHooks('__test_hook_for_events__', eventObject);
      });
    });
  }
});
enifed('ember-runtime/tests/system/lazy_load_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/system');
  test('ember-runtime/tests/system/lazy_load_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/system/lazy_load_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/system/lazy_load_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/system');
  QUnit.test('ember-runtime/tests/system/lazy_load_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/system/lazy_load_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/system/namespace/base_test', ['exports', 'ember-metal/core', 'ember-metal/run_loop', 'ember-metal/property_get', 'ember-runtime/system/object', 'ember-runtime/system/namespace'], function (exports, _emberMetalCore, _emberMetalRun_loop, _emberMetalProperty_get, _emberRuntimeSystemObject, _emberRuntimeSystemNamespace) {
  'use strict';

  var originalLookup, lookup;

  QUnit.module('Namespace', {
    setup: function () {
      originalLookup = _emberMetalCore.default.lookup;
      _emberMetalCore.default.BOOTED = false;

      lookup = _emberMetalCore.default.lookup = {};
    },
    teardown: function () {
      _emberMetalCore.default.BOOTED = false;

      for (var prop in lookup) {
        if (lookup[prop]) {
          _emberMetalRun_loop.default(lookup[prop], 'destroy');
        }
      }

      _emberMetalCore.default.lookup = originalLookup;
    }
  });

  QUnit.test('Namespace should be a subclass of EmberObject', function () {
    ok(_emberRuntimeSystemObject.default.detect(_emberRuntimeSystemNamespace.default));
  });

  QUnit.test('Namespace should be duck typed', function () {
    ok(_emberMetalProperty_get.get(_emberRuntimeSystemNamespace.default.create(), 'isNamespace'), 'isNamespace property is true');
  });

  QUnit.test('Namespace is found and named', function () {
    var nsA = lookup.NamespaceA = _emberRuntimeSystemNamespace.default.create();
    equal(nsA.toString(), 'NamespaceA', 'namespaces should have a name if they are on lookup');

    var nsB = lookup.NamespaceB = _emberRuntimeSystemNamespace.default.create();
    equal(nsB.toString(), 'NamespaceB', 'namespaces work if created after the first namespace processing pass');
  });

  QUnit.test('Classes under an Namespace are properly named', function () {
    var nsA = lookup.NamespaceA = _emberRuntimeSystemNamespace.default.create();
    nsA.Foo = _emberRuntimeSystemObject.default.extend();
    equal(nsA.Foo.toString(), 'NamespaceA.Foo', 'Classes pick up their parent namespace');

    nsA.Bar = _emberRuntimeSystemObject.default.extend();
    equal(nsA.Bar.toString(), 'NamespaceA.Bar', 'New Classes get the naming treatment too');

    var nsB = lookup.NamespaceB = _emberRuntimeSystemNamespace.default.create();
    nsB.Foo = _emberRuntimeSystemObject.default.extend();
    equal(nsB.Foo.toString(), 'NamespaceB.Foo', 'Classes in new namespaces get the naming treatment');
  });

  //test("Classes under Ember are properly named", function() {
  //  // ES6TODO: This test does not work reliably when running independent package build with Broccoli config.
  //  Ember.TestObject = EmberObject.extend({});
  //  equal(Ember.TestObject.toString(), "Ember.TestObject", "class under Ember is given a string representation");
  //});

  QUnit.test('Lowercase namespaces are no longer supported', function () {
    var nsC = lookup.namespaceC = _emberRuntimeSystemNamespace.default.create();
    equal(nsC.toString(), undefined);
  });

  QUnit.test('A namespace can be assigned a custom name', function () {
    var nsA = _emberRuntimeSystemNamespace.default.create({
      name: 'NamespaceA'
    });

    var nsB = lookup.NamespaceB = _emberRuntimeSystemNamespace.default.create({
      name: 'CustomNamespaceB'
    });

    nsA.Foo = _emberRuntimeSystemObject.default.extend();
    nsB.Foo = _emberRuntimeSystemObject.default.extend();

    equal(nsA.Foo.toString(), 'NamespaceA.Foo', 'The namespace\'s name is used when the namespace is not in the lookup object');
    equal(nsB.Foo.toString(), 'CustomNamespaceB.Foo', 'The namespace\'s name is used when the namespace is in the lookup object');
  });

  QUnit.test('Calling namespace.nameClasses() eagerly names all classes', function () {
    _emberMetalCore.default.BOOTED = true;

    var namespace = lookup.NS = _emberRuntimeSystemNamespace.default.create();

    namespace.ClassA = _emberRuntimeSystemObject.default.extend();
    namespace.ClassB = _emberRuntimeSystemObject.default.extend();

    _emberRuntimeSystemNamespace.default.processAll();

    equal(namespace.ClassA.toString(), 'NS.ClassA');
    equal(namespace.ClassB.toString(), 'NS.ClassB');
  });

  QUnit.test('A namespace can be looked up by its name', function () {
    var NS = lookup.NS = _emberRuntimeSystemNamespace.default.create();
    var UI = lookup.UI = _emberRuntimeSystemNamespace.default.create();
    var CF = lookup.CF = _emberRuntimeSystemNamespace.default.create();

    equal(_emberRuntimeSystemNamespace.default.byName('NS'), NS);
    equal(_emberRuntimeSystemNamespace.default.byName('UI'), UI);
    equal(_emberRuntimeSystemNamespace.default.byName('CF'), CF);
  });

  QUnit.test('A nested namespace can be looked up by its name', function () {
    var UI = lookup.UI = _emberRuntimeSystemNamespace.default.create();
    UI.Nav = _emberRuntimeSystemNamespace.default.create();

    equal(_emberRuntimeSystemNamespace.default.byName('UI.Nav'), UI.Nav);
  });

  QUnit.test('Destroying a namespace before caching lookup removes it from the list of namespaces', function () {
    var CF = lookup.CF = _emberRuntimeSystemNamespace.default.create();

    _emberMetalRun_loop.default(CF, 'destroy');
    equal(_emberRuntimeSystemNamespace.default.byName('CF'), undefined, 'namespace can not be found after destroyed');
  });

  QUnit.test('Destroying a namespace after looking up removes it from the list of namespaces', function () {
    var CF = lookup.CF = _emberRuntimeSystemNamespace.default.create();

    equal(_emberRuntimeSystemNamespace.default.byName('CF'), CF, 'precondition - namespace can be looked up by name');

    _emberMetalRun_loop.default(CF, 'destroy');
    equal(_emberRuntimeSystemNamespace.default.byName('CF'), undefined, 'namespace can not be found after destroyed');
  });
});
enifed('ember-runtime/tests/system/namespace/base_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/system/namespace');
  test('ember-runtime/tests/system/namespace/base_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/system/namespace/base_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/system/namespace/base_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/system/namespace');
  QUnit.test('ember-runtime/tests/system/namespace/base_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/system/namespace/base_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/system/native_array/copyable_suite_test', ['exports', 'ember-metal/core', 'ember-metal/utils', 'ember-runtime/tests/suites/copyable'], function (exports, _emberMetalCore, _emberMetalUtils, _emberRuntimeTestsSuitesCopyable) {
  'use strict';

  _emberRuntimeTestsSuitesCopyable.default.extend({
    name: 'NativeArray Copyable',

    newObject: function () {
      return _emberMetalCore.default.A([_emberMetalUtils.generateGuid()]);
    },

    isEqual: function (a, b) {
      if (!(a instanceof Array)) {
        return false;
      }

      if (!(b instanceof Array)) {
        return false;
      }

      if (a.length !== b.length) {
        return false;
      }

      return a[0] === b[0];
    },

    shouldBeFreezable: false
  }).run();

  QUnit.module('NativeArray Copyable');

  QUnit.test('deep copy is respected', function () {
    var array = _emberMetalCore.default.A([{ id: 1 }, { id: 2 }, { id: 3 }]);

    var copiedArray = array.copy(true);

    deepEqual(copiedArray, array, 'copied array is equivalent');
    ok(copiedArray[0] !== array[0], 'objects inside should be unique');
  });
});
enifed('ember-runtime/tests/system/native_array/copyable_suite_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/system/native_array');
  test('ember-runtime/tests/system/native_array/copyable_suite_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/system/native_array/copyable_suite_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/system/native_array/copyable_suite_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/system/native_array');
  QUnit.test('ember-runtime/tests/system/native_array/copyable_suite_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/system/native_array/copyable_suite_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/system/native_array/suite_test', ['exports', 'ember-metal/core', 'ember-runtime/tests/suites/mutable_array'], function (exports, _emberMetalCore, _emberRuntimeTestsSuitesMutable_array) {
  'use strict';

  _emberRuntimeTestsSuitesMutable_array.default.extend({

    name: 'Native Array',

    newObject: function (ary) {
      return _emberMetalCore.default.A(ary ? ary.slice() : this.newFixture(3));
    },

    mutate: function (obj) {
      obj.pushObject(obj.length + 1);
    },

    toArray: function (obj) {
      return obj.slice(); // make a copy.
    }

  }).run();
});
enifed('ember-runtime/tests/system/native_array/suite_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/system/native_array');
  test('ember-runtime/tests/system/native_array/suite_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/system/native_array/suite_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/system/native_array/suite_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/system/native_array');
  QUnit.test('ember-runtime/tests/system/native_array/suite_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/system/native_array/suite_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/system/object/computed_test', ['exports', 'ember-metal/computed', 'ember-metal/property_get', 'ember-metal/mixin', 'ember-metal/tests/props_helper', 'ember-runtime/system/object'], function (exports, _emberMetalComputed, _emberMetalProperty_get, _emberMetalMixin, _emberMetalTestsProps_helper, _emberRuntimeSystemObject) {
  'use strict';

  function K() {
    return this;
  }

  QUnit.module('EmberObject computed property');

  _emberMetalTestsProps_helper.testWithDefault('computed property on instance', function (get, set) {

    var MyClass = _emberRuntimeSystemObject.default.extend({
      foo: _emberMetalComputed.computed(function () {
        return 'FOO';
      })
    });

    equal(get(new MyClass(), 'foo'), 'FOO');
  });

  _emberMetalTestsProps_helper.testWithDefault('computed property on subclass', function (get, set) {

    var MyClass = _emberRuntimeSystemObject.default.extend({
      foo: _emberMetalComputed.computed(function () {
        return 'FOO';
      })
    });

    var Subclass = MyClass.extend({
      foo: _emberMetalComputed.computed(function () {
        return 'BAR';
      })
    });

    equal(get(new Subclass(), 'foo'), 'BAR');
  });

  _emberMetalTestsProps_helper.testWithDefault('replacing computed property with regular val', function (get, set) {

    var MyClass = _emberRuntimeSystemObject.default.extend({
      foo: _emberMetalComputed.computed(function () {
        return 'FOO';
      })
    });

    var Subclass = MyClass.extend({
      foo: 'BAR'
    });

    equal(get(new Subclass(), 'foo'), 'BAR');
  });

  _emberMetalTestsProps_helper.testWithDefault('complex depndent keys', function (get, set) {

    var MyClass = _emberRuntimeSystemObject.default.extend({

      init: function () {
        this._super.apply(this, arguments);
        set(this, 'bar', { baz: 'BIFF' });
      },

      count: 0,

      foo: _emberMetalComputed.computed(function () {
        set(this, 'count', get(this, 'count') + 1);
        return _emberMetalProperty_get.get(get(this, 'bar'), 'baz') + ' ' + get(this, 'count');
      }).property('bar.baz')

    });

    var Subclass = MyClass.extend({
      count: 20
    });

    var obj1 = new MyClass();
    var obj2 = new Subclass();

    equal(get(obj1, 'foo'), 'BIFF 1');
    equal(get(obj2, 'foo'), 'BIFF 21');

    set(get(obj1, 'bar'), 'baz', 'BLARG');

    equal(get(obj1, 'foo'), 'BLARG 2');
    equal(get(obj2, 'foo'), 'BIFF 21');

    set(get(obj2, 'bar'), 'baz', 'BOOM');

    equal(get(obj1, 'foo'), 'BLARG 2');
    equal(get(obj2, 'foo'), 'BOOM 22');
  });

  _emberMetalTestsProps_helper.testWithDefault('complex dependent keys changing complex dependent keys', function (get, set) {

    var MyClass = _emberRuntimeSystemObject.default.extend({

      init: function () {
        this._super.apply(this, arguments);
        set(this, 'bar', { baz: 'BIFF' });
      },

      count: 0,

      foo: _emberMetalComputed.computed(function () {
        set(this, 'count', get(this, 'count') + 1);
        return _emberMetalProperty_get.get(get(this, 'bar'), 'baz') + ' ' + get(this, 'count');
      }).property('bar.baz')

    });

    var Subclass = MyClass.extend({

      init: function () {
        this._super.apply(this, arguments);
        set(this, 'bar2', { baz: 'BIFF2' });
      },

      count: 0,

      foo: _emberMetalComputed.computed(function () {
        set(this, 'count', get(this, 'count') + 1);
        return _emberMetalProperty_get.get(get(this, 'bar2'), 'baz') + ' ' + get(this, 'count');
      }).property('bar2.baz')
    });

    var obj2 = new Subclass();

    equal(get(obj2, 'foo'), 'BIFF2 1');

    set(get(obj2, 'bar'), 'baz', 'BLARG');
    equal(get(obj2, 'foo'), 'BIFF2 1', 'should not invalidate property');

    set(get(obj2, 'bar2'), 'baz', 'BLARG');
    equal(get(obj2, 'foo'), 'BLARG 2', 'should invalidate property');
  });

  QUnit.test('can retrieve metadata for a computed property', function () {
    var MyClass = _emberRuntimeSystemObject.default.extend({
      computedProperty: _emberMetalComputed.computed(function () {}).meta({ key: 'keyValue' })
    });

    equal(_emberMetalProperty_get.get(MyClass.metaForProperty('computedProperty'), 'key'), 'keyValue', 'metadata saved on the computed property can be retrieved');

    var ClassWithNoMetadata = _emberRuntimeSystemObject.default.extend({
      computedProperty: _emberMetalComputed.computed(function () {}).volatile(),

      staticProperty: 12
    });

    equal(typeof ClassWithNoMetadata.metaForProperty('computedProperty'), 'object', 'returns empty hash if no metadata has been saved');

    expectAssertion(function () {
      ClassWithNoMetadata.metaForProperty('nonexistentProperty');
    }, 'metaForProperty() could not find a computed property with key \'nonexistentProperty\'.');

    expectAssertion(function () {
      ClassWithNoMetadata.metaForProperty('staticProperty');
    }, 'metaForProperty() could not find a computed property with key \'staticProperty\'.');
  });

  QUnit.test('can iterate over a list of computed properties for a class', function () {
    var MyClass = _emberRuntimeSystemObject.default.extend({
      foo: _emberMetalComputed.computed(function () {}),

      fooDidChange: _emberMetalMixin.observer('foo', function () {}),

      bar: _emberMetalComputed.computed(function () {})
    });

    var SubClass = MyClass.extend({
      baz: _emberMetalComputed.computed(function () {})
    });

    SubClass.reopen({
      bat: _emberMetalComputed.computed(function () {}).meta({ iAmBat: true })
    });

    var list = [];

    MyClass.eachComputedProperty(function (name) {
      list.push(name);
    });

    deepEqual(list.sort(), ['bar', 'foo'], 'watched and unwatched computed properties are iterated');

    list = [];

    SubClass.eachComputedProperty(function (name, meta) {
      list.push(name);

      if (name === 'bat') {
        deepEqual(meta, { iAmBat: true });
      } else {
        deepEqual(meta, {});
      }
    });

    deepEqual(list.sort(), ['bar', 'bat', 'baz', 'foo'], 'all inherited properties are included');
  });

  QUnit.test('list of properties updates when an additional property is added (such cache busting)', function () {
    var MyClass = _emberRuntimeSystemObject.default.extend({
      foo: _emberMetalComputed.computed(K),

      fooDidChange: _emberMetalMixin.observer('foo', function () {}),

      bar: _emberMetalComputed.computed(K)
    });

    var list = [];

    MyClass.eachComputedProperty(function (name) {
      list.push(name);
    });

    deepEqual(list.sort(), ['bar', 'foo'].sort(), 'expected two computed properties');

    MyClass.reopen({
      baz: _emberMetalComputed.computed(K)
    });

    MyClass.create(); // force apply mixins

    list = [];

    MyClass.eachComputedProperty(function (name) {
      list.push(name);
    });

    deepEqual(list.sort(), ['bar', 'foo', 'baz'].sort(), 'expected three computed properties');
  });
});
enifed('ember-runtime/tests/system/object/computed_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/system/object');
  test('ember-runtime/tests/system/object/computed_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/system/object/computed_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/system/object/computed_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/system/object');
  QUnit.test('ember-runtime/tests/system/object/computed_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/system/object/computed_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/system/object/create_test', ['exports', 'ember-metal/core', 'ember-metal/features', 'ember-metal/computed', 'ember-metal/mixin', 'ember-runtime/system/object'], function (exports, _emberMetalCore, _emberMetalFeatures, _emberMetalComputed, _emberMetalMixin, _emberRuntimeSystemObject) {
  'use strict';

  var moduleOptions, originalLookup;

  moduleOptions = {
    setup: function () {
      originalLookup = _emberMetalCore.default.lookup;
      _emberMetalCore.default.lookup = {};
    },

    teardown: function () {
      _emberMetalCore.default.lookup = originalLookup;
    }
  };

  QUnit.module('EmberObject.create', moduleOptions);

  QUnit.test('simple properties are set', function () {
    var o = _emberRuntimeSystemObject.default.create({ ohai: 'there' });
    equal(o.get('ohai'), 'there');
  });

  QUnit.test('calls computed property setters', function () {
    var MyClass = _emberRuntimeSystemObject.default.extend({
      foo: _emberMetalComputed.computed({
        get: function () {
          return 'this is not the value you\'re looking for';
        },
        set: function (key, value) {
          return value;
        }
      })
    });

    var o = MyClass.create({ foo: 'bar' });
    equal(o.get('foo'), 'bar');
  });

  QUnit.test('sets up mandatory setters for watched simple properties', function () {

    var MyClass = _emberRuntimeSystemObject.default.extend({
      foo: null,
      bar: null,
      fooDidChange: _emberMetalMixin.observer('foo', function () {})
    });

    var o = MyClass.create({ foo: 'bar', bar: 'baz' });
    equal(o.get('foo'), 'bar');

    // Catch IE8 where Object.getOwnPropertyDescriptor exists but only works on DOM elements
    try {
      Object.getOwnPropertyDescriptor({}, 'foo');
    } catch (e) {
      return;
    }

    var descriptor = Object.getOwnPropertyDescriptor(o, 'foo');
    ok(descriptor.set, 'Mandatory setter was setup');

    descriptor = Object.getOwnPropertyDescriptor(o, 'bar');
    ok(!descriptor.set, 'Mandatory setter was not setup');
  });

  QUnit.test('allows bindings to be defined', function () {
    var obj = _emberRuntimeSystemObject.default.create({
      foo: 'foo',
      barBinding: 'foo'
    });

    equal(obj.get('bar'), 'foo', 'The binding value is correct');
  });

  QUnit.test('calls setUnknownProperty if defined', function () {
    var setUnknownPropertyCalled = false;

    var MyClass = _emberRuntimeSystemObject.default.extend({
      setUnknownProperty: function (key, value) {
        setUnknownPropertyCalled = true;
      }
    });

    MyClass.create({ foo: 'bar' });
    ok(setUnknownPropertyCalled, 'setUnknownProperty was called');
  });

  QUnit.test('throws if you try to define a computed property', function () {
    expectAssertion(function () {
      _emberRuntimeSystemObject.default.create({
        foo: _emberMetalComputed.computed(function () {})
      });
    }, 'Ember.Object.create no longer supports defining computed properties. Define computed properties using extend() or reopen() before calling create().');
  });

  QUnit.test('throws if you try to call _super in a method', function () {
    expectAssertion(function () {
      _emberRuntimeSystemObject.default.create({
        foo: function () {
          this._super.apply(this, arguments);
        }
      });
    }, 'Ember.Object.create no longer supports defining methods that call _super.');
  });

  QUnit.test('throws if you try to \'mixin\' a definition', function () {
    var myMixin = _emberMetalMixin.Mixin.create({
      adder: function (arg1, arg2) {
        return arg1 + arg2;
      }
    });

    expectAssertion(function () {
      _emberRuntimeSystemObject.default.create(myMixin);
    }, 'Ember.Object.create no longer supports mixing in other definitions, use .extend & .create seperately instead.');
  });

  // This test is for IE8.
  QUnit.test('property name is the same as own prototype property', function () {
    var MyClass = _emberRuntimeSystemObject.default.extend({
      toString: function () {
        return 'MyClass';
      }
    });

    equal(MyClass.create().toString(), 'MyClass', 'should inherit property from the arguments of `EmberObject.create`');
  });

  QUnit.test('inherits properties from passed in EmberObject', function () {
    var baseObj = _emberRuntimeSystemObject.default.create({ foo: 'bar' });
    var secondaryObj = _emberRuntimeSystemObject.default.create(baseObj);

    equal(secondaryObj.foo, baseObj.foo, 'Em.O.create inherits properties from EmberObject parameter');
  });

  QUnit.test('throws if you try to pass anything a string as a parameter', function () {
    var expected = 'EmberObject.create only accepts an objects.';

    throws(function () {
      _emberRuntimeSystemObject.default.create('some-string');
    }, expected);
  });

  QUnit.test('EmberObject.create can take undefined as a parameter', function () {
    var o = _emberRuntimeSystemObject.default.create(undefined);
    deepEqual(_emberRuntimeSystemObject.default.create(), o);
  });

  QUnit.test('EmberObject.create can take null as a parameter', function () {
    var o = _emberRuntimeSystemObject.default.create(null);
    deepEqual(_emberRuntimeSystemObject.default.create(), o);
  });
});
enifed('ember-runtime/tests/system/object/create_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/system/object');
  test('ember-runtime/tests/system/object/create_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/system/object/create_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/system/object/create_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/system/object');
  QUnit.test('ember-runtime/tests/system/object/create_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/system/object/create_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/system/object/destroy_test', ['exports', 'ember-metal/features', 'ember-metal/run_loop', 'ember-metal/mixin', 'ember-metal/property_set', 'ember-metal/binding', 'ember-metal/property_events', 'ember-metal/tests/props_helper', 'ember-runtime/system/object'], function (exports, _emberMetalFeatures, _emberMetalRun_loop, _emberMetalMixin, _emberMetalProperty_set, _emberMetalBinding, _emberMetalProperty_events, _emberMetalTestsProps_helper, _emberRuntimeSystemObject) {
  'use strict';

  QUnit.module('ember-runtime/system/object/destroy_test');

  _emberMetalTestsProps_helper.testBoth('should schedule objects to be destroyed at the end of the run loop', function (get, set) {
    var obj = _emberRuntimeSystemObject.default.create();
    var meta;

    _emberMetalRun_loop.default(function () {
      obj.destroy();
      meta = obj['__ember_meta__'];
      ok(meta, 'meta is not destroyed immediately');
      ok(get(obj, 'isDestroying'), 'object is marked as destroying immediately');
      ok(!get(obj, 'isDestroyed'), 'object is not destroyed immediately');
    });

    meta = obj['__ember_meta__'];
    ok(!meta, 'meta is destroyed after run loop finishes');
    ok(get(obj, 'isDestroyed'), 'object is destroyed after run loop finishes');
  });

  // MANDATORY_SETTER moves value to meta.values
  // a destroyed object removes meta but leaves the accessor
  // that looks it up
  QUnit.test('should raise an exception when modifying watched properties on a destroyed object', function () {
    var obj = _emberRuntimeSystemObject.default.extend({
      fooDidChange: _emberMetalMixin.observer('foo', function () {})
    }).create({
      foo: 'bar'
    });

    _emberMetalRun_loop.default(function () {
      obj.destroy();
    });

    throws(function () {
      _emberMetalProperty_set.set(obj, 'foo', 'baz');
    }, Error, 'raises an exception');
  });

  QUnit.test('observers should not fire after an object has been destroyed', function () {
    var count = 0;
    var obj = _emberRuntimeSystemObject.default.extend({
      fooDidChange: _emberMetalMixin.observer('foo', function () {
        count++;
      })
    }).create();

    obj.set('foo', 'bar');

    equal(count, 1, 'observer was fired once');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_events.beginPropertyChanges();
      obj.set('foo', 'quux');
      obj.destroy();
      _emberMetalProperty_events.endPropertyChanges();
    });

    equal(count, 1, 'observer was not called after object was destroyed');
  });

  QUnit.test('destroyed objects should not see each others changes during teardown but a long lived object should', function () {
    var shouldChange = 0;
    var shouldNotChange = 0;

    var objs = {};

    var A = _emberRuntimeSystemObject.default.extend({
      objs: objs,
      isAlive: true,
      willDestroy: function () {
        this.set('isAlive', false);
      },
      bDidChange: _emberMetalMixin.observer('objs.b.isAlive', function () {
        shouldNotChange++;
      }),
      cDidChange: _emberMetalMixin.observer('objs.c.isAlive', function () {
        shouldNotChange++;
      })
    });

    var B = _emberRuntimeSystemObject.default.extend({
      objs: objs,
      isAlive: true,
      willDestroy: function () {
        this.set('isAlive', false);
      },
      aDidChange: _emberMetalMixin.observer('objs.a.isAlive', function () {
        shouldNotChange++;
      }),
      cDidChange: _emberMetalMixin.observer('objs.c.isAlive', function () {
        shouldNotChange++;
      })
    });

    var C = _emberRuntimeSystemObject.default.extend({
      objs: objs,
      isAlive: true,
      willDestroy: function () {
        this.set('isAlive', false);
      },
      aDidChange: _emberMetalMixin.observer('objs.a.isAlive', function () {
        shouldNotChange++;
      }),
      bDidChange: _emberMetalMixin.observer('objs.b.isAlive', function () {
        shouldNotChange++;
      })
    });

    var LongLivedObject = _emberRuntimeSystemObject.default.extend({
      objs: objs,
      isAliveDidChange: _emberMetalMixin.observer('objs.a.isAlive', function () {
        shouldChange++;
      })
    });

    objs.a = new A();

    objs.b = new B();

    objs.c = new C();

    new LongLivedObject();

    _emberMetalRun_loop.default(function () {
      var keys = Object.keys(objs);
      for (var i = 0, l = keys.length; i < l; i++) {
        objs[keys[i]].destroy();
      }
    });

    equal(shouldNotChange, 0, 'destroyed graph objs should not see change in willDestroy');
    equal(shouldChange, 1, 'long lived should see change in willDestroy');
  });

  QUnit.test('bindings should be synced when are updated in the willDestroy hook', function () {
    var bar = _emberRuntimeSystemObject.default.create({
      value: false,
      willDestroy: function () {
        this.set('value', true);
      }
    });

    var foo = _emberRuntimeSystemObject.default.create({
      value: null,
      bar: bar
    });

    _emberMetalRun_loop.default(function () {
      _emberMetalBinding.bind(foo, 'value', 'bar.value');
    });

    ok(bar.get('value') === false, 'the initial value has been bound');

    _emberMetalRun_loop.default(function () {
      bar.destroy();
    });

    ok(foo.get('value'), 'foo is synced when the binding is updated in the willDestroy hook');
  });
});
enifed('ember-runtime/tests/system/object/destroy_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/system/object');
  test('ember-runtime/tests/system/object/destroy_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/system/object/destroy_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/system/object/destroy_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/system/object');
  QUnit.test('ember-runtime/tests/system/object/destroy_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/system/object/destroy_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/system/object/detectInstance_test', ['exports', 'ember-runtime/system/object'], function (exports, _emberRuntimeSystemObject) {
  'use strict';

  QUnit.module('system/object/detectInstance');

  QUnit.test('detectInstance detects instances correctly', function () {

    var A = _emberRuntimeSystemObject.default.extend();
    var B = A.extend();
    var C = A.extend();

    var o = _emberRuntimeSystemObject.default.create();
    var a = A.create();
    var b = B.create();
    var c = C.create();

    ok(_emberRuntimeSystemObject.default.detectInstance(o), 'o is an instance of EmberObject');
    ok(_emberRuntimeSystemObject.default.detectInstance(a), 'a is an instance of EmberObject');
    ok(_emberRuntimeSystemObject.default.detectInstance(b), 'b is an instance of EmberObject');
    ok(_emberRuntimeSystemObject.default.detectInstance(c), 'c is an instance of EmberObject');

    ok(!A.detectInstance(o), 'o is not an instance of A');
    ok(A.detectInstance(a), 'a is an instance of A');
    ok(A.detectInstance(b), 'b is an instance of A');
    ok(A.detectInstance(c), 'c is an instance of A');

    ok(!B.detectInstance(o), 'o is not an instance of B');
    ok(!B.detectInstance(a), 'a is not an instance of B');
    ok(B.detectInstance(b), 'b is an instance of B');
    ok(!B.detectInstance(c), 'c is not an instance of B');

    ok(!C.detectInstance(o), 'o is not an instance of C');
    ok(!C.detectInstance(a), 'a is not an instance of C');
    ok(!C.detectInstance(b), 'b is not an instance of C');
    ok(C.detectInstance(c), 'c is an instance of C');
  });
});
enifed('ember-runtime/tests/system/object/detectInstance_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/system/object');
  test('ember-runtime/tests/system/object/detectInstance_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/system/object/detectInstance_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/system/object/detectInstance_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/system/object');
  QUnit.test('ember-runtime/tests/system/object/detectInstance_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/system/object/detectInstance_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/system/object/detect_test', ['exports', 'ember-runtime/system/object'], function (exports, _emberRuntimeSystemObject) {
  'use strict';

  QUnit.module('system/object/detect');

  QUnit.test('detect detects classes correctly', function () {

    var A = _emberRuntimeSystemObject.default.extend();
    var B = A.extend();
    var C = A.extend();

    ok(_emberRuntimeSystemObject.default.detect(_emberRuntimeSystemObject.default), 'EmberObject is an EmberObject class');
    ok(_emberRuntimeSystemObject.default.detect(A), 'A is an EmberObject class');
    ok(_emberRuntimeSystemObject.default.detect(B), 'B is an EmberObject class');
    ok(_emberRuntimeSystemObject.default.detect(C), 'C is an EmberObject class');

    ok(!A.detect(_emberRuntimeSystemObject.default), 'EmberObject is not an A class');
    ok(A.detect(A), 'A is an A class');
    ok(A.detect(B), 'B is an A class');
    ok(A.detect(C), 'C is an A class');

    ok(!B.detect(_emberRuntimeSystemObject.default), 'EmberObject is not a B class');
    ok(!B.detect(A), 'A is not a B class');
    ok(B.detect(B), 'B is a B class');
    ok(!B.detect(C), 'C is not a B class');

    ok(!C.detect(_emberRuntimeSystemObject.default), 'EmberObject is not a C class');
    ok(!C.detect(A), 'A is not a C class');
    ok(!C.detect(B), 'B is not a C class');
    ok(C.detect(C), 'C is a C class');
  });
});
enifed('ember-runtime/tests/system/object/detect_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/system/object');
  test('ember-runtime/tests/system/object/detect_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/system/object/detect_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/system/object/detect_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/system/object');
  QUnit.test('ember-runtime/tests/system/object/detect_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/system/object/detect_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/system/object/events_test', ['exports', 'ember-runtime/system/object', 'ember-runtime/mixins/evented'], function (exports, _emberRuntimeSystemObject, _emberRuntimeMixinsEvented) {
  'use strict';

  QUnit.module('Object events');

  QUnit.test('a listener can be added to an object', function () {
    var count = 0;
    var F = function () {
      count++;
    };

    var obj = _emberRuntimeSystemObject.default.extend(_emberRuntimeMixinsEvented.default).create();

    obj.on('event!', F);
    obj.trigger('event!');

    equal(count, 1, 'the event was triggered');

    obj.trigger('event!');

    equal(count, 2, 'the event was triggered');
  });

  QUnit.test('a listener can be added and removed automatically the first time it is triggered', function () {
    var count = 0;
    var F = function () {
      count++;
    };

    var obj = _emberRuntimeSystemObject.default.extend(_emberRuntimeMixinsEvented.default).create();

    obj.one('event!', F);
    obj.trigger('event!');

    equal(count, 1, 'the event was triggered');

    obj.trigger('event!');

    equal(count, 1, 'the event was not triggered again');
  });

  QUnit.test('triggering an event can have arguments', function () {
    var self, args;

    var obj = _emberRuntimeSystemObject.default.extend(_emberRuntimeMixinsEvented.default).create();

    obj.on('event!', function () {
      args = [].slice.call(arguments);
      self = this;
    });

    obj.trigger('event!', 'foo', 'bar');

    deepEqual(args, ['foo', 'bar']);
    equal(self, obj);
  });

  QUnit.test('a listener can be added and removed automatically and have arguments', function () {
    var self, args;
    var count = 0;

    var obj = _emberRuntimeSystemObject.default.extend(_emberRuntimeMixinsEvented.default).create();

    obj.one('event!', function () {
      args = [].slice.call(arguments);
      self = this;
      count++;
    });

    obj.trigger('event!', 'foo', 'bar');

    deepEqual(args, ['foo', 'bar']);
    equal(self, obj);
    equal(count, 1, 'the event is triggered once');

    obj.trigger('event!', 'baz', 'bat');

    deepEqual(args, ['foo', 'bar']);
    equal(count, 1, 'the event was not triggered again');
    equal(self, obj);
  });

  QUnit.test('binding an event can specify a different target', function () {
    var self, args;

    var obj = _emberRuntimeSystemObject.default.extend(_emberRuntimeMixinsEvented.default).create();
    var target = {};

    obj.on('event!', target, function () {
      args = [].slice.call(arguments);
      self = this;
    });

    obj.trigger('event!', 'foo', 'bar');

    deepEqual(args, ['foo', 'bar']);
    equal(self, target);
  });

  QUnit.test('a listener registered with one can take method as string and can be added with different target', function () {
    var count = 0;
    var target = {};
    target.fn = function () {
      count++;
    };

    var obj = _emberRuntimeSystemObject.default.extend(_emberRuntimeMixinsEvented.default).create();

    obj.one('event!', target, 'fn');
    obj.trigger('event!');

    equal(count, 1, 'the event was triggered');

    obj.trigger('event!');

    equal(count, 1, 'the event was not triggered again');
  });

  QUnit.test('a listener registered with one can be removed with off', function () {
    var obj = _emberRuntimeSystemObject.default.extend(_emberRuntimeMixinsEvented.default, {
      F: function () {}
    }).create();
    var F = function () {};

    obj.one('event!', F);
    obj.one('event!', obj, 'F');

    equal(obj.has('event!'), true, 'has events');

    obj.off('event!', F);
    obj.off('event!', obj, 'F');

    equal(obj.has('event!'), false, 'has no more events');
  });

  QUnit.test('adding and removing listeners should be chainable', function () {
    var obj = _emberRuntimeSystemObject.default.extend(_emberRuntimeMixinsEvented.default).create();
    var F = function () {};

    var ret = obj.on('event!', F);
    equal(ret, obj, '#on returns self');

    ret = obj.off('event!', F);
    equal(ret, obj, '#off returns self');

    ret = obj.one('event!', F);
    equal(ret, obj, '#one returns self');
  });
});
enifed('ember-runtime/tests/system/object/events_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/system/object');
  test('ember-runtime/tests/system/object/events_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/system/object/events_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/system/object/events_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/system/object');
  QUnit.test('ember-runtime/tests/system/object/events_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/system/object/events_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/system/object/extend_test', ['exports', 'ember-metal/property_get', 'ember-runtime/system/object'], function (exports, _emberMetalProperty_get, _emberRuntimeSystemObject) {
  'use strict';

  QUnit.module('EmberObject.extend');

  QUnit.test('Basic extend', function () {
    var SomeClass = _emberRuntimeSystemObject.default.extend({ foo: 'BAR' });
    ok(SomeClass.isClass, 'A class has isClass of true');
    var obj = new SomeClass();
    equal(obj.foo, 'BAR');
  });

  QUnit.test('Sub-subclass', function () {
    var SomeClass = _emberRuntimeSystemObject.default.extend({ foo: 'BAR' });
    var AnotherClass = SomeClass.extend({ bar: 'FOO' });
    var obj = new AnotherClass();
    equal(obj.foo, 'BAR');
    equal(obj.bar, 'FOO');
  });

  QUnit.test('Overriding a method several layers deep', function () {
    var SomeClass = _emberRuntimeSystemObject.default.extend({
      fooCnt: 0,
      foo: function () {
        this.fooCnt++;
      },

      barCnt: 0,
      bar: function () {
        this.barCnt++;
      }
    });

    var AnotherClass = SomeClass.extend({
      barCnt: 0,
      bar: function () {
        this.barCnt++;
        this._super.apply(this, arguments);
      }
    });

    var FinalClass = AnotherClass.extend({
      fooCnt: 0,
      foo: function () {
        this.fooCnt++;
        this._super.apply(this, arguments);
      }
    });

    var obj = new FinalClass();
    obj.foo();
    obj.bar();
    equal(obj.fooCnt, 2, 'should invoke both');
    equal(obj.barCnt, 2, 'should invoke both');

    // Try overriding on create also
    obj = FinalClass.extend({
      foo: function () {
        this.fooCnt++;
        this._super.apply(this, arguments);
      }
    }).create();

    obj.foo();
    obj.bar();
    equal(obj.fooCnt, 3, 'should invoke final as well');
    equal(obj.barCnt, 2, 'should invoke both');
  });

  QUnit.test('With concatenatedProperties', function () {
    var SomeClass = _emberRuntimeSystemObject.default.extend({ things: 'foo', concatenatedProperties: ['things'] });
    var AnotherClass = SomeClass.extend({ things: 'bar' });
    var YetAnotherClass = SomeClass.extend({ things: 'baz' });
    var some = new SomeClass();
    var another = new AnotherClass();
    var yetAnother = new YetAnotherClass();
    deepEqual(some.get('things'), ['foo'], 'base class should have just its value');
    deepEqual(another.get('things'), ['foo', 'bar'], 'subclass should have base class\' and its own');
    deepEqual(yetAnother.get('things'), ['foo', 'baz'], 'subclass should have base class\' and its own');
  });

  QUnit.test('With concatenatedProperties class properties', function () {
    var SomeClass = _emberRuntimeSystemObject.default.extend();
    SomeClass.reopenClass({
      concatenatedProperties: ['things'],
      things: 'foo'
    });
    var AnotherClass = SomeClass.extend();
    AnotherClass.reopenClass({ things: 'bar' });
    var YetAnotherClass = SomeClass.extend();
    YetAnotherClass.reopenClass({ things: 'baz' });
    var some = new SomeClass();
    var another = new AnotherClass();
    var yetAnother = new YetAnotherClass();
    deepEqual(_emberMetalProperty_get.get(some.constructor, 'things'), ['foo'], 'base class should have just its value');
    deepEqual(_emberMetalProperty_get.get(another.constructor, 'things'), ['foo', 'bar'], 'subclass should have base class\' and its own');
    deepEqual(_emberMetalProperty_get.get(yetAnother.constructor, 'things'), ['foo', 'baz'], 'subclass should have base class\' and its own');
  });
});
enifed('ember-runtime/tests/system/object/extend_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/system/object');
  test('ember-runtime/tests/system/object/extend_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/system/object/extend_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/system/object/extend_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/system/object');
  QUnit.test('ember-runtime/tests/system/object/extend_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/system/object/extend_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/system/object/observer_test', ['exports', 'ember-metal/core', 'ember-metal/mixin', 'ember-metal/run_loop', 'ember-metal/tests/props_helper', 'ember-runtime/system/object'], function (exports, _emberMetalCore, _emberMetalMixin, _emberMetalRun_loop, _emberMetalTestsProps_helper, _emberRuntimeSystemObject) {
  'use strict';

  QUnit.module('EmberObject observer');

  _emberMetalTestsProps_helper.testBoth('observer on class', function (get, set) {

    var MyClass = _emberRuntimeSystemObject.default.extend({

      count: 0,

      foo: _emberMetalMixin.observer('bar', function () {
        set(this, 'count', get(this, 'count') + 1);
      })

    });

    var obj = new MyClass();
    equal(get(obj, 'count'), 0, 'should not invoke observer immediately');

    set(obj, 'bar', 'BAZ');
    equal(get(obj, 'count'), 1, 'should invoke observer after change');
  });

  _emberMetalTestsProps_helper.testBoth('observer on subclass', function (get, set) {

    var MyClass = _emberRuntimeSystemObject.default.extend({

      count: 0,

      foo: _emberMetalMixin.observer('bar', function () {
        set(this, 'count', get(this, 'count') + 1);
      })

    });

    var Subclass = MyClass.extend({
      foo: _emberMetalMixin.observer('baz', function () {
        set(this, 'count', get(this, 'count') + 1);
      })
    });

    var obj = new Subclass();
    equal(get(obj, 'count'), 0, 'should not invoke observer immediately');

    set(obj, 'bar', 'BAZ');
    equal(get(obj, 'count'), 0, 'should not invoke observer after change');

    set(obj, 'baz', 'BAZ');
    equal(get(obj, 'count'), 1, 'should invoke observer after change');
  });

  _emberMetalTestsProps_helper.testBoth('observer on instance', function (get, set) {

    var obj = _emberRuntimeSystemObject.default.extend({
      foo: _emberMetalMixin.observer('bar', function () {
        set(this, 'count', get(this, 'count') + 1);
      })
    }).create({
      count: 0
    });

    equal(get(obj, 'count'), 0, 'should not invoke observer immediately');

    set(obj, 'bar', 'BAZ');
    equal(get(obj, 'count'), 1, 'should invoke observer after change');
  });

  _emberMetalTestsProps_helper.testBoth('observer on instance overriding class', function (get, set) {

    var MyClass = _emberRuntimeSystemObject.default.extend({
      count: 0,

      foo: _emberMetalMixin.observer('bar', function () {
        set(this, 'count', get(this, 'count') + 1);
      })
    });

    var obj = MyClass.extend({
      foo: _emberMetalMixin.observer('baz', function () {
        // <-- change property we observe
        set(this, 'count', get(this, 'count') + 1);
      })
    }).create();

    equal(get(obj, 'count'), 0, 'should not invoke observer immediately');

    set(obj, 'bar', 'BAZ');
    equal(get(obj, 'count'), 0, 'should not invoke observer after change');

    set(obj, 'baz', 'BAZ');
    equal(get(obj, 'count'), 1, 'should invoke observer after change');
  });

  _emberMetalTestsProps_helper.testBoth('observer should not fire after being destroyed', function (get, set) {

    var obj = _emberRuntimeSystemObject.default.extend({
      count: 0,
      foo: _emberMetalMixin.observer('bar', function () {
        set(this, 'count', get(this, 'count') + 1);
      })
    }).create();

    equal(get(obj, 'count'), 0, 'precond - should not invoke observer immediately');

    _emberMetalRun_loop.default(function () {
      obj.destroy();
    });

    if (_emberMetalCore.default.assert) {
      expectAssertion(function () {
        set(obj, 'bar', 'BAZ');
      }, 'calling set on destroyed object');
    } else {
      set(obj, 'bar', 'BAZ');
    }

    equal(get(obj, 'count'), 0, 'should not invoke observer after change');
  });
  // ..........................................................
  // COMPLEX PROPERTIES
  //

  _emberMetalTestsProps_helper.testBoth('chain observer on class', function (get, set) {

    var MyClass = _emberRuntimeSystemObject.default.extend({
      count: 0,

      foo: _emberMetalMixin.observer('bar.baz', function () {
        set(this, 'count', get(this, 'count') + 1);
      })
    });

    var obj1 = MyClass.create({
      bar: { baz: 'biff' }
    });

    var obj2 = MyClass.create({
      bar: { baz: 'biff2' }
    });

    equal(get(obj1, 'count'), 0, 'should not invoke yet');
    equal(get(obj2, 'count'), 0, 'should not invoke yet');

    set(get(obj1, 'bar'), 'baz', 'BIFF1');
    equal(get(obj1, 'count'), 1, 'should invoke observer on obj1');
    equal(get(obj2, 'count'), 0, 'should not invoke yet');

    set(get(obj2, 'bar'), 'baz', 'BIFF2');
    equal(get(obj1, 'count'), 1, 'should not invoke again');
    equal(get(obj2, 'count'), 1, 'should invoke observer on obj2');
  });

  _emberMetalTestsProps_helper.testBoth('chain observer on class', function (get, set) {

    var MyClass = _emberRuntimeSystemObject.default.extend({
      count: 0,

      foo: _emberMetalMixin.observer('bar.baz', function () {
        set(this, 'count', get(this, 'count') + 1);
      })
    });

    var obj1 = MyClass.extend().create({
      bar: { baz: 'biff' }
    });

    var obj2 = MyClass.extend({
      foo: _emberMetalMixin.observer('bar2.baz', function () {
        set(this, 'count', get(this, 'count') + 1);
      })
    }).create({
      bar: { baz: 'biff2' },
      bar2: { baz: 'biff3' }
    });

    equal(get(obj1, 'count'), 0, 'should not invoke yet');
    equal(get(obj2, 'count'), 0, 'should not invoke yet');

    set(get(obj1, 'bar'), 'baz', 'BIFF1');
    equal(get(obj1, 'count'), 1, 'should invoke observer on obj1');
    equal(get(obj2, 'count'), 0, 'should not invoke yet');

    set(get(obj2, 'bar'), 'baz', 'BIFF2');
    equal(get(obj1, 'count'), 1, 'should not invoke again');
    equal(get(obj2, 'count'), 0, 'should not invoke yet');

    set(get(obj2, 'bar2'), 'baz', 'BIFF3');
    equal(get(obj1, 'count'), 1, 'should not invoke again');
    equal(get(obj2, 'count'), 1, 'should invoke observer on obj2');
  });

  _emberMetalTestsProps_helper.testBoth('chain observer on class that has a reference to an uninitialized object will finish chains that reference it', function (get, set) {
    var changed = false;

    var ChildClass = _emberRuntimeSystemObject.default.extend({
      parent: null,
      parentOneTwoDidChange: _emberMetalMixin.observer('parent.one.two', function () {
        changed = true;
      })
    });

    var ParentClass = _emberRuntimeSystemObject.default.extend({
      one: {
        two: 'old'
      },
      init: function () {
        this.child = ChildClass.create({
          parent: this
        });
      }
    });

    var parent = new ParentClass();

    equal(changed, false, 'precond');

    parent.set('one.two', 'new');

    equal(changed, true, 'child should have been notified of change to path');
  });
});
enifed('ember-runtime/tests/system/object/observer_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/system/object');
  test('ember-runtime/tests/system/object/observer_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/system/object/observer_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/system/object/observer_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/system/object');
  QUnit.test('ember-runtime/tests/system/object/observer_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/system/object/observer_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/system/object/reopenClass_test', ['exports', 'ember-metal/property_get', 'ember-runtime/system/object'], function (exports, _emberMetalProperty_get, _emberRuntimeSystemObject) {
  'use strict';

  QUnit.module('system/object/reopenClass');

  QUnit.test('adds new properties to subclass', function () {

    var Subclass = _emberRuntimeSystemObject.default.extend();
    Subclass.reopenClass({
      foo: function () {
        return 'FOO';
      },
      bar: 'BAR'
    });

    equal(Subclass.foo(), 'FOO', 'Adds method');
    equal(_emberMetalProperty_get.get(Subclass, 'bar'), 'BAR', 'Adds property');
  });

  QUnit.test('class properties inherited by subclasses', function () {

    var Subclass = _emberRuntimeSystemObject.default.extend();
    Subclass.reopenClass({
      foo: function () {
        return 'FOO';
      },
      bar: 'BAR'
    });

    var SubSub = Subclass.extend();

    equal(SubSub.foo(), 'FOO', 'Adds method');
    equal(_emberMetalProperty_get.get(SubSub, 'bar'), 'BAR', 'Adds property');
  });
});
enifed('ember-runtime/tests/system/object/reopenClass_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/system/object');
  test('ember-runtime/tests/system/object/reopenClass_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/system/object/reopenClass_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/system/object/reopenClass_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/system/object');
  QUnit.test('ember-runtime/tests/system/object/reopenClass_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/system/object/reopenClass_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/system/object/reopen_test', ['exports', 'ember-metal/property_get', 'ember-runtime/system/object'], function (exports, _emberMetalProperty_get, _emberRuntimeSystemObject) {
  'use strict';

  QUnit.module('system/core_object/reopen');

  QUnit.test('adds new properties to subclass instance', function () {

    var Subclass = _emberRuntimeSystemObject.default.extend();
    Subclass.reopen({
      foo: function () {
        return 'FOO';
      },
      bar: 'BAR'
    });

    equal(new Subclass().foo(), 'FOO', 'Adds method');
    equal(_emberMetalProperty_get.get(new Subclass(), 'bar'), 'BAR', 'Adds property');
  });

  QUnit.test('reopened properties inherited by subclasses', function () {

    var Subclass = _emberRuntimeSystemObject.default.extend();
    var SubSub = Subclass.extend();

    Subclass.reopen({
      foo: function () {
        return 'FOO';
      },
      bar: 'BAR'
    });

    equal(new SubSub().foo(), 'FOO', 'Adds method');
    equal(_emberMetalProperty_get.get(new SubSub(), 'bar'), 'BAR', 'Adds property');
  });

  QUnit.test('allows reopening already instantiated classes', function () {
    var Subclass = _emberRuntimeSystemObject.default.extend();

    Subclass.create();

    Subclass.reopen({
      trololol: true
    });

    equal(Subclass.create().get('trololol'), true, 'reopen works');
  });
});
enifed('ember-runtime/tests/system/object/reopen_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/system/object');
  test('ember-runtime/tests/system/object/reopen_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/system/object/reopen_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/system/object/reopen_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/system/object');
  QUnit.test('ember-runtime/tests/system/object/reopen_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/system/object/reopen_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/system/object/strict-mode-test', ['exports', 'ember-runtime/system/object'], function (exports, _emberRuntimeSystemObject) {
  'use strict';

  QUnit.module('strict mode tests');

  QUnit.test('__superWrapper does not throw errors in strict mode', function () {
    var Foo = _emberRuntimeSystemObject.default.extend({
      blah: function () {
        return 'foo';
      }
    });

    var Bar = Foo.extend({
      blah: function () {
        return 'bar';
      },

      callBlah: function () {
        var blah = this.blah;

        return blah();
      }
    });

    var bar = Bar.create();

    equal(bar.callBlah(), 'bar', 'can call local function without call/apply');
  });
});
enifed('ember-runtime/tests/system/object/strict-mode-test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/system/object');
  test('ember-runtime/tests/system/object/strict-mode-test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/system/object/strict-mode-test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/system/object/strict-mode-test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/system/object');
  QUnit.test('ember-runtime/tests/system/object/strict-mode-test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/system/object/strict-mode-test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/system/object/subclasses_test', ['exports', 'ember-metal/run_loop', 'ember-metal/computed', 'ember-runtime/system/object'], function (exports, _emberMetalRun_loop, _emberMetalComputed, _emberRuntimeSystemObject) {
  'use strict';

  QUnit.module('system/object/subclasses');

  QUnit.test('chains should copy forward to subclasses when prototype created', function () {
    var ObjectWithChains, objWithChains, SubWithChains, SubSub, subSub;
    _emberMetalRun_loop.default(function () {
      ObjectWithChains = _emberRuntimeSystemObject.default.extend({
        obj: {
          a: 'a',
          hi: 'hi'
        },
        aBinding: 'obj.a' // add chain
      });
      // realize prototype
      objWithChains = ObjectWithChains.create();
      // should not copy chains from parent yet
      SubWithChains = ObjectWithChains.extend({
        hiBinding: 'obj.hi', // add chain
        hello: _emberMetalComputed.computed(function () {
          return this.get('obj.hi') + ' world';
        }).property('hi'), // observe chain
        greetingBinding: 'hello'
      });
      SubSub = SubWithChains.extend();
      // should realize prototypes and copy forward chains
      subSub = SubSub.create();
    });
    equal(subSub.get('greeting'), 'hi world');
    _emberMetalRun_loop.default(function () {
      objWithChains.set('obj.hi', 'hello');
    });
    equal(subSub.get('greeting'), 'hello world');
  });
});
enifed('ember-runtime/tests/system/object/subclasses_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/system/object');
  test('ember-runtime/tests/system/object/subclasses_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/system/object/subclasses_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/system/object/subclasses_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/system/object');
  QUnit.test('ember-runtime/tests/system/object/subclasses_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/system/object/subclasses_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/system/object/toString_test', ['exports', 'ember-metal/core', 'ember-metal/utils', 'ember-runtime/system/object', 'ember-runtime/system/namespace'], function (exports, _emberMetalCore, _emberMetalUtils, _emberRuntimeSystemObject, _emberRuntimeSystemNamespace) {
  'use strict';

  var originalLookup, lookup;

  QUnit.module('system/object/toString', {
    setup: function () {
      originalLookup = _emberMetalCore.default.lookup;
      lookup = _emberMetalCore.default.lookup = {};
    },
    teardown: function () {
      _emberMetalCore.default.lookup = originalLookup;
    }
  });

  QUnit.test('toString() returns the same value if called twice', function () {
    var Foo = _emberRuntimeSystemNamespace.default.create();
    Foo.toString = function () {
      return 'Foo';
    };

    Foo.Bar = _emberRuntimeSystemObject.default.extend();

    equal(Foo.Bar.toString(), 'Foo.Bar');
    equal(Foo.Bar.toString(), 'Foo.Bar');

    var obj = Foo.Bar.create();

    equal(obj.toString(), '<Foo.Bar:' + _emberMetalUtils.guidFor(obj) + '>');
    equal(obj.toString(), '<Foo.Bar:' + _emberMetalUtils.guidFor(obj) + '>');

    equal(Foo.Bar.toString(), 'Foo.Bar');
  });

  QUnit.test('toString on a class returns a useful value when nested in a namespace', function () {
    var obj;

    var Foo = _emberRuntimeSystemNamespace.default.create();
    Foo.toString = function () {
      return 'Foo';
    };

    Foo.Bar = _emberRuntimeSystemObject.default.extend();
    equal(Foo.Bar.toString(), 'Foo.Bar');

    obj = Foo.Bar.create();
    equal(obj.toString(), '<Foo.Bar:' + _emberMetalUtils.guidFor(obj) + '>');

    Foo.Baz = Foo.Bar.extend();
    equal(Foo.Baz.toString(), 'Foo.Baz');

    obj = Foo.Baz.create();
    equal(obj.toString(), '<Foo.Baz:' + _emberMetalUtils.guidFor(obj) + '>');

    obj = Foo.Bar.create();
    equal(obj.toString(), '<Foo.Bar:' + _emberMetalUtils.guidFor(obj) + '>');
  });

  QUnit.test('toString on a namespace finds the namespace in Ember.lookup', function () {
    var Foo = lookup.Foo = _emberRuntimeSystemNamespace.default.create();

    equal(Foo.toString(), 'Foo');
  });

  QUnit.test('toString on a namespace finds the namespace in Ember.lookup', function () {
    var Foo = lookup.Foo = _emberRuntimeSystemNamespace.default.create();
    var obj;

    Foo.Bar = _emberRuntimeSystemObject.default.extend();

    equal(Foo.Bar.toString(), 'Foo.Bar');

    obj = Foo.Bar.create();
    equal(obj.toString(), '<Foo.Bar:' + _emberMetalUtils.guidFor(obj) + '>');
  });

  QUnit.test('toString on a namespace falls back to modulePrefix, if defined', function () {
    var Foo = _emberRuntimeSystemNamespace.default.create({ modulePrefix: 'foo' });

    equal(Foo.toString(), 'foo');
  });

  QUnit.test('toString includes toStringExtension if defined', function () {
    var Foo = _emberRuntimeSystemObject.default.extend({
      toStringExtension: function () {
        return 'fooey';
      }
    });
    var foo = Foo.create();
    var Bar = _emberRuntimeSystemObject.default.extend({});
    var bar = Bar.create();

    // simulate these classes being defined on a Namespace
    Foo[_emberMetalUtils.GUID_KEY + '_name'] = 'Foo';
    Bar[_emberMetalUtils.GUID_KEY + '_name'] = 'Bar';

    equal(bar.toString(), '<Bar:' + _emberMetalUtils.guidFor(bar) + '>', 'does not include toStringExtension part');
    equal(foo.toString(), '<Foo:' + _emberMetalUtils.guidFor(foo) + ':fooey>', 'Includes toStringExtension result');
  });
});
enifed('ember-runtime/tests/system/object/toString_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/system/object');
  test('ember-runtime/tests/system/object/toString_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/system/object/toString_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/system/object/toString_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/system/object');
  QUnit.test('ember-runtime/tests/system/object/toString_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/system/object/toString_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/system/object_proxy_test', ['exports', 'ember-metal/observer', 'ember-metal/computed', 'ember-metal/watching', 'ember-metal/tests/props_helper', 'ember-runtime/system/object_proxy'], function (exports, _emberMetalObserver, _emberMetalComputed, _emberMetalWatching, _emberMetalTestsProps_helper, _emberRuntimeSystemObject_proxy) {
  'use strict';

  QUnit.module('ObjectProxy');

  _emberMetalTestsProps_helper.testBoth('should not proxy properties passed to create', function (get, set) {
    var Proxy = _emberRuntimeSystemObject_proxy.default.extend({
      cp: _emberMetalComputed.computed({
        get: function (key) {
          return this._cp;
        },
        set: function (key, value) {
          this._cp = value;
          return this._cp;
        }
      })
    });
    var proxy = Proxy.create({
      prop: 'Foo',
      cp: 'Bar'
    });

    equal(get(proxy, 'prop'), 'Foo', 'should not have tried to proxy set');
    equal(proxy._cp, 'Bar', 'should use CP setter');
  });

  _emberMetalTestsProps_helper.testBoth('should proxy properties to content', function (get, set) {
    var content = {
      firstName: 'Tom',
      lastName: 'Dale',
      unknownProperty: function (key) {
        return key + ' unknown';
      }
    };
    var proxy = _emberRuntimeSystemObject_proxy.default.create();

    equal(get(proxy, 'firstName'), undefined, 'get on proxy without content should return undefined');
    expectAssertion(function () {
      set(proxy, 'firstName', 'Foo');
    }, /Cannot delegate set\('firstName', Foo\) to the 'content'/i);

    set(proxy, 'content', content);

    equal(get(proxy, 'firstName'), 'Tom', 'get on proxy with content should forward to content');
    equal(get(proxy, 'lastName'), 'Dale', 'get on proxy with content should forward to content');
    equal(get(proxy, 'foo'), 'foo unknown', 'get on proxy with content should forward to content');

    set(proxy, 'lastName', 'Huda');

    equal(get(content, 'lastName'), 'Huda', 'content should have new value from set on proxy');
    equal(get(proxy, 'lastName'), 'Huda', 'proxy should have new value from set on proxy');

    set(proxy, 'content', { firstName: 'Yehuda', lastName: 'Katz' });

    equal(get(proxy, 'firstName'), 'Yehuda', 'proxy should reflect updated content');
    equal(get(proxy, 'lastName'), 'Katz', 'proxy should reflect updated content');
  });

  _emberMetalTestsProps_helper.testBoth('should work with watched properties', function (get, set) {
    var content1 = { firstName: 'Tom', lastName: 'Dale' };
    var content2 = { firstName: 'Yehuda', lastName: 'Katz' };
    var count = 0;
    var Proxy, proxy, last;

    Proxy = _emberRuntimeSystemObject_proxy.default.extend({
      fullName: _emberMetalComputed.computed(function () {
        var firstName = this.get('firstName');
        var lastName = this.get('lastName');

        if (firstName && lastName) {
          return firstName + ' ' + lastName;
        }
        return firstName || lastName;
      }).property('firstName', 'lastName')
    });

    proxy = Proxy.create();

    _emberMetalObserver.addObserver(proxy, 'fullName', function () {
      last = get(proxy, 'fullName');
      count++;
    });

    // proxy without content returns undefined
    equal(get(proxy, 'fullName'), undefined);

    // setting content causes all watched properties to change
    set(proxy, 'content', content1);
    // both dependent keys changed
    equal(count, 2);
    equal(last, 'Tom Dale');

    // setting property in content causes proxy property to change
    set(content1, 'lastName', 'Huda');
    equal(count, 3);
    equal(last, 'Tom Huda');

    // replacing content causes all watched properties to change
    set(proxy, 'content', content2);
    // both dependent keys changed
    equal(count, 5);
    equal(last, 'Yehuda Katz');
    // content1 is no longer watched
    ok(!_emberMetalWatching.isWatching(content1, 'firstName'), 'not watching firstName');
    ok(!_emberMetalWatching.isWatching(content1, 'lastName'), 'not watching lastName');

    // setting property in new content
    set(content2, 'firstName', 'Tomhuda');
    equal(last, 'Tomhuda Katz');
    equal(count, 6);

    // setting property in proxy syncs with new content
    set(proxy, 'lastName', 'Katzdale');
    equal(count, 7);
    equal(last, 'Tomhuda Katzdale');
    equal(get(content2, 'firstName'), 'Tomhuda');
    equal(get(content2, 'lastName'), 'Katzdale');
  });

  QUnit.test('set and get should work with paths', function () {
    var content = { foo: { bar: 'baz' } };
    var proxy = _emberRuntimeSystemObject_proxy.default.create({ content: content });
    var count = 0;

    proxy.set('foo.bar', 'hello');
    equal(proxy.get('foo.bar'), 'hello');
    equal(proxy.get('content.foo.bar'), 'hello');

    proxy.addObserver('foo.bar', function () {
      count++;
    });

    proxy.set('foo.bar', 'bye');

    equal(count, 1);
    equal(proxy.get('foo.bar'), 'bye');
    equal(proxy.get('content.foo.bar'), 'bye');
  });

  _emberMetalTestsProps_helper.testBoth('should transition between watched and unwatched strategies', function (get, set) {
    var content = { foo: 'foo' };
    var proxy = _emberRuntimeSystemObject_proxy.default.create({ content: content });
    var count = 0;

    function observer() {
      count++;
    }

    equal(get(proxy, 'foo'), 'foo');

    set(content, 'foo', 'bar');

    equal(get(proxy, 'foo'), 'bar');

    set(proxy, 'foo', 'foo');

    equal(get(content, 'foo'), 'foo');
    equal(get(proxy, 'foo'), 'foo');

    _emberMetalObserver.addObserver(proxy, 'foo', observer);

    equal(count, 0);
    equal(get(proxy, 'foo'), 'foo');

    set(content, 'foo', 'bar');

    equal(count, 1);
    equal(get(proxy, 'foo'), 'bar');

    set(proxy, 'foo', 'foo');

    equal(count, 2);
    equal(get(content, 'foo'), 'foo');
    equal(get(proxy, 'foo'), 'foo');

    _emberMetalObserver.removeObserver(proxy, 'foo', observer);

    set(content, 'foo', 'bar');

    equal(get(proxy, 'foo'), 'bar');

    set(proxy, 'foo', 'foo');

    equal(get(content, 'foo'), 'foo');
    equal(get(proxy, 'foo'), 'foo');
  });

  _emberMetalTestsProps_helper.testBoth('setting `undefined` to a proxied content property should override its existing value', function (get, set) {
    var proxyObject = _emberRuntimeSystemObject_proxy.default.create({
      content: {
        prop: 'emberjs'
      }
    });
    set(proxyObject, 'prop', undefined);
    equal(get(proxyObject, 'prop'), undefined, 'sets the `undefined` value to the proxied content');
  });
});
enifed('ember-runtime/tests/system/object_proxy_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/system');
  test('ember-runtime/tests/system/object_proxy_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/system/object_proxy_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/system/object_proxy_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/system');
  QUnit.test('ember-runtime/tests/system/object_proxy_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/system/object_proxy_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/system/string/camelize_test', ['exports', 'ember-metal/core', 'ember-runtime/system/string'], function (exports, _emberMetalCore, _emberRuntimeSystemString) {
  'use strict';

  QUnit.module('EmberStringUtils.camelize');

  if (!_emberMetalCore.default.EXTEND_PROTOTYPES && !_emberMetalCore.default.EXTEND_PROTOTYPES.String) {
    QUnit.test('String.prototype.camelize is not modified without EXTEND_PROTOTYPES', function () {
      ok('undefined' === typeof String.prototype.camelize, 'String.prototype helper disabled');
    });
  }

  QUnit.test('camelize normal string', function () {
    deepEqual(_emberRuntimeSystemString.camelize('my favorite items'), 'myFavoriteItems');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('my favorite items'.camelize(), 'myFavoriteItems');
    }
  });

  QUnit.test('camelize capitalized string', function () {
    deepEqual(_emberRuntimeSystemString.camelize('I Love Ramen'), 'iLoveRamen');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('I Love Ramen'.camelize(), 'iLoveRamen');
    }
  });

  QUnit.test('camelize dasherized string', function () {
    deepEqual(_emberRuntimeSystemString.camelize('css-class-name'), 'cssClassName');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('css-class-name'.camelize(), 'cssClassName');
    }
  });

  QUnit.test('camelize underscored string', function () {
    deepEqual(_emberRuntimeSystemString.camelize('action_name'), 'actionName');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('action_name'.camelize(), 'actionName');
    }
  });

  QUnit.test('camelize dot notation string', function () {
    deepEqual(_emberRuntimeSystemString.camelize('action.name'), 'actionName');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('action.name'.camelize(), 'actionName');
    }
  });

  QUnit.test('does nothing with camelcased string', function () {
    deepEqual(_emberRuntimeSystemString.camelize('innerHTML'), 'innerHTML');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('innerHTML'.camelize(), 'innerHTML');
    }
  });

  QUnit.test('camelize namespaced classified string', function () {
    deepEqual(_emberRuntimeSystemString.camelize('PrivateDocs/OwnerInvoice'), 'privateDocs/ownerInvoice');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('PrivateDocs/OwnerInvoice'.camelize(), 'privateDocs/ownerInvoice');
    }
  });

  QUnit.test('camelize namespaced underscored string', function () {
    deepEqual(_emberRuntimeSystemString.camelize('private_docs/owner_invoice'), 'privateDocs/ownerInvoice');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('private_docs/owner_invoice'.camelize(), 'privateDocs/ownerInvoice');
    }
  });

  QUnit.test('camelize namespaced dasherized string', function () {
    deepEqual(_emberRuntimeSystemString.camelize('private-docs/owner-invoice'), 'privateDocs/ownerInvoice');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('private-docs/owner-invoice'.camelize(), 'privateDocs/ownerInvoice');
    }
  });
});
enifed('ember-runtime/tests/system/string/camelize_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/system/string');
  test('ember-runtime/tests/system/string/camelize_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/system/string/camelize_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/system/string/camelize_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/system/string');
  QUnit.test('ember-runtime/tests/system/string/camelize_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/system/string/camelize_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/system/string/capitalize_test', ['exports', 'ember-metal/core', 'ember-runtime/system/string'], function (exports, _emberMetalCore, _emberRuntimeSystemString) {
  'use strict';

  QUnit.module('EmberStringUtils.capitalize');

  if (!_emberMetalCore.default.EXTEND_PROTOTYPES && !_emberMetalCore.default.EXTEND_PROTOTYPES.String) {
    QUnit.test('String.prototype.capitalize is not modified without EXTEND_PROTOTYPES', function () {
      ok('undefined' === typeof String.prototype.capitalize, 'String.prototype helper disabled');
    });
  }

  QUnit.test('capitalize normal string', function () {
    deepEqual(_emberRuntimeSystemString.capitalize('my favorite items'), 'My favorite items');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('my favorite items'.capitalize(), 'My favorite items');
    }
  });

  QUnit.test('capitalize dasherized string', function () {
    deepEqual(_emberRuntimeSystemString.capitalize('css-class-name'), 'Css-class-name');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('css-class-name'.capitalize(), 'Css-class-name');
    }
  });

  QUnit.test('capitalize underscored string', function () {
    deepEqual(_emberRuntimeSystemString.capitalize('action_name'), 'Action_name');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('action_name'.capitalize(), 'Action_name');
    }
  });

  QUnit.test('capitalize camelcased string', function () {
    deepEqual(_emberRuntimeSystemString.capitalize('innerHTML'), 'InnerHTML');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('innerHTML'.capitalize(), 'InnerHTML');
    }
  });

  QUnit.test('does nothing with capitalized string', function () {
    deepEqual(_emberRuntimeSystemString.capitalize('Capitalized string'), 'Capitalized string');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('Capitalized string'.capitalize(), 'Capitalized string');
    }
  });

  QUnit.test('capitalize namespaced camelized string', function () {
    deepEqual(_emberRuntimeSystemString.capitalize('privateDocs/ownerInvoice'), 'PrivateDocs/OwnerInvoice');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('privateDocs/ownerInvoice'.capitalize(), 'PrivateDocs/OwnerInvoice');
    }
  });

  QUnit.test('capitalize namespaced underscored string', function () {
    deepEqual(_emberRuntimeSystemString.capitalize('private_docs/owner_invoice'), 'Private_docs/Owner_invoice');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('private_docs/owner_invoice'.capitalize(), 'Private_docs/Owner_invoice');
    }
  });

  QUnit.test('capitalize namespaced dasherized string', function () {
    deepEqual(_emberRuntimeSystemString.capitalize('private-docs/owner-invoice'), 'Private-docs/Owner-invoice');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('private-docs/owner-invoice'.capitalize(), 'Private-docs/Owner-invoice');
    }
  });
});
enifed('ember-runtime/tests/system/string/capitalize_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/system/string');
  test('ember-runtime/tests/system/string/capitalize_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/system/string/capitalize_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/system/string/capitalize_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/system/string');
  QUnit.test('ember-runtime/tests/system/string/capitalize_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/system/string/capitalize_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/system/string/classify_test', ['exports', 'ember-metal/core', 'ember-runtime/system/string'], function (exports, _emberMetalCore, _emberRuntimeSystemString) {
  'use strict';

  QUnit.module('EmberStringUtils.classify');

  if (!_emberMetalCore.default.EXTEND_PROTOTYPES && !_emberMetalCore.default.EXTEND_PROTOTYPES.String) {
    QUnit.test('String.prototype.classify is not modified without EXTEND_PROTOTYPES', function () {
      ok('undefined' === typeof String.prototype.classify, 'String.prototype helper disabled');
    });
  }

  QUnit.test('classify normal string', function () {
    deepEqual(_emberRuntimeSystemString.classify('my favorite items'), 'MyFavoriteItems');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('my favorite items'.classify(), 'MyFavoriteItems');
    }
  });

  QUnit.test('classify dasherized string', function () {
    deepEqual(_emberRuntimeSystemString.classify('css-class-name'), 'CssClassName');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('css-class-name'.classify(), 'CssClassName');
    }
  });

  QUnit.test('classify underscored string', function () {
    deepEqual(_emberRuntimeSystemString.classify('action_name'), 'ActionName');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('action_name'.classify(), 'ActionName');
    }
  });

  QUnit.test('does nothing with classified string', function () {
    deepEqual(_emberRuntimeSystemString.classify('InnerHTML'), 'InnerHTML');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('InnerHTML'.classify(), 'InnerHTML');
    }
  });

  QUnit.test('classify namespaced camelized string', function () {
    deepEqual(_emberRuntimeSystemString.classify('privateDocs/ownerInvoice'), 'PrivateDocs/OwnerInvoice');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('privateDocs/ownerInvoice'.classify(), 'PrivateDocs/OwnerInvoice');
    }
  });

  QUnit.test('classify namespaced underscored string', function () {
    deepEqual(_emberRuntimeSystemString.classify('private_docs/owner_invoice'), 'PrivateDocs/OwnerInvoice');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('private_docs/owner_invoice'.classify(), 'PrivateDocs/OwnerInvoice');
    }
  });

  QUnit.test('classify namespaced dasherized string', function () {
    deepEqual(_emberRuntimeSystemString.classify('private-docs/owner-invoice'), 'PrivateDocs/OwnerInvoice');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('private-docs/owner-invoice'.classify(), 'PrivateDocs/OwnerInvoice');
    }
  });
});
enifed('ember-runtime/tests/system/string/classify_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/system/string');
  test('ember-runtime/tests/system/string/classify_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/system/string/classify_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/system/string/classify_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/system/string');
  QUnit.test('ember-runtime/tests/system/string/classify_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/system/string/classify_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/system/string/dasherize_test', ['exports', 'ember-metal/core', 'ember-runtime/system/string'], function (exports, _emberMetalCore, _emberRuntimeSystemString) {
  'use strict';

  QUnit.module('EmberStringUtils.dasherize');

  if (!_emberMetalCore.default.EXTEND_PROTOTYPES && !_emberMetalCore.default.EXTEND_PROTOTYPES.String) {
    QUnit.test('String.prototype.dasherize is not modified without EXTEND_PROTOTYPES', function () {
      ok('undefined' === typeof String.prototype.dasherize, 'String.prototype helper disabled');
    });
  }

  QUnit.test('dasherize normal string', function () {
    deepEqual(_emberRuntimeSystemString.dasherize('my favorite items'), 'my-favorite-items');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('my favorite items'.dasherize(), 'my-favorite-items');
    }
  });

  QUnit.test('does nothing with dasherized string', function () {
    deepEqual(_emberRuntimeSystemString.dasherize('css-class-name'), 'css-class-name');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('css-class-name'.dasherize(), 'css-class-name');
    }
  });

  QUnit.test('dasherize underscored string', function () {
    deepEqual(_emberRuntimeSystemString.dasherize('action_name'), 'action-name');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('action_name'.dasherize(), 'action-name');
    }
  });

  QUnit.test('dasherize camelcased string', function () {
    deepEqual(_emberRuntimeSystemString.dasherize('innerHTML'), 'inner-html');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('innerHTML'.dasherize(), 'inner-html');
    }
  });

  QUnit.test('dasherize string that is the property name of Object.prototype', function () {
    deepEqual(_emberRuntimeSystemString.dasherize('toString'), 'to-string');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('toString'.dasherize(), 'to-string');
    }
  });

  QUnit.test('dasherize namespaced classified string', function () {
    deepEqual(_emberRuntimeSystemString.dasherize('PrivateDocs/OwnerInvoice'), 'private-docs/owner-invoice');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('PrivateDocs/OwnerInvoice'.dasherize(), 'private-docs/owner-invoice');
    }
  });

  QUnit.test('dasherize namespaced camelized string', function () {
    deepEqual(_emberRuntimeSystemString.dasherize('privateDocs/ownerInvoice'), 'private-docs/owner-invoice');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('privateDocs/ownerInvoice'.dasherize(), 'private-docs/owner-invoice');
    }
  });

  QUnit.test('dasherize namespaced underscored string', function () {
    deepEqual(_emberRuntimeSystemString.dasherize('private_docs/owner_invoice'), 'private-docs/owner-invoice');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('private_docs/owner_invoice'.dasherize(), 'private-docs/owner-invoice');
    }
  });
});
enifed('ember-runtime/tests/system/string/dasherize_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/system/string');
  test('ember-runtime/tests/system/string/dasherize_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/system/string/dasherize_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/system/string/dasherize_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/system/string');
  QUnit.test('ember-runtime/tests/system/string/dasherize_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/system/string/dasherize_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/system/string/decamelize_test', ['exports', 'ember-metal/core', 'ember-runtime/system/string'], function (exports, _emberMetalCore, _emberRuntimeSystemString) {
  'use strict';

  QUnit.module('EmberStringUtils.decamelize');

  if (!_emberMetalCore.default.EXTEND_PROTOTYPES && !_emberMetalCore.default.EXTEND_PROTOTYPES.String) {
    QUnit.test('String.prototype.decamelize is not modified without EXTEND_PROTOTYPES', function () {
      ok('undefined' === typeof String.prototype.decamelize, 'String.prototype helper disabled');
    });
  }

  QUnit.test('does nothing with normal string', function () {
    deepEqual(_emberRuntimeSystemString.decamelize('my favorite items'), 'my favorite items');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('my favorite items'.decamelize(), 'my favorite items');
    }
  });

  QUnit.test('does nothing with dasherized string', function () {
    deepEqual(_emberRuntimeSystemString.decamelize('css-class-name'), 'css-class-name');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('css-class-name'.decamelize(), 'css-class-name');
    }
  });

  QUnit.test('does nothing with underscored string', function () {
    deepEqual(_emberRuntimeSystemString.decamelize('action_name'), 'action_name');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('action_name'.decamelize(), 'action_name');
    }
  });

  QUnit.test('converts a camelized string into all lower case separated by underscores.', function () {
    deepEqual(_emberRuntimeSystemString.decamelize('innerHTML'), 'inner_html');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('innerHTML'.decamelize(), 'inner_html');
    }
  });

  QUnit.test('decamelizes strings with numbers', function () {
    deepEqual(_emberRuntimeSystemString.decamelize('size160Url'), 'size160_url');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('size160Url'.decamelize(), 'size160_url');
    }
  });

  QUnit.test('decamelize namespaced classified string', function () {
    deepEqual(_emberRuntimeSystemString.decamelize('PrivateDocs/OwnerInvoice'), 'private_docs/owner_invoice');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('PrivateDocs/OwnerInvoice'.decamelize(), 'private_docs/owner_invoice');
    }
  });

  QUnit.test('decamelize namespaced camelized string', function () {
    deepEqual(_emberRuntimeSystemString.decamelize('privateDocs/ownerInvoice'), 'private_docs/owner_invoice');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('privateDocs/ownerInvoice'.decamelize(), 'private_docs/owner_invoice');
    }
  });
});
enifed('ember-runtime/tests/system/string/decamelize_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/system/string');
  test('ember-runtime/tests/system/string/decamelize_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/system/string/decamelize_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/system/string/decamelize_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/system/string');
  QUnit.test('ember-runtime/tests/system/string/decamelize_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/system/string/decamelize_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/system/string/fmt_string_test', ['exports', 'ember-metal/core', 'ember-runtime/system/string'], function (exports, _emberMetalCore, _emberRuntimeSystemString) {
  'use strict';

  QUnit.module('EmberStringUtils.fmt');

  if (!_emberMetalCore.default.EXTEND_PROTOTYPES && !_emberMetalCore.default.EXTEND_PROTOTYPES.String) {
    QUnit.test('String.prototype.fmt is not modified without EXTEND_PROTOTYPES', function () {
      ok('undefined' === typeof String.prototype.fmt, 'String.prototype helper disabled');
    });
  }

  QUnit.test('\'Hello %@ %@\'.fmt(\'John\', \'Doe\') => \'Hello John Doe\'', function () {
    expectDeprecation('Ember.String.fmt is deprecated, use ES6 template strings instead.');
    equal(_emberRuntimeSystemString.fmt('Hello %@ %@', ['John', 'Doe']), 'Hello John Doe');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      equal('Hello %@ %@'.fmt('John', 'Doe'), 'Hello John Doe');
    }
  });

  QUnit.test('\'Hello %@2 %@1\'.fmt(\'John\', \'Doe\') => \'Hello Doe John\'', function () {
    expectDeprecation('Ember.String.fmt is deprecated, use ES6 template strings instead.');
    equal(_emberRuntimeSystemString.fmt('Hello %@2 %@1', ['John', 'Doe']), 'Hello Doe John');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      equal('Hello %@2 %@1'.fmt('John', 'Doe'), 'Hello Doe John');
    }
  });

  QUnit.test('\'%@08 %@07 %@06 %@05 %@04 %@03 %@02 %@01\'.fmt(\'One\', \'Two\', \'Three\', \'Four\', \'Five\', \'Six\', \'Seven\', \'Eight\') => \'Eight Seven Six Five Four Three Two One\'', function () {
    expectDeprecation('Ember.String.fmt is deprecated, use ES6 template strings instead.');
    equal(_emberRuntimeSystemString.fmt('%@08 %@07 %@06 %@05 %@04 %@03 %@02 %@01', ['One', 'Two', 'Three', 'Four', 'Five', 'Six', 'Seven', 'Eight']), 'Eight Seven Six Five Four Three Two One');

    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      equal('%@08 %@07 %@06 %@05 %@04 %@03 %@02 %@01'.fmt('One', 'Two', 'Three', 'Four', 'Five', 'Six', 'Seven', 'Eight'), 'Eight Seven Six Five Four Three Two One');
    }
  });

  QUnit.test('\'data: %@\'.fmt({ id: 3 }) => \'data: {id: 3}\'', function () {
    expectDeprecation('Ember.String.fmt is deprecated, use ES6 template strings instead.');
    equal(_emberRuntimeSystemString.fmt('data: %@', [{ id: 3 }]), 'data: {id: 3}');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      equal('data: %@'.fmt({ id: 3 }), 'data: {id: 3}');
    }
  });

  QUnit.test('works with argument form', function () {
    expectDeprecation('Ember.String.fmt is deprecated, use ES6 template strings instead.');
    equal(_emberRuntimeSystemString.fmt('%@', 'John'), 'John');
    equal(_emberRuntimeSystemString.fmt('%@ %@', ['John'], 'Doe'), '[John] Doe');
  });
});
enifed('ember-runtime/tests/system/string/fmt_string_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/system/string');
  test('ember-runtime/tests/system/string/fmt_string_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/system/string/fmt_string_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/system/string/fmt_string_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/system/string');
  QUnit.test('ember-runtime/tests/system/string/fmt_string_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/system/string/fmt_string_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/system/string/loc_test', ['exports', 'ember-metal/core', 'ember-runtime/system/string'], function (exports, _emberMetalCore, _emberRuntimeSystemString) {
  'use strict';

  var oldString;

  QUnit.module('EmberStringUtils.loc', {
    setup: function () {
      oldString = _emberMetalCore.default.STRINGS;
      _emberMetalCore.default.STRINGS = {
        '_Hello World': 'Bonjour le monde',
        '_Hello %@': 'Bonjour %@',
        '_Hello %@ %@': 'Bonjour %@ %@',
        '_Hello %@# %@#': 'Bonjour %@2 %@1'
      };
    },

    teardown: function () {
      _emberMetalCore.default.STRINGS = oldString;
    }
  });

  if (!_emberMetalCore.default.EXTEND_PROTOTYPES && !_emberMetalCore.default.EXTEND_PROTOTYPES.String) {
    QUnit.test('String.prototype.loc is not available without EXTEND_PROTOTYPES', function () {
      ok('undefined' === typeof String.prototype.loc, 'String.prototype helper disabled');
    });
  }

  QUnit.test('\'_Hello World\'.loc() => \'Bonjour le monde\'', function () {
    equal(_emberRuntimeSystemString.loc('_Hello World'), 'Bonjour le monde');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      equal('_Hello World'.loc(), 'Bonjour le monde');
    }
  });

  QUnit.test('\'_Hello %@ %@\'.loc(\'John\', \'Doe\') => \'Bonjour John Doe\'', function () {
    equal(_emberRuntimeSystemString.loc('_Hello %@ %@', ['John', 'Doe']), 'Bonjour John Doe');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      equal('_Hello %@ %@'.loc('John', 'Doe'), 'Bonjour John Doe');
    }
  });

  QUnit.test('\'_Hello %@# %@#\'.loc(\'John\', \'Doe\') => \'Bonjour Doe John\'', function () {
    equal(_emberRuntimeSystemString.loc('_Hello %@# %@#', ['John', 'Doe']), 'Bonjour Doe John');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      equal('_Hello %@# %@#'.loc('John', 'Doe'), 'Bonjour Doe John');
    }
  });

  QUnit.test('\'_Not In Strings\'.loc() => \'_Not In Strings\'', function () {
    equal(_emberRuntimeSystemString.loc('_Not In Strings'), '_Not In Strings');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      equal('_Not In Strings'.loc(), '_Not In Strings');
    }
  });

  QUnit.test('works with argument form', function () {
    equal(_emberRuntimeSystemString.loc('_Hello %@', 'John'), 'Bonjour John');
    equal(_emberRuntimeSystemString.loc('_Hello %@ %@', ['John'], 'Doe'), 'Bonjour [John] Doe');
  });
});
enifed('ember-runtime/tests/system/string/loc_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/system/string');
  test('ember-runtime/tests/system/string/loc_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/system/string/loc_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/system/string/loc_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/system/string');
  QUnit.test('ember-runtime/tests/system/string/loc_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/system/string/loc_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/system/string/underscore_test', ['exports', 'ember-metal/core', 'ember-runtime/system/string'], function (exports, _emberMetalCore, _emberRuntimeSystemString) {
  'use strict';

  QUnit.module('EmberStringUtils.underscore');

  if (!_emberMetalCore.default.EXTEND_PROTOTYPES && !_emberMetalCore.default.EXTEND_PROTOTYPES.String) {
    QUnit.test('String.prototype.underscore is not available without EXTEND_PROTOTYPES', function () {
      ok('undefined' === typeof String.prototype.underscore, 'String.prototype helper disabled');
    });
  }

  QUnit.test('with normal string', function () {
    deepEqual(_emberRuntimeSystemString.underscore('my favorite items'), 'my_favorite_items');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('my favorite items'.underscore(), 'my_favorite_items');
    }
  });

  QUnit.test('with dasherized string', function () {
    deepEqual(_emberRuntimeSystemString.underscore('css-class-name'), 'css_class_name');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('css-class-name'.underscore(), 'css_class_name');
    }
  });

  QUnit.test('does nothing with underscored string', function () {
    deepEqual(_emberRuntimeSystemString.underscore('action_name'), 'action_name');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('action_name'.underscore(), 'action_name');
    }
  });

  QUnit.test('with camelcased string', function () {
    deepEqual(_emberRuntimeSystemString.underscore('innerHTML'), 'inner_html');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('innerHTML'.underscore(), 'inner_html');
    }
  });

  QUnit.test('underscore namespaced classified string', function () {
    deepEqual(_emberRuntimeSystemString.underscore('PrivateDocs/OwnerInvoice'), 'private_docs/owner_invoice');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('PrivateDocs/OwnerInvoice'.underscore(), 'private_docs/owner_invoice');
    }
  });

  QUnit.test('underscore namespaced camelized string', function () {
    deepEqual(_emberRuntimeSystemString.underscore('privateDocs/ownerInvoice'), 'private_docs/owner_invoice');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('privateDocs/ownerInvoice'.underscore(), 'private_docs/owner_invoice');
    }
  });

  QUnit.test('underscore namespaced dasherized string', function () {
    deepEqual(_emberRuntimeSystemString.underscore('private-docs/owner-invoice'), 'private_docs/owner_invoice');
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('private-docs/owner-invoice'.underscore(), 'private_docs/owner_invoice');
    }
  });
});
enifed('ember-runtime/tests/system/string/underscore_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/system/string');
  test('ember-runtime/tests/system/string/underscore_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/system/string/underscore_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/system/string/underscore_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/system/string');
  QUnit.test('ember-runtime/tests/system/string/underscore_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/system/string/underscore_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/system/string/w_test', ['exports', 'ember-metal/core', 'ember-runtime/system/string'], function (exports, _emberMetalCore, _emberRuntimeSystemString) {
  'use strict';

  QUnit.module('EmberStringUtils.w');

  if (!_emberMetalCore.default.EXTEND_PROTOTYPES && !_emberMetalCore.default.EXTEND_PROTOTYPES.String) {
    QUnit.test('String.prototype.w is not available without EXTEND_PROTOTYPES', function () {
      ok('undefined' === typeof String.prototype.w, 'String.prototype helper disabled');
    });
  }

  QUnit.test('\'one two three\'.w() => [\'one\',\'two\',\'three\']', function () {
    deepEqual(_emberRuntimeSystemString.w('one two three'), ['one', 'two', 'three']);
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('one two three'.w(), ['one', 'two', 'three']);
    }
  });

  QUnit.test('\'one    two    three\'.w() with extra spaces between words => [\'one\',\'two\',\'three\']', function () {
    deepEqual(_emberRuntimeSystemString.w('one   two  three'), ['one', 'two', 'three']);
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('one   two  three'.w(), ['one', 'two', 'three']);
    }
  });

  QUnit.test('\'one two three\'.w() with tabs', function () {
    deepEqual(_emberRuntimeSystemString.w('one\ttwo  three'), ['one', 'two', 'three']);
    if (_emberMetalCore.default.EXTEND_PROTOTYPES) {
      deepEqual('one\ttwo  three'.w(), ['one', 'two', 'three']);
    }
  });
});
enifed('ember-runtime/tests/system/string/w_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests/system/string');
  test('ember-runtime/tests/system/string/w_test.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/system/string/w_test.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/system/string/w_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests/system/string');
  QUnit.test('ember-runtime/tests/system/string/w_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/system/string/w_test.js should pass jshint.');
  });
});
enifed('ember-runtime/tests/utils', ['exports', 'ember-metal/run_loop'], function (exports, _emberMetalRun_loop) {
  'use strict';

  function runAppend(view) {
    _emberMetalRun_loop.default(view, 'appendTo', '#qunit-fixture');
  }

  function runDestroy(destroyed) {
    if (destroyed) {
      _emberMetalRun_loop.default(destroyed, 'destroy');
    }
  }

  exports.runAppend = runAppend;
  exports.runDestroy = runDestroy;
});
enifed('ember-runtime/tests/utils.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime/tests');
  test('ember-runtime/tests/utils.js should pass jscs', function () {
    ok(true, 'ember-runtime/tests/utils.js should pass jscs.');
  });
});
enifed('ember-runtime/tests/utils.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime/tests');
  QUnit.test('ember-runtime/tests/utils.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/tests/utils.js should pass jshint.');
  });
});
enifed('ember-runtime/utils.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-runtime');
  test('ember-runtime/utils.js should pass jscs', function () {
    ok(true, 'ember-runtime/utils.js should pass jscs.');
  });
});
enifed('ember-runtime/utils.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-runtime');
  QUnit.test('ember-runtime/utils.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-runtime/utils.js should pass jshint.');
  });
});
enifed('ember-template-compiler.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - .');
  test('ember-template-compiler.js should pass jscs', function () {
    ok(true, 'ember-template-compiler.js should pass jscs.');
  });
});
enifed('ember-template-compiler.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - .');
  QUnit.test('ember-template-compiler.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-template-compiler.js should pass jshint.');
  });
});
enifed('ember-template-compiler/compat.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-template-compiler');
  test('ember-template-compiler/compat.js should pass jscs', function () {
    ok(true, 'ember-template-compiler/compat.js should pass jscs.');
  });
});
enifed('ember-template-compiler/compat.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-template-compiler');
  QUnit.test('ember-template-compiler/compat.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-template-compiler/compat.js should pass jshint.');
  });
});
enifed('ember-template-compiler/compat/precompile.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-template-compiler/compat');
  test('ember-template-compiler/compat/precompile.js should pass jscs', function () {
    ok(true, 'ember-template-compiler/compat/precompile.js should pass jscs.');
  });
});
enifed('ember-template-compiler/compat/precompile.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-template-compiler/compat');
  QUnit.test('ember-template-compiler/compat/precompile.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-template-compiler/compat/precompile.js should pass jshint.');
  });
});
enifed('ember-template-compiler/plugins.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-template-compiler');
  test('ember-template-compiler/plugins.js should pass jscs', function () {
    ok(true, 'ember-template-compiler/plugins.js should pass jscs.');
  });
});
enifed('ember-template-compiler/plugins.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-template-compiler');
  QUnit.test('ember-template-compiler/plugins.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-template-compiler/plugins.js should pass jshint.');
  });
});
enifed('ember-template-compiler/plugins/assert-no-view-and-controller-paths.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-template-compiler/plugins');
  test('ember-template-compiler/plugins/assert-no-view-and-controller-paths.js should pass jscs', function () {
    ok(true, 'ember-template-compiler/plugins/assert-no-view-and-controller-paths.js should pass jscs.');
  });
});
enifed('ember-template-compiler/plugins/assert-no-view-and-controller-paths.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-template-compiler/plugins');
  QUnit.test('ember-template-compiler/plugins/assert-no-view-and-controller-paths.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-template-compiler/plugins/assert-no-view-and-controller-paths.js should pass jshint.');
  });
});
enifed('ember-template-compiler/plugins/assert-no-view-helper.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-template-compiler/plugins');
  test('ember-template-compiler/plugins/assert-no-view-helper.js should pass jscs', function () {
    ok(true, 'ember-template-compiler/plugins/assert-no-view-helper.js should pass jscs.');
  });
});
enifed('ember-template-compiler/plugins/assert-no-view-helper.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-template-compiler/plugins');
  QUnit.test('ember-template-compiler/plugins/assert-no-view-helper.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-template-compiler/plugins/assert-no-view-helper.js should pass jshint.');
  });
});
enifed('ember-template-compiler/plugins/transform-angle-bracket-components.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-template-compiler/plugins');
  test('ember-template-compiler/plugins/transform-angle-bracket-components.js should pass jscs', function () {
    ok(true, 'ember-template-compiler/plugins/transform-angle-bracket-components.js should pass jscs.');
  });
});
enifed('ember-template-compiler/plugins/transform-angle-bracket-components.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-template-compiler/plugins');
  QUnit.test('ember-template-compiler/plugins/transform-angle-bracket-components.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-template-compiler/plugins/transform-angle-bracket-components.js should pass jshint.');
  });
});
enifed('ember-template-compiler/plugins/transform-component-attrs-into-mut.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-template-compiler/plugins');
  test('ember-template-compiler/plugins/transform-component-attrs-into-mut.js should pass jscs', function () {
    ok(true, 'ember-template-compiler/plugins/transform-component-attrs-into-mut.js should pass jscs.');
  });
});
enifed('ember-template-compiler/plugins/transform-component-attrs-into-mut.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-template-compiler/plugins');
  QUnit.test('ember-template-compiler/plugins/transform-component-attrs-into-mut.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-template-compiler/plugins/transform-component-attrs-into-mut.js should pass jshint.');
  });
});
enifed('ember-template-compiler/plugins/transform-component-curly-to-readonly.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-template-compiler/plugins');
  test('ember-template-compiler/plugins/transform-component-curly-to-readonly.js should pass jscs', function () {
    ok(true, 'ember-template-compiler/plugins/transform-component-curly-to-readonly.js should pass jscs.');
  });
});
enifed('ember-template-compiler/plugins/transform-component-curly-to-readonly.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-template-compiler/plugins');
  QUnit.test('ember-template-compiler/plugins/transform-component-curly-to-readonly.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-template-compiler/plugins/transform-component-curly-to-readonly.js should pass jshint.');
  });
});
enifed('ember-template-compiler/plugins/transform-each-in-to-hash.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-template-compiler/plugins');
  test('ember-template-compiler/plugins/transform-each-in-to-hash.js should pass jscs', function () {
    ok(true, 'ember-template-compiler/plugins/transform-each-in-to-hash.js should pass jscs.');
  });
});
enifed('ember-template-compiler/plugins/transform-each-in-to-hash.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-template-compiler/plugins');
  QUnit.test('ember-template-compiler/plugins/transform-each-in-to-hash.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-template-compiler/plugins/transform-each-in-to-hash.js should pass jshint.');
  });
});
enifed('ember-template-compiler/plugins/transform-each-into-collection.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-template-compiler/plugins');
  test('ember-template-compiler/plugins/transform-each-into-collection.js should pass jscs', function () {
    ok(true, 'ember-template-compiler/plugins/transform-each-into-collection.js should pass jscs.');
  });
});
enifed('ember-template-compiler/plugins/transform-each-into-collection.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-template-compiler/plugins');
  QUnit.test('ember-template-compiler/plugins/transform-each-into-collection.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-template-compiler/plugins/transform-each-into-collection.js should pass jshint.');
  });
});
enifed('ember-template-compiler/plugins/transform-input-on-to-onEvent.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-template-compiler/plugins');
  test('ember-template-compiler/plugins/transform-input-on-to-onEvent.js should pass jscs', function () {
    ok(true, 'ember-template-compiler/plugins/transform-input-on-to-onEvent.js should pass jscs.');
  });
});
enifed('ember-template-compiler/plugins/transform-input-on-to-onEvent.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-template-compiler/plugins');
  QUnit.test('ember-template-compiler/plugins/transform-input-on-to-onEvent.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-template-compiler/plugins/transform-input-on-to-onEvent.js should pass jshint.');
  });
});
enifed('ember-template-compiler/plugins/transform-item-class.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-template-compiler/plugins');
  test('ember-template-compiler/plugins/transform-item-class.js should pass jscs', function () {
    ok(true, 'ember-template-compiler/plugins/transform-item-class.js should pass jscs.');
  });
});
enifed('ember-template-compiler/plugins/transform-item-class.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-template-compiler/plugins');
  QUnit.test('ember-template-compiler/plugins/transform-item-class.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-template-compiler/plugins/transform-item-class.js should pass jshint.');
  });
});
enifed('ember-template-compiler/plugins/transform-old-binding-syntax.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-template-compiler/plugins');
  test('ember-template-compiler/plugins/transform-old-binding-syntax.js should pass jscs', function () {
    ok(true, 'ember-template-compiler/plugins/transform-old-binding-syntax.js should pass jscs.');
  });
});
enifed('ember-template-compiler/plugins/transform-old-binding-syntax.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-template-compiler/plugins');
  QUnit.test('ember-template-compiler/plugins/transform-old-binding-syntax.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-template-compiler/plugins/transform-old-binding-syntax.js should pass jshint.');
  });
});
enifed('ember-template-compiler/plugins/transform-old-class-binding-syntax.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-template-compiler/plugins');
  test('ember-template-compiler/plugins/transform-old-class-binding-syntax.js should pass jscs', function () {
    ok(true, 'ember-template-compiler/plugins/transform-old-class-binding-syntax.js should pass jscs.');
  });
});
enifed('ember-template-compiler/plugins/transform-old-class-binding-syntax.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-template-compiler/plugins');
  QUnit.test('ember-template-compiler/plugins/transform-old-class-binding-syntax.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-template-compiler/plugins/transform-old-class-binding-syntax.js should pass jshint.');
  });
});
enifed('ember-template-compiler/system/calculate-location-display.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-template-compiler/system');
  test('ember-template-compiler/system/calculate-location-display.js should pass jscs', function () {
    ok(true, 'ember-template-compiler/system/calculate-location-display.js should pass jscs.');
  });
});
enifed('ember-template-compiler/system/calculate-location-display.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-template-compiler/system');
  QUnit.test('ember-template-compiler/system/calculate-location-display.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-template-compiler/system/calculate-location-display.js should pass jshint.');
  });
});
enifed('ember-template-compiler/system/compile.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-template-compiler/system');
  test('ember-template-compiler/system/compile.js should pass jscs', function () {
    ok(true, 'ember-template-compiler/system/compile.js should pass jscs.');
  });
});
enifed('ember-template-compiler/system/compile.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-template-compiler/system');
  QUnit.test('ember-template-compiler/system/compile.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-template-compiler/system/compile.js should pass jshint.');
  });
});
enifed('ember-template-compiler/system/compile_options.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-template-compiler/system');
  test('ember-template-compiler/system/compile_options.js should pass jscs', function () {
    ok(true, 'ember-template-compiler/system/compile_options.js should pass jscs.');
  });
});
enifed('ember-template-compiler/system/compile_options.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-template-compiler/system');
  QUnit.test('ember-template-compiler/system/compile_options.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-template-compiler/system/compile_options.js should pass jshint.');
  });
});
enifed('ember-template-compiler/system/precompile.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-template-compiler/system');
  test('ember-template-compiler/system/precompile.js should pass jscs', function () {
    ok(true, 'ember-template-compiler/system/precompile.js should pass jscs.');
  });
});
enifed('ember-template-compiler/system/precompile.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-template-compiler/system');
  QUnit.test('ember-template-compiler/system/precompile.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-template-compiler/system/precompile.js should pass jshint.');
  });
});
enifed('ember-template-compiler/system/template.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-template-compiler/system');
  test('ember-template-compiler/system/template.js should pass jscs', function () {
    ok(true, 'ember-template-compiler/system/template.js should pass jscs.');
  });
});
enifed('ember-template-compiler/system/template.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-template-compiler/system');
  QUnit.test('ember-template-compiler/system/template.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-template-compiler/system/template.js should pass jshint.');
  });
});
enifed("ember-template-compiler/tests/main_test", ["exports"], function (exports) {
  "use strict";
});
enifed('ember-template-compiler/tests/main_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-template-compiler/tests');
  test('ember-template-compiler/tests/main_test.js should pass jscs', function () {
    ok(true, 'ember-template-compiler/tests/main_test.js should pass jscs.');
  });
});
enifed('ember-template-compiler/tests/main_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-template-compiler/tests');
  QUnit.test('ember-template-compiler/tests/main_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-template-compiler/tests/main_test.js should pass jshint.');
  });
});
enifed('ember-template-compiler/tests/plugins/transform-each-into-collection-test', ['exports', 'ember-template-compiler', 'ember-htmlbars/tests/utils', 'ember-template-compiler/plugins/transform-each-into-collection'], function (exports, _emberTemplateCompiler, _emberHtmlbarsTestsUtils, _emberTemplateCompilerPluginsTransformEachIntoCollection) {
  'use strict';

  QUnit.module('ember-template-compiler: transform-each-into-collection', {
    setup: function () {
      _emberHtmlbarsTestsUtils.registerAstPlugin(_emberTemplateCompilerPluginsTransformEachIntoCollection.default);
    },
    teardown: function () {
      _emberHtmlbarsTestsUtils.removeAstPlugin(_emberTemplateCompilerPluginsTransformEachIntoCollection.default);
    }
  });

  var deprecatedAttrs = ['itemController', 'itemView', 'itemViewClass', 'tagName', 'emptyView', 'emptyViewClass'];

  function testBlockForm(attr) {
    QUnit.test('Using the \'' + attr + '\' hash argument with a block results in a deprecation', function () {
      expect(1);

      expectDeprecation(function () {
        _emberTemplateCompiler.compile('\n\n    {{#each model ' + attr + '="foo" as |item|}}{{item}}{{/each}}', {
          moduleName: 'lol-wat-app/index/template'
        });
      }, 'Using \'' + attr + '\' with \'{{each}}\' (\'lol-wat-app/index/template\' @ L3:C18) is deprecated.  Please refactor to a component.');
    });
  }

  function testNonBlockForm(attr) {
    QUnit.test('Using the \'' + attr + '\' hash argument in non-block form results in a deprecation', function () {
      expect(1);

      expectDeprecation(function () {
        _emberTemplateCompiler.compile('\n\n    {{each model ' + attr + '="foo"}}', {
          moduleName: 'lol-wat-app/index/template'
        });
      }, 'Using \'' + attr + '\' with \'{{each}}\' (\'lol-wat-app/index/template\' @ L3:C17) is deprecated.  Please refactor to a component.');
    });
  }

  for (var i = 0, l = deprecatedAttrs.length; i < l; i++) {
    var attr = deprecatedAttrs[i];

    testBlockForm(attr);
    testNonBlockForm(attr);
  }
});
enifed('ember-template-compiler/tests/plugins/transform-each-into-collection-test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-template-compiler/tests/plugins');
  test('ember-template-compiler/tests/plugins/transform-each-into-collection-test.js should pass jscs', function () {
    ok(true, 'ember-template-compiler/tests/plugins/transform-each-into-collection-test.js should pass jscs.');
  });
});
enifed('ember-template-compiler/tests/plugins/transform-each-into-collection-test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-template-compiler/tests/plugins');
  QUnit.test('ember-template-compiler/tests/plugins/transform-each-into-collection-test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-template-compiler/tests/plugins/transform-each-into-collection-test.js should pass jshint.');
  });
});
enifed('ember-template-compiler/tests/plugins/transform-input-on-test', ['exports', 'ember-template-compiler'], function (exports, _emberTemplateCompiler) {
  'use strict';

  QUnit.module('ember-template-compiler: transform-input-on');

  QUnit.test('Using `action` without `on` provides a deprecation', function () {
    expect(1);

    expectDeprecation(function () {
      _emberTemplateCompiler.compile('{{input action="foo"}}', {
        moduleName: 'foo/bar/baz'
      });
    }, 'Using \'{{input action="foo"}}\' (\'foo/bar/baz\' @ L1:C0) is deprecated. Please use \'{{input enter="foo"}}\' instead.');
  });

  QUnit.test('Using `action` with `on` provides a deprecation', function () {
    expect(1);

    expectDeprecation(function () {
      _emberTemplateCompiler.compile('{{input on="focus-in" action="foo"}}', {
        moduleName: 'foo/bar/baz'
      });
    }, 'Using \'{{input on="focus-in" action="foo"}}\' (\'foo/bar/baz\' @ L1:C0) is deprecated. Please use \'{{input focus-in="foo"}}\' instead.');
  });

  QUnit.test('Using `on=\'keyPress\'` does not clobber `keyPress`', function () {
    expect(1);

    expectDeprecation(function () {
      _emberTemplateCompiler.compile('{{input on="keyPress" action="foo"}}', {
        moduleName: 'foo/bar/baz'
      });
    }, 'Using \'{{input on="keyPress" action="foo"}}\' (\'foo/bar/baz\' @ L1:C0) is deprecated. Please use \'{{input key-press="foo"}}\' instead.');
  });

  QUnit.test('Using `on=\'foo\'` without `action=\'asdf\'` raises specific deprecation', function () {
    expect(1);

    expectDeprecation(function () {
      _emberTemplateCompiler.compile('{{input on="asdf"}}', {
        moduleName: 'foo/bar/baz'
      });
    }, 'Using \'{{input on="asdf" ...}}\' without specifying an action (\'foo/bar/baz\' @ L1:C0) will do nothing.');
  });
});
enifed('ember-template-compiler/tests/plugins/transform-input-on-test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-template-compiler/tests/plugins');
  test('ember-template-compiler/tests/plugins/transform-input-on-test.js should pass jscs', function () {
    ok(true, 'ember-template-compiler/tests/plugins/transform-input-on-test.js should pass jscs.');
  });
});
enifed('ember-template-compiler/tests/plugins/transform-input-on-test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-template-compiler/tests/plugins');
  QUnit.test('ember-template-compiler/tests/plugins/transform-input-on-test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-template-compiler/tests/plugins/transform-input-on-test.js should pass jshint.');
  });
});
enifed('ember-template-compiler/tests/plugins_test', ['exports', 'ember-template-compiler/plugins', 'ember-template-compiler/system/compile'], function (exports, _emberTemplateCompilerPlugins, _emberTemplateCompilerSystemCompile) {
  'use strict';

  var originalASTPlugins;

  QUnit.module('ember-htmlbars: Ember.HTMLBars.registerASTPlugin', {
    setup: function () {
      originalASTPlugins = _emberTemplateCompilerPlugins.default.ast.slice();
    },

    teardown: function () {
      _emberTemplateCompilerPlugins.default.ast = originalASTPlugins;
    }
  });

  QUnit.test('registering a plugin adds it to htmlbars-compiler options', function () {
    expect(2);

    function TestPlugin() {
      ok(true, 'TestPlugin instantiated');
    }

    TestPlugin.prototype.transform = function (ast) {
      ok(true, 'transform was called');

      return ast;
    };

    _emberTemplateCompilerPlugins.registerPlugin('ast', TestPlugin);

    _emberTemplateCompilerSystemCompile.default('some random template');
  });

  QUnit.test('registering an unknown type throws an error', function () {
    throws(function () {
      _emberTemplateCompilerPlugins.registerPlugin('asdf', 'whatever');
    }, /Attempting to register "whatever" as "asdf" which is not a valid HTMLBars plugin type./);
  });
});
enifed('ember-template-compiler/tests/plugins_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-template-compiler/tests');
  test('ember-template-compiler/tests/plugins_test.js should pass jscs', function () {
    ok(true, 'ember-template-compiler/tests/plugins_test.js should pass jscs.');
  });
});
enifed('ember-template-compiler/tests/plugins_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-template-compiler/tests');
  QUnit.test('ember-template-compiler/tests/plugins_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-template-compiler/tests/plugins_test.js should pass jshint.');
  });
});
enifed('ember-template-compiler/tests/system/compile_options_test', ['exports', 'ember-template-compiler/plugins', 'ember-template-compiler/system/compile_options'], function (exports, _emberTemplateCompilerPlugins, _emberTemplateCompilerSystemCompile_options) {
  'use strict';

  function comparePlugins(options) {
    var results = _emberTemplateCompilerSystemCompile_options.default(options);
    var expectedPlugins = _emberTemplateCompilerPlugins.default.ast.slice();

    expectedPlugins = expectedPlugins.concat(options.plugins.ast.slice());

    deepEqual(results.plugins.ast, expectedPlugins);
  }

  QUnit.module('ember-htmlbars: compile_options');

  QUnit.test('repeated function calls should be able to have separate plugins', function () {
    comparePlugins({
      plugins: {
        ast: ['foo', 'bar']
      }
    });

    comparePlugins({
      plugins: {
        ast: ['baz', 'qux']
      }
    });
  });

  QUnit.test('options is not required', function () {
    var results = _emberTemplateCompilerSystemCompile_options.default();

    deepEqual(results.plugins.ast, _emberTemplateCompilerPlugins.default.ast.slice());
  });

  QUnit.test('options.plugins is not required', function () {
    var results = _emberTemplateCompilerSystemCompile_options.default({});

    deepEqual(results.plugins.ast, _emberTemplateCompilerPlugins.default.ast.slice());
  });

  QUnit.test('options.plugins.ast is not required', function () {
    var results = _emberTemplateCompilerSystemCompile_options.default({
      plugins: {}
    });

    deepEqual(results.plugins.ast, _emberTemplateCompilerPlugins.default.ast.slice());
  });
});
enifed('ember-template-compiler/tests/system/compile_options_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-template-compiler/tests/system');
  test('ember-template-compiler/tests/system/compile_options_test.js should pass jscs', function () {
    ok(true, 'ember-template-compiler/tests/system/compile_options_test.js should pass jscs.');
  });
});
enifed('ember-template-compiler/tests/system/compile_options_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-template-compiler/tests/system');
  QUnit.test('ember-template-compiler/tests/system/compile_options_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-template-compiler/tests/system/compile_options_test.js should pass jshint.');
  });
});
enifed('ember-template-compiler/tests/system/compile_test', ['exports', 'ember-template-compiler/system/compile', 'htmlbars-compiler/compiler'], function (exports, _emberTemplateCompilerSystemCompile, _htmlbarsCompilerCompiler) {
  'use strict';

  QUnit.module('ember-htmlbars: compile');

  QUnit.test('compiles the provided template with htmlbars', function () {
    var templateString = '{{foo}} -- {{some-bar blah=\'foo\'}}';

    var actual = _emberTemplateCompilerSystemCompile.default(templateString);
    var expected = _htmlbarsCompilerCompiler.compile(templateString);

    equal(actual.toString(), expected.toString(), 'compile function matches content with htmlbars compile');
  });

  QUnit.test('calls template on the compiled function', function () {
    var templateString = '{{foo}} -- {{some-bar blah=\'foo\'}}';

    var actual = _emberTemplateCompilerSystemCompile.default(templateString);

    ok(actual.isTop, 'sets isTop via template function');
    ok(actual.isMethod === false, 'sets isMethod via template function');
  });

  QUnit.test('includes the current revision in the compiled template', function () {
    var templateString = '{{foo}} -- {{some-bar blah=\'foo\'}}';

    var actual = _emberTemplateCompilerSystemCompile.default(templateString);

    equal(actual.meta.revision, 'Ember@2.0.3', 'revision is included in generated template');
  });

  QUnit.test('the template revision is different than the HTMLBars default revision', function () {
    var templateString = '{{foo}} -- {{some-bar blah=\'foo\'}}';

    var actual = _emberTemplateCompilerSystemCompile.default(templateString);
    var expected = _htmlbarsCompilerCompiler.compile(templateString);

    ok(actual.meta.revision !== expected.meta.revision, 'revision differs from default');
  });
});
enifed('ember-template-compiler/tests/system/compile_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-template-compiler/tests/system');
  test('ember-template-compiler/tests/system/compile_test.js should pass jscs', function () {
    ok(true, 'ember-template-compiler/tests/system/compile_test.js should pass jscs.');
  });
});
enifed('ember-template-compiler/tests/system/compile_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-template-compiler/tests/system');
  QUnit.test('ember-template-compiler/tests/system/compile_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-template-compiler/tests/system/compile_test.js should pass jshint.');
  });
});
enifed('ember-template-compiler/tests/system/template_test', ['exports', 'ember-template-compiler/system/template'], function (exports, _emberTemplateCompilerSystemTemplate) {
  'use strict';

  QUnit.module('ember-htmlbars: template');

  QUnit.test('sets `isTop` on the provided function', function () {
    function test() {}

    var result = _emberTemplateCompilerSystemTemplate.default(test);

    equal(result.isTop, true, 'sets isTop on the provided function');
  });

  QUnit.test('sets `isMethod` on the provided function', function () {
    function test() {}

    var result = _emberTemplateCompilerSystemTemplate.default(test);

    equal(result.isMethod, false, 'sets isMethod on the provided function');
  });
});
enifed('ember-template-compiler/tests/system/template_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-template-compiler/tests/system');
  test('ember-template-compiler/tests/system/template_test.js should pass jscs', function () {
    ok(true, 'ember-template-compiler/tests/system/template_test.js should pass jscs.');
  });
});
enifed('ember-template-compiler/tests/system/template_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-template-compiler/tests/system');
  QUnit.test('ember-template-compiler/tests/system/template_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-template-compiler/tests/system/template_test.js should pass jshint.');
  });
});
enifed('ember-testing.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - .');
  test('ember-testing.js should pass jscs', function () {
    ok(true, 'ember-testing.js should pass jscs.');
  });
});
enifed('ember-testing.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - .');
  QUnit.test('ember-testing.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-testing.js should pass jshint.');
  });
});
enifed('ember-testing/adapters/adapter.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-testing/adapters');
  test('ember-testing/adapters/adapter.js should pass jscs', function () {
    ok(true, 'ember-testing/adapters/adapter.js should pass jscs.');
  });
});
enifed('ember-testing/adapters/adapter.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-testing/adapters');
  QUnit.test('ember-testing/adapters/adapter.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-testing/adapters/adapter.js should pass jshint.');
  });
});
enifed('ember-testing/adapters/qunit.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-testing/adapters');
  test('ember-testing/adapters/qunit.js should pass jscs', function () {
    ok(true, 'ember-testing/adapters/qunit.js should pass jscs.');
  });
});
enifed('ember-testing/adapters/qunit.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-testing/adapters');
  QUnit.test('ember-testing/adapters/qunit.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-testing/adapters/qunit.js should pass jshint.');
  });
});
enifed('ember-testing/helpers.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-testing');
  test('ember-testing/helpers.js should pass jscs', function () {
    ok(true, 'ember-testing/helpers.js should pass jscs.');
  });
});
enifed('ember-testing/helpers.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-testing');
  QUnit.test('ember-testing/helpers.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-testing/helpers.js should pass jshint.');
  });
});
enifed('ember-testing/initializers.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-testing');
  test('ember-testing/initializers.js should pass jscs', function () {
    ok(true, 'ember-testing/initializers.js should pass jscs.');
  });
});
enifed('ember-testing/initializers.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-testing');
  QUnit.test('ember-testing/initializers.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-testing/initializers.js should pass jshint.');
  });
});
enifed('ember-testing/setup_for_testing.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-testing');
  test('ember-testing/setup_for_testing.js should pass jscs', function () {
    ok(true, 'ember-testing/setup_for_testing.js should pass jscs.');
  });
});
enifed('ember-testing/setup_for_testing.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-testing');
  QUnit.test('ember-testing/setup_for_testing.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-testing/setup_for_testing.js should pass jshint.');
  });
});
enifed('ember-testing/support.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-testing');
  test('ember-testing/support.js should pass jscs', function () {
    ok(true, 'ember-testing/support.js should pass jscs.');
  });
});
enifed('ember-testing/support.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-testing');
  QUnit.test('ember-testing/support.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-testing/support.js should pass jshint.');
  });
});
enifed('ember-testing/test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-testing');
  test('ember-testing/test.js should pass jscs', function () {
    ok(true, 'ember-testing/test.js should pass jscs.');
  });
});
enifed('ember-testing/test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-testing');
  QUnit.test('ember-testing/test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-testing/test.js should pass jshint.');
  });
});
enifed('ember-testing/tests/acceptance_test', ['exports', 'ember-metal/run_loop', 'ember-views/system/jquery', 'ember-testing/test', 'ember-testing/adapters/qunit', 'ember-views/views/view', 'ember-testing/initializers', 'ember-application/system/application', 'ember-routing/system/route', 'ember-template-compiler/system/compile', 'ember-runtime/ext/rsvp', 'ember-routing'], function (exports, _emberMetalRun_loop, _emberViewsSystemJquery, _emberTestingTest, _emberTestingAdaptersQunit, _emberViewsViewsView, _emberTestingInitializers, _emberApplicationSystemApplication, _emberRoutingSystemRoute, _emberTemplateCompilerSystemCompile, _emberRuntimeExtRsvp, _emberRouting) {
  'use strict';

  //ES6TODO: fixme?

  var App, find, click, fillIn, currentRoute, currentURL, visit, originalAdapter, andThen, indexHitCount;

  QUnit.module('ember-testing Acceptance', {
    setup: function () {
      _emberViewsSystemJquery.default('<style>#ember-testing-container { position: absolute; background: white; bottom: 0; right: 0; width: 640px; height: 384px; overflow: auto; z-index: 9999; border: 1px solid #ccc; } #ember-testing { zoom: 50%; }</style>').appendTo('head');
      _emberViewsSystemJquery.default('<div id="ember-testing-container"><div id="ember-testing"></div></div>').appendTo('body');
      _emberMetalRun_loop.default(function () {
        indexHitCount = 0;

        App = _emberApplicationSystemApplication.default.create({
          rootElement: '#ember-testing'
        });

        App.Router.map(function () {
          this.route('posts');
          this.route('comments');

          this.route('abort_transition');

          this.route('redirect');
        });

        App.IndexRoute = _emberRoutingSystemRoute.default.extend({
          model: function () {
            indexHitCount += 1;
          }
        });

        App.PostsRoute = _emberRoutingSystemRoute.default.extend({
          renderTemplate: function () {
            currentRoute = 'posts';
            this._super.apply(this, arguments);
          }
        });

        App.PostsView = _emberViewsViewsView.default.extend({
          defaultTemplate: _emberTemplateCompilerSystemCompile.default('<a class="dummy-link"></a><div id="comments-link">{{#link-to \'comments\'}}Comments{{/link-to}}</div>'),
          classNames: ['posts-view']
        });

        App.CommentsRoute = _emberRoutingSystemRoute.default.extend({
          renderTemplate: function () {
            currentRoute = 'comments';
            this._super.apply(this, arguments);
          }
        });

        App.CommentsView = _emberViewsViewsView.default.extend({
          defaultTemplate: _emberTemplateCompilerSystemCompile.default('{{input type="text"}}')
        });

        App.AbortTransitionRoute = _emberRoutingSystemRoute.default.extend({
          beforeModel: function (transition) {
            transition.abort();
          }
        });

        App.RedirectRoute = _emberRoutingSystemRoute.default.extend({
          beforeModel: function () {
            this.transitionTo('comments');
          }
        });

        App.setupForTesting();
      });

      _emberTestingTest.default.registerAsyncHelper('slowHelper', function () {
        return new _emberRuntimeExtRsvp.default.Promise(function (resolve) {
          setTimeout(resolve, 10);
        });
      });

      App.injectTestHelpers();

      find = window.find;
      click = window.click;
      fillIn = window.fillIn;
      visit = window.visit;
      andThen = window.andThen;
      currentURL = window.currentURL;

      originalAdapter = _emberTestingTest.default.adapter;
    },

    teardown: function () {
      _emberTestingTest.default.unregisterHelper('slowHelper');
      _emberViewsSystemJquery.default('#ember-testing-container, #ember-testing').remove();
      _emberMetalRun_loop.default(App, App.destroy);
      App = null;
      _emberTestingTest.default.adapter = originalAdapter;
      indexHitCount = 0;
    }
  });

  QUnit.test('helpers can be chained with then', function () {
    expect(6);

    currentRoute = 'index';

    visit('/posts').then(function () {
      equal(currentRoute, 'posts', 'Successfully visited posts route');
      equal(currentURL(), '/posts', 'posts URL is correct');
      return click('a:contains("Comments")');
    }).then(function () {
      equal(currentRoute, 'comments', 'visit chained with click');
      return fillIn('.ember-text-field', 'yeah');
    }).then(function () {
      equal(_emberViewsSystemJquery.default('.ember-text-field').val(), 'yeah', 'chained with fillIn');
      return fillIn('.ember-text-field', '#ember-testing-container', 'context working');
    }).then(function () {
      equal(_emberViewsSystemJquery.default('.ember-text-field').val(), 'context working', 'chained with fillIn');
      return click('.does-not-exist');
    }).then(null, function (e) {
      equal(e.message, 'Element .does-not-exist not found.', 'Non-existent click exception caught');
    });
  });

  // Keep this for backwards compatibility

  QUnit.test('helpers can be chained to each other', function () {
    expect(7);

    currentRoute = 'index';

    visit('/posts').click('a:first', '#comments-link').fillIn('.ember-text-field', 'hello').then(function () {
      equal(currentRoute, 'comments', 'Successfully visited comments route');
      equal(currentURL(), '/comments', 'Comments URL is correct');
      equal(_emberViewsSystemJquery.default('.ember-text-field').val(), 'hello', 'Fillin successfully works');
      find('.ember-text-field').one('keypress', function (e) {
        equal(e.keyCode, 13, 'keyevent chained with correct keyCode.');
        equal(e.which, 13, 'keyevent chained with correct which.');
      });
    }).keyEvent('.ember-text-field', 'keypress', 13).visit('/posts').then(function () {
      equal(currentRoute, 'posts', 'Thens can also be chained to helpers');
      equal(currentURL(), '/posts', 'URL is set correct on chained helpers');
    });
  });

  QUnit.test('helpers don\'t need to be chained', function () {
    expect(5);

    currentRoute = 'index';

    visit('/posts');

    click('a:first', '#comments-link');

    fillIn('.ember-text-field', 'hello');

    andThen(function () {
      equal(currentRoute, 'comments', 'Successfully visited comments route');
      equal(currentURL(), '/comments', 'Comments URL is correct');
      equal(find('.ember-text-field').val(), 'hello', 'Fillin successfully works');
    });

    visit('/posts');

    andThen(function () {
      equal(currentRoute, 'posts');
      equal(currentURL(), '/posts');
    });
  });

  QUnit.test('Nested async helpers', function () {
    expect(5);

    currentRoute = 'index';

    visit('/posts');

    andThen(function () {
      click('a:first', '#comments-link');

      fillIn('.ember-text-field', 'hello');
    });

    andThen(function () {
      equal(currentRoute, 'comments', 'Successfully visited comments route');
      equal(currentURL(), '/comments', 'Comments URL is correct');
      equal(find('.ember-text-field').val(), 'hello', 'Fillin successfully works');
    });

    visit('/posts');

    andThen(function () {
      equal(currentRoute, 'posts');
      equal(currentURL(), '/posts');
    });
  });

  QUnit.test('Multiple nested async helpers', function () {
    expect(3);

    visit('/posts');

    andThen(function () {
      click('a:first', '#comments-link');

      fillIn('.ember-text-field', 'hello');
      fillIn('.ember-text-field', 'goodbye');
    });

    andThen(function () {
      equal(find('.ember-text-field').val(), 'goodbye', 'Fillin successfully works');
      equal(currentRoute, 'comments', 'Successfully visited comments route');
      equal(currentURL(), '/comments', 'Comments URL is correct');
    });
  });

  QUnit.test('Helpers nested in thens', function () {
    expect(5);

    currentRoute = 'index';

    visit('/posts').then(function () {
      click('a:first', '#comments-link');
    });

    andThen(function () {
      fillIn('.ember-text-field', 'hello');
    });

    andThen(function () {
      equal(currentRoute, 'comments', 'Successfully visited comments route');
      equal(currentURL(), '/comments', 'Comments URL is correct');
      equal(find('.ember-text-field').val(), 'hello', 'Fillin successfully works');
    });

    visit('/posts');

    andThen(function () {
      equal(currentRoute, 'posts');
      equal(currentURL(), '/posts', 'Posts URL is correct');
    });
  });

  QUnit.test('Aborted transitions are not logged via Ember.Test.adapter#exception', function () {
    expect(0);

    _emberTestingTest.default.adapter = _emberTestingAdaptersQunit.default.create({
      exception: function (error) {
        ok(false, 'aborted transitions are not logged');
      }
    });

    visit('/abort_transition');
  });

  QUnit.test('Unhandled exceptions are logged via Ember.Test.adapter#exception', function () {
    expect(2);

    var asyncHandled;
    _emberTestingTest.default.adapter = _emberTestingAdaptersQunit.default.create({
      exception: function (error) {
        equal(error.message, 'Element .does-not-exist not found.', 'Exception successfully caught and passed to Ember.Test.adapter.exception');
        asyncHandled['catch'](function () {}); // handle the rejection so it doesn't leak later.
      }
    });

    visit('/posts');

    click('.invalid-element').then(null, function (error) {
      equal(error.message, 'Element .invalid-element not found.', 'Exception successfully handled in the rejection handler');
    });

    asyncHandled = click('.does-not-exist');
  });

  QUnit.test('Unhandled exceptions in `andThen` are logged via Ember.Test.adapter#exception', function () {
    expect(1);

    _emberTestingTest.default.adapter = _emberTestingAdaptersQunit.default.create({
      exception: function (error) {
        equal(error.message, 'Catch me', 'Exception successfully caught and passed to Ember.Test.adapter.exception');
      }
    });

    visit('/posts');

    andThen(function () {
      throw new Error('Catch me');
    });
  });

  QUnit.test('should not start routing on the root URL when visiting another', function () {
    expect(4);

    visit('/posts');

    andThen(function () {
      ok(find('#comments-link'), 'found comments-link');
      equal(currentRoute, 'posts', 'Successfully visited posts route');
      equal(currentURL(), '/posts', 'Posts URL is correct');
      equal(indexHitCount, 0, 'should not hit index route when visiting another route');
    });
  });

  QUnit.test('only enters the index route once when visiting /', function () {
    expect(1);

    visit('/');

    andThen(function () {
      equal(indexHitCount, 1, 'should hit index once when visiting /');
    });
  });

  QUnit.test('test must not finish while asyncHelpers are pending', function () {
    expect(2);

    var async = 0;
    var innerRan = false;

    _emberTestingTest.default.adapter = _emberTestingAdaptersQunit.default.extend({
      asyncStart: function () {
        async++;
        this._super();
      },
      asyncEnd: function () {
        async--;
        this._super();
      }
    }).create();

    App.testHelpers.slowHelper();
    andThen(function () {
      innerRan = true;
    });

    equal(innerRan, false, 'should not have run yet');
    ok(async > 0, 'should have told the adapter to pause');

    if (async === 0) {
      // If we failed the test, prevent zalgo from escaping and breaking
      // our other tests.
      _emberTestingTest.default.adapter.asyncStart();
      _emberTestingTest.default.resolve().then(function () {
        _emberTestingTest.default.adapter.asyncEnd();
      });
    }
  });

  QUnit.test('visiting a URL and then visiting a second URL with a transition should yield the correct URL', function () {
    expect(2);

    visit('/posts');

    andThen(function () {
      equal(currentURL(), '/posts', 'First visited URL is correct');
    });

    visit('/redirect');

    andThen(function () {
      equal(currentURL(), '/comments', 'Redirected to Comments URL');
    });
  });

  QUnit.module('ember-testing Acceptance – teardown');

  QUnit.test('that the setup/teardown happens correct', function () {
    expect(2);

    _emberViewsSystemJquery.default('<style>#ember-testing-container { position: absolute; background: white; bottom: 0; right: 0; width: 640px; height: 384px; overflow: auto; z-index: 9999; border: 1px solid #ccc; } #ember-testing { zoom: 50%; }</style>').appendTo('head');
    _emberViewsSystemJquery.default('<div id="ember-testing-container"><div id="ember-testing"></div></div>').appendTo('body');

    _emberMetalRun_loop.default(function () {
      indexHitCount = 0;
      App = _emberApplicationSystemApplication.default.create({
        rootElement: '#ember-testing'
      });
    });
    App.injectTestHelpers();

    _emberViewsSystemJquery.default('#ember-testing-container, #ember-testing').remove();
    ok(typeof _emberTestingTest.default.Promise.prototype.click === 'function');
    _emberMetalRun_loop.default(App, App.destroy);
    equal(_emberTestingTest.default.Promise.prototype.click, undefined);
    App = null;
    _emberTestingTest.default.adapter = originalAdapter;
    indexHitCount = 0;
  });
});
// ensure the initializer is setup

//ES6TODO: we need {{link-to}}  and {{outlet}} to exist here
enifed('ember-testing/tests/acceptance_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-testing/tests');
  test('ember-testing/tests/acceptance_test.js should pass jscs', function () {
    ok(true, 'ember-testing/tests/acceptance_test.js should pass jscs.');
  });
});
enifed('ember-testing/tests/acceptance_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-testing/tests');
  QUnit.test('ember-testing/tests/acceptance_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-testing/tests/acceptance_test.js should pass jshint.');
  });
});
enifed('ember-testing/tests/adapters/adapter_test', ['exports', 'ember-metal/run_loop', 'ember-testing/adapters/adapter'], function (exports, _emberMetalRun_loop, _emberTestingAdaptersAdapter) {
  'use strict';

  var adapter;

  QUnit.module('ember-testing Adapter', {
    setup: function () {
      adapter = new _emberTestingAdaptersAdapter.default();
    },
    teardown: function () {
      _emberMetalRun_loop.default(adapter, adapter.destroy);
    }
  });

  // Can't test these this way anymore since we have nothing to compare to
  // test("asyncStart is a noop", function() {
  //   equal(adapter.asyncStart, K);
  // });

  // test("asyncEnd is a noop", function() {
  //   equal(adapter.asyncEnd, K);
  // });

  QUnit.test('exception throws', function () {
    var error = 'Hai';
    var thrown;

    try {
      adapter.exception(error);
    } catch (e) {
      thrown = e;
    }
    equal(thrown, error);
  });
});
enifed('ember-testing/tests/adapters/adapter_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-testing/tests/adapters');
  test('ember-testing/tests/adapters/adapter_test.js should pass jscs', function () {
    ok(true, 'ember-testing/tests/adapters/adapter_test.js should pass jscs.');
  });
});
enifed('ember-testing/tests/adapters/adapter_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-testing/tests/adapters');
  QUnit.test('ember-testing/tests/adapters/adapter_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-testing/tests/adapters/adapter_test.js should pass jshint.');
  });
});
enifed('ember-testing/tests/adapters/qunit_test', ['exports', 'ember-metal/run_loop', 'ember-testing/adapters/qunit'], function (exports, _emberMetalRun_loop, _emberTestingAdaptersQunit) {
  'use strict';

  var adapter;

  QUnit.module('ember-testing QUnitAdapter', {
    setup: function () {
      adapter = new _emberTestingAdaptersQunit.default();
    },
    teardown: function () {
      _emberMetalRun_loop.default(adapter, adapter.destroy);
    }
  });

  QUnit.test('asyncStart calls stop', function () {
    var originalStop = QUnit.stop;
    try {
      QUnit.stop = function () {
        ok(true, 'stop called');
      };
      adapter.asyncStart();
    } finally {
      QUnit.stop = originalStop;
    }
  });

  QUnit.test('asyncEnd calls start', function () {
    var originalStart = QUnit.start;
    try {
      QUnit.start = function () {
        ok(true, 'start called');
      };
      adapter.asyncEnd();
    } finally {
      QUnit.start = originalStart;
    }
  });

  QUnit.test('exception causes a failing assertion', function () {
    var error = { err: 'hai' };
    var originalOk = window.ok;
    try {
      window.ok = function (val, msg) {
        originalOk(!val, 'ok is called with false');
        originalOk(msg, '{err: "hai"}');
      };
      adapter.exception(error);
    } finally {
      window.ok = originalOk;
    }
  });
});
enifed('ember-testing/tests/adapters/qunit_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-testing/tests/adapters');
  test('ember-testing/tests/adapters/qunit_test.js should pass jscs', function () {
    ok(true, 'ember-testing/tests/adapters/qunit_test.js should pass jscs.');
  });
});
enifed('ember-testing/tests/adapters/qunit_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-testing/tests/adapters');
  QUnit.test('ember-testing/tests/adapters/qunit_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-testing/tests/adapters/qunit_test.js should pass jshint.');
  });
});
enifed('ember-testing/tests/adapters_test', ['exports', 'ember-metal/run_loop', 'ember-testing/test', 'ember-testing/adapters/adapter', 'ember-testing/adapters/qunit', 'ember-application/system/application'], function (exports, _emberMetalRun_loop, _emberTestingTest, _emberTestingAdaptersAdapter, _emberTestingAdaptersQunit, _emberApplicationSystemApplication) {
  'use strict';

  var App, originalAdapter;

  QUnit.module('ember-testing Adapters', {
    setup: function () {
      originalAdapter = _emberTestingTest.default.adapter;
    },
    teardown: function () {
      _emberMetalRun_loop.default(App, App.destroy);
      App.removeTestHelpers();
      App = null;

      _emberTestingTest.default.adapter = originalAdapter;
    }
  });

  QUnit.test('Setting a test adapter manually', function () {
    expect(1);
    var CustomAdapter;

    CustomAdapter = _emberTestingAdaptersAdapter.default.extend({
      asyncStart: function () {
        ok(true, 'Correct adapter was used');
      }
    });

    _emberMetalRun_loop.default(function () {
      App = _emberApplicationSystemApplication.default.create();
      _emberTestingTest.default.adapter = CustomAdapter.create();
      App.setupForTesting();
    });

    _emberTestingTest.default.adapter.asyncStart();
  });

  QUnit.test('QUnitAdapter is used by default', function () {
    expect(1);

    _emberTestingTest.default.adapter = null;

    _emberMetalRun_loop.default(function () {
      App = _emberApplicationSystemApplication.default.create();
      App.setupForTesting();
    });

    ok(_emberTestingTest.default.adapter instanceof _emberTestingAdaptersQunit.default);
  });
});
enifed('ember-testing/tests/adapters_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-testing/tests');
  test('ember-testing/tests/adapters_test.js should pass jscs', function () {
    ok(true, 'ember-testing/tests/adapters_test.js should pass jscs.');
  });
});
enifed('ember-testing/tests/adapters_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-testing/tests');
  QUnit.test('ember-testing/tests/adapters_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-testing/tests/adapters_test.js should pass jshint.');
  });
});
enifed('ember-testing/tests/helper_registration_test', ['exports', 'ember-metal/run_loop', 'ember-testing/test', 'ember-application/system/application'], function (exports, _emberMetalRun_loop, _emberTestingTest, _emberApplicationSystemApplication) {
  'use strict';

  var App, appBooted, helperContainer;

  function registerHelper() {
    _emberTestingTest.default.registerHelper('boot', function (app) {
      _emberMetalRun_loop.default(app, app.advanceReadiness);
      appBooted = true;
      return app.testHelpers.wait();
    });
  }

  function unregisterHelper() {
    _emberTestingTest.default.unregisterHelper('boot');
  }

  var originalAdapter = _emberTestingTest.default.adapter;

  function setupApp() {
    appBooted = false;
    helperContainer = {};

    _emberMetalRun_loop.default(function () {
      App = _emberApplicationSystemApplication.default.create();
      App.setupForTesting();
      App.injectTestHelpers(helperContainer);
    });
  }

  function destroyApp() {
    if (App) {
      _emberMetalRun_loop.default(App, 'destroy');
      App = null;
    }
  }

  QUnit.module('Test - registerHelper/unregisterHelper', {
    teardown: function () {
      _emberTestingTest.default.adapter = originalAdapter;
      destroyApp();
    }
  });

  QUnit.test('Helper gets registered', function () {
    expect(2);

    registerHelper();
    setupApp();

    ok(App.testHelpers.boot);
    ok(helperContainer.boot);
  });

  QUnit.test('Helper is ran when called', function () {
    expect(1);

    registerHelper();
    setupApp();

    App.testHelpers.boot().then(function () {
      ok(appBooted);
    });
  });

  QUnit.test('Helper can be unregistered', function () {
    expect(4);

    registerHelper();
    setupApp();

    ok(App.testHelpers.boot);
    ok(helperContainer.boot);

    unregisterHelper();

    setupApp();

    ok(!App.testHelpers.boot, 'once unregistered the helper is not added to App.testHelpers');
    ok(!helperContainer.boot, 'once unregistered the helper is not added to the helperContainer');
  });
});
enifed('ember-testing/tests/helper_registration_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-testing/tests');
  test('ember-testing/tests/helper_registration_test.js should pass jscs', function () {
    ok(true, 'ember-testing/tests/helper_registration_test.js should pass jscs.');
  });
});
enifed('ember-testing/tests/helper_registration_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-testing/tests');
  QUnit.test('ember-testing/tests/helper_registration_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-testing/tests/helper_registration_test.js should pass jshint.');
  });
});
enifed('ember-testing/tests/helpers_test', ['exports', 'ember-metal/core', 'ember-metal/features', 'ember-metal/run_loop', 'ember-runtime/system/object', 'ember-runtime/ext/rsvp', 'ember-views/views/view', 'ember-views/system/jquery', 'ember-testing/test', 'ember-testing/helpers', 'ember-testing/initializers', 'ember-testing/setup_for_testing', 'ember-routing/system/router', 'ember-routing/system/route', 'ember-application/system/application', 'ember-template-compiler/system/compile', 'ember-htmlbars/tests/utils', 'ember-htmlbars/keywords/view'], function (exports, _emberMetalCore, _emberMetalFeatures, _emberMetalRun_loop, _emberRuntimeSystemObject, _emberRuntimeExtRsvp, _emberViewsViewsView, _emberViewsSystemJquery, _emberTestingTest, _emberTestingHelpers, _emberTestingInitializers, _emberTestingSetup_for_testing, _emberRoutingSystemRouter, _emberRoutingSystemRoute, _emberApplicationSystemApplication, _emberTemplateCompilerSystemCompile, _emberHtmlbarsTestsUtils, _emberHtmlbarsKeywordsView) {
  'use strict';

  var App;
  var originalAdapter = _emberTestingTest.default.adapter;
  var originalViewKeyword;

  function cleanup() {
    // Teardown setupForTesting

    _emberTestingTest.default.adapter = originalAdapter;
    _emberMetalRun_loop.default(function () {
      _emberViewsSystemJquery.default(document).off('ajaxSend');
      _emberViewsSystemJquery.default(document).off('ajaxComplete');
    });
    _emberTestingTest.default.pendingAjaxRequests = null;
    _emberTestingTest.default.waiters = null;

    // Other cleanup

    if (App) {
      _emberMetalRun_loop.default(App, App.destroy);
      App.removeTestHelpers();
      App = null;
    }

    _emberMetalCore.default.TEMPLATES = {};
  }

  function assertHelpers(application, helperContainer, expected) {
    if (!helperContainer) {
      helperContainer = window;
    }
    if (expected === undefined) {
      expected = true;
    }

    function checkHelperPresent(helper, expected) {
      var presentInHelperContainer = !!helperContainer[helper];
      var presentInTestHelpers = !!application.testHelpers[helper];

      ok(presentInHelperContainer === expected, 'Expected \'' + helper + '\' to be present in the helper container (defaults to window).');
      ok(presentInTestHelpers === expected, 'Expected \'' + helper + '\' to be present in App.testHelpers.');
    }

    checkHelperPresent('visit', expected);
    checkHelperPresent('click', expected);
    checkHelperPresent('keyEvent', expected);
    checkHelperPresent('fillIn', expected);
    checkHelperPresent('wait', expected);
    checkHelperPresent('triggerEvent', expected);
  }

  function assertNoHelpers(application, helperContainer) {
    assertHelpers(application, helperContainer, false);
  }

  function currentRouteName(app) {
    return app.testHelpers.currentRouteName();
  }

  function currentPath(app) {
    return app.testHelpers.currentPath();
  }

  function currentURL(app) {
    return app.testHelpers.currentURL();
  }

  function setupApp() {
    _emberMetalRun_loop.default(function () {
      App = _emberApplicationSystemApplication.default.create();
      App.setupForTesting();

      App.injectTestHelpers();
    });
  }

  QUnit.module('ember-testing: Helper setup', {
    setup: function () {
      cleanup();
    },
    teardown: function () {
      cleanup();
    }
  });

  function registerHelper() {
    _emberTestingTest.default.registerHelper('LeakyMcLeakLeak', function (app) {});
  }

  QUnit.test('Ember.Application#injectTestHelpers/#removeTestHelpers', function () {
    App = _emberMetalRun_loop.default(_emberApplicationSystemApplication.default, _emberApplicationSystemApplication.default.create);
    assertNoHelpers(App);

    registerHelper();

    App.injectTestHelpers();
    assertHelpers(App);
    ok(_emberMetalCore.default.Test.Promise.prototype.LeakyMcLeakLeak, 'helper in question SHOULD be present');

    App.removeTestHelpers();
    assertNoHelpers(App);

    equal(_emberMetalCore.default.Test.Promise.prototype.LeakyMcLeakLeak, undefined, 'should NOT leak test promise extensions');
  });

  QUnit.test('Ember.Application#setupForTesting', function () {
    _emberMetalRun_loop.default(function () {
      App = _emberApplicationSystemApplication.default.create();
      App.setupForTesting();
    });

    equal(App.__container__.lookup('router:main').location, 'none');
  });

  QUnit.test('Ember.Application.setupForTesting sets the application to `testing`.', function () {
    _emberMetalRun_loop.default(function () {
      App = _emberApplicationSystemApplication.default.create();
      App.setupForTesting();
    });

    equal(App.testing, true, 'Application instance is set to testing.');
  });

  QUnit.test('Ember.Application.setupForTesting leaves the system in a deferred state.', function () {
    _emberMetalRun_loop.default(function () {
      App = _emberApplicationSystemApplication.default.create();
      App.setupForTesting();
    });

    equal(App._readinessDeferrals, 1, 'App is in deferred state after setupForTesting.');
  });

  QUnit.test('App.reset() after Application.setupForTesting leaves the system in a deferred state.', function () {
    _emberMetalRun_loop.default(function () {
      App = _emberApplicationSystemApplication.default.create();
      App.setupForTesting();
    });

    equal(App._readinessDeferrals, 1, 'App is in deferred state after setupForTesting.');

    App.reset();
    equal(App._readinessDeferrals, 1, 'App is in deferred state after setupForTesting.');
  });

  QUnit.test('Ember.Application#setupForTesting attaches ajax listeners', function () {
    var documentEvents;

    documentEvents = _emberViewsSystemJquery.default._data(document, 'events');

    if (!documentEvents) {
      documentEvents = {};
    }

    ok(documentEvents['ajaxSend'] === undefined, 'there are no ajaxSend listers setup prior to calling injectTestHelpers');
    ok(documentEvents['ajaxComplete'] === undefined, 'there are no ajaxComplete listers setup prior to calling injectTestHelpers');

    _emberMetalRun_loop.default(function () {
      _emberTestingSetup_for_testing.default();
    });

    documentEvents = _emberViewsSystemJquery.default._data(document, 'events');

    equal(documentEvents['ajaxSend'].length, 1, 'calling injectTestHelpers registers an ajaxSend handler');
    equal(documentEvents['ajaxComplete'].length, 1, 'calling injectTestHelpers registers an ajaxComplete handler');
  });

  QUnit.test('Ember.Application#setupForTesting attaches ajax listeners only once', function () {
    var documentEvents;

    documentEvents = _emberViewsSystemJquery.default._data(document, 'events');

    if (!documentEvents) {
      documentEvents = {};
    }

    ok(documentEvents['ajaxSend'] === undefined, 'there are no ajaxSend listeners setup prior to calling injectTestHelpers');
    ok(documentEvents['ajaxComplete'] === undefined, 'there are no ajaxComplete listeners setup prior to calling injectTestHelpers');

    _emberMetalRun_loop.default(function () {
      _emberTestingSetup_for_testing.default();
    });
    _emberMetalRun_loop.default(function () {
      _emberTestingSetup_for_testing.default();
    });

    documentEvents = _emberViewsSystemJquery.default._data(document, 'events');

    equal(documentEvents['ajaxSend'].length, 1, 'calling injectTestHelpers registers an ajaxSend handler');
    equal(documentEvents['ajaxComplete'].length, 1, 'calling injectTestHelpers registers an ajaxComplete handler');
  });

  QUnit.test('Ember.Application#injectTestHelpers calls callbacks registered with onInjectHelpers', function () {
    var injected = 0;

    _emberTestingTest.default.onInjectHelpers(function () {
      injected++;
    });

    _emberMetalRun_loop.default(function () {
      App = _emberApplicationSystemApplication.default.create();
      App.setupForTesting();
    });

    equal(injected, 0, 'onInjectHelpers are not called before injectTestHelpers');

    App.injectTestHelpers();

    equal(injected, 1, 'onInjectHelpers are called after injectTestHelpers');
  });

  QUnit.test('Ember.Application#injectTestHelpers adds helpers to provided object.', function () {
    var helpers = {};

    _emberMetalRun_loop.default(function () {
      App = _emberApplicationSystemApplication.default.create();
      App.setupForTesting();
    });

    App.injectTestHelpers(helpers);
    assertHelpers(App, helpers);

    App.removeTestHelpers();
    assertNoHelpers(App, helpers);
  });

  QUnit.test('Ember.Application#removeTestHelpers resets the helperContainer\'s original values', function () {
    var helpers = { visit: 'snazzleflabber' };

    _emberMetalRun_loop.default(function () {
      App = _emberApplicationSystemApplication.default.create();
      App.setupForTesting();
    });

    App.injectTestHelpers(helpers);

    ok(helpers.visit !== 'snazzleflabber', 'helper added to container');
    App.removeTestHelpers();

    ok(helpers.visit === 'snazzleflabber', 'original value added back to container');
  });

  QUnit.module('ember-testing: Helper methods', {
    setup: function () {
      originalViewKeyword = _emberHtmlbarsTestsUtils.registerKeyword('view', _emberHtmlbarsKeywordsView.default);
      setupApp();
    },
    teardown: function () {
      cleanup();
      _emberHtmlbarsTestsUtils.resetKeyword('view', originalViewKeyword);
    }
  });

  QUnit.test('`wait` respects registerWaiters', function () {
    expect(3);

    var counter = 0;
    function waiter() {
      return ++counter > 2;
    }

    var other = 0;
    function otherWaiter() {
      return ++other > 2;
    }

    _emberMetalRun_loop.default(App, App.advanceReadiness);
    _emberTestingTest.default.registerWaiter(waiter);
    _emberTestingTest.default.registerWaiter(otherWaiter);

    App.testHelpers.wait().then(function () {
      equal(waiter(), true, 'should not resolve until our waiter is ready');
      _emberTestingTest.default.unregisterWaiter(waiter);
      equal(_emberTestingTest.default.waiters.length, 1, 'should not leave the waiter registered');
      other = 0;
      return App.testHelpers.wait();
    }).then(function () {
      equal(otherWaiter(), true, 'other waiter is still registered');
    });
  });

  QUnit.test('`visit` advances readiness.', function () {
    expect(2);

    equal(App._readinessDeferrals, 1, 'App is in deferred state after setupForTesting.');

    App.testHelpers.visit('/').then(function () {
      equal(App._readinessDeferrals, 0, 'App\'s readiness was advanced by visit.');
    });
  });

  QUnit.test('`wait` helper can be passed a resolution value', function () {
    expect(4);

    var promise, wait;

    promise = new _emberRuntimeExtRsvp.default.Promise(function (resolve) {
      _emberMetalRun_loop.default(null, resolve, 'promise');
    });

    _emberMetalRun_loop.default(App, App.advanceReadiness);

    wait = App.testHelpers.wait;

    wait('text').then(function (val) {
      equal(val, 'text', 'can resolve to a string');
      return wait(1);
    }).then(function (val) {
      equal(val, 1, 'can resolve to an integer');
      return wait({ age: 10 });
    }).then(function (val) {
      deepEqual(val, { age: 10 }, 'can resolve to an object');
      return wait(promise);
    }).then(function (val) {
      equal(val, 'promise', 'can resolve to a promise resolution value');
    });
  });

  QUnit.test('`click` triggers appropriate events in order', function () {
    expect(5);

    var click, wait, events;

    App.IndexView = _emberViewsViewsView.default.extend({
      classNames: 'index-view',

      didInsertElement: function () {
        this.$().on('mousedown focusin mouseup click', function (e) {
          events.push(e.type);
        });
      },

      Checkbox: _emberMetalCore.default.Checkbox.extend({
        click: function () {
          events.push('click:' + this.get('checked'));
        },

        change: function () {
          events.push('change:' + this.get('checked'));
        }
      })
    });

    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompilerSystemCompile.default('{{input type="text"}} {{view view.Checkbox}} {{textarea}} <div contenteditable="true"> </div>');

    _emberMetalRun_loop.default(App, App.advanceReadiness);

    click = App.testHelpers.click;
    wait = App.testHelpers.wait;

    wait().then(function () {
      events = [];
      return click('.index-view');
    }).then(function () {
      deepEqual(events, ['mousedown', 'mouseup', 'click'], 'fires events in order');
    }).then(function () {
      events = [];
      return click('.index-view input[type=text]');
    }).then(function () {
      deepEqual(events, ['mousedown', 'focusin', 'mouseup', 'click'], 'fires focus events on inputs');
    }).then(function () {
      events = [];
      return click('.index-view textarea');
    }).then(function () {
      deepEqual(events, ['mousedown', 'focusin', 'mouseup', 'click'], 'fires focus events on textareas');
    }).then(function () {
      events = [];
      return click('.index-view div');
    }).then(function () {
      deepEqual(events, ['mousedown', 'focusin', 'mouseup', 'click'], 'fires focus events on contenteditable');
    }).then(function () {
      // In IE (< 8), the change event only fires when the value changes before element focused.
      _emberViewsSystemJquery.default('.index-view input[type=checkbox]').focus();
      events = [];
      return click('.index-view input[type=checkbox]');
    }).then(function () {
      // i.e. mousedown, mouseup, change:true, click, click:true
      // Firefox differs so we can't assert the exact ordering here.
      // See https://bugzilla.mozilla.org/show_bug.cgi?id=843554.
      equal(events.length, 5, 'fires click and change on checkboxes');
    });
  });

  QUnit.test('`wait` waits for outstanding timers', function () {
    expect(1);

    var wait_done = false;

    _emberMetalRun_loop.default(App, App.advanceReadiness);

    _emberMetalRun_loop.default.later(this, function () {
      wait_done = true;
    }, 500);

    App.testHelpers.wait().then(function () {
      equal(wait_done, true, 'should wait for the timer to be fired.');
    });
  });

  QUnit.test('`wait` respects registerWaiters with optional context', function () {
    expect(3);

    var obj = {
      counter: 0,
      ready: function () {
        return ++this.counter > 2;
      }
    };

    var other = 0;
    function otherWaiter() {
      return ++other > 2;
    }

    _emberMetalRun_loop.default(App, App.advanceReadiness);
    _emberTestingTest.default.registerWaiter(obj, obj.ready);
    _emberTestingTest.default.registerWaiter(otherWaiter);

    App.testHelpers.wait().then(function () {
      equal(obj.ready(), true, 'should not resolve until our waiter is ready');
      _emberTestingTest.default.unregisterWaiter(obj, obj.ready);
      equal(_emberTestingTest.default.waiters.length, 1, 'should not leave the waiter registered');
      return App.testHelpers.wait();
    }).then(function () {
      equal(otherWaiter(), true, 'other waiter should still be registered');
    });
  });

  QUnit.test('`wait` does not error if routing has not begun', function () {
    expect(1);

    App.testHelpers.wait().then(function () {
      ok(true, 'should not error without `visit`');
    });
  });

  QUnit.test('`triggerEvent accepts an optional options hash without context', function () {
    expect(3);

    var triggerEvent, wait, event;

    App.IndexView = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('{{input type="text" id="scope" class="input"}}'),

      didInsertElement: function () {
        this.$('.input').on('blur change', function (e) {
          event = e;
        });
      }
    });

    _emberMetalRun_loop.default(App, App.advanceReadiness);

    triggerEvent = App.testHelpers.triggerEvent;
    wait = App.testHelpers.wait;

    wait().then(function () {
      return triggerEvent('.input', 'blur', { keyCode: 13 });
    }).then(function () {
      equal(event.keyCode, 13, 'options were passed');
      equal(event.type, 'blur', 'correct event was triggered');
      equal(event.target.getAttribute('id'), 'scope', 'triggered on the correct element');
    });
  });

  QUnit.test('`triggerEvent can limit searching for a selector to a scope', function () {
    expect(2);

    var triggerEvent, wait, event;

    App.IndexView = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('{{input type="text" id="outside-scope" class="input"}}<div id="limited">{{input type="text" id="inside-scope" class="input"}}</div>'),

      didInsertElement: function () {
        this.$('.input').on('blur change', function (e) {
          event = e;
        });
      }
    });

    _emberMetalRun_loop.default(App, App.advanceReadiness);

    triggerEvent = App.testHelpers.triggerEvent;
    wait = App.testHelpers.wait;

    wait().then(function () {
      return triggerEvent('.input', '#limited', 'blur');
    }).then(function () {
      equal(event.type, 'blur', 'correct event was triggered');
      equal(event.target.getAttribute('id'), 'inside-scope', 'triggered on the correct element');
    });
  });

  QUnit.test('`triggerEvent` can be used to trigger arbitrary events', function () {
    expect(2);

    var triggerEvent, wait, event;

    App.IndexView = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('{{input type="text" id="foo"}}'),

      didInsertElement: function () {
        this.$('#foo').on('blur change', function (e) {
          event = e;
        });
      }
    });

    _emberMetalRun_loop.default(App, App.advanceReadiness);

    triggerEvent = App.testHelpers.triggerEvent;
    wait = App.testHelpers.wait;

    wait().then(function () {
      return triggerEvent('#foo', 'blur');
    }).then(function () {
      equal(event.type, 'blur', 'correct event was triggered');
      equal(event.target.getAttribute('id'), 'foo', 'triggered on the correct element');
    });
  });

  QUnit.test('`fillIn` takes context into consideration', function () {
    expect(2);
    var fillIn, find, visit, andThen;

    App.IndexView = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('<div id="parent">{{input type="text" id="first" class="current"}}</div>{{input type="text" id="second" class="current"}}')
    });

    _emberMetalRun_loop.default(App, App.advanceReadiness);

    fillIn = App.testHelpers.fillIn;
    find = App.testHelpers.find;
    visit = App.testHelpers.visit;
    andThen = App.testHelpers.andThen;

    visit('/');
    fillIn('.current', '#parent', 'current value');
    andThen(function () {
      equal(find('#first').val(), 'current value');
      equal(find('#second').val(), '');
    });
  });

  QUnit.test('`fillIn` focuses on the element', function () {
    expect(2);
    var fillIn, find, visit, andThen;

    App.ApplicationRoute = _emberMetalCore.default.Route.extend({
      actions: {
        wasFocused: function () {
          ok(true, 'focusIn event was triggered');
        }
      }
    });

    App.IndexView = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('<div id="parent">{{input type="text" id="first" focus-in="wasFocused"}}</div>')
    });

    _emberMetalRun_loop.default(App, App.advanceReadiness);

    fillIn = App.testHelpers.fillIn;
    find = App.testHelpers.find;
    visit = App.testHelpers.visit;
    andThen = App.testHelpers.andThen;

    visit('/');
    fillIn('#first', 'current value');
    andThen(function () {
      equal(find('#first').val(), 'current value');
    });
  });

  QUnit.test('`fillIn` fires `input` and `change` events in the proper order', function () {
    expect(1);

    var fillIn, visit, andThen;
    var events = [];
    App.IndexController = _emberMetalCore.default.Controller.extend({
      actions: {
        oninputHandler: function (e) {
          events.push(e.type);
        },
        onchangeHanlders: function (e) {
          events.push(e.type);
        }
      }
    });

    App.IndexView = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('<input type="text" id="first" oninput={{action "oninputHandler"}} onchange={{action "onchangeHanlders"}}>')
    });

    _emberMetalRun_loop.default(App, App.advanceReadiness);

    fillIn = App.testHelpers.fillIn;
    visit = App.testHelpers.visit;
    andThen = App.testHelpers.andThen;

    visit('/');
    fillIn('#first', 'current value');
    andThen(function () {
      deepEqual(events, ['input', 'change'], '`input` and `change` events are fired in the proper order');
    });
  });

  QUnit.test('`triggerEvent accepts an optional options hash and context', function () {
    expect(3);

    var triggerEvent, wait, event;

    App.IndexView = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('{{input type="text" id="outside-scope" class="input"}}<div id="limited">{{input type="text" id="inside-scope" class="input"}}</div>'),

      didInsertElement: function () {
        this.$('.input').on('blur change', function (e) {
          event = e;
        });
      }
    });

    _emberMetalRun_loop.default(App, App.advanceReadiness);

    triggerEvent = App.testHelpers.triggerEvent;
    wait = App.testHelpers.wait;

    wait().then(function () {
      return triggerEvent('.input', '#limited', 'blur', { keyCode: 13 });
    }).then(function () {
      equal(event.keyCode, 13, 'options were passed');
      equal(event.type, 'blur', 'correct event was triggered');
      equal(event.target.getAttribute('id'), 'inside-scope', 'triggered on the correct element');
    });
  });

  QUnit.module('ember-testing debugging helpers', {
    setup: function () {
      setupApp();

      _emberMetalRun_loop.default(function () {
        App.Router = _emberRoutingSystemRouter.default.extend({
          location: 'none'
        });
      });

      _emberMetalRun_loop.default(App, 'advanceReadiness');
    },

    teardown: function () {
      cleanup();
    }
  });

  QUnit.test('pauseTest pauses', function () {
    expect(1);
    function fakeAdapterAsyncStart() {
      ok(true, 'Async start should be called');
    }

    _emberTestingTest.default.adapter.asyncStart = fakeAdapterAsyncStart;

    App.testHelpers.pauseTest();
  });

  QUnit.module('ember-testing routing helpers', {
    setup: function () {
      _emberMetalRun_loop.default(function () {
        App = _emberApplicationSystemApplication.default.create();
        App.setupForTesting();

        App.injectTestHelpers();

        App.Router = _emberRoutingSystemRouter.default.extend({
          location: 'none'
        });

        App.Router.map(function () {
          this.route('posts', { resetNamespace: true }, function () {
            this.route('new');
          });
        });
      });

      _emberMetalRun_loop.default(App, 'advanceReadiness');
    },

    teardown: function () {
      cleanup();
    }
  });

  QUnit.test('currentRouteName for \'/\'', function () {
    expect(3);

    App.testHelpers.visit('/').then(function () {
      equal(App.testHelpers.currentRouteName(), 'index', 'should equal \'index\'.');
      equal(App.testHelpers.currentPath(), 'index', 'should equal \'index\'.');
      equal(App.testHelpers.currentURL(), '/', 'should equal \'/\'.');
    });
  });

  QUnit.test('currentRouteName for \'/posts\'', function () {
    expect(3);

    App.testHelpers.visit('/posts').then(function () {
      equal(App.testHelpers.currentRouteName(), 'posts.index', 'should equal \'posts.index\'.');
      equal(App.testHelpers.currentPath(), 'posts.index', 'should equal \'posts.index\'.');
      equal(App.testHelpers.currentURL(), '/posts', 'should equal \'/posts\'.');
    });
  });

  QUnit.test('currentRouteName for \'/posts/new\'', function () {
    expect(3);

    App.testHelpers.visit('/posts/new').then(function () {
      equal(App.testHelpers.currentRouteName(), 'posts.new', 'should equal \'posts.new\'.');
      equal(App.testHelpers.currentPath(), 'posts.new', 'should equal \'posts.new\'.');
      equal(App.testHelpers.currentURL(), '/posts/new', 'should equal \'/posts/new\'.');
    });
  });

  QUnit.module('ember-testing pendingAjaxRequests', {
    setup: function () {
      setupApp();
    },

    teardown: function () {
      cleanup();
    }
  });

  QUnit.test('pendingAjaxRequests is maintained for ajaxSend and ajaxComplete events', function () {
    equal(_emberTestingTest.default.pendingAjaxRequests, 0);
    var xhr = { some: 'xhr' };
    _emberViewsSystemJquery.default(document).trigger('ajaxSend', xhr);
    equal(_emberTestingTest.default.pendingAjaxRequests, 1, 'Ember.Test.pendingAjaxRequests was incremented');
    _emberViewsSystemJquery.default(document).trigger('ajaxComplete', xhr);
    equal(_emberTestingTest.default.pendingAjaxRequests, 0, 'Ember.Test.pendingAjaxRequests was decremented');
  });

  QUnit.test('pendingAjaxRequests is ignores ajaxComplete events from past setupForTesting calls', function () {
    equal(_emberTestingTest.default.pendingAjaxRequests, 0);
    var xhr = { some: 'xhr' };
    _emberViewsSystemJquery.default(document).trigger('ajaxSend', xhr);
    equal(_emberTestingTest.default.pendingAjaxRequests, 1, 'Ember.Test.pendingAjaxRequests was incremented');

    _emberMetalRun_loop.default(function () {
      _emberTestingSetup_for_testing.default();
    });
    equal(_emberTestingTest.default.pendingAjaxRequests, 0, 'Ember.Test.pendingAjaxRequests was reset');

    var altXhr = { some: 'more xhr' };
    _emberViewsSystemJquery.default(document).trigger('ajaxSend', altXhr);
    equal(_emberTestingTest.default.pendingAjaxRequests, 1, 'Ember.Test.pendingAjaxRequests was incremented');
    _emberViewsSystemJquery.default(document).trigger('ajaxComplete', xhr);
    equal(_emberTestingTest.default.pendingAjaxRequests, 1, 'Ember.Test.pendingAjaxRequests is not impressed with your unexpected complete');
  });

  QUnit.test('pendingAjaxRequests is reset by setupForTesting', function () {
    _emberTestingTest.default.pendingAjaxRequests = 1;
    _emberMetalRun_loop.default(function () {
      _emberTestingSetup_for_testing.default();
    });
    equal(_emberTestingTest.default.pendingAjaxRequests, 0, 'pendingAjaxRequests is reset');
  });

  QUnit.module('ember-testing async router', {
    setup: function () {
      cleanup();

      _emberMetalRun_loop.default(function () {
        App = _emberApplicationSystemApplication.default.create();
        App.Router = _emberRoutingSystemRouter.default.extend({
          location: 'none'
        });

        App.Router.map(function () {
          this.route('user', { resetNamespace: true }, function () {
            this.route('profile');
            this.route('edit');
          });
        });

        App.UserRoute = _emberRoutingSystemRoute.default.extend({
          model: function () {
            return resolveLater();
          }
        });

        App.UserProfileRoute = _emberRoutingSystemRoute.default.extend({
          beforeModel: function () {
            var self = this;
            return resolveLater().then(function () {
              self.transitionTo('user.edit');
            });
          }
        });

        // Emulates a long-running unscheduled async operation.
        function resolveLater() {
          var promise;

          _emberMetalRun_loop.default(function () {
            promise = new _emberRuntimeExtRsvp.default.Promise(function (resolve) {
              // The wait() helper has a 10ms tick. We should resolve() after at least one tick
              // to test whether wait() held off while the async router was still loading. 20ms
              // should be enough.
              setTimeout(function () {
                _emberMetalRun_loop.default(function () {
                  resolve(_emberRuntimeSystemObject.default.create({ firstName: 'Tom' }));
                });
              }, 20);
            });
          });

          return promise;
        }

        App.setupForTesting();
      });

      App.injectTestHelpers();
      _emberMetalRun_loop.default(App, 'advanceReadiness');
    },

    teardown: function () {
      cleanup();
    }
  });

  QUnit.test('currentRouteName for \'/user\'', function () {
    expect(4);

    App.testHelpers.visit('/user').then(function () {
      equal(currentRouteName(App), 'user.index', 'should equal \'user.index\'.');
      equal(currentPath(App), 'user.index', 'should equal \'user.index\'.');
      equal(currentURL(App), '/user', 'should equal \'/user\'.');
      equal(App.__container__.lookup('route:user').get('controller.model.firstName'), 'Tom', 'should equal \'Tom\'.');
    });
  });

  QUnit.test('currentRouteName for \'/user/profile\'', function () {
    expect(4);

    App.testHelpers.visit('/user/profile').then(function () {
      equal(currentRouteName(App), 'user.edit', 'should equal \'user.edit\'.');
      equal(currentPath(App), 'user.edit', 'should equal \'user.edit\'.');
      equal(currentURL(App), '/user/edit', 'should equal \'/user/edit\'.');
      equal(App.__container__.lookup('route:user').get('controller.model.firstName'), 'Tom', 'should equal \'Tom\'.');
    });
  });

  var originalVisitHelper, originalFindHelper, originalWaitHelper;

  QUnit.module('can override built-in helpers', {
    setup: function () {
      originalVisitHelper = _emberTestingTest.default._helpers.visit;
      originalFindHelper = _emberTestingTest.default._helpers.find;
      originalWaitHelper = _emberTestingTest.default._helpers.wait;

      _emberViewsSystemJquery.default('<style>#ember-testing-container { position: absolute; background: white; bottom: 0; right: 0; width: 640px; height: 384px; overflow: auto; z-index: 9999; border: 1px solid #ccc; } #ember-testing { zoom: 50%; }</style>').appendTo('head');
      _emberViewsSystemJquery.default('<div id="ember-testing-container"><div id="ember-testing"></div></div>').appendTo('body');
      _emberMetalRun_loop.default(function () {
        App = _emberMetalCore.default.Application.create({
          rootElement: '#ember-testing'
        });

        App.setupForTesting();
      });
    },

    teardown: function () {
      App.removeTestHelpers();
      _emberViewsSystemJquery.default('#ember-testing-container, #ember-testing').remove();
      _emberMetalRun_loop.default(App, App.destroy);
      App = null;

      _emberTestingTest.default._helpers.visit = originalVisitHelper;
      _emberTestingTest.default._helpers.find = originalFindHelper;
      _emberTestingTest.default._helpers.wait = originalWaitHelper;
    }
  });

  QUnit.test('can override visit helper', function () {
    expect(1);

    _emberTestingTest.default.registerHelper('visit', function () {
      ok(true, 'custom visit helper was called');
    });

    App.injectTestHelpers();
    App.testHelpers.visit();
  });

  QUnit.test('can override find helper', function () {
    expect(1);

    _emberTestingTest.default.registerHelper('find', function () {
      ok(true, 'custom find helper was called');

      return ['not empty array'];
    });

    App.injectTestHelpers();
    App.testHelpers.findWithAssert('.who-cares');
  });
});
// ensure that the helpers are loaded
// ensure the initializer is setup
enifed('ember-testing/tests/helpers_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-testing/tests');
  test('ember-testing/tests/helpers_test.js should pass jscs', function () {
    ok(true, 'ember-testing/tests/helpers_test.js should pass jscs.');
  });
});
enifed('ember-testing/tests/helpers_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-testing/tests');
  QUnit.test('ember-testing/tests/helpers_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-testing/tests/helpers_test.js should pass jshint.');
  });
});
enifed('ember-testing/tests/integration_test', ['exports', 'ember-metal/core', 'ember-metal/run_loop', 'ember-runtime/system/object', 'ember-views/system/jquery', 'ember-views/views/view', 'ember-testing/test', 'ember-routing/system/route', 'ember-application/system/application', 'ember-template-compiler/system/compile', 'ember-runtime/controllers/controller', 'ember-application'], function (exports, _emberMetalCore, _emberMetalRun_loop, _emberRuntimeSystemObject, _emberViewsSystemJquery, _emberViewsViewsView, _emberTestingTest, _emberRoutingSystemRoute, _emberApplicationSystemApplication, _emberTemplateCompilerSystemCompile, _emberRuntimeControllersController, _emberApplication) {
  'use strict';

  var App, find, visit;
  var originalAdapter = _emberTestingTest.default.adapter;

  QUnit.module('ember-testing Integration', {
    setup: function () {
      _emberViewsSystemJquery.default('<div id="ember-testing-container"><div id="ember-testing"></div></div>').appendTo('body');
      _emberMetalRun_loop.default(function () {
        App = _emberApplicationSystemApplication.default.create({
          rootElement: '#ember-testing'
        });

        App.Router.map(function () {
          this.route('people', { path: '/' });
        });

        App.PeopleRoute = _emberRoutingSystemRoute.default.extend({
          model: function () {
            return App.Person.find();
          }
        });

        App.PeopleView = _emberViewsViewsView.default.extend({
          defaultTemplate: _emberTemplateCompilerSystemCompile.default('{{#each model as |person|}}<div class="name">{{person.firstName}}</div>{{/each}}')
        });

        App.PeopleController = _emberRuntimeControllersController.default.extend({});

        App.Person = _emberRuntimeSystemObject.default.extend({
          firstName: ''
        });

        App.Person.reopenClass({
          find: function () {
            return _emberMetalCore.default.A();
          }
        });

        App.ApplicationView = _emberViewsViewsView.default.extend({
          defaultTemplate: _emberTemplateCompilerSystemCompile.default('{{outlet}}')
        });

        App.setupForTesting();
      });

      _emberMetalRun_loop.default(function () {
        App.reset();
      });

      App.injectTestHelpers();

      find = window.find;
      visit = window.visit;
    },

    teardown: function () {
      App.removeTestHelpers();
      _emberViewsSystemJquery.default('#ember-testing-container, #ember-testing').remove();
      _emberMetalRun_loop.default(App, App.destroy);
      App = null;
      _emberTestingTest.default.adapter = originalAdapter;
    }
  });

  QUnit.test('template is bound to empty array of people', function () {
    App.Person.find = function () {
      return _emberMetalCore.default.A();
    };
    _emberMetalRun_loop.default(App, 'advanceReadiness');
    visit('/').then(function () {
      var rows = find('.name').length;
      equal(rows, 0, 'successfully stubbed an empty array of people');
    });
  });

  QUnit.test('template is bound to array of 2 people', function () {
    App.Person.find = function () {
      var people = _emberMetalCore.default.A();
      var first = App.Person.create({ firstName: 'x' });
      var last = App.Person.create({ firstName: 'y' });
      _emberMetalRun_loop.default(people, people.pushObject, first);
      _emberMetalRun_loop.default(people, people.pushObject, last);
      return people;
    };
    _emberMetalRun_loop.default(App, 'advanceReadiness');
    visit('/').then(function () {
      var rows = find('.name').length;
      equal(rows, 2, 'successfully stubbed a non empty array of people');
    });
  });

  QUnit.test('template is again bound to empty array of people', function () {
    App.Person.find = function () {
      return _emberMetalCore.default.A();
    };
    _emberMetalRun_loop.default(App, 'advanceReadiness');
    visit('/').then(function () {
      var rows = find('.name').length;
      equal(rows, 0, 'successfully stubbed another empty array of people');
    });
  });

  QUnit.test('`visit` can be called without advancedReadiness.', function () {
    App.Person.find = function () {
      return _emberMetalCore.default.A();
    };

    visit('/').then(function () {
      var rows = find('.name').length;
      equal(rows, 0, 'stubbed an empty array of people without calling advancedReadiness.');
    });
  });
});
enifed('ember-testing/tests/integration_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-testing/tests');
  test('ember-testing/tests/integration_test.js should pass jscs', function () {
    ok(true, 'ember-testing/tests/integration_test.js should pass jscs.');
  });
});
enifed('ember-testing/tests/integration_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-testing/tests');
  QUnit.test('ember-testing/tests/integration_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-testing/tests/integration_test.js should pass jshint.');
  });
});
enifed('ember-testing/tests/simple_setup', ['exports', 'ember-metal/run_loop', 'ember-views/system/jquery'], function (exports, _emberMetalRun_loop, _emberViewsSystemJquery) {
  'use strict';

  var App;

  QUnit.module('Simple Testing Setup', {
    teardown: function () {
      if (App) {
        App.removeTestHelpers();
        _emberViewsSystemJquery.default('#ember-testing-container, #ember-testing').remove();
        _emberMetalRun_loop.default(App, 'destroy');
        App = null;
      }
    }
  });
});
enifed('ember-testing/tests/simple_setup.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-testing/tests');
  test('ember-testing/tests/simple_setup.js should pass jscs', function () {
    ok(true, 'ember-testing/tests/simple_setup.js should pass jscs.');
  });
});
enifed('ember-testing/tests/simple_setup.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-testing/tests');
  QUnit.test('ember-testing/tests/simple_setup.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-testing/tests/simple_setup.js should pass jshint.');
  });
});
enifed('ember-views.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - .');
  test('ember-views.js should pass jscs', function () {
    ok(true, 'ember-views.js should pass jscs.');
  });
});
enifed('ember-views.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - .');
  QUnit.test('ember-views.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views.js should pass jshint.');
  });
});
enifed('ember-views/compat/attrs-proxy.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/compat');
  test('ember-views/compat/attrs-proxy.js should pass jscs', function () {
    ok(true, 'ember-views/compat/attrs-proxy.js should pass jscs.');
  });
});
enifed('ember-views/compat/attrs-proxy.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/compat');
  QUnit.test('ember-views/compat/attrs-proxy.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/compat/attrs-proxy.js should pass jshint.');
  });
});
enifed('ember-views/compat/metamorph_view.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/compat');
  test('ember-views/compat/metamorph_view.js should pass jscs', function () {
    ok(true, 'ember-views/compat/metamorph_view.js should pass jscs.');
  });
});
enifed('ember-views/compat/metamorph_view.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/compat');
  QUnit.test('ember-views/compat/metamorph_view.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/compat/metamorph_view.js should pass jshint.');
  });
});
enifed('ember-views/component_lookup.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views');
  test('ember-views/component_lookup.js should pass jscs', function () {
    ok(true, 'ember-views/component_lookup.js should pass jscs.');
  });
});
enifed('ember-views/component_lookup.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views');
  QUnit.test('ember-views/component_lookup.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/component_lookup.js should pass jshint.');
  });
});
enifed('ember-views/mixins/aria_role_support.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/mixins');
  test('ember-views/mixins/aria_role_support.js should pass jscs', function () {
    ok(true, 'ember-views/mixins/aria_role_support.js should pass jscs.');
  });
});
enifed('ember-views/mixins/aria_role_support.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/mixins');
  QUnit.test('ember-views/mixins/aria_role_support.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/mixins/aria_role_support.js should pass jshint.');
  });
});
enifed('ember-views/mixins/class_names_support.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/mixins');
  test('ember-views/mixins/class_names_support.js should pass jscs', function () {
    ok(true, 'ember-views/mixins/class_names_support.js should pass jscs.');
  });
});
enifed('ember-views/mixins/class_names_support.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/mixins');
  QUnit.test('ember-views/mixins/class_names_support.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/mixins/class_names_support.js should pass jshint.');
  });
});
enifed('ember-views/mixins/empty_view_support.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/mixins');
  test('ember-views/mixins/empty_view_support.js should pass jscs', function () {
    ok(true, 'ember-views/mixins/empty_view_support.js should pass jscs.');
  });
});
enifed('ember-views/mixins/empty_view_support.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/mixins');
  QUnit.test('ember-views/mixins/empty_view_support.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/mixins/empty_view_support.js should pass jshint.');
  });
});
enifed('ember-views/mixins/instrumentation_support.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/mixins');
  test('ember-views/mixins/instrumentation_support.js should pass jscs', function () {
    ok(true, 'ember-views/mixins/instrumentation_support.js should pass jscs.');
  });
});
enifed('ember-views/mixins/instrumentation_support.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/mixins');
  QUnit.test('ember-views/mixins/instrumentation_support.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/mixins/instrumentation_support.js should pass jshint.');
  });
});
enifed('ember-views/mixins/legacy_view_support.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/mixins');
  test('ember-views/mixins/legacy_view_support.js should pass jscs', function () {
    ok(true, 'ember-views/mixins/legacy_view_support.js should pass jscs.');
  });
});
enifed('ember-views/mixins/legacy_view_support.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/mixins');
  QUnit.test('ember-views/mixins/legacy_view_support.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/mixins/legacy_view_support.js should pass jshint.');
  });
});
enifed('ember-views/mixins/normalized_rerender_if_needed.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/mixins');
  test('ember-views/mixins/normalized_rerender_if_needed.js should pass jscs', function () {
    ok(true, 'ember-views/mixins/normalized_rerender_if_needed.js should pass jscs.');
  });
});
enifed('ember-views/mixins/normalized_rerender_if_needed.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/mixins');
  QUnit.test('ember-views/mixins/normalized_rerender_if_needed.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/mixins/normalized_rerender_if_needed.js should pass jshint.');
  });
});
enifed('ember-views/mixins/template_rendering_support.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/mixins');
  test('ember-views/mixins/template_rendering_support.js should pass jscs', function () {
    ok(true, 'ember-views/mixins/template_rendering_support.js should pass jscs.');
  });
});
enifed('ember-views/mixins/template_rendering_support.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/mixins');
  QUnit.test('ember-views/mixins/template_rendering_support.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/mixins/template_rendering_support.js should pass jshint.');
  });
});
enifed('ember-views/mixins/text_support.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/mixins');
  test('ember-views/mixins/text_support.js should pass jscs', function () {
    ok(true, 'ember-views/mixins/text_support.js should pass jscs.');
  });
});
enifed('ember-views/mixins/text_support.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/mixins');
  QUnit.test('ember-views/mixins/text_support.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/mixins/text_support.js should pass jshint.');
  });
});
enifed('ember-views/mixins/view_child_views_support.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/mixins');
  test('ember-views/mixins/view_child_views_support.js should pass jscs', function () {
    ok(true, 'ember-views/mixins/view_child_views_support.js should pass jscs.');
  });
});
enifed('ember-views/mixins/view_child_views_support.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/mixins');
  QUnit.test('ember-views/mixins/view_child_views_support.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/mixins/view_child_views_support.js should pass jshint.');
  });
});
enifed('ember-views/mixins/view_context_support.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/mixins');
  test('ember-views/mixins/view_context_support.js should pass jscs', function () {
    ok(true, 'ember-views/mixins/view_context_support.js should pass jscs.');
  });
});
enifed('ember-views/mixins/view_context_support.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/mixins');
  QUnit.test('ember-views/mixins/view_context_support.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/mixins/view_context_support.js should pass jshint.');
  });
});
enifed('ember-views/mixins/view_state_support.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/mixins');
  test('ember-views/mixins/view_state_support.js should pass jscs', function () {
    ok(true, 'ember-views/mixins/view_state_support.js should pass jscs.');
  });
});
enifed('ember-views/mixins/view_state_support.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/mixins');
  QUnit.test('ember-views/mixins/view_state_support.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/mixins/view_state_support.js should pass jshint.');
  });
});
enifed('ember-views/mixins/view_target_action_support.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/mixins');
  test('ember-views/mixins/view_target_action_support.js should pass jscs', function () {
    ok(true, 'ember-views/mixins/view_target_action_support.js should pass jscs.');
  });
});
enifed('ember-views/mixins/view_target_action_support.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/mixins');
  QUnit.test('ember-views/mixins/view_target_action_support.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/mixins/view_target_action_support.js should pass jshint.');
  });
});
enifed('ember-views/mixins/visibility_support.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/mixins');
  test('ember-views/mixins/visibility_support.js should pass jscs', function () {
    ok(true, 'ember-views/mixins/visibility_support.js should pass jscs.');
  });
});
enifed('ember-views/mixins/visibility_support.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/mixins');
  QUnit.test('ember-views/mixins/visibility_support.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/mixins/visibility_support.js should pass jshint.');
  });
});
enifed('ember-views/streams/class_name_binding.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/streams');
  test('ember-views/streams/class_name_binding.js should pass jscs', function () {
    ok(true, 'ember-views/streams/class_name_binding.js should pass jscs.');
  });
});
enifed('ember-views/streams/class_name_binding.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/streams');
  QUnit.test('ember-views/streams/class_name_binding.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/streams/class_name_binding.js should pass jshint.');
  });
});
enifed('ember-views/streams/should_display.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/streams');
  test('ember-views/streams/should_display.js should pass jscs', function () {
    ok(true, 'ember-views/streams/should_display.js should pass jscs.');
  });
});
enifed('ember-views/streams/should_display.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/streams');
  QUnit.test('ember-views/streams/should_display.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/streams/should_display.js should pass jshint.');
  });
});
enifed('ember-views/streams/utils.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/streams');
  test('ember-views/streams/utils.js should pass jscs', function () {
    ok(true, 'ember-views/streams/utils.js should pass jscs.');
  });
});
enifed('ember-views/streams/utils.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/streams');
  QUnit.test('ember-views/streams/utils.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/streams/utils.js should pass jshint.');
  });
});
enifed('ember-views/system/action_manager.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/system');
  test('ember-views/system/action_manager.js should pass jscs', function () {
    ok(true, 'ember-views/system/action_manager.js should pass jscs.');
  });
});
enifed('ember-views/system/action_manager.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/system');
  QUnit.test('ember-views/system/action_manager.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/system/action_manager.js should pass jshint.');
  });
});
enifed('ember-views/system/build-component-template.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/system');
  test('ember-views/system/build-component-template.js should pass jscs', function () {
    ok(true, 'ember-views/system/build-component-template.js should pass jscs.');
  });
});
enifed('ember-views/system/build-component-template.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/system');
  QUnit.test('ember-views/system/build-component-template.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/system/build-component-template.js should pass jshint.');
  });
});
enifed('ember-views/system/event_dispatcher.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/system');
  test('ember-views/system/event_dispatcher.js should pass jscs', function () {
    ok(true, 'ember-views/system/event_dispatcher.js should pass jscs.');
  });
});
enifed('ember-views/system/event_dispatcher.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/system');
  QUnit.test('ember-views/system/event_dispatcher.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/system/event_dispatcher.js should pass jshint.');
  });
});
enifed('ember-views/system/ext.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/system');
  test('ember-views/system/ext.js should pass jscs', function () {
    ok(true, 'ember-views/system/ext.js should pass jscs.');
  });
});
enifed('ember-views/system/ext.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/system');
  QUnit.test('ember-views/system/ext.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/system/ext.js should pass jshint.');
  });
});
enifed('ember-views/system/jquery.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/system');
  test('ember-views/system/jquery.js should pass jscs', function () {
    ok(true, 'ember-views/system/jquery.js should pass jscs.');
  });
});
enifed('ember-views/system/jquery.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/system');
  QUnit.test('ember-views/system/jquery.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/system/jquery.js should pass jshint.');
  });
});
enifed('ember-views/system/lookup_partial.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/system');
  test('ember-views/system/lookup_partial.js should pass jscs', function () {
    ok(true, 'ember-views/system/lookup_partial.js should pass jscs.');
  });
});
enifed('ember-views/system/lookup_partial.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/system');
  QUnit.test('ember-views/system/lookup_partial.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/system/lookup_partial.js should pass jshint.');
  });
});
enifed('ember-views/system/platform.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/system');
  test('ember-views/system/platform.js should pass jscs', function () {
    ok(true, 'ember-views/system/platform.js should pass jscs.');
  });
});
enifed('ember-views/system/platform.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/system');
  QUnit.test('ember-views/system/platform.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/system/platform.js should pass jshint.');
  });
});
enifed('ember-views/system/utils.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/system');
  test('ember-views/system/utils.js should pass jscs', function () {
    ok(true, 'ember-views/system/utils.js should pass jscs.');
  });
});
enifed('ember-views/system/utils.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/system');
  QUnit.test('ember-views/system/utils.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/system/utils.js should pass jshint.');
  });
});
enifed('ember-views/tests/compat/attrs_proxy_test', ['exports', 'ember-views/views/view', 'ember-runtime/tests/utils', 'ember-template-compiler/system/compile', 'container/registry', 'ember-metal/run_loop', 'ember-metal/property_set', 'ember-metal/property_get', 'ember-metal/mixin', 'ember-metal/events', 'ember-htmlbars/tests/utils', 'ember-htmlbars/keywords/view'], function (exports, _emberViewsViewsView, _emberRuntimeTestsUtils, _emberTemplateCompilerSystemCompile, _containerRegistry, _emberMetalRun_loop, _emberMetalProperty_set, _emberMetalProperty_get, _emberMetalMixin, _emberMetalEvents, _emberHtmlbarsTestsUtils, _emberHtmlbarsKeywordsView) {
  'use strict';

  var view, registry, container, originalViewKeyword;

  QUnit.module('ember-views: attrs-proxy', {
    setup: function () {
      originalViewKeyword = _emberHtmlbarsTestsUtils.registerKeyword('view', _emberHtmlbarsKeywordsView.default);
      registry = new _containerRegistry.default();
      container = registry.container();
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(view);
      _emberHtmlbarsTestsUtils.resetKeyword('view', originalViewKeyword);
    }
  });

  QUnit.test('works with properties setup in root of view', function () {
    registry.register('view:foo', _emberViewsViewsView.default.extend({
      bar: 'qux',

      template: _emberTemplateCompilerSystemCompile.default('{{view.bar}}')
    }));

    view = _emberViewsViewsView.default.extend({
      container: registry.container(),
      template: _emberTemplateCompilerSystemCompile.default('{{view "foo" bar="baz"}}')
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'baz', 'value specified in the template is used');
  });

  QUnit.test('works with undefined attributes', function () {
    // TODO: attrs
    // expectDeprecation();

    var childView;
    registry.register('view:foo', _emberViewsViewsView.default.extend({
      init: function () {
        this._super.apply(this, arguments);

        childView = this;
      },

      template: _emberTemplateCompilerSystemCompile.default('{{bar}}')
    }));

    view = _emberViewsViewsView.default.extend({
      container: registry.container(),

      template: _emberTemplateCompilerSystemCompile.default('{{view "foo" bar=undefined}}')
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), '', 'precond - value is used');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(childView, 'bar', 'stuff');
    });

    equal(_emberMetalProperty_get.get(view, 'bar'), undefined, 'value is updated upstream');
  });

  QUnit.test('an observer on an attribute in the root of the component is fired when attrs are set', function () {
    expect(2);

    registry.register('view:foo', _emberViewsViewsView.default.extend({
      observerFiredCount: 0,

      barObserver: _emberMetalEvents.on('init', _emberMetalMixin.observer('bar', function () {
        var count = _emberMetalProperty_get.get(this, 'observerFiredCount');
        _emberMetalProperty_set.set(this, 'observerFiredCount', count + 1);
      })),

      template: _emberTemplateCompilerSystemCompile.default('{{view.bar}} - {{view.observerFiredCount}}')
    }));

    view = _emberViewsViewsView.default.extend({
      container: registry.container(),
      baz: 'baz',
      template: _emberTemplateCompilerSystemCompile.default('{{view "foo" bar=view.baz}}')
    }).create();

    _emberRuntimeTestsUtils.runAppend(view);

    equal(view.$().text(), 'baz - 1', 'observer is fired on initial set');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'baz', 'qux');
    });

    equal(view.$().text(), 'qux - 2', 'observer is fired on update');
  });
});
enifed('ember-views/tests/compat/attrs_proxy_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/tests/compat');
  test('ember-views/tests/compat/attrs_proxy_test.js should pass jscs', function () {
    ok(true, 'ember-views/tests/compat/attrs_proxy_test.js should pass jscs.');
  });
});
enifed('ember-views/tests/compat/attrs_proxy_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/tests/compat');
  QUnit.test('ember-views/tests/compat/attrs_proxy_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/tests/compat/attrs_proxy_test.js should pass jshint.');
  });
});
enifed('ember-views/tests/compat/metamorph_test', ['exports', 'ember-views/views/view', 'ember-views/compat/metamorph_view'], function (exports, _emberViewsViewsView, _emberViewsCompatMetamorph_view) {
  'use strict';

  QUnit.module('ember-views: _Metamorph [DEPRECATED]');

  QUnit.test('Instantiating _MetamorphView triggers deprecation', function () {
    expectDeprecation(function () {
      _emberViewsViewsView.default.extend(_emberViewsCompatMetamorph_view._Metamorph).create();
    }, /Using Ember\._Metamorph is deprecated./);
  });

  QUnit.test('Instantiating _MetamorphView triggers deprecation', function () {
    expectDeprecation(function () {
      _emberViewsCompatMetamorph_view.default.create();
    }, /Using Ember\._MetamorphView is deprecated./);
  });
});
enifed('ember-views/tests/compat/metamorph_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/tests/compat');
  test('ember-views/tests/compat/metamorph_test.js should pass jscs', function () {
    ok(true, 'ember-views/tests/compat/metamorph_test.js should pass jscs.');
  });
});
enifed('ember-views/tests/compat/metamorph_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/tests/compat');
  QUnit.test('ember-views/tests/compat/metamorph_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/tests/compat/metamorph_test.js should pass jshint.');
  });
});
enifed('ember-views/tests/compat/view_render_hook_test', ['exports', 'ember-runtime/tests/utils', 'ember-views/views/view', 'ember-htmlbars/tests/utils', 'ember-htmlbars/keywords/view'], function (exports, _emberRuntimeTestsUtils, _emberViewsViewsView, _emberHtmlbarsTestsUtils, _emberHtmlbarsKeywordsView) {
  'use strict';

  var view, parentView, originalViewKeyword;

  QUnit.module('ember-views: View#render hook', {
    setup: function () {
      originalViewKeyword = _emberHtmlbarsTestsUtils.registerKeyword('view', _emberHtmlbarsKeywordsView.default);
    },
    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(view);
      _emberRuntimeTestsUtils.runDestroy(parentView);
      _emberHtmlbarsTestsUtils.resetKeyword('view', originalViewKeyword);
    }
  });

  QUnit.test('the render hook triggers an assertion', function (assert) {
    expectAssertion(function () {
      view = _emberViewsViewsView.default.create({
        render: function (buffer) {
          buffer.push('<span>Nancy</span>');
        }
      });
    }, 'Using a custom `.render` function is no longer supported.');
  });
});
enifed('ember-views/tests/compat/view_render_hook_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/tests/compat');
  test('ember-views/tests/compat/view_render_hook_test.js should pass jscs', function () {
    ok(true, 'ember-views/tests/compat/view_render_hook_test.js should pass jscs.');
  });
});
enifed('ember-views/tests/compat/view_render_hook_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/tests/compat');
  QUnit.test('ember-views/tests/compat/view_render_hook_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/tests/compat/view_render_hook_test.js should pass jshint.');
  });
});
enifed('ember-views/tests/mixins/view_target_action_support_test', ['exports', 'ember-runtime/system/object', 'ember-views/views/view', 'ember-views/mixins/view_target_action_support'], function (exports, _emberRuntimeSystemObject, _emberViewsViewsView, _emberViewsMixinsView_target_action_support) {
  'use strict';

  QUnit.module('ViewTargetActionSupport');

  QUnit.test('it should return false if no action is specified', function () {
    expect(1);

    var view = _emberViewsViewsView.default.extend(_emberViewsMixinsView_target_action_support.default).create({
      controller: _emberRuntimeSystemObject.default.create()
    });

    ok(false === view.triggerAction(), 'a valid target and action were specified');
  });

  QUnit.test('it should support actions specified as strings', function () {
    expect(2);

    var view = _emberViewsViewsView.default.extend(_emberViewsMixinsView_target_action_support.default).create({
      controller: _emberRuntimeSystemObject.default.create({
        anEvent: function () {
          ok(true, 'anEvent method was called');
        }
      }),
      action: 'anEvent'
    });

    ok(true === view.triggerAction(), 'a valid target and action were specified');
  });

  QUnit.test('it should invoke the send() method on the controller with the view\'s context', function () {
    expect(3);

    var view = _emberViewsViewsView.default.extend(_emberViewsMixinsView_target_action_support.default, {
      controller: _emberRuntimeSystemObject.default.create({
        send: function (evt, context) {
          equal(evt, 'anEvent', 'send() method was invoked with correct event name');
          equal(context, view.get('context'), 'send() method was invoked with correct context');
        }
      })
    }).create({
      context: {},
      action: 'anEvent'
    });

    ok(true === view.triggerAction(), 'a valid target and action were specified');
  });
});
enifed('ember-views/tests/mixins/view_target_action_support_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/tests/mixins');
  test('ember-views/tests/mixins/view_target_action_support_test.js should pass jscs', function () {
    ok(true, 'ember-views/tests/mixins/view_target_action_support_test.js should pass jscs.');
  });
});
enifed('ember-views/tests/mixins/view_target_action_support_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/tests/mixins');
  QUnit.test('ember-views/tests/mixins/view_target_action_support_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/tests/mixins/view_target_action_support_test.js should pass jshint.');
  });
});
enifed('ember-views/tests/streams/streams-test', ['exports', 'ember-views/streams/should_display', 'ember-metal/properties', 'ember-metal/computed'], function (exports, _emberViewsStreamsShould_display, _emberMetalProperties, _emberMetalComputed) {
  'use strict';

  QUnit.module('shouldDisplay');

  QUnit.test('predicate permutations', function () {
    equal(_emberViewsStreamsShould_display.default(0), false, 'shouldDisplay(0)');
    equal(_emberViewsStreamsShould_display.default(-1), true, 'shouldDisplay(-1)');
    equal(_emberViewsStreamsShould_display.default(1), true, 'shouldDisplay(1)');
    equal(_emberViewsStreamsShould_display.default(Number(1)), true, 'shouldDisplay(Number(1))');
    equal(_emberViewsStreamsShould_display.default(Number(0)), false, 'shouldDisplay(Number(0))');
    equal(_emberViewsStreamsShould_display.default(Number(-1)), true, 'shouldDisplay(Number(-1))');
    equal(_emberViewsStreamsShould_display.default(Boolean(true)), true, 'shouldDisplay(Boolean(true))');
    equal(_emberViewsStreamsShould_display.default(Boolean(false)), false, 'shouldDisplay(Boolean(false))');
    equal(_emberViewsStreamsShould_display.default(NaN), false, 'shouldDisplay(NaN)');
    equal(_emberViewsStreamsShould_display.default('string'), true, 'shouldDisplay("string")');
    equal(_emberViewsStreamsShould_display.default(String('string')), true, 'shouldDisplay(String("string"))');
    equal(_emberViewsStreamsShould_display.default(Infinity), true, 'shouldDisplay(Infinity)');
    equal(_emberViewsStreamsShould_display.default(-Infinity), true, 'shouldDisplay(-Infinity)');
    equal(_emberViewsStreamsShould_display.default([]), false, 'shouldDisplay([])');
    equal(_emberViewsStreamsShould_display.default([1]), true, 'shouldDisplay([1])');
    equal(_emberViewsStreamsShould_display.default({}), true, 'shouldDisplay({})');
    equal(_emberViewsStreamsShould_display.default(true), true, 'shouldDisplay(true)');
    equal(_emberViewsStreamsShould_display.default(false), false, 'shouldDisplay(false)');
    equal(_emberViewsStreamsShould_display.default({ isTruthy: true }), true, 'shouldDisplay({ isTruthy: true })');
    equal(_emberViewsStreamsShould_display.default({ isTruthy: false }), false, 'shouldDisplay({ isTruthy: false })');

    equal(_emberViewsStreamsShould_display.default(function foo() {}), true, 'shouldDisplay(function (){})');

    function falseFunction() {}
    falseFunction.isTruthy = false;

    equal(_emberViewsStreamsShould_display.default(falseFunction), true, 'shouldDisplay(function.isTruthy = false)');

    function trueFunction() {}
    falseFunction.isTruthy = true;
    equal(_emberViewsStreamsShould_display.default(trueFunction), true, 'shouldDisplay(function.isTruthy = true)');

    var truthyObj = {};
    _emberMetalProperties.defineProperty(truthyObj, 'isTruthy', _emberMetalComputed.default(function () {
      return true;
    }));
    equal(_emberViewsStreamsShould_display.default(truthyObj), true, 'shouldDisplay(obj.get("isTruthy") === true)');

    var falseyObj = {};
    _emberMetalProperties.defineProperty(falseyObj, 'isTruthy', _emberMetalComputed.default(function () {
      return false;
    }));
    equal(_emberViewsStreamsShould_display.default(falseyObj), false, 'shouldDisplay(obj.get("isFalsey") === false)');

    var falsyArray = [1];
    falsyArray.isTruthy = false;
    equal(_emberViewsStreamsShould_display.default(falsyArray), false, '[1].isTruthy = false');

    var falseyCPArray = [1];
    _emberMetalProperties.defineProperty(falseyCPArray, 'isTruthy', _emberMetalComputed.default(function () {
      return false;
    }));
    equal(_emberViewsStreamsShould_display.default(falseyCPArray), false, 'shouldDisplay([1].get("isFalsey") === true');
  });
});
enifed('ember-views/tests/streams/streams-test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/tests/streams');
  test('ember-views/tests/streams/streams-test.js should pass jscs', function () {
    ok(true, 'ember-views/tests/streams/streams-test.js should pass jscs.');
  });
});
enifed('ember-views/tests/streams/streams-test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/tests/streams');
  QUnit.test('ember-views/tests/streams/streams-test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/tests/streams/streams-test.js should pass jshint.');
  });
});
enifed('ember-views/tests/system/event_dispatcher_test', ['exports', 'ember-metal/property_get', 'ember-metal/run_loop', 'ember-runtime/system/object', 'ember-views/system/jquery', 'ember-views/views/view', 'ember-views/system/event_dispatcher', 'ember-views/views/container_view', 'ember-template-compiler/system/compile', 'ember-htmlbars/tests/utils', 'ember-htmlbars/keywords/view'], function (exports, _emberMetalProperty_get, _emberMetalRun_loop, _emberRuntimeSystemObject, _emberViewsSystemJquery, _emberViewsViewsView, _emberViewsSystemEvent_dispatcher, _emberViewsViewsContainer_view, _emberTemplateCompilerSystemCompile, _emberHtmlbarsTestsUtils, _emberHtmlbarsKeywordsView) {
  'use strict';

  var view, originalViewKeyword;
  var dispatcher;

  QUnit.module('EventDispatcher', {
    setup: function () {
      originalViewKeyword = _emberHtmlbarsTestsUtils.registerKeyword('view', _emberHtmlbarsKeywordsView.default);
      _emberMetalRun_loop.default(function () {
        dispatcher = _emberViewsSystemEvent_dispatcher.default.create();
        dispatcher.setup();
      });
    },

    teardown: function () {
      _emberMetalRun_loop.default(function () {
        if (view) {
          view.destroy();
        }
        dispatcher.destroy();
      });
      _emberHtmlbarsTestsUtils.resetKeyword('view', originalViewKeyword);
    }
  });

  QUnit.test('should dispatch events to views', function () {
    var receivedEvent;
    var parentMouseDownCalled = 0;
    var childKeyDownCalled = 0;
    var parentKeyDownCalled = 0;

    var childView = _emberViewsViewsView.default.extend({
      keyDown: function (evt) {
        childKeyDownCalled++;

        return false;
      }
    }).create({
      template: _emberTemplateCompilerSystemCompile.default('<span id="wot">ewot</span>')
    });

    view = _emberViewsViewsView.default.extend({
      mouseDown: function (evt) {
        parentMouseDownCalled++;
        receivedEvent = evt;
      },

      keyDown: function (evt) {
        parentKeyDownCalled++;
      }
    }).create({
      template: _emberTemplateCompilerSystemCompile.default('some <span id="awesome">awesome</span> content {{view view.childView}}'),
      childView: childView
    });

    _emberMetalRun_loop.default(function () {
      view.appendTo('#qunit-fixture');
    });

    view.$().trigger('mousedown');

    ok(receivedEvent, 'passes event to associated event method');
    receivedEvent = null;
    parentMouseDownCalled = 0;

    view.$('span#awesome').trigger('mousedown');
    ok(receivedEvent, 'event bubbles up to nearest View');
    equal(parentMouseDownCalled, 1, 'does not trigger the parent handlers twice because of browser bubbling');
    receivedEvent = null;

    _emberViewsSystemJquery.default('#wot').trigger('mousedown');
    ok(receivedEvent, 'event bubbles up to nearest View');

    _emberViewsSystemJquery.default('#wot').trigger('keydown');
    equal(childKeyDownCalled, 1, 'calls keyDown on child view');
    equal(parentKeyDownCalled, 0, 'does not call keyDown on parent if child handles event');
  });

  QUnit.test('should not dispatch events to views not inDOM', function () {
    var receivedEvent;

    view = _emberViewsViewsView.default.extend({
      mouseDown: function (evt) {
        receivedEvent = evt;
      }
    }).create({
      template: _emberTemplateCompilerSystemCompile.default('some <span id="awesome">awesome</span> content')
    });

    _emberMetalRun_loop.default(function () {
      view.append();
    });

    var $element = view.$();

    _emberMetalRun_loop.default(function () {
      // TODO change this test not to use private API
      // Force into preRender
      view.renderer.remove(view, false, true);
    });

    $element.trigger('mousedown');

    ok(!receivedEvent, 'does not pass event to associated event method');
    receivedEvent = null;

    $element.find('span#awesome').trigger('mousedown');
    ok(!receivedEvent, 'event does not bubble up to nearest View');
    receivedEvent = null;

    // Cleanup
    $element.remove();
  });

  QUnit.test('should send change events up view hierarchy if view contains form elements', function () {
    var receivedEvent;
    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('<input id="is-done" type="checkbox">'),

      change: function (evt) {
        receivedEvent = evt;
      }
    });

    _emberMetalRun_loop.default(function () {
      view.append();
    });

    _emberViewsSystemJquery.default('#is-done').trigger('change');
    ok(receivedEvent, 'calls change method when a child element is changed');
    equal(receivedEvent.target, _emberViewsSystemJquery.default('#is-done')[0], 'target property is the element that was clicked');
  });

  QUnit.test('events should stop propagating if the view is destroyed', function () {
    var parentViewReceived, receivedEvent;

    var parentView = _emberViewsViewsContainer_view.default.create({
      change: function (evt) {
        parentViewReceived = true;
      }
    });

    view = parentView.createChildView(_emberViewsViewsView.default, {
      template: _emberTemplateCompilerSystemCompile.default('<input id="is-done" type="checkbox">'),

      change: function (evt) {
        receivedEvent = true;
        var self = this;
        _emberMetalRun_loop.default(function () {
          _emberMetalProperty_get.get(self, 'parentView').destroy();
        });
      }
    });

    parentView.pushObject(view);

    _emberMetalRun_loop.default(function () {
      parentView.append();
    });

    ok(_emberViewsSystemJquery.default('#is-done').length, 'precond - view is in the DOM');
    _emberViewsSystemJquery.default('#is-done').trigger('change');
    ok(!_emberViewsSystemJquery.default('#is-done').length, 'precond - view is not in the DOM');
    ok(receivedEvent, 'calls change method when a child element is changed');
    ok(!parentViewReceived, 'parent view does not receive the event');
  });

  QUnit.test('should dispatch events to nearest event manager', function () {
    var receivedEvent = 0;
    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('<input id="is-done" type="checkbox">'),

      eventManager: _emberRuntimeSystemObject.default.create({
        mouseDown: function () {
          receivedEvent++;
        }
      }),

      mouseDown: function () {}
    });

    _emberMetalRun_loop.default(function () {
      view.append();
    });

    _emberViewsSystemJquery.default('#is-done').trigger('mousedown');
    equal(receivedEvent, 1, 'event should go to manager and not view');
  });

  QUnit.test('event manager should be able to re-dispatch events to view', function () {
    expectDeprecation('Setting `childViews` on a Container is deprecated.');

    var receivedEvent = 0;
    view = _emberViewsViewsContainer_view.default.extend({

      eventManager: _emberRuntimeSystemObject.default.extend({
        mouseDown: function (evt, view) {
          // Re-dispatch event when you get it.
          //
          // The second parameter tells the dispatcher
          // that this event has been handled. This
          // API will clearly need to be reworked since
          // multiple eventManagers in a single view
          // hierarchy would break, but it shows that
          // re-dispatching works
          view.$().trigger('mousedown', this);
        }
      }).create(),

      child: _emberViewsViewsView.default.extend({
        elementId: 'nestedView',

        mouseDown: function (evt) {
          receivedEvent++;
        }
      }),

      mouseDown: function (evt) {
        receivedEvent++;
      }
    }).create({
      elementId: 'containerView',
      childViews: ['child']
    });

    _emberMetalRun_loop.default(function () {
      view.append();
    });

    _emberViewsSystemJquery.default('#nestedView').trigger('mousedown');
    equal(receivedEvent, 2, 'event should go to manager and not view');
  });

  QUnit.test('event handlers should be wrapped in a run loop', function () {
    expect(1);

    view = _emberViewsViewsView.default.extend({
      eventManager: _emberRuntimeSystemObject.default.extend({
        mouseDown: function () {
          ok(_emberMetalRun_loop.default.currentRunLoop, 'a run loop should have started');
        }
      }).create()
    }).create({
      elementId: 'test-view'
    });

    _emberMetalRun_loop.default(function () {
      view.append();
    });

    _emberViewsSystemJquery.default('#test-view').trigger('mousedown');
  });

  QUnit.module('EventDispatcher#setup', {
    setup: function () {
      _emberMetalRun_loop.default(function () {
        dispatcher = _emberViewsSystemEvent_dispatcher.default.create({
          rootElement: '#qunit-fixture'
        });
      });
    },

    teardown: function () {
      _emberMetalRun_loop.default(function () {
        if (view) {
          view.destroy();
        }
        dispatcher.destroy();
      });
    }
  });

  QUnit.test('additional events which should be listened on can be passed', function () {
    expect(1);

    _emberMetalRun_loop.default(function () {
      dispatcher.setup({ myevent: 'myEvent' });

      view = _emberViewsViewsView.default.create({
        elementId: 'leView',
        myEvent: function () {
          ok(true, 'custom event has been triggered');
        }
      }).appendTo(dispatcher.get('rootElement'));
    });

    _emberViewsSystemJquery.default('#leView').trigger('myevent');
  });

  QUnit.test('additional events and rootElement can be specified', function () {
    expect(3);

    _emberViewsSystemJquery.default('#qunit-fixture').append('<div class=\'custom-root\'></div>');

    _emberMetalRun_loop.default(function () {
      dispatcher.setup({ myevent: 'myEvent' }, '.custom-root');

      view = _emberViewsViewsView.default.create({
        elementId: 'leView',
        myEvent: function () {
          ok(true, 'custom event has been triggered');
        }
      }).appendTo(dispatcher.get('rootElement'));
    });

    ok(_emberViewsSystemJquery.default('.custom-root').hasClass('ember-application'), 'the custom rootElement is used');
    equal(dispatcher.get('rootElement'), '.custom-root', 'the rootElement is updated');

    _emberViewsSystemJquery.default('#leView').trigger('myevent');
  });
});
enifed('ember-views/tests/system/event_dispatcher_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/tests/system');
  test('ember-views/tests/system/event_dispatcher_test.js should pass jscs', function () {
    ok(true, 'ember-views/tests/system/event_dispatcher_test.js should pass jscs.');
  });
});
enifed('ember-views/tests/system/event_dispatcher_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/tests/system');
  QUnit.test('ember-views/tests/system/event_dispatcher_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/tests/system/event_dispatcher_test.js should pass jshint.');
  });
});
enifed('ember-views/tests/system/ext_test', ['exports', 'ember-metal/run_loop', 'ember-views/views/view', 'ember-template-compiler', 'ember-htmlbars/tests/utils', 'ember-htmlbars/keywords/view'], function (exports, _emberMetalRun_loop, _emberViewsViewsView, _emberTemplateCompiler, _emberHtmlbarsTestsUtils, _emberHtmlbarsKeywordsView) {
  'use strict';

  var originalViewKeyword;

  QUnit.module('Ember.View additions to run queue', {
    setup: function () {
      originalViewKeyword = _emberHtmlbarsTestsUtils.registerKeyword('view', _emberHtmlbarsKeywordsView.default);
    },
    teardown: function () {
      _emberHtmlbarsTestsUtils.resetKeyword('view', originalViewKeyword);
    }
  });

  QUnit.test('View hierarchy is done rendering to DOM when functions queued in afterRender execute', function () {
    var didInsert = 0;
    var childView = _emberViewsViewsView.default.create({
      elementId: 'child_view',
      didInsertElement: function () {
        didInsert++;
      }
    });
    var parentView = _emberViewsViewsView.default.create({
      elementId: 'parent_view',
      template: _emberTemplateCompiler.compile('{{view view.childView}}'),
      childView: childView,
      didInsertElement: function () {
        didInsert++;
      }
    });

    _emberMetalRun_loop.default(function () {
      parentView.appendTo('#qunit-fixture');
      _emberMetalRun_loop.default.schedule('afterRender', this, function () {
        equal(didInsert, 2, 'all didInsertElement hooks fired for hierarchy');
      });
    });

    _emberMetalRun_loop.default(function () {
      parentView.destroy();
    });
  });
});
enifed('ember-views/tests/system/ext_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/tests/system');
  test('ember-views/tests/system/ext_test.js should pass jscs', function () {
    ok(true, 'ember-views/tests/system/ext_test.js should pass jscs.');
  });
});
enifed('ember-views/tests/system/ext_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/tests/system');
  QUnit.test('ember-views/tests/system/ext_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/tests/system/ext_test.js should pass jshint.');
  });
});
enifed('ember-views/tests/system/jquery_ext_test', ['exports', 'ember-metal/run_loop', 'ember-views/system/event_dispatcher', 'ember-views/system/jquery', 'ember-views/views/view'], function (exports, _emberMetalRun_loop, _emberViewsSystemEvent_dispatcher, _emberViewsSystemJquery, _emberViewsViewsView) {
  'use strict';

  var view, dispatcher;

  // Adapted from https://github.com/jquery/jquery/blob/f30f7732e7775b6e417c4c22ced7adb2bf76bf89/test/data/testinit.js
  var canDataTransfer, fireNativeWithDataTransfer;

  if (document.createEvent) {
    canDataTransfer = !!document.createEvent('HTMLEvents').dataTransfer;
    fireNativeWithDataTransfer = function (node, type, dataTransfer) {
      var event = document.createEvent('HTMLEvents');
      event.initEvent(type, true, true);
      event.dataTransfer = dataTransfer;
      node.dispatchEvent(event);
    };
  } else {
    canDataTransfer = !!document.createEventObject().dataTransfer;
    fireNativeWithDataTransfer = function (node, type, dataTransfer) {
      var event = document.createEventObject();
      event.dataTransfer = dataTransfer;
      node.fireEvent('on' + type, event);
    };
  }

  QUnit.module('EventDispatcher - jQuery integration', {
    setup: function () {
      _emberMetalRun_loop.default(function () {
        dispatcher = _emberViewsSystemEvent_dispatcher.default.create();
        dispatcher.setup();
      });
    },

    teardown: function () {
      _emberMetalRun_loop.default(function () {
        if (view) {
          view.destroy();
        }
        dispatcher.destroy();
      });
    }
  });

  if (canDataTransfer) {
    QUnit.test('jQuery.event.fix copies over the dataTransfer property', function () {
      var originalEvent;
      var receivedEvent;

      originalEvent = {
        type: 'drop',
        dataTransfer: 'success',
        target: document.body
      };

      receivedEvent = _emberViewsSystemJquery.default.event.fix(originalEvent);

      ok(receivedEvent !== originalEvent, 'attributes are copied to a new event object');
      equal(receivedEvent.dataTransfer, originalEvent.dataTransfer, 'copies dataTransfer property to jQuery event');
    });

    QUnit.test('drop handler should receive event with dataTransfer property', function () {
      var receivedEvent;
      var dropCalled = 0;

      view = _emberViewsViewsView.default.extend({
        drop: function (evt) {
          receivedEvent = evt;
          dropCalled++;
        }
      }).create();

      _emberMetalRun_loop.default(function () {
        view.append();
      });

      fireNativeWithDataTransfer(view.$().get(0), 'drop', 'success');

      equal(dropCalled, 1, 'called drop handler once');
      equal(receivedEvent.dataTransfer, 'success', 'copies dataTransfer property to jQuery event');
    });
  }
});
enifed('ember-views/tests/system/jquery_ext_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/tests/system');
  test('ember-views/tests/system/jquery_ext_test.js should pass jscs', function () {
    ok(true, 'ember-views/tests/system/jquery_ext_test.js should pass jscs.');
  });
});
enifed('ember-views/tests/system/jquery_ext_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/tests/system');
  QUnit.test('ember-views/tests/system/jquery_ext_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/tests/system/jquery_ext_test.js should pass jshint.');
  });
});
enifed('ember-views/tests/system/view_utils_test', ['exports', 'ember-metal/core', 'ember-metal/run_loop', 'ember-views/views/view'], function (exports, _emberMetalCore, _emberMetalRun_loop, _emberViewsViewsView) {
  'use strict';

  var hasGetClientRects, hasGetBoundingClientRect;
  var ClientRectListCtor, ClientRectCtor;

  (function () {
    if (document.createRange) {
      var range = document.createRange();

      if (range.getClientRects) {
        var clientRectsList = range.getClientRects();
        hasGetClientRects = true;
        ClientRectListCtor = clientRectsList && clientRectsList.constructor;
      }

      if (range.getBoundingClientRect) {
        var clientRect = range.getBoundingClientRect();
        hasGetBoundingClientRect = true;
        ClientRectCtor = clientRect && clientRect.constructor;
      }
    }
  })();

  var view;

  QUnit.module('ViewUtils', {
    teardown: function () {
      _emberMetalRun_loop.default(function () {
        if (view) {
          view.destroy();
        }
      });
    }
  });

  QUnit.test('getViewClientRects', function () {
    if (!hasGetClientRects || !ClientRectListCtor) {
      ok(true, 'The test environment does not support the DOM API required to run this test.');
      return;
    }

    view = _emberViewsViewsView.default.create();

    _emberMetalRun_loop.default(function () {
      view.appendTo('#qunit-fixture');
    });

    ok(_emberMetalCore.default.ViewUtils.getViewClientRects(view) instanceof ClientRectListCtor);
  });

  QUnit.test('getViewBoundingClientRect', function () {
    if (!hasGetBoundingClientRect || !ClientRectCtor) {
      ok(true, 'The test environment does not support the DOM API required to run this test.');
      return;
    }

    view = _emberViewsViewsView.default.create();

    _emberMetalRun_loop.default(function () {
      view.appendTo('#qunit-fixture');
    });

    ok(_emberMetalCore.default.ViewUtils.getViewBoundingClientRect(view) instanceof ClientRectCtor);
  });
});
enifed('ember-views/tests/system/view_utils_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/tests/system');
  test('ember-views/tests/system/view_utils_test.js should pass jscs', function () {
    ok(true, 'ember-views/tests/system/view_utils_test.js should pass jscs.');
  });
});
enifed('ember-views/tests/system/view_utils_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/tests/system');
  QUnit.test('ember-views/tests/system/view_utils_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/tests/system/view_utils_test.js should pass jshint.');
  });
});
enifed('ember-views/tests/test-helpers/equal-html', ['exports'], function (exports) {
  'use strict';

  exports.equalHTML = equalHTML;

  function equalHTML(element, expectedHTML, message) {
    var html;
    if (typeof element === 'string') {
      html = document.getElementById(element).innerHTML;
    } else {
      if (element instanceof window.NodeList) {
        var fragment = document.createElement('div');
        while (element[0]) {
          fragment.appendChild(element[0]);
        }
        html = fragment.innerHTML;
      } else {
        html = element.outerHTML;
      }
    }

    var actualHTML = html.replace(/ id="[^"]+"/gmi, '');
    actualHTML = actualHTML.replace(/<\/?([A-Z]+)/gi, function (tag) {
      return tag.toLowerCase();
    });
    actualHTML = actualHTML.replace(/\r\n/gm, '');
    actualHTML = actualHTML.replace(/ $/, '');
    equal(actualHTML, expectedHTML, message || 'HTML matches');
  }
});
enifed('ember-views/tests/test-helpers/equal-html.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/tests/test-helpers');
  test('ember-views/tests/test-helpers/equal-html.js should pass jscs', function () {
    ok(true, 'ember-views/tests/test-helpers/equal-html.js should pass jscs.');
  });
});
enifed('ember-views/tests/test-helpers/equal-html.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/tests/test-helpers');
  QUnit.test('ember-views/tests/test-helpers/equal-html.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/tests/test-helpers/equal-html.js should pass jshint.');
  });
});
enifed('ember-views/tests/test-helpers/get-element-style', ['exports'], function (exports) {
  'use strict';

  exports.default = function (element) {
    var style = element.getAttribute('style');
    style = style.toUpperCase(); // IE8 keeps this is uppercase, so lets just upcase them all

    if (style !== '' && style.slice(-1) !== ';') {
      style += ';'; // IE8 drops the trailing so lets add it back
    }

    return style;
  };
});
enifed('ember-views/tests/test-helpers/get-element-style.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/tests/test-helpers');
  test('ember-views/tests/test-helpers/get-element-style.js should pass jscs', function () {
    ok(true, 'ember-views/tests/test-helpers/get-element-style.js should pass jscs.');
  });
});
enifed('ember-views/tests/test-helpers/get-element-style.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/tests/test-helpers');
  QUnit.test('ember-views/tests/test-helpers/get-element-style.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/tests/test-helpers/get-element-style.js should pass jshint.');
  });
});
enifed('ember-views/tests/views/checkbox_test', ['exports', 'ember-views/views/checkbox', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/run_loop', 'ember-views/system/event_dispatcher'], function (exports, _emberViewsViewsCheckbox, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalRun_loop, _emberViewsSystemEvent_dispatcher) {
  'use strict';

  function set(obj, key, value) {
    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(obj, key, value);
    });
  }

  function append() {
    _emberMetalRun_loop.default(function () {
      checkboxComponent.appendTo('#qunit-fixture');
    });
  }

  var checkboxComponent, dispatcher;

  QUnit.module('Ember.Checkbox', {
    setup: function () {
      dispatcher = _emberViewsSystemEvent_dispatcher.default.create();
      dispatcher.setup();
    },

    teardown: function () {
      _emberMetalRun_loop.default(function () {
        dispatcher.destroy();
        checkboxComponent.destroy();
      });
    }
  });

  QUnit.test('should begin disabled if the disabled attribute is true', function () {
    checkboxComponent = _emberViewsViewsCheckbox.default.create({});

    checkboxComponent.set('disabled', true);
    append();

    ok(checkboxComponent.$().is(':disabled'));
  });

  QUnit.test('should become disabled if the disabled attribute is changed', function () {
    checkboxComponent = _emberViewsViewsCheckbox.default.create({});

    append();
    ok(checkboxComponent.$().is(':not(:disabled)'));

    _emberMetalRun_loop.default(function () {
      checkboxComponent.set('disabled', true);
    });
    ok(checkboxComponent.$().is(':disabled'));

    _emberMetalRun_loop.default(function () {
      checkboxComponent.set('disabled', false);
    });
    ok(checkboxComponent.$().is(':not(:disabled)'));
  });

  QUnit.test('should begin indeterminate if the indeterminate attribute is true', function () {
    checkboxComponent = _emberViewsViewsCheckbox.default.create({});

    checkboxComponent.set('indeterminate', true);
    append();

    equal(checkboxComponent.$().prop('indeterminate'), true, 'Checkbox should be indeterminate');
  });

  QUnit.test('should become indeterminate if the indeterminate attribute is changed', function () {
    checkboxComponent = _emberViewsViewsCheckbox.default.create({});

    append();

    equal(checkboxComponent.$().prop('indeterminate'), false, 'Checkbox should not be indeterminate');

    _emberMetalRun_loop.default(function () {
      checkboxComponent.set('indeterminate', true);
    });
    equal(checkboxComponent.$().prop('indeterminate'), true, 'Checkbox should be indeterminate');

    _emberMetalRun_loop.default(function () {
      checkboxComponent.set('indeterminate', false);
    });
    equal(checkboxComponent.$().prop('indeterminate'), false, 'Checkbox should not be indeterminate');
  });

  QUnit.test('should support the tabindex property', function () {
    checkboxComponent = _emberViewsViewsCheckbox.default.create({});

    _emberMetalRun_loop.default(function () {
      checkboxComponent.set('tabindex', 6);
    });
    append();

    equal(checkboxComponent.$().prop('tabindex'), '6', 'the initial checkbox tabindex is set in the DOM');

    _emberMetalRun_loop.default(function () {
      checkboxComponent.set('tabindex', 3);
    });
    equal(checkboxComponent.$().prop('tabindex'), '3', 'the checkbox tabindex changes when it is changed in the component');
  });

  QUnit.test('checkbox name is updated when setting name property of view', function () {
    checkboxComponent = _emberViewsViewsCheckbox.default.create({});

    _emberMetalRun_loop.default(function () {
      checkboxComponent.set('name', 'foo');
    });
    append();

    equal(checkboxComponent.$().attr('name'), 'foo', 'renders checkbox with the name');

    _emberMetalRun_loop.default(function () {
      checkboxComponent.set('name', 'bar');
    });

    equal(checkboxComponent.$().attr('name'), 'bar', 'updates checkbox after name changes');
  });

  QUnit.test('checked property mirrors input value', function () {
    checkboxComponent = _emberViewsViewsCheckbox.default.create({});
    _emberMetalRun_loop.default(function () {
      checkboxComponent.append();
    });

    equal(_emberMetalProperty_get.get(checkboxComponent, 'checked'), false, 'initially starts with a false value');
    equal(!!checkboxComponent.$().prop('checked'), false, 'the initial checked property is false');

    set(checkboxComponent, 'checked', true);

    equal(checkboxComponent.$().prop('checked'), true, 'changing the value property changes the DOM');

    _emberMetalRun_loop.default(function () {
      checkboxComponent.remove();
    });
    _emberMetalRun_loop.default(function () {
      checkboxComponent.append();
    });

    equal(checkboxComponent.$().prop('checked'), true, 'changing the value property changes the DOM');

    _emberMetalRun_loop.default(function () {
      checkboxComponent.remove();
    });
    _emberMetalRun_loop.default(function () {
      set(checkboxComponent, 'checked', false);
    });
    _emberMetalRun_loop.default(function () {
      checkboxComponent.append();
    });

    equal(checkboxComponent.$().prop('checked'), false, 'changing the value property changes the DOM');
  });

  QUnit.test('checking the checkbox updates the value', function () {
    checkboxComponent = _emberViewsViewsCheckbox.default.create({ checked: true });
    append();

    equal(_emberMetalProperty_get.get(checkboxComponent, 'checked'), true, 'precond - initially starts with a true value');
    equal(!!checkboxComponent.$().prop('checked'), true, 'precond - the initial checked property is true');

    // IE fires 'change' event on blur.
    checkboxComponent.$()[0].focus();
    checkboxComponent.$()[0].click();
    checkboxComponent.$()[0].blur();

    equal(!!checkboxComponent.$().prop('checked'), false, 'after clicking a checkbox, the checked property changed');
    equal(_emberMetalProperty_get.get(checkboxComponent, 'checked'), false, 'changing the checkbox causes the view\'s value to get updated');
  });
});
enifed('ember-views/tests/views/checkbox_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/tests/views');
  test('ember-views/tests/views/checkbox_test.js should pass jscs', function () {
    ok(true, 'ember-views/tests/views/checkbox_test.js should pass jscs.');
  });
});
enifed('ember-views/tests/views/checkbox_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/tests/views');
  QUnit.test('ember-views/tests/views/checkbox_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/tests/views/checkbox_test.js should pass jshint.');
  });
});
enifed('ember-views/tests/views/collection_test', ['exports', 'ember-metal/core', 'ember-metal/property_set', 'ember-metal/run_loop', 'ember-metal/mixin', 'ember-views/system/jquery', 'ember-views/views/collection_view', 'ember-views/views/view', 'container/registry', 'ember-template-compiler/system/compile', 'ember-views/tests/test-helpers/get-element-style', 'ember-htmlbars/tests/utils', 'ember-htmlbars/keywords/view'], function (exports, _emberMetalCore, _emberMetalProperty_set, _emberMetalRun_loop, _emberMetalMixin, _emberViewsSystemJquery, _emberViewsViewsCollection_view, _emberViewsViewsView, _containerRegistry, _emberTemplateCompilerSystemCompile, _emberViewsTestsTestHelpersGetElementStyle, _emberHtmlbarsTestsUtils, _emberHtmlbarsKeywordsView) {
  'use strict';

  var trim = _emberViewsSystemJquery.default.trim;
  var registry;
  var view;

  var originalLookup, originalViewKeyword;

  QUnit.module('CollectionView', {
    setup: function () {
      _emberViewsViewsCollection_view.default.CONTAINER_MAP.del = 'em';
      originalViewKeyword = _emberHtmlbarsTestsUtils.registerKeyword('view', _emberHtmlbarsKeywordsView.default);
      originalLookup = _emberMetalCore.default.lookup;
      registry = new _containerRegistry.default();
    },
    teardown: function () {
      delete _emberViewsViewsCollection_view.default.CONTAINER_MAP.del;
      _emberMetalRun_loop.default(function () {
        if (view) {
          view.destroy();
        }
      });

      _emberMetalCore.default.lookup = originalLookup;
      _emberHtmlbarsTestsUtils.resetKeyword('view', originalViewKeyword);
    }
  });

  QUnit.test('should render a view for each item in its content array', function () {
    view = _emberViewsViewsCollection_view.default.create({
      content: _emberMetalCore.default.A([1, 2, 3, 4])
    });

    _emberMetalRun_loop.default(function () {
      view.append();
    });
    equal(view.$('div').length, 4);
  });

  QUnit.test('should render the emptyView if content array is empty (view class)', function () {
    view = _emberViewsViewsCollection_view.default.create({
      content: _emberMetalCore.default.A(),

      emptyView: _emberViewsViewsView.default.extend({
        template: _emberTemplateCompilerSystemCompile.default('OY SORRY GUVNAH NO NEWS TODAY EH')
      })
    });

    _emberMetalRun_loop.default(function () {
      view.append();
    });

    ok(view.$().find('div:contains("OY SORRY GUVNAH")').length, 'displays empty view');
  });

  QUnit.test('should render the emptyView if content array is empty (view class with custom tagName)', function () {
    view = _emberViewsViewsCollection_view.default.create({
      tagName: 'del',
      content: _emberMetalCore.default.A(),

      emptyView: _emberViewsViewsView.default.extend({
        tagName: 'kbd',
        template: _emberTemplateCompilerSystemCompile.default('OY SORRY GUVNAH NO NEWS TODAY EH')
      })
    });

    _emberMetalRun_loop.default(function () {
      view.append();
    });

    ok(view.$().find('kbd:contains("OY SORRY GUVNAH")').length, 'displays empty view');
  });

  QUnit.test('should render the emptyView if content array is empty (view instance)', function () {
    view = _emberViewsViewsCollection_view.default.create({
      tagName: 'del',
      content: _emberMetalCore.default.A(),

      emptyView: _emberViewsViewsView.default.create({
        tagName: 'kbd',
        template: _emberTemplateCompilerSystemCompile.default('OY SORRY GUVNAH NO NEWS TODAY EH')
      })
    });

    _emberMetalRun_loop.default(function () {
      view.append();
    });

    ok(view.$().find('kbd:contains("OY SORRY GUVNAH")').length, 'displays empty view');
  });

  QUnit.test('should be able to override the tag name of itemViewClass even if tag is in default mapping', function () {
    view = _emberViewsViewsCollection_view.default.create({
      tagName: 'del',
      content: _emberMetalCore.default.A(['NEWS GUVNAH']),

      itemViewClass: _emberViewsViewsView.default.extend({
        tagName: 'kbd',
        template: _emberTemplateCompilerSystemCompile.default('{{view.content}}')
      })
    });

    _emberMetalRun_loop.default(function () {
      view.append();
    });

    ok(view.$().find('kbd:contains("NEWS GUVNAH")').length, 'displays the item view with proper tag name');
  });

  QUnit.test('should allow custom item views by setting itemViewClass', function () {
    var content = _emberMetalCore.default.A(['foo', 'bar', 'baz']);
    view = _emberViewsViewsCollection_view.default.create({
      content: content,

      itemViewClass: _emberViewsViewsView.default.extend({
        template: _emberTemplateCompilerSystemCompile.default('{{view.content}}')
      })
    });

    _emberMetalRun_loop.default(function () {
      view.append();
    });

    content.forEach(function (item) {
      return equal(view.$(':contains("' + item + '")').length, 1);
    });
  });

  QUnit.test('should insert a new item in DOM when an item is added to the content array', function () {
    var content = _emberMetalCore.default.A(['foo', 'bar', 'baz']);

    view = _emberViewsViewsCollection_view.default.create({
      content: content,

      itemViewClass: _emberViewsViewsView.default.extend({
        template: _emberTemplateCompilerSystemCompile.default('{{view.content}}')
      })
    });

    _emberMetalRun_loop.default(function () {
      view.append();
    });

    content.forEach(function (item) {
      equal(view.$(':contains("' + item + '")').length, 1, 'precond - generates pre-existing items');
    });

    _emberMetalRun_loop.default(function () {
      content.insertAt(1, 'quux');
    });

    equal(trim(view.$(':nth-child(2)').text()), 'quux');
  });

  QUnit.test('should remove an item from DOM when an item is removed from the content array', function () {
    var content = _emberMetalCore.default.A(['foo', 'bar', 'baz']);

    view = _emberViewsViewsCollection_view.default.create({
      content: content,

      itemViewClass: _emberViewsViewsView.default.extend({
        template: _emberTemplateCompilerSystemCompile.default('{{view.content}}')
      })
    });

    _emberMetalRun_loop.default(function () {
      return view.append();
    });

    content.forEach(function (item) {
      equal(view.$(':contains("' + item + '")').length, 1, 'precond - generates pre-existing items');
    });

    _emberMetalRun_loop.default(function () {
      return content.removeAt(1);
    });

    content.forEach(function (item, idx) {
      equal(view.$(':nth-child(' + (idx + 1) + ')').text(), item);
    });
  });

  QUnit.test('it updates the view if an item is replaced', function () {
    var content = _emberMetalCore.default.A(['foo', 'bar', 'baz']);
    view = _emberViewsViewsCollection_view.default.create({
      content: content,

      itemViewClass: _emberViewsViewsView.default.extend({
        template: _emberTemplateCompilerSystemCompile.default('{{view.content}}')
      })
    });

    _emberMetalRun_loop.default(function () {
      view.append();
    });

    content.forEach(function (item) {
      equal(view.$(':contains("' + item + '")').length, 1, 'precond - generates pre-existing items');
    });

    _emberMetalRun_loop.default(function () {
      content.removeAt(1);
      content.insertAt(1, 'Kazuki');
    });

    content.forEach(function (item, idx) {
      equal(trim(view.$(':nth-child(' + (idx + 1) + ')').text()), item, 'postcond - correct array update');
    });
  });

  QUnit.test('can add and replace in the same runloop', function () {
    var content = _emberMetalCore.default.A(['foo', 'bar', 'baz']);
    view = _emberViewsViewsCollection_view.default.create({
      content: content,

      itemViewClass: _emberViewsViewsView.default.extend({
        template: _emberTemplateCompilerSystemCompile.default('{{view.content}}')
      })
    });

    _emberMetalRun_loop.default(function () {
      return view.append();
    });

    content.forEach(function (item) {
      equal(view.$(':contains("' + item + '")').length, 1, 'precond - generates pre-existing items');
    });

    _emberMetalRun_loop.default(function () {
      content.pushObject('Tom Dale');
      content.removeAt(0);
      content.insertAt(0, 'Kazuki');
    });

    content.forEach(function (item, idx) {
      equal(trim(view.$(':nth-child(' + (idx + 1) + ')').text()), item, 'postcond - correct array update');
    });
  });

  QUnit.test('can add and replace the object before the add in the same runloop', function () {
    var content = _emberMetalCore.default.A(['foo', 'bar', 'baz']);
    view = _emberViewsViewsCollection_view.default.create({
      content: content,

      itemViewClass: _emberViewsViewsView.default.extend({
        template: _emberTemplateCompilerSystemCompile.default('{{view.content}}')
      })
    });

    _emberMetalRun_loop.default(function () {
      return view.append();
    });

    content.forEach(function (item) {
      equal(view.$(':contains("' + item + '")').length, 1, 'precond - generates pre-existing items');
    });

    _emberMetalRun_loop.default(function () {
      content.pushObject('Tom Dale');
      content.removeAt(1);
      content.insertAt(1, 'Kazuki');
    });

    content.forEach(function (item, idx) {
      equal(trim(view.$(':nth-child(' + (idx + 1) + ')').text()), item, 'postcond - correct array update');
    });
  });

  QUnit.test('can add and replace complicatedly', function () {
    var content = _emberMetalCore.default.A(['foo', 'bar', 'baz']);
    view = _emberViewsViewsCollection_view.default.create({
      content: content,

      itemViewClass: _emberViewsViewsView.default.extend({
        template: _emberTemplateCompilerSystemCompile.default('{{view.content}}')
      })
    });

    _emberMetalRun_loop.default(function () {
      return view.append();
    });

    content.forEach(function (item) {
      equal(view.$(':contains("' + item + '")').length, 1, 'precond - generates pre-existing items');
    });

    _emberMetalRun_loop.default(function () {
      content.pushObject('Tom Dale');
      content.removeAt(1);
      content.insertAt(1, 'Kazuki');
      content.pushObject('Firestone');
      content.pushObject('McMunch');
    });

    content.forEach(function (item, idx) {
      equal(trim(view.$(':nth-child(' + (idx + 1) + ')').text()), item, 'postcond - correct array update: ' + item.name + '!=' + view.$(':nth-child(' + (idx + 1) + ')').text());
    });
  });

  QUnit.test('can add and replace complicatedly harder', function () {
    var content = _emberMetalCore.default.A(['foo', 'bar', 'baz']);
    view = _emberViewsViewsCollection_view.default.create({
      content: content,

      itemViewClass: _emberViewsViewsView.default.extend({
        template: _emberTemplateCompilerSystemCompile.default('{{view.content}}')
      })
    });

    _emberMetalRun_loop.default(function () {
      view.append();
    });

    content.forEach(function (item) {
      equal(view.$(':contains("' + item + '")').length, 1, 'precond - generates pre-existing items');
    });

    _emberMetalRun_loop.default(function () {
      content.pushObject('Tom Dale');
      content.removeAt(1);
      content.insertAt(1, 'Kazuki');
      content.pushObject('Firestone');
      content.pushObject('McMunch');
      content.removeAt(2);
    });

    content.forEach(function (item, idx) {
      equal(trim(view.$(':nth-child(' + (idx + 1) + ')').text()), item, 'postcond - correct array update');
    });
  });

  QUnit.test('should allow changes to content object before layer is created', function () {
    view = _emberViewsViewsCollection_view.default.create({
      content: null
    });

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'content', _emberMetalCore.default.A());
      _emberMetalProperty_set.set(view, 'content', _emberMetalCore.default.A([1, 2, 3]));
      _emberMetalProperty_set.set(view, 'content', _emberMetalCore.default.A([1, 2]));
      view.append();
    });

    ok(view.$().children().length);
  });

  QUnit.test('should fire life cycle events when elements are added and removed', function () {
    var view;
    var didInsertElement = 0;
    var willDestroyElement = 0;
    var willDestroy = 0;
    var destroy = 0;
    var content = _emberMetalCore.default.A([1, 2, 3]);
    _emberMetalRun_loop.default(function () {
      view = _emberViewsViewsCollection_view.default.create({
        content: content,
        itemViewClass: _emberViewsViewsView.default.extend({
          template: _emberTemplateCompilerSystemCompile.default('{{view.content}}'),
          didInsertElement: function () {
            didInsertElement++;
          },
          willDestroyElement: function () {
            willDestroyElement++;
          },
          willDestroy: function () {
            willDestroy++;
            this._super.apply(this, arguments);
          },
          destroy: function () {
            destroy++;
            this._super.apply(this, arguments);
          }
        })
      });
      view.appendTo('#qunit-fixture');
    });

    equal(didInsertElement, 3);
    equal(willDestroyElement, 0);
    equal(willDestroy, 0);
    equal(destroy, 0);
    equal(view.$().text(), '123');

    _emberMetalRun_loop.default(function () {
      content.pushObject(4);
      content.unshiftObject(0);
    });

    equal(didInsertElement, 5);
    equal(willDestroyElement, 0);
    equal(willDestroy, 0);
    equal(destroy, 0);
    // Remove whitespace added by IE 8
    equal(trim(view.$().text()), '01234');

    _emberMetalRun_loop.default(function () {
      content.popObject();
      content.shiftObject();
    });

    equal(didInsertElement, 5);
    equal(willDestroyElement, 2);
    equal(willDestroy, 2);
    equal(destroy, 2);
    // Remove whitspace added by IE 8
    equal(trim(view.$().text()), '123');

    _emberMetalRun_loop.default(function () {
      view.set('content', _emberMetalCore.default.A([7, 8, 9]));
    });

    equal(didInsertElement, 8);
    equal(willDestroyElement, 5);
    equal(willDestroy, 5);
    equal(destroy, 5);
    // Remove whitespace added by IE 8
    equal(trim(view.$().text()), '789');

    _emberMetalRun_loop.default(function () {
      view.destroy();
    });

    equal(didInsertElement, 8);
    equal(willDestroyElement, 8);
    equal(willDestroy, 8);
    equal(destroy, 8);
  });

  QUnit.test('should allow changing content property to be null', function () {
    view = _emberViewsViewsCollection_view.default.create({
      content: _emberMetalCore.default.A([1, 2, 3]),

      emptyView: _emberViewsViewsView.default.extend({
        template: _emberTemplateCompilerSystemCompile.default('(empty)')
      })
    });

    _emberMetalRun_loop.default(function () {
      view.append();
    });

    equal(view.$().children().length, 3, 'precond - creates three elements');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'content', null);
    });

    equal(trim(view.$().children().text()), '(empty)', 'should display empty view');
  });

  QUnit.test('should allow items to access to the CollectionView\'s current index in the content array', function () {
    view = _emberViewsViewsCollection_view.default.create({
      content: _emberMetalCore.default.A(['zero', 'one', 'two']),
      itemViewClass: _emberViewsViewsView.default.extend({
        template: _emberTemplateCompilerSystemCompile.default('{{view.contentIndex}}')
      })
    });

    _emberMetalRun_loop.default(function () {
      view.append();
    });

    deepEqual(view.$(':nth-child(1)').text(), '0');
    deepEqual(view.$(':nth-child(2)').text(), '1');
    deepEqual(view.$(':nth-child(3)').text(), '2');
  });

  QUnit.test('should allow declaration of itemViewClass as a string', function () {
    registry.register('view:simple-view', _emberViewsViewsView.default.extend());

    view = _emberViewsViewsCollection_view.default.create({
      container: registry.container(),
      content: _emberMetalCore.default.A([1, 2, 3]),
      itemViewClass: 'simple-view'
    });

    _emberMetalRun_loop.default(function () {
      view.appendTo('#qunit-fixture');
    });

    equal(view.$('.ember-view').length, 3);
  });

  QUnit.test('should not render the emptyView if content is emptied and refilled in the same run loop', function () {
    view = _emberViewsViewsCollection_view.default.create({
      tagName: 'div',
      content: _emberMetalCore.default.A(['NEWS GUVNAH']),

      emptyView: _emberViewsViewsView.default.extend({
        tagName: 'kbd',
        template: _emberTemplateCompilerSystemCompile.default('OY SORRY GUVNAH NO NEWS TODAY EH')
      })
    });

    _emberMetalRun_loop.default(function () {
      view.append();
    });

    equal(view.$().find('kbd:contains("OY SORRY GUVNAH")').length, 0);

    _emberMetalRun_loop.default(function () {
      view.get('content').popObject();
      view.get('content').pushObject(['NEWS GUVNAH']);
    });
    equal(view.$('div').length, 1);
    equal(view.$().find('kbd:contains("OY SORRY GUVNAH")').length, 0);
  });

  QUnit.test('when a collection view is emptied, deeply nested views elements are not removed from the DOM and then destroyed again', function () {
    var gotDestroyed = [];

    var assertProperDestruction = _emberMetalMixin.Mixin.create({
      destroy: function () {
        gotDestroyed.push(this.label);
        this._super.apply(this, arguments);
      }
    });

    var ChildView = _emberViewsViewsView.default.extend(assertProperDestruction, {
      template: _emberTemplateCompilerSystemCompile.default('{{#view view.assertDestruction}}<div class="inner_element"></div>{{/view}}'),
      label: 'parent',
      assertDestruction: _emberViewsViewsView.default.extend(assertProperDestruction, {
        label: 'child'
      })
    });

    var view = _emberViewsViewsCollection_view.default.create({
      content: _emberMetalCore.default.A([1]),
      itemViewClass: ChildView
    });

    _emberMetalRun_loop.default(function () {
      view.append();
    });
    equal(_emberViewsSystemJquery.default('.inner_element').length, 1, 'precond - generates inner element');

    _emberMetalRun_loop.default(function () {
      view.get('content').clear();
    });
    equal(_emberViewsSystemJquery.default('.inner_element').length, 0, 'elements removed');

    _emberMetalRun_loop.default(function () {
      view.destroy();
    });

    deepEqual(gotDestroyed, ['parent', 'child'], 'The child view was destroyed');
  });

  QUnit.test('should render the emptyView if content array is empty and emptyView is given as string', function () {
    registry.register('view:custom-empty', _emberViewsViewsView.default.extend({
      tagName: 'kbd',
      template: _emberTemplateCompilerSystemCompile.default('THIS IS AN EMPTY VIEW')
    }));

    view = _emberViewsViewsCollection_view.default.create({
      tagName: 'del',
      content: _emberMetalCore.default.A(),
      container: registry.container(),

      emptyView: 'custom-empty'
    });

    _emberMetalRun_loop.default(function () {
      view.append();
    });

    ok(view.$().find('kbd:contains("THIS IS AN EMPTY VIEW")').length, 'displays empty view');
  });

  QUnit.test('should lookup against the container if itemViewClass is given as a string', function () {
    var ItemView = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('{{view.content}}')
    });

    registry.register('view:item', ItemView);

    view = _emberViewsViewsCollection_view.default.create({
      container: registry.container(),
      content: _emberMetalCore.default.A([1, 2, 3, 4]),
      itemViewClass: 'item'
    });

    _emberMetalRun_loop.default(function () {
      view.appendTo('#qunit-fixture');
    });

    equal(view.$('.ember-view').length, 4);
  });

  QUnit.test('should lookup only global path against the container if itemViewClass is given as a string', function () {
    var ItemView = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('{{view.content}}')
    });

    registry.register('view:top', ItemView);

    view = _emberViewsViewsCollection_view.default.create({
      container: registry.container(),
      content: _emberMetalCore.default.A(['hi']),
      itemViewClass: 'top'
    });

    _emberMetalRun_loop.default(function () {
      view.appendTo('#qunit-fixture');
    });

    equal(view.$().text(), 'hi');
  });

  QUnit.test('should lookup against the container and render the emptyView if emptyView is given as string and content array is empty ', function () {
    var EmptyView = _emberViewsViewsView.default.extend({
      tagName: 'kbd',
      template: _emberTemplateCompilerSystemCompile.default('THIS IS AN EMPTY VIEW')
    });

    registry.register('view:empty', EmptyView);

    view = _emberViewsViewsCollection_view.default.create({
      container: registry.container(),
      tagName: 'del',
      content: _emberMetalCore.default.A(),
      emptyView: 'empty'
    });

    _emberMetalRun_loop.default(function () {
      view.append();
    });

    ok(view.$().find('kbd:contains("THIS IS AN EMPTY VIEW")').length, 'displays empty view');
  });

  QUnit.test('should lookup from only global path against the container if emptyView is given as string and content array is empty ', function () {
    var EmptyView = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('EMPTY')
    });

    registry.register('view:top', EmptyView);

    view = _emberViewsViewsCollection_view.default.create({
      container: registry.container(),
      content: _emberMetalCore.default.A(),
      emptyView: 'top'
    });

    _emberMetalRun_loop.default(function () {
      view.append();
    });

    equal(view.$().text(), 'EMPTY');
  });

  QUnit.test('Collection with style attribute supports changing content', function () {
    view = _emberViewsViewsCollection_view.default.create({
      attributeBindings: ['style'],
      style: 'width: 100px;',
      content: _emberMetalCore.default.A(['foo', 'bar'])
    });

    _emberMetalRun_loop.default(function () {
      view.appendTo('#qunit-fixture');
    });

    var style = _emberViewsTestsTestHelpersGetElementStyle.default(view.element);

    equal(style, 'WIDTH: 100PX;', 'width is applied to the element');

    _emberMetalRun_loop.default(function () {
      view.get('content').pushObject('baz');
    });
  });

  QUnit.module('DeprecatedCollectionView [LEGACY]');

  QUnit.test('calling reopen on DeprecatedCollectionView delegates to CollectionView', function () {
    expect(2);
    var originalReopen = _emberViewsViewsCollection_view.default.reopen;
    var obj = {};

    _emberViewsViewsCollection_view.default.reopen = function (arg) {
      ok(arg === obj);
    };

    expectNoDeprecation();
    _emberViewsViewsCollection_view.DeprecatedCollectionView.reopen(obj);

    _emberViewsViewsCollection_view.default.reopen = originalReopen;
  });
});
// Ember.A
enifed('ember-views/tests/views/collection_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/tests/views');
  test('ember-views/tests/views/collection_test.js should pass jscs', function () {
    ok(true, 'ember-views/tests/views/collection_test.js should pass jscs.');
  });
});
enifed('ember-views/tests/views/collection_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/tests/views');
  QUnit.test('ember-views/tests/views/collection_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/tests/views/collection_test.js should pass jshint.');
  });
});
enifed('ember-views/tests/views/component_test', ['exports', 'ember-metal/property_set', 'ember-metal/run_loop', 'ember-runtime/system/object', 'ember-runtime/system/service', 'ember-runtime/system/container', 'ember-runtime/inject', 'ember-metal/property_get', 'ember-views/views/view', 'ember-views/views/component', 'ember-views/compat/attrs-proxy'], function (exports, _emberMetalProperty_set, _emberMetalRun_loop, _emberRuntimeSystemObject, _emberRuntimeSystemService, _emberRuntimeSystemContainer, _emberRuntimeInject, _emberMetalProperty_get, _emberViewsViewsView, _emberViewsViewsComponent, _emberViewsCompatAttrsProxy) {
  'use strict';

  var a_slice = Array.prototype.slice;

  var component, controller, actionCounts, sendCount, actionArguments;

  QUnit.module('Ember.Component', {
    setup: function () {
      component = _emberViewsViewsComponent.default.create();
    },
    teardown: function () {
      _emberMetalRun_loop.default(function () {
        if (component) {
          component.destroy();
        }
        if (controller) {
          controller.destroy();
        }
      });
    }
  });

  QUnit.test('can access `actions` hash via `_actions` [DEPRECATED]', function () {
    expect(2);

    component = _emberViewsViewsComponent.default.extend({
      actions: {
        foo: function () {
          ok(true, 'called foo action');
        }
      }
    }).create();

    expectDeprecation(function () {
      component._actions.foo();
    }, 'Usage of `_actions` is deprecated, use `actions` instead.');
  });

  QUnit.test('The context of an Ember.Component is itself', function () {
    strictEqual(component, component.get('context'), 'A component\'s context is itself');
  });

  QUnit.test('The controller (target of `action`) of an Ember.Component is itself', function () {
    strictEqual(component, component.get('controller'), 'A component\'s controller is itself');
  });

  QUnit.test('Specifying both templateName and layoutName to a component is NOT deprecated', function () {
    expectNoDeprecation();
    component = _emberViewsViewsComponent.default.extend({
      templateName: 'blah-blah',
      layoutName: 'hum-drum'
    }).create();

    equal(_emberMetalProperty_get.get(component, 'templateName'), 'blah-blah');
    equal(_emberMetalProperty_get.get(component, 'layoutName'), 'hum-drum');
  });

  QUnit.test('Specifying a templateName on a component with a layoutName specified in a superclass is NOT deprecated', function () {
    expectNoDeprecation();
    var Parent = _emberViewsViewsComponent.default.extend({
      layoutName: 'hum-drum'
    });

    component = Parent.extend({
      templateName: 'blah-blah'
    }).create();

    equal(_emberMetalProperty_get.get(component, 'templateName'), 'blah-blah');
    equal(_emberMetalProperty_get.get(component, 'layoutName'), 'hum-drum');
  });

  QUnit.module('Ember.Component - Actions', {
    setup: function () {
      actionCounts = {};
      sendCount = 0;
      actionArguments = null;

      controller = _emberRuntimeSystemObject.default.create({
        send: function (actionName) {
          sendCount++;
          actionCounts[actionName] = actionCounts[actionName] || 0;
          actionCounts[actionName]++;
          actionArguments = a_slice.call(arguments, 1);
        }
      });

      component = _emberViewsViewsComponent.default.create({
        parentView: _emberViewsViewsView.default.create({
          controller: controller
        })
      });
    },

    teardown: function () {
      _emberMetalRun_loop.default(function () {
        component.destroy();
        controller.destroy();
      });
    }
  });

  QUnit.test('Calling sendAction on a component without an action defined does nothing', function () {
    component.sendAction();
    equal(sendCount, 0, 'addItem action was not invoked');
  });

  QUnit.test('Calling sendAction on a component with an action defined calls send on the controller', function () {
    _emberMetalProperty_set.set(component, 'action', 'addItem');

    component.sendAction();

    equal(sendCount, 1, 'send was called once');
    equal(actionCounts['addItem'], 1, 'addItem event was sent once');
  });

  QUnit.test('Calling sendAction on a component with a function calls the function', function () {
    expect(1);
    _emberMetalProperty_set.set(component, 'action', function () {
      ok(true, 'function is called');
    });

    component.sendAction();
  });

  QUnit.test('Calling sendAction on a component with a function calls the function with arguments', function () {
    expect(1);
    var argument = {};
    _emberMetalProperty_set.set(component, 'action', function (actualArgument) {
      equal(actualArgument, argument, 'argument is passed');
    });

    component.sendAction('action', argument);
  });

  QUnit.test('Calling sendAction on a component with a mut attr calls the function with arguments', function () {
    var _mut;

    var mut = (_mut = {
      value: 'didStartPlaying'
    }, _mut[_emberViewsCompatAttrsProxy.MUTABLE_CELL] = true, _mut);
    _emberMetalProperty_set.set(component, 'playing', null);
    _emberMetalProperty_set.set(component, 'attrs', { playing: mut });

    component.sendAction('playing');

    equal(sendCount, 1, 'send was called once');
    equal(actionCounts['didStartPlaying'], 1, 'named action was sent');
  });

  QUnit.test('Calling sendAction with a named action uses the component\'s property as the action name', function () {
    _emberMetalProperty_set.set(component, 'playing', 'didStartPlaying');
    _emberMetalProperty_set.set(component, 'action', 'didDoSomeBusiness');

    component.sendAction('playing');

    equal(sendCount, 1, 'send was called once');
    equal(actionCounts['didStartPlaying'], 1, 'named action was sent');

    component.sendAction('playing');

    equal(sendCount, 2, 'send was called twice');
    equal(actionCounts['didStartPlaying'], 2, 'named action was sent');

    component.sendAction();

    equal(sendCount, 3, 'send was called three times');
    equal(actionCounts['didDoSomeBusiness'], 1, 'default action was sent');
  });

  QUnit.test('Calling sendAction when the action name is not a string raises an exception', function () {
    _emberMetalProperty_set.set(component, 'action', {});
    _emberMetalProperty_set.set(component, 'playing', {});

    expectAssertion(function () {
      component.sendAction();
    });

    expectAssertion(function () {
      component.sendAction('playing');
    });
  });

  QUnit.test('Calling sendAction on a component with a context', function () {
    _emberMetalProperty_set.set(component, 'playing', 'didStartPlaying');

    var testContext = { song: 'She Broke My Ember' };

    component.sendAction('playing', testContext);

    deepEqual(actionArguments, [testContext], 'context was sent with the action');
  });

  QUnit.test('Calling sendAction on a component with multiple parameters', function () {
    _emberMetalProperty_set.set(component, 'playing', 'didStartPlaying');

    var firstContext = { song: 'She Broke My Ember' };
    var secondContext = { song: 'My Achey Breaky Ember' };

    component.sendAction('playing', firstContext, secondContext);

    deepEqual(actionArguments, [firstContext, secondContext], 'arguments were sent to the action');
  });

  QUnit.module('Ember.Component - injected properties');

  QUnit.test('services can be injected into components', function () {
    var registry = new _emberRuntimeSystemContainer.Registry();
    var container = registry.container();

    registry.register('component:application', _emberViewsViewsComponent.default.extend({
      profilerService: _emberRuntimeInject.default.service('profiler')
    }));

    registry.register('service:profiler', _emberRuntimeSystemService.default.extend());

    var appComponent = container.lookup('component:application');
    var profilerService = container.lookup('service:profiler');

    equal(profilerService, appComponent.get('profilerService'), 'service.profiler is injected');
  });

  QUnit.module('Ember.Component - subscribed and sent actions trigger errors');

  QUnit.test('something', function () {
    expect(2);

    var appComponent = _emberViewsViewsComponent.default.extend({
      actions: {
        foo: function (message) {
          equal('bar', message);
        }
      }
    }).create();

    appComponent.send('foo', 'bar');

    throws(function () {
      appComponent.send('baz', 'bar');
    }, /had no action handler for: baz/, 'asdf');
  });

  QUnit.test('component with target', function () {
    expect(2);

    var target = {
      send: function (message, payload) {
        equal('foo', message);
        equal('baz', payload);
      }
    };

    var appComponent = _emberViewsViewsComponent.default.create({
      target: target
    });

    appComponent.send('foo', 'baz');
  });
});
enifed('ember-views/tests/views/component_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/tests/views');
  test('ember-views/tests/views/component_test.js should pass jscs', function () {
    ok(true, 'ember-views/tests/views/component_test.js should pass jscs.');
  });
});
enifed('ember-views/tests/views/component_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/tests/views');
  QUnit.test('ember-views/tests/views/component_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/tests/views/component_test.js should pass jshint.');
  });
});
enifed('ember-views/tests/views/container_view_test', ['exports', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/run_loop', 'ember-metal/computed', 'ember-runtime/controllers/controller', 'ember-views/system/jquery', 'ember-views/views/view', 'ember-views/views/container_view', 'container/registry', 'ember-template-compiler/system/compile', 'ember-views/tests/test-helpers/get-element-style', 'ember-htmlbars/tests/utils', 'ember-htmlbars/keywords/view'], function (exports, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalRun_loop, _emberMetalComputed, _emberRuntimeControllersController, _emberViewsSystemJquery, _emberViewsViewsView, _emberViewsViewsContainer_view, _containerRegistry, _emberTemplateCompilerSystemCompile, _emberViewsTestsTestHelpersGetElementStyle, _emberHtmlbarsTestsUtils, _emberHtmlbarsKeywordsView) {
  'use strict';

  var trim = _emberViewsSystemJquery.default.trim;
  var container, registry, view, otherContainer, originalViewKeyword;

  QUnit.module('ember-views/views/container_view_test', {
    setup: function () {
      originalViewKeyword = _emberHtmlbarsTestsUtils.registerKeyword('view', _emberHtmlbarsKeywordsView.default);
      registry = new _containerRegistry.default();
    },
    teardown: function () {
      _emberMetalRun_loop.default(function () {
        if (container) {
          container.destroy();
        }
        if (view) {
          view.destroy();
        }
        if (otherContainer) {
          otherContainer.destroy();
        }
      });
      _emberHtmlbarsTestsUtils.resetKeyword('view', originalViewKeyword);
    }
  });

  QUnit.test('should be able to insert views after the DOM representation is created', function () {
    container = _emberViewsViewsContainer_view.default.create({
      classNameBindings: ['name'],
      name: 'foo',
      container: registry.container()
    });

    _emberMetalRun_loop.default(function () {
      container.appendTo('#qunit-fixture');
    });

    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('This is my moment')
    });

    _emberMetalRun_loop.default(function () {
      container.pushObject(view);
    });

    equal(view.container, container.container, 'view gains its containerViews container');
    equal(view.parentView, container, 'view\'s parentView is the container');
    equal(trim(container.$().text()), 'This is my moment');

    _emberMetalRun_loop.default(function () {
      container.destroy();
    });
  });

  QUnit.test('should be able to observe properties that contain child views', function () {
    expectDeprecation('Setting `childViews` on a Container is deprecated.');

    _emberMetalRun_loop.default(function () {
      var Container = _emberViewsViewsContainer_view.default.extend({
        childViews: ['displayView'],
        displayIsDisplayed: _emberMetalComputed.computed.alias('displayView.isDisplayed'),

        displayView: _emberViewsViewsView.default.extend({
          isDisplayed: true
        })
      });

      container = Container.create();
      container.appendTo('#qunit-fixture');
    });
    equal(container.get('displayIsDisplayed'), true, 'can bind to child view');

    _emberMetalRun_loop.default(function () {
      container.set('displayView.isDisplayed', false);
    });

    equal(container.get('displayIsDisplayed'), false, 'can bind to child view');
  });

  QUnit.test('childViews inherit their parents iocContainer, and retain the original container even when moved', function () {
    var iocContainer = registry.container();

    container = _emberViewsViewsContainer_view.default.create({
      container: iocContainer
    });

    otherContainer = _emberViewsViewsContainer_view.default.create({
      container: iocContainer
    });

    view = _emberViewsViewsView.default.create();

    container.pushObject(view);

    strictEqual(view.get('parentView'), container, 'sets the parent view after the childView is appended');
    strictEqual(_emberMetalProperty_get.get(view, 'container'), container.container, 'inherits its parentViews iocContainer');

    container.removeObject(view);

    strictEqual(_emberMetalProperty_get.get(view, 'container'), container.container, 'leaves existing iocContainer alone');

    otherContainer.pushObject(view);

    strictEqual(view.get('parentView'), otherContainer, 'sets the new parent view after the childView is appended');
    strictEqual(_emberMetalProperty_get.get(view, 'container'), container.container, 'still inherits its original parentViews iocContainer');
  });

  QUnit.test('should set the parentView property on views that are added to the child views array', function () {
    container = _emberViewsViewsContainer_view.default.create();

    var ViewKlass = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompilerSystemCompile.default('This is my moment')
    });

    view = ViewKlass.create();

    container.pushObject(view);
    equal(view.get('parentView'), container, 'sets the parent view after the childView is appended');

    _emberMetalRun_loop.default(function () {
      container.removeObject(view);
    });
    equal(_emberMetalProperty_get.get(view, 'parentView'), null, 'sets parentView to null when a view is removed');

    _emberMetalRun_loop.default(function () {
      container.appendTo('#qunit-fixture');
    });

    _emberMetalRun_loop.default(function () {
      container.pushObject(view);
    });

    equal(_emberMetalProperty_get.get(view, 'parentView'), container, 'sets the parent view after the childView is appended');

    var secondView = ViewKlass.create();
    var thirdView = ViewKlass.create();
    var fourthView = ViewKlass.create();

    _emberMetalRun_loop.default(function () {
      container.pushObject(secondView);
      container.replace(1, 0, [thirdView, fourthView]);
    });

    equal(_emberMetalProperty_get.get(secondView, 'parentView'), container, 'sets the parent view of the second view');
    equal(_emberMetalProperty_get.get(thirdView, 'parentView'), container, 'sets the parent view of the third view');
    equal(_emberMetalProperty_get.get(fourthView, 'parentView'), container, 'sets the parent view of the fourth view');

    _emberMetalRun_loop.default(function () {
      container.replace(2, 2);
    });

    equal(_emberMetalProperty_get.get(view, 'parentView'), container, 'doesn\'t change non-removed view');
    equal(_emberMetalProperty_get.get(thirdView, 'parentView'), container, 'doesn\'t change non-removed view');
    equal(_emberMetalProperty_get.get(secondView, 'parentView'), null, 'clears the parent view of the third view');
    equal(_emberMetalProperty_get.get(fourthView, 'parentView'), null, 'clears the parent view of the fourth view');

    _emberMetalRun_loop.default(function () {
      secondView.destroy();
      thirdView.destroy();
      fourthView.destroy();
    });
  });

  QUnit.test('should trigger parentViewDidChange when parentView is changed', function () {
    container = _emberViewsViewsContainer_view.default.create();

    var secondContainer = _emberViewsViewsContainer_view.default.create();
    var parentViewChanged = 0;

    var ViewKlass = _emberViewsViewsView.default.extend({
      parentViewDidChange: function () {
        parentViewChanged++;
      }
    });

    view = ViewKlass.create();

    container.pushObject(view);
    container.removeChild(view);
    secondContainer.pushObject(view);

    equal(parentViewChanged, 3);

    _emberMetalRun_loop.default(function () {
      secondContainer.destroy();
    });
  });

  QUnit.test('should be able to push initial views onto the ContainerView and have it behave', function () {
    var Container = _emberViewsViewsContainer_view.default.extend({
      init: function () {
        this._super.apply(this, arguments);
        this.pushObject(_emberViewsViewsView.default.create({
          name: 'A',
          template: _emberTemplateCompilerSystemCompile.default('A')
        }));
        this.pushObject(_emberViewsViewsView.default.create({
          name: 'B',
          template: _emberTemplateCompilerSystemCompile.default('B')
        }));
      },
      // functions here avoid attaching an observer, which is
      // not supported.
      lengthSquared: function () {
        return this.get('length') * this.get('length');
      },
      mapViewNames: function () {
        return this.map(function (_view) {
          return _view.get('name');
        });
      }
    });

    container = Container.create();

    equal(container.lengthSquared(), 4);

    deepEqual(container.mapViewNames(), ['A', 'B']);

    _emberMetalRun_loop.default(container, 'appendTo', '#qunit-fixture');

    equal(container.$().text(), 'AB');

    _emberMetalRun_loop.default(function () {
      container.pushObject(_emberViewsViewsView.default.create({
        name: 'C',
        template: _emberTemplateCompilerSystemCompile.default('C')
      }));
    });

    equal(container.lengthSquared(), 9);

    deepEqual(container.mapViewNames(), ['A', 'B', 'C']);

    equal(container.$().text(), 'ABC');

    _emberMetalRun_loop.default(container, 'destroy');
  });

  QUnit.test('views that are removed from a ContainerView should have their child views cleared', function () {
    container = _emberViewsViewsContainer_view.default.create();

    var ChildView = _emberViewsViewsView.default.extend({
      MyView: _emberViewsViewsView.default,
      template: _emberTemplateCompilerSystemCompile.default('{{view MyView}}')
    });
    var view = ChildView.create();

    container.pushObject(view);

    _emberMetalRun_loop.default(function () {
      container.appendTo('#qunit-fixture');
    });

    equal(_emberMetalProperty_get.get(view, 'childViews.length'), 1, 'precond - renders one child view');
    _emberMetalRun_loop.default(function () {
      container.removeObject(view);
    });
    strictEqual(container.$('div').length, 0, 'the child view is removed from the DOM');
  });

  QUnit.test('if a ContainerView starts with an empty currentView, nothing is displayed', function () {
    container = _emberViewsViewsContainer_view.default.create();

    _emberMetalRun_loop.default(function () {
      container.appendTo('#qunit-fixture');
    });

    equal(container.$().text(), '', 'has a empty contents');
    equal(_emberMetalProperty_get.get(container, 'childViews.length'), 0, 'should not have any child views');
  });

  QUnit.test('if a ContainerView starts with a currentView, it is rendered as a child view', function () {
    var controller = _emberRuntimeControllersController.default.create();
    container = _emberViewsViewsContainer_view.default.create({
      controller: controller
    });

    var mainView = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('This is the main view.')
    });

    _emberMetalProperty_set.set(container, 'currentView', mainView);

    _emberMetalRun_loop.default(function () {
      container.appendTo('#qunit-fixture');
    });

    equal(trim(container.$().text()), 'This is the main view.', 'should render its child');
    equal(_emberMetalProperty_get.get(container, 'length'), 1, 'should have one child view');
    equal(container.objectAt(0), mainView, 'should have the currentView as the only child view');
    equal(mainView.get('parentView'), container, 'parentView is setup');
  });

  QUnit.test('if a ContainerView is created with a currentView, it is rendered as a child view', function () {
    var mainView = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('This is the main view.')
    });

    var controller = _emberRuntimeControllersController.default.create();

    container = _emberViewsViewsContainer_view.default.create({
      currentView: mainView,
      controller: controller
    });

    _emberMetalRun_loop.default(function () {
      container.appendTo('#qunit-fixture');
    });

    equal(container.$().text(), 'This is the main view.', 'should render its child');
    equal(_emberMetalProperty_get.get(container, 'length'), 1, 'should have one child view');
    equal(container.objectAt(0), mainView, 'should have the currentView as the only child view');
    equal(mainView.get('parentView'), container, 'parentView is setup');
  });

  QUnit.test('if a ContainerView starts with no currentView and then one is set, the ContainerView is updated', function () {
    var mainView = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('This is the {{name}} view.')
    });

    var controller = _emberRuntimeControllersController.default.create({
      name: 'main'
    });

    container = _emberViewsViewsContainer_view.default.create({
      controller: controller
    });

    _emberMetalRun_loop.default(function () {
      container.appendTo('#qunit-fixture');
    });

    equal(container.$().text(), '', 'has a empty contents');
    equal(_emberMetalProperty_get.get(container, 'childViews.length'), 0, 'should not have any child views');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(container, 'currentView', mainView);
    });

    equal(container.$().text(), 'This is the main view.', 'should render its child');
    equal(_emberMetalProperty_get.get(container, 'length'), 1, 'should have one child view');
    equal(container.objectAt(0), mainView, 'should have the currentView as the only child view');
    equal(mainView.get('parentView'), container, 'parentView is setup');
  });

  QUnit.test('if a ContainerView starts with a currentView and then is set to null, the ContainerView is updated', function () {
    var mainView = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('This is the main view.')
    });

    var controller = _emberRuntimeControllersController.default.create();

    container = _emberViewsViewsContainer_view.default.create({
      controller: controller
    });

    container.set('currentView', mainView);

    _emberMetalRun_loop.default(function () {
      container.appendTo('#qunit-fixture');
    });

    equal(container.$().text(), 'This is the main view.', 'should render its child');
    equal(_emberMetalProperty_get.get(container, 'length'), 1, 'should have one child view');
    equal(container.objectAt(0), mainView, 'should have the currentView as the only child view');
    equal(mainView.get('parentView'), container, 'parentView is setup');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(container, 'currentView', null);
    });

    equal(container.$().text(), '', 'has a empty contents');
    equal(_emberMetalProperty_get.get(container, 'childViews.length'), 0, 'should not have any child views');
  });

  QUnit.test('if a ContainerView starts with a currentView and then is set to null, the ContainerView is updated and the previous currentView is destroyed', function () {
    var mainView = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('This is the main view.')
    });

    var controller = _emberRuntimeControllersController.default.create();

    container = _emberViewsViewsContainer_view.default.create({
      controller: controller
    });

    container.set('currentView', mainView);

    _emberMetalRun_loop.default(function () {
      container.appendTo('#qunit-fixture');
    });

    equal(container.$().text(), 'This is the main view.', 'should render its child');
    equal(_emberMetalProperty_get.get(container, 'length'), 1, 'should have one child view');
    equal(container.objectAt(0), mainView, 'should have the currentView as the only child view');
    equal(mainView.get('parentView'), container, 'parentView is setup');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(container, 'currentView', null);
    });

    equal(mainView.isDestroyed, true, 'should destroy the previous currentView.');

    equal(container.$().text(), '', 'has a empty contents');
    equal(_emberMetalProperty_get.get(container, 'childViews.length'), 0, 'should not have any child views');
  });

  QUnit.test('if a ContainerView starts with a currentView and then a different currentView is set, the old view is destroyed and the new one is added', function () {
    container = _emberViewsViewsContainer_view.default.create();
    var mainView = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('This is the main view.')
    });

    var secondaryView = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('This is the secondary view.')
    });

    var tertiaryView = _emberViewsViewsView.default.create({
      template: _emberTemplateCompilerSystemCompile.default('This is the tertiary view.')
    });

    container.set('currentView', mainView);

    _emberMetalRun_loop.default(function () {
      container.appendTo('#qunit-fixture');
    });

    equal(container.$().text(), 'This is the main view.', 'should render its child');
    equal(_emberMetalProperty_get.get(container, 'length'), 1, 'should have one child view');
    equal(container.objectAt(0), mainView, 'should have the currentView as the only child view');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(container, 'currentView', secondaryView);
    });

    equal(_emberMetalProperty_get.get(container, 'length'), 1, 'should have one child view');
    equal(container.objectAt(0), secondaryView, 'should have the currentView as the only child view');
    equal(mainView.isDestroyed, true, 'should destroy the previous currentView: mainView.');

    equal(trim(container.$().text()), 'This is the secondary view.', 'should render its child');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(container, 'currentView', tertiaryView);
    });

    equal(_emberMetalProperty_get.get(container, 'length'), 1, 'should have one child view');
    equal(container.objectAt(0), tertiaryView, 'should have the currentView as the only child view');
    equal(secondaryView.isDestroyed, true, 'should destroy the previous currentView: secondaryView.');

    equal(trim(container.$().text()), 'This is the tertiary view.', 'should render its child');
  });

  var child, count;
  QUnit.module('Ember.ContainerView - modify childViews', {
    setup: function () {
      originalViewKeyword = _emberHtmlbarsTestsUtils.registerKeyword('view', _emberHtmlbarsKeywordsView.default);
      registry = new _containerRegistry.default();
      container = _emberViewsViewsContainer_view.default.create({
        _viewRegistry: {}
      });

      _emberMetalRun_loop.default(function () {
        container.appendTo('#qunit-fixture');
      });

      count = 0;
      child = _emberViewsViewsView.default.create({
        template: function () {
          count++;
          return 'child';
        }
      });
    },
    teardown: function () {
      _emberMetalRun_loop.default(function () {
        container.destroy();
        if (view) {
          view.destroy();
        }
        if (child) {
          child.destroy();
        }
        if (otherContainer) {
          otherContainer.destroy();
        }
      });
    }
  });
  QUnit.test('should be able to modify childViews then rerender the ContainerView in same run loop', function () {
    container = _emberViewsViewsContainer_view.default.create({});

    _emberMetalRun_loop.default(function () {
      container.appendTo('#qunit-fixture');
    });

    var child = _emberViewsViewsView.default.create({
      _viewRegistry: {},
      template: _emberTemplateCompilerSystemCompile.default('child')
    });

    _emberMetalRun_loop.default(function () {
      container.pushObject(child);
      container.rerender();
    });

    equal(trim(container.$().text()), 'child');
  });

  QUnit.test('should be able to modify childViews then rerender then modify again the ContainerView in same run loop', function () {
    container = _emberViewsViewsContainer_view.default.create();

    _emberMetalRun_loop.default(function () {
      container.appendTo('#qunit-fixture');
    });

    var Child = _emberViewsViewsView.default.extend({
      count: 0,
      _willRender: function () {
        this.count++;
      },
      template: _emberTemplateCompilerSystemCompile.default('{{view.label}}')
    });

    var one = Child.create({ label: 'one' });
    var two = Child.create({ label: 'two' });

    _emberMetalRun_loop.default(function () {
      container.pushObject(one);
      container.pushObject(two);
    });

    equal(one.count, 1, 'rendered one.count child only once');
    equal(two.count, 1, 'rendered two.count child only once');
    // Remove whitespace added by IE 8
    equal(trim(container.$().text()), 'onetwo');
  });

  QUnit.test('should be able to modify childViews then rerender again the ContainerView in same run loop and then modify again', function () {
    container = _emberViewsViewsContainer_view.default.create();

    _emberMetalRun_loop.default(function () {
      container.appendTo('#qunit-fixture');
    });

    var Child = _emberViewsViewsView.default.extend({
      count: 0,
      _willRender: function () {
        this.count++;
      },
      template: _emberTemplateCompilerSystemCompile.default('{{view.label}}')
    });

    var one = Child.create({ label: 'one' });
    var two = Child.create({ label: 'two' });

    _emberMetalRun_loop.default(function () {
      container.pushObject(one);
      container.rerender();
    });

    equal(one.count, 1, 'rendered one child only once');
    equal(container.$().text(), 'one');

    _emberMetalRun_loop.default(function () {
      container.pushObject(two);
    });

    equal(one.count, 1, 'rendered one child only once');
    equal(two.count, 1, 'rendered two child only once');

    // IE 8 adds a line break but this shouldn't affect validity
    equal(trim(container.$().text()), 'onetwo');
  });

  QUnit.test('should invalidate `element` on itself and childViews when being rendered by ensureChildrenAreInDOM', function () {
    expectDeprecation('Setting `childViews` on a Container is deprecated.');

    var root = _emberViewsViewsContainer_view.default.create();

    view = _emberViewsViewsView.default.create({ template: _emberTemplateCompilerSystemCompile.default('child view') });
    container = _emberViewsViewsContainer_view.default.create({ childViews: ['child'], child: view });

    _emberMetalRun_loop.default(function () {
      root.appendTo('#qunit-fixture');
    });

    _emberMetalRun_loop.default(function () {
      root.pushObject(container);

      // Get the parent and child's elements to cause them to be cached as null
      container.get('element');
      view.get('element');
    });

    ok(!!container.get('element'), 'Parent\'s element should have been recomputed after being rendered');
    ok(!!view.get('element'), 'Child\'s element should have been recomputed after being rendered');

    _emberMetalRun_loop.default(function () {
      root.destroy();
    });
  });

  QUnit.test('Child view can only be added to one container at a time', function () {
    expect(2);

    container = _emberViewsViewsContainer_view.default.create();
    var secondContainer = _emberViewsViewsContainer_view.default.create();

    _emberMetalRun_loop.default(function () {
      container.appendTo('#qunit-fixture');
    });

    var view = _emberViewsViewsView.default.create();

    _emberMetalRun_loop.default(function () {
      container.set('currentView', view);
    });

    expectAssertion(function () {
      _emberMetalRun_loop.default(function () {
        secondContainer.set('currentView', view);
      });
    });

    expectAssertion(function () {
      _emberMetalRun_loop.default(function () {
        secondContainer.pushObject(view);
      });
    });

    _emberMetalRun_loop.default(function () {
      secondContainer.destroy();
    });
  });

  QUnit.test('if a containerView appends a child in its didInsertElement event, the didInsertElement event of the child view should be fired once', function (assert) {

    var counter = 0;
    var root = _emberViewsViewsContainer_view.default.create({});

    container = _emberViewsViewsContainer_view.default.create({

      didInsertElement: function () {

        var view = _emberViewsViewsContainer_view.default.create({
          didInsertElement: function () {
            counter++;
          }
        });

        this.pushObject(view);
      }

    });

    _emberMetalRun_loop.default(function () {
      root.appendTo('#qunit-fixture');
    });

    expectDeprecation(function () {
      _emberMetalRun_loop.default(function () {
        root.pushObject(container);
      });
    }, /was modified inside the didInsertElement hook/);

    assert.strictEqual(counter, 1, 'child didInsertElement was invoked');

    _emberMetalRun_loop.default(function () {
      root.destroy();
    });
  });

  QUnit.test('ContainerView is observable [DEPRECATED]', function () {
    container = _emberViewsViewsContainer_view.default.create();
    var observerFired = false;
    expectDeprecation(function () {
      container.addObserver('this.[]', function () {
        observerFired = true;
      });
    }, /ContainerViews should not be observed as arrays. This behavior will change in future implementations of ContainerView./);

    ok(!observerFired, 'Nothing changed, no observer fired');

    container.pushObject(_emberViewsViewsView.default.create());
    ok(observerFired, 'View pushed, observer fired');
  });

  QUnit.test('ContainerView supports bound attributes', function () {
    container = _emberViewsViewsContainer_view.default.create({
      attributeBindings: ['width'],
      width: '100px'
    });

    _emberMetalRun_loop.default(function () {
      container.appendTo('#qunit-fixture');
    });

    equal(container.$().attr('width'), '100px', 'width is applied to the element');

    _emberMetalRun_loop.default(function () {
      container.set('width', '200px');
    });

    equal(container.$().attr('width'), '200px', 'width is applied to the element');
  });

  QUnit.test('ContainerView supports bound style attribute', function () {
    container = _emberViewsViewsContainer_view.default.create({
      attributeBindings: ['style'],
      style: 'width: 100px;'
    });

    _emberMetalRun_loop.default(function () {
      container.appendTo('#qunit-fixture');
    });

    equal(_emberViewsTestsTestHelpersGetElementStyle.default(container.element), 'WIDTH: 100PX;', 'width is applied to the element');

    _emberMetalRun_loop.default(function () {
      container.set('style', 'width: 200px;');
    });

    equal(_emberViewsTestsTestHelpersGetElementStyle.default(container.element), 'WIDTH: 200PX;', 'width is applied to the element');
  });

  QUnit.test('ContainerView supports changing children with style attribute', function () {
    container = _emberViewsViewsContainer_view.default.create({
      attributeBindings: ['style'],
      style: 'width: 100px;'
    });

    _emberMetalRun_loop.default(function () {
      container.appendTo('#qunit-fixture');
    });

    equal(_emberViewsTestsTestHelpersGetElementStyle.default(container.element), 'WIDTH: 100PX;', 'width is applied to the element');

    view = _emberViewsViewsView.default.create();

    _emberMetalRun_loop.default(function () {
      container.pushObject(view);
    });
  });

  QUnit.test('should render child views with a different tagName', function () {
    expectDeprecation('Setting `childViews` on a Container is deprecated.');

    container = _emberViewsViewsContainer_view.default.create({
      childViews: ['child'],

      child: _emberViewsViewsView.default.create({
        tagName: 'aside'
      })
    });

    _emberMetalRun_loop.default(function () {
      container.createElement();
    });

    equal(container.$('aside').length, 1);
  });

  QUnit.test('should allow hX tags as tagName', function () {
    expectDeprecation('Setting `childViews` on a Container is deprecated.');

    container = _emberViewsViewsContainer_view.default.create({
      childViews: ['child'],

      child: _emberViewsViewsView.default.create({
        tagName: 'h3'
      })
    });

    _emberMetalRun_loop.default(function () {
      container.createElement();
    });

    ok(container.$('h3').length, 'does not render the h3 tag correctly');
  });

  QUnit.test('renders contained view with omitted start tag and parent view context', function () {
    expectDeprecation('Setting `childViews` on a Container is deprecated.');

    view = _emberViewsViewsContainer_view.default.extend({
      tagName: 'table',
      childViews: ['row'],
      row: _emberViewsViewsView.default.create({
        tagName: 'tr'
      })
    }).create();

    _emberMetalRun_loop.default(view, view.append);

    equal(view.element.tagName, 'TABLE', 'container view is table');
    equal(view.element.childNodes[2].tagName, 'TR', 'inner view is tr');

    _emberMetalRun_loop.default(view, view.rerender);

    equal(view.element.tagName, 'TABLE', 'container view is table');
    equal(view.element.childNodes[2].tagName, 'TR', 'inner view is tr');
  });

  QUnit.module('DeprecatedContainerView');

  QUnit.test('calling reopen on DeprecatedContainerView delegates to ContainerView', function () {
    expect(2);
    var originalReopen = _emberViewsViewsContainer_view.default.reopen;
    var obj = {};

    _emberViewsViewsContainer_view.default.reopen = function (arg) {
      ok(arg === obj);
    };

    expectNoDeprecation();
    _emberViewsViewsContainer_view.DeprecatedContainerView.reopen(obj);

    _emberViewsViewsContainer_view.default.reopen = originalReopen;
  });
});
enifed('ember-views/tests/views/container_view_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/tests/views');
  test('ember-views/tests/views/container_view_test.js should pass jscs', function () {
    ok(true, 'ember-views/tests/views/container_view_test.js should pass jscs.');
  });
});
enifed('ember-views/tests/views/container_view_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/tests/views');
  QUnit.test('ember-views/tests/views/container_view_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/tests/views/container_view_test.js should pass jshint.');
  });
});
enifed('ember-views/tests/views/instrumentation_test', ['exports', 'ember-metal/instrumentation', 'ember-metal/run_loop', 'ember-views/views/view'], function (exports, _emberMetalInstrumentation, _emberMetalRun_loop, _emberViewsViewsView) {
  'use strict';

  var view, beforeCalls, afterCalls;

  function confirmPayload(payload, view) {
    equal(payload && payload.object, view.toString(), 'payload object equals view.toString()');
    equal(payload && payload.containerKey, view._debugContainerKey, 'payload contains the containerKey');
    equal(payload && payload.view, view, 'payload contains the view itself');
  }

  QUnit.module('EmberView#instrumentation', {
    setup: function () {
      beforeCalls = [];
      afterCalls = [];

      _emberMetalInstrumentation.subscribe('render', {
        before: function (name, timestamp, payload) {
          beforeCalls.push(payload);
        },

        after: function (name, timestamp, payload) {
          afterCalls.push(payload);
        }
      });

      view = _emberViewsViewsView.default.create({
        _debugContainerKey: 'suchryzsd',
        instrumentDisplay: 'asdfasdfmewj'
      });
    },

    teardown: function () {
      if (view) {
        _emberMetalRun_loop.default(view, 'destroy');
      }

      _emberMetalInstrumentation.reset();
    }
  });

  QUnit.test('generates the proper instrumentation details when called directly', function () {
    var payload = {};

    view.instrumentDetails(payload);

    confirmPayload(payload, view);
  });

  QUnit.test('should add ember-view to views', function () {
    _emberMetalRun_loop.default(view, 'createElement');

    confirmPayload(beforeCalls[0], view);
  });
});
enifed('ember-views/tests/views/instrumentation_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/tests/views');
  test('ember-views/tests/views/instrumentation_test.js should pass jscs', function () {
    ok(true, 'ember-views/tests/views/instrumentation_test.js should pass jscs.');
  });
});
enifed('ember-views/tests/views/instrumentation_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/tests/views');
  QUnit.test('ember-views/tests/views/instrumentation_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/tests/views/instrumentation_test.js should pass jshint.');
  });
});
enifed('ember-views/tests/views/select_test', ['exports', 'ember-metal/core', 'ember-metal/run_loop', 'ember-runtime/system/object', 'ember-views/views/select', 'ember-views/system/jquery', 'ember-views/system/event_dispatcher', 'htmlbars-util/safe-string', 'ember-htmlbars/tests/utils', 'ember-htmlbars/keywords/view'], function (exports, _emberMetalCore, _emberMetalRun_loop, _emberRuntimeSystemObject, _emberViewsViewsSelect, _emberViewsSystemJquery, _emberViewsSystemEvent_dispatcher, _htmlbarsUtilSafeString, _emberHtmlbarsTestsUtils, _emberHtmlbarsKeywordsView) {
  'use strict';

  var trim = _emberViewsSystemJquery.default.trim;

  var dispatcher, select;
  var originalViewKeyword;

  QUnit.module('Ember.Select [LEGACY]', {
    setup: function () {
      originalViewKeyword = _emberHtmlbarsTestsUtils.registerKeyword('view', _emberHtmlbarsKeywordsView.default);
      dispatcher = _emberViewsSystemEvent_dispatcher.default.create();
      dispatcher.setup();
      select = _emberViewsViewsSelect.default.create();
    },

    teardown: function () {
      _emberMetalRun_loop.default(function () {
        dispatcher.destroy();
        select.destroy();
      });
      _emberHtmlbarsTestsUtils.resetKeyword('view', originalViewKeyword);
    }
  });

  function append() {
    _emberMetalRun_loop.default(function () {
      select.appendTo('#qunit-fixture');
    });
  }

  function selectedOptions() {
    return select.get('childViews').mapBy('selected');
  }

  QUnit.test('has \'ember-view\' and \'ember-select\' CSS classes', function () {
    deepEqual(select.get('classNames'), ['ember-view', 'ember-select']);
  });

  QUnit.test('should render', function () {
    append();

    ok(select.$().length, 'Select renders');
  });

  QUnit.test('should begin disabled if the disabled attribute is true', function () {
    select.set('disabled', true);
    append();

    ok(select.$().is(':disabled'));
  });

  // Browsers before IE10 do not support the required property.
  if (document && 'required' in document.createElement('input')) {
    QUnit.test('should begin required if the required attribute is true', function () {
      select.set('required', true);
      append();

      ok(select.element.required, 'required property is truthy');
    });

    QUnit.test('should become required if the required attribute is changed', function () {
      append();
      ok(!select.element.required, 'required property is falsy');

      _emberMetalRun_loop.default(function () {
        select.set('required', true);
      });
      ok(select.element.required, 'required property is truthy');

      _emberMetalRun_loop.default(function () {
        select.set('required', false);
      });
      ok(!select.element.required, 'required property is falsy');
    });
  }

  QUnit.test('should become disabled if the disabled attribute is changed', function () {
    append();
    ok(!select.element.disabled, 'disabled property is falsy');

    _emberMetalRun_loop.default(function () {
      select.set('disabled', true);
    });
    ok(select.element.disabled, 'disabled property is truthy');

    _emberMetalRun_loop.default(function () {
      select.set('disabled', false);
    });
    ok(!select.element.disabled, 'disabled property is falsy');
  });

  QUnit.test('can have options', function () {
    select.set('content', _emberMetalCore.default.A([1, 2, 3]));

    append();

    equal(select.$('option').length, 3, 'Should have three options');
    // IE 8 adds whitespace
    equal(trim(select.$().text()), '123', 'Options should have content');
  });

  QUnit.test('select tabindex is updated when setting tabindex property of view', function () {
    _emberMetalRun_loop.default(function () {
      select.set('tabindex', '4');
    });
    append();

    equal(select.$().attr('tabindex'), '4', 'renders select with the tabindex');

    _emberMetalRun_loop.default(function () {
      select.set('tabindex', '1');
    });

    equal(select.$().attr('tabindex'), '1', 'updates select after tabindex changes');
  });

  QUnit.test('select name is updated when setting name property of view', function () {
    _emberMetalRun_loop.default(function () {
      select.set('name', 'foo');
    });
    append();

    equal(select.$().attr('name'), 'foo', 'renders select with the name');

    _emberMetalRun_loop.default(function () {
      select.set('name', 'bar');
    });

    equal(select.$().attr('name'), 'bar', 'updates select after name changes');
  });

  QUnit.test('can specify the property path for an option\'s label and value', function () {
    select.set('content', _emberMetalCore.default.A([{ id: 1, firstName: 'Yehuda' }, { id: 2, firstName: 'Tom' }]));

    select.set('optionLabelPath', 'content.firstName');
    select.set('optionValuePath', 'content.id');

    append();

    equal(select.$('option').length, 2, 'Should have two options');
    // IE 8 adds whitespace
    equal(trim(select.$().text()), 'YehudaTom', 'Options should have content');
    deepEqual(select.$('option').toArray().map(function (el) {
      return _emberViewsSystemJquery.default(el).attr('value');
    }), ['1', '2'], 'Options should have values');
  });

  QUnit.test('XSS: does not escape label value when it is a SafeString', function () {
    select.set('content', _emberMetalCore.default.A([{ id: 1, firstName: new _htmlbarsUtilSafeString.default('<p>Yehuda</p>') }, { id: 2, firstName: new _htmlbarsUtilSafeString.default('<p>Tom</p>') }]));

    select.set('optionLabelPath', 'content.firstName');
    select.set('optionValuePath', 'content.id');

    append();

    equal(select.$('option').length, 2, 'Should have two options');
    equal(select.$('option[value=1] p').length, 1, 'Should have child elements');

    // IE 8 adds whitespace
    equal(trim(select.$().text()), 'YehudaTom', 'Options should have content');
    deepEqual(select.$('option').toArray().map(function (el) {
      return _emberViewsSystemJquery.default(el).attr('value');
    }), ['1', '2'], 'Options should have values');
  });

  QUnit.test('XSS: escapes label value content', function () {
    select.set('content', _emberMetalCore.default.A([{ id: 1, firstName: '<p>Yehuda</p>' }, { id: 2, firstName: '<p>Tom</p>' }]));

    select.set('optionLabelPath', 'content.firstName');
    select.set('optionValuePath', 'content.id');

    append();

    equal(select.$('option').length, 2, 'Should have two options');
    equal(select.$('option[value=1] b').length, 0, 'Should have no child elements');

    // IE 8 adds whitespace
    equal(trim(select.$().text()), '<p>Yehuda</p><p>Tom</p>', 'Options should have content');
    deepEqual(select.$('option').toArray().map(function (el) {
      return _emberViewsSystemJquery.default(el).attr('value');
    }), ['1', '2'], 'Options should have values');
  });

  QUnit.test('can retrieve the current selected option when multiple=false', function () {
    var yehuda = { id: 1, firstName: 'Yehuda' };
    var tom = { id: 2, firstName: 'Tom' };

    select.set('content', _emberMetalCore.default.A([yehuda, tom]));

    append();

    equal(select.get('selection'), yehuda, 'By default, the first option is selected');

    select.$()[0].selectedIndex = 1; // select Tom
    select.$().trigger('change');

    equal(select.get('selection'), tom, 'On change, the new option should be selected');
  });

  QUnit.test('can retrieve the current selected options when multiple=true', function () {
    var yehuda = { id: 1, firstName: 'Yehuda' };
    var tom = { id: 2, firstName: 'Tom' };
    var david = { id: 3, firstName: 'David' };
    var brennain = { id: 4, firstName: 'Brennain' };

    select.set('content', _emberMetalCore.default.A([yehuda, tom, david, brennain]));
    select.set('multiple', true);
    select.set('optionLabelPath', 'content.firstName');
    select.set('optionValuePath', 'content.firstName');

    append();

    deepEqual(select.get('selection'), [], 'By default, nothing is selected');

    select.$('option').each(function () {
      if (this.value === 'Tom' || this.value === 'David') {
        this.selected = true;
      }
    });

    select.$().trigger('change');

    deepEqual(select.get('selection'), [tom, david], 'On change, the new options should be selected');
  });

  QUnit.test('selection can be set when multiple=false', function () {
    var yehuda = { id: 1, firstName: 'Yehuda' };
    var tom = { id: 2, firstName: 'Tom' };

    _emberMetalRun_loop.default(function () {
      select.set('content', _emberMetalCore.default.A([yehuda, tom]));
      select.set('multiple', false);
      select.set('selection', tom);
    });

    append();

    equal(select.get('selection'), tom, 'Initial selection should be correct');

    _emberMetalRun_loop.default(function () {
      select.set('selection', yehuda);
    });

    equal(select.$()[0].selectedIndex, 0, 'After changing it, selection should be correct');
  });

  QUnit.test('selection can be set from a Promise when multiple=false', function () {
    expect(1);

    var yehuda = { id: 1, firstName: 'Yehuda' };
    var tom = { id: 2, firstName: 'Tom' };

    _emberMetalRun_loop.default(function () {
      select.set('content', _emberMetalCore.default.A([yehuda, tom]));
      select.set('multiple', false);
      select.set('selection', _emberMetalCore.default.RSVP.Promise.resolve(tom));
    });

    append();

    equal(select.$()[0].selectedIndex, 1, 'Should select from Promise content');
  });

  QUnit.test('selection from a Promise don\'t overwrite newer selection once resolved, when multiple=false', function () {
    expect(1);

    var yehuda = { id: 1, firstName: 'Yehuda' };
    var tom = { id: 2, firstName: 'Tom' };
    var seb = { id: 3, firstName: 'Seb' };

    QUnit.stop();

    _emberMetalRun_loop.default(function () {
      select.set('content', _emberMetalCore.default.A([yehuda, tom, seb]));
      select.set('multiple', false);
      select.set('selection', new _emberMetalCore.default.RSVP.Promise(function (resolve, reject) {
        _emberMetalCore.default.run.later(function () {
          _emberMetalRun_loop.default(function () {
            resolve(tom);
          });
          QUnit.start();
          equal(select.$()[0].selectedIndex, 2, 'Should not select from Promise if newer selection');
        }, 40);
      }));
      select.set('selection', new _emberMetalCore.default.RSVP.Promise(function (resolve, reject) {
        _emberMetalCore.default.run.later(function () {
          _emberMetalRun_loop.default(function () {
            resolve(seb);
          });
        }, 30);
      }));
    });

    append();
  });

  QUnit.test('selection from a Promise resolving to null should not select when multiple=false', function () {
    expect(1);

    var yehuda = { id: 1, firstName: 'Yehuda' };
    var tom = { id: 2, firstName: 'Tom' };

    _emberMetalRun_loop.default(function () {
      select.set('content', _emberMetalCore.default.A([yehuda, tom]));
      select.set('multiple', false);
      select.set('selection', _emberMetalCore.default.RSVP.Promise.resolve(null));
    });

    append();

    equal(select.$()[0].selectedIndex, -1, 'Should not select any object when the Promise resolve to null');
  });

  QUnit.test('selection can be set when multiple=true', function () {
    var yehuda = { id: 1, firstName: 'Yehuda' };
    var tom = { id: 2, firstName: 'Tom' };
    var david = { id: 3, firstName: 'David' };
    var brennain = { id: 4, firstName: 'Brennain' };

    _emberMetalRun_loop.default(function () {
      select.set('content', _emberMetalCore.default.A([yehuda, tom, david, brennain]));
      select.set('multiple', true);
      select.set('selection', tom);
    });

    append();

    deepEqual(select.get('selection'), [tom], 'Initial selection should be correct');

    _emberMetalRun_loop.default(function () {
      return select.set('selection', yehuda);
    });

    deepEqual(select.get('selection'), [yehuda], 'After changing it, selection should be correct');
  });

  QUnit.test('selection can be set when multiple=true and prompt', function () {
    var yehuda = { id: 1, firstName: 'Yehuda' };
    var tom = { id: 2, firstName: 'Tom' };
    var david = { id: 3, firstName: 'David' };
    var brennain = { id: 4, firstName: 'Brennain' };

    _emberMetalRun_loop.default(function () {
      select.set('content', _emberMetalCore.default.A([yehuda, tom, david, brennain]));
      select.set('multiple', true);
      select.set('prompt', 'Pick one!');
      select.set('selection', tom);
    });

    append();

    deepEqual(select.get('selection'), [tom], 'Initial selection should be correct');

    _emberMetalRun_loop.default(function () {
      select.set('selection', yehuda);
    });

    deepEqual(select.get('selection'), [yehuda], 'After changing it, selection should be correct');
  });

  QUnit.test('multiple selections can be set when multiple=true', function () {
    var yehuda = { id: 1, firstName: 'Yehuda' };
    var tom = { id: 2, firstName: 'Tom' };
    var david = { id: 3, firstName: 'David' };
    var brennain = { id: 4, firstName: 'Brennain' };

    _emberMetalRun_loop.default(function () {
      select.set('content', _emberMetalCore.default.A([yehuda, tom, david, brennain]));
      select.set('optionLabelPath', 'content.firstName');
      select.set('multiple', true);

      select.set('selection', _emberMetalCore.default.A([yehuda, david]));
    });

    append();

    deepEqual(select.get('selection'), [yehuda, david], 'Initial selection should be correct');

    _emberMetalRun_loop.default(function () {
      return select.set('selection', _emberMetalCore.default.A([tom, brennain]));
    });

    deepEqual(select.$(':selected').map(function (index, element) {
      return trim(_emberViewsSystemJquery.default(element).text());
    }).toArray(), ['Tom', 'Brennain'], 'After changing it, selection should be correct');
  });

  QUnit.test('multiple selections can be set by changing in place the selection array when multiple=true', function () {
    var yehuda = { id: 1, firstName: 'Yehuda' };
    var tom = { id: 2, firstName: 'Tom' };
    var david = { id: 3, firstName: 'David' };
    var brennain = { id: 4, firstName: 'Brennain' };
    var selection = _emberMetalCore.default.A([yehuda, tom]);

    _emberMetalRun_loop.default(function () {
      select.set('content', _emberMetalCore.default.A([yehuda, tom, david, brennain]));
      select.set('optionLabelPath', 'content.firstName');
      select.set('multiple', true);
      select.set('selection', selection);
    });

    append();

    deepEqual(select.get('selection'), [yehuda, tom], 'Initial selection should be correct');

    _emberMetalRun_loop.default(function () {
      selection.replace(0, selection.get('length'), _emberMetalCore.default.A([david, brennain]));
    });

    deepEqual(select.$(':selected').map(function (index, element) {
      return trim(_emberViewsSystemJquery.default(element).text());
    }).toArray(), ['David', 'Brennain'], 'After updating the selection array in-place, selection should be correct');
  });

  QUnit.test('multiple selections can be set indirectly via bindings and in-place when multiple=true (issue #1058)', function () {
    var indirectContent = _emberRuntimeSystemObject.default.create();

    var tom = { id: 2, firstName: 'Tom' };
    var david = { id: 3, firstName: 'David' };
    var brennain = { id: 4, firstName: 'Brennain' };
    var cyril = { id: 5, firstName: 'Cyril' };

    _emberMetalRun_loop.default(function () {
      select.destroy(); // Destroy the existing select

      _emberMetalRun_loop.default(function () {
        select = _emberViewsViewsSelect.default.extend({
          indirectContent: indirectContent,
          contentBinding: 'indirectContent.controller.content',
          selectionBinding: 'indirectContent.controller.selection',
          multiple: true,
          optionLabelPath: 'content.firstName'
        }).create();

        indirectContent.set('controller', _emberRuntimeSystemObject.default.create({
          content: _emberMetalCore.default.A([tom, david, brennain]),
          selection: _emberMetalCore.default.A([david])
        }));
      });

      append();
    });

    deepEqual(select.get('content'), [tom, david, brennain], 'Initial content should be correct');
    deepEqual(select.get('selection'), [david], 'Initial selection should be correct');

    _emberMetalRun_loop.default(function () {
      indirectContent.set('controller.content', _emberMetalCore.default.A([david, cyril]));
      indirectContent.set('controller.selection', _emberMetalCore.default.A([cyril]));
    });

    deepEqual(select.get('content'), [david, cyril], 'After updating bound content, content should be correct');
    deepEqual(select.get('selection'), [cyril], 'After updating bound selection, selection should be correct');
  });

  QUnit.test('select with group can group options', function () {
    var content = _emberMetalCore.default.A([{ firstName: 'Yehuda', organization: 'Tilde' }, { firstName: 'Tom', organization: 'Tilde' }, { firstName: 'Keith', organization: 'Envato' }]);

    _emberMetalRun_loop.default(function () {
      select.set('content', content);
      select.set('optionGroupPath', 'organization');
      select.set('optionLabelPath', 'content.firstName');
    });

    append();

    equal(select.$('optgroup').length, 2);

    var labels = [];
    select.$('optgroup').each(function () {
      labels.push(this.label);
    });
    equal(labels.join(''), ['TildeEnvato']);

    equal(trim(select.$('optgroup').first().text()), 'YehudaTom');
    equal(trim(select.$('optgroup').last().text()), 'Keith');
  });

  QUnit.test('select with group doesn\'t break options', function () {
    var content = _emberMetalCore.default.A([{ id: 1, firstName: 'Yehuda', organization: 'Tilde' }, { id: 2, firstName: 'Tom', organization: 'Tilde' }, { id: 3, firstName: 'Keith', organization: 'Envato' }]);

    _emberMetalRun_loop.default(function () {
      select.set('content', content);
      select.set('optionGroupPath', 'organization');
      select.set('optionLabelPath', 'content.firstName');
      select.set('optionValuePath', 'content.id');
    });

    append();

    equal(select.$('option').length, 3);
    equal(trim(select.$().text()), 'YehudaTomKeith');

    _emberMetalRun_loop.default(function () {
      content.set('firstObject.firstName', 'Peter');
    });
    equal(select.$().text(), 'PeterTomKeith\n');

    select.$('option').get(0).selected = true;
    select.$().trigger('change');
    deepEqual(select.get('selection'), content.get('firstObject'));
  });

  QUnit.test('select with group works for initial value', function () {
    var content = _emberMetalCore.default.A([{ id: 1, firstName: 'Yehuda', organization: 'Tilde' }, { id: 2, firstName: 'Tom', organization: 'Tilde' }, { id: 3, firstName: 'Keith', organization: 'Envato' }]);

    _emberMetalRun_loop.default(function () {
      select.set('content', content);
      select.set('optionGroupPath', 'organization');
      select.set('optionValuePath', 'content.id');
      select.set('value', 2);
    });

    append();

    equal(select.$().val(), 2, 'Initial value is set properly');
  });

  QUnit.test('select with group observes its content', function () {
    var wycats = { firstName: 'Yehuda', organization: 'Tilde' };
    var content = _emberMetalCore.default.A([wycats]);

    _emberMetalRun_loop.default(function () {
      select.set('content', content);
      select.set('optionGroupPath', 'organization');
      select.set('optionLabelPath', 'content.firstName');
    });

    append();

    _emberMetalRun_loop.default(function () {
      content.pushObject({ firstName: 'Keith', organization: 'Envato' });
    });

    equal(select.$('optgroup').length, 2);
    equal(select.$('optgroup[label=Envato]').length, 1);

    _emberMetalRun_loop.default(function () {
      select.set('optionGroupPath', 'firstName');
    });
    var labels = [];
    select.$('optgroup').each(function () {
      labels.push(this.label);
    });
    equal(labels.join(''), 'YehudaKeith');
  });

  QUnit.test('select with group whose content is undefined doesn\'t breaks', function () {

    var content;
    _emberMetalRun_loop.default(function () {
      select.set('content', content);
      select.set('optionGroupPath', 'organization');
      select.set('optionLabelPath', 'content.firstName');
    });

    append();

    equal(select.$('optgroup').length, 0);
  });

  QUnit.test('selection uses the same array when multiple=true', function () {
    var yehuda = { id: 1, firstName: 'Yehuda' };
    var tom = { id: 2, firstName: 'Tom' };
    var david = { id: 3, firstName: 'David' };
    var brennain = { id: 4, firstName: 'Brennain' };
    var selection = _emberMetalCore.default.A([yehuda, david]);

    _emberMetalRun_loop.default(function () {
      select.set('content', _emberMetalCore.default.A([yehuda, tom, david, brennain]));
      select.set('multiple', true);
      select.set('optionLabelPath', 'content.firstName');
      select.set('selection', selection);
    });

    append();

    deepEqual(select.get('selection'), [yehuda, david], 'Initial selection should be correct');

    select.$('option').each(function () {
      this.selected = false;
    });
    select.$(':contains("Tom"), :contains("David")').each(function () {
      this.selected = true;
    });

    select.$().trigger('change');

    deepEqual(select.get('selection'), [tom, david], 'On change the selection is updated');
    deepEqual(selection, [tom, david], 'On change the original selection array is updated');
  });

  QUnit.test('Ember.SelectedOption knows when it is selected when multiple=false', function () {
    var yehuda = { id: 1, firstName: 'Yehuda' };
    var tom = { id: 2, firstName: 'Tom' };
    var david = { id: 3, firstName: 'David' };
    var brennain = { id: 4, firstName: 'Brennain' };

    _emberMetalRun_loop.default(function () {
      select.set('content', _emberMetalCore.default.A([yehuda, tom, david, brennain]));
      select.set('multiple', false);

      select.set('selection', david);
    });

    append();

    deepEqual(selectedOptions(), [false, false, true, false], 'Initial selection should be correct');

    _emberMetalRun_loop.default(function () {
      select.set('selection', brennain);
    });

    deepEqual(selectedOptions(), [false, false, false, true], 'After changing it, selection should be correct');
  });

  QUnit.test('Ember.SelectedOption knows when it is selected when multiple=true', function () {
    var yehuda = { id: 1, firstName: 'Yehuda' };
    var tom = { id: 2, firstName: 'Tom' };
    var david = { id: 3, firstName: 'David' };
    var brennain = { id: 4, firstName: 'Brennain' };

    _emberMetalRun_loop.default(function () {
      select.set('content', _emberMetalCore.default.A([yehuda, tom, david, brennain]));
      select.set('multiple', true);

      select.set('selection', [yehuda, david]);
    });

    append();

    deepEqual(selectedOptions(), [true, false, true, false], 'Initial selection should be correct');

    _emberMetalRun_loop.default(function () {
      select.set('selection', [tom, david]);
    });

    deepEqual(selectedOptions(), [false, true, true, false], 'After changing it, selection should be correct');
  });

  QUnit.test('Ember.SelectedOption knows when it is selected when multiple=true and options are primitives', function () {
    _emberMetalRun_loop.default(function () {
      select.set('content', _emberMetalCore.default.A([1, 2, 3, 4]));
      select.set('multiple', true);
      select.set('selection', [1, 3]);
    });

    append();

    deepEqual(selectedOptions(), [true, false, true, false], 'Initial selection should be correct');

    _emberMetalRun_loop.default(function () {
      select.set('selection', [2, 3]);
    });

    deepEqual(selectedOptions(), [false, true, true, false], 'After changing it, selection should be correct');
  });

  QUnit.test('a prompt can be specified', function () {
    var yehuda = { id: 1, firstName: 'Yehuda' };
    var tom = { id: 2, firstName: 'Tom' };

    _emberMetalRun_loop.default(function () {
      select.set('content', _emberMetalCore.default.A([yehuda, tom]));
      select.set('prompt', 'Pick a person');
      select.set('optionLabelPath', 'content.firstName');
      select.set('optionValuePath', 'content.id');
    });

    append();

    equal(select.$('option').length, 3, 'There should be three options');
    equal(select.$()[0].selectedIndex, 0, 'By default, the prompt is selected in the DOM');
    equal(trim(select.$('option:selected').text()), 'Pick a person', 'By default, the prompt is selected in the DOM');
    equal(select.$().val(), '', 'By default, the prompt has no value');

    equal(select.get('selection'), null, 'When the prompt is selected, the selection should be null');

    _emberMetalRun_loop.default(function () {
      select.set('selection', tom);
    });

    equal(select.$()[0].selectedIndex, 2, 'The selectedIndex accounts for the prompt');

    select.$()[0].selectedIndex = 0;
    select.$().trigger('change');

    equal(select.get('selection'), null, 'When the prompt is selected again after another option, the selection should be null');

    select.$()[0].selectedIndex = 2;
    select.$().trigger('change');
    equal(select.get('selection'), tom, 'Properly accounts for the prompt when DOM change occurs');
  });

  QUnit.test('handles null content', function () {
    append();

    _emberMetalRun_loop.default(function () {
      select.set('content', null);
      select.set('selection', 'invalid');
      select.set('value', 'also_invalid');
    });

    equal(select.get('element').selectedIndex, -1, 'should have no selection');

    _emberMetalRun_loop.default(function () {
      select.set('multiple', true);
      select.set('selection', [{ content: 'invalid' }]);
    });

    equal(select.get('element').selectedIndex, -1, 'should have no selection');
  });

  QUnit.test('valueBinding handles 0 as initiated value (issue #2763)', function () {
    var indirectData = _emberRuntimeSystemObject.default.create({
      value: 0
    });

    _emberMetalRun_loop.default(function () {
      select.destroy(); // Destroy the existing select

      select = _emberViewsViewsSelect.default.extend({
        content: _emberMetalCore.default.A([1, 0]),
        indirectData: indirectData,
        valueBinding: 'indirectData.value'
      }).create();

      // append();
      _emberMetalRun_loop.default(function () {
        select.appendTo('#qunit-fixture');
      });
    });

    equal(select.get('value'), 0, 'Value property should equal 0');
  });

  QUnit.test('should be able to select an option and then reselect the prompt', function () {
    _emberMetalRun_loop.default(function () {
      select.set('content', _emberMetalCore.default.A(['one', 'two', 'three']));
      select.set('prompt', 'Select something');
    });

    append();

    select.$()[0].selectedIndex = 2;
    select.$().trigger('change');
    equal(select.get('selection'), 'two');

    select.$()[0].selectedIndex = 0;
    select.$().trigger('change');
    equal(select.get('selection'), null);
    equal(select.$()[0].selectedIndex, 0);
  });

  QUnit.test('should be able to get the current selection\'s value', function () {
    _emberMetalRun_loop.default(function () {
      select.set('content', _emberMetalCore.default.A([{ label: 'Yehuda Katz', value: 'wycats' }, { label: 'Tom Dale', value: 'tomdale' }, { label: 'Peter Wagenet', value: 'wagenet' }, { label: 'Erik Bryn', value: 'ebryn' }]));
      select.set('optionLabelPath', 'content.label');
      select.set('optionValuePath', 'content.value');
    });

    append();

    equal(select.get('value'), 'wycats');
  });

  QUnit.test('should be able to set the current selection by value', function () {
    var ebryn = { label: 'Erik Bryn', value: 'ebryn' };

    _emberMetalRun_loop.default(function () {
      select.set('content', _emberMetalCore.default.A([{ label: 'Yehuda Katz', value: 'wycats' }, { label: 'Tom Dale', value: 'tomdale' }, { label: 'Peter Wagenet', value: 'wagenet' }, ebryn]));
      select.set('optionLabelPath', 'content.label');
      select.set('optionValuePath', 'content.value');
      select.set('value', 'ebryn');
    });

    append();

    equal(select.get('value'), 'ebryn');
    equal(select.get('selection'), ebryn);
  });
});
enifed('ember-views/tests/views/select_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/tests/views');
  test('ember-views/tests/views/select_test.js should pass jscs', function () {
    ok(true, 'ember-views/tests/views/select_test.js should pass jscs.');
  });
});
enifed('ember-views/tests/views/select_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/tests/views');
  QUnit.test('ember-views/tests/views/select_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/tests/views/select_test.js should pass jshint.');
  });
});
enifed('ember-views/tests/views/text_area_test', ['exports', 'ember-runtime/system/object', 'ember-metal/run_loop', 'ember-views/views/text_area', 'ember-metal/property_get', 'ember-metal/property_set'], function (exports, _emberRuntimeSystemObject, _emberMetalRun_loop, _emberViewsViewsText_area, _emberMetalProperty_get, _emberMetalProperty_set) {
  'use strict';

  var textArea, TestObject;

  function set(object, key, value) {
    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(object, key, value);
    });
  }

  function append() {
    _emberMetalRun_loop.default(function () {
      textArea.appendTo('#qunit-fixture');
    });
  }

  QUnit.module('TextArea', {
    setup: function () {
      TestObject = window.TestObject = _emberRuntimeSystemObject.default.create({
        value: null
      });

      textArea = _emberViewsViewsText_area.default.create();
    },

    teardown: function () {
      _emberMetalRun_loop.default(function () {
        textArea.destroy();
      });

      TestObject = window.TestObject = textArea = null;
    }
  });

  QUnit.test('should become disabled if the disabled attribute is true', function () {
    textArea.set('disabled', true);
    append();

    ok(textArea.$().is(':disabled'));
  });

  QUnit.test('should become disabled if the disabled attribute is true', function () {
    append();
    ok(textArea.$().is(':not(:disabled)'));

    _emberMetalRun_loop.default(function () {
      textArea.set('disabled', true);
    });
    ok(textArea.$().is(':disabled'));

    _emberMetalRun_loop.default(function () {
      textArea.set('disabled', false);
    });
    ok(textArea.$().is(':not(:disabled)'));
  });

  QUnit.test('input value is updated when setting value property of view', function () {
    _emberMetalRun_loop.default(function () {
      set(textArea, 'value', 'foo');
      textArea.append();
    });

    equal(textArea.$().val(), 'foo', 'renders text field with value');

    _emberMetalRun_loop.default(function () {
      set(textArea, 'value', 'bar');
    });

    equal(textArea.$().val(), 'bar', 'updates text field after value changes');
  });

  QUnit.test('input placeholder is updated when setting placeholder property of view', function () {
    _emberMetalRun_loop.default(function () {
      set(textArea, 'placeholder', 'foo');
      textArea.append();
    });

    equal(textArea.$().attr('placeholder'), 'foo', 'renders text area with placeholder');

    _emberMetalRun_loop.default(function () {
      set(textArea, 'placeholder', 'bar');
    });

    equal(textArea.$().attr('placeholder'), 'bar', 'updates text area after placeholder changes');
  });

  QUnit.test('input name is updated when setting name property of view', function () {
    _emberMetalRun_loop.default(function () {
      set(textArea, 'name', 'foo');
      textArea.append();
    });

    equal(textArea.$().attr('name'), 'foo', 'renders text area with name');

    _emberMetalRun_loop.default(function () {
      set(textArea, 'name', 'bar');
    });

    equal(textArea.$().attr('name'), 'bar', 'updates text area after name changes');
  });

  QUnit.test('input maxlength is updated when setting maxlength property of view', function () {
    _emberMetalRun_loop.default(function () {
      set(textArea, 'maxlength', '300');
      textArea.append();
    });

    equal(textArea.$().attr('maxlength'), '300', 'renders text area with maxlength');

    _emberMetalRun_loop.default(function () {
      set(textArea, 'maxlength', '400');
    });

    equal(textArea.$().attr('maxlength'), '400', 'updates text area after maxlength changes');
  });

  QUnit.test('input rows is updated when setting rows property of view', function () {
    _emberMetalRun_loop.default(function () {
      set(textArea, 'rows', '3');
      textArea.append();
    });

    equal(textArea.$().attr('rows'), '3', 'renders text area with rows');

    _emberMetalRun_loop.default(function () {
      set(textArea, 'rows', '4');
    });

    equal(textArea.$().attr('rows'), '4', 'updates text area after rows changes');
  });

  QUnit.test('input cols is updated when setting cols property of view', function () {
    _emberMetalRun_loop.default(function () {
      set(textArea, 'cols', '30');
      textArea.append();
    });

    equal(textArea.$().attr('cols'), '30', 'renders text area with cols');

    _emberMetalRun_loop.default(function () {
      set(textArea, 'cols', '40');
    });

    equal(textArea.$().attr('cols'), '40', 'updates text area after cols changes');
  });

  QUnit.test('input tabindex is updated when setting tabindex property of view', function () {
    _emberMetalRun_loop.default(function () {
      set(textArea, 'tabindex', '4');
      textArea.append();
    });

    equal(textArea.$().attr('tabindex'), '4', 'renders text area with the tabindex');

    _emberMetalRun_loop.default(function () {
      set(textArea, 'tabindex', '1');
    });

    equal(textArea.$().attr('tabindex'), '1', 'updates text area after tabindex changes');
  });

  QUnit.test('input title is updated when setting title property of view', function () {
    _emberMetalRun_loop.default(function () {
      set(textArea, 'title', 'FooTitle');
      textArea.append();
    });
    equal(textArea.$().attr('title'), 'FooTitle', 'renders text area with the title');

    _emberMetalRun_loop.default(function () {
      set(textArea, 'title', 'BarTitle');
    });
    equal(textArea.$().attr('title'), 'BarTitle', 'updates text area after title changes');
  });

  QUnit.test('value binding works properly for inputs that haven\'t been created', function () {
    _emberMetalRun_loop.default(function () {
      textArea.destroy(); // destroy existing textarea
      textArea = _emberViewsViewsText_area.default.create({
        valueBinding: 'TestObject.value'
      });
    });

    equal(_emberMetalProperty_get.get(textArea, 'value'), null, 'precond - default value is null');
    equal(textArea.$(), undefined, 'precond - view doesn\'t have its layer created yet, thus no input element');

    _emberMetalRun_loop.default(function () {
      set(TestObject, 'value', 'ohai');
    });

    equal(_emberMetalProperty_get.get(textArea, 'value'), 'ohai', 'value property was properly updated');

    _emberMetalRun_loop.default(function () {
      textArea.append();
    });

    equal(_emberMetalProperty_get.get(textArea, 'value'), 'ohai', 'value property remains the same once the view has been appended');
    equal(textArea.$().val(), 'ohai', 'value is reflected in the input element once it is created');
  });

  ['cut', 'paste', 'input'].forEach(function (eventName) {
    QUnit.test('should update the value on ' + eventName + ' events', function () {

      _emberMetalRun_loop.default(function () {
        textArea.append();
      });

      textArea.$().val('new value');
      _emberMetalRun_loop.default(function () {
        textArea.trigger(eventName, _emberRuntimeSystemObject.default.create({
          type: eventName
        }));
      });

      equal(textArea.get('value'), 'new value', 'value property updates on ' + eventName + ' events');
    });
  });

  QUnit.test('should call the insertNewline method when return key is pressed', function () {
    var wasCalled;
    var event = _emberRuntimeSystemObject.default.create({
      keyCode: 13
    });

    _emberMetalRun_loop.default(function () {
      textArea.append();
    });

    textArea.insertNewline = function () {
      wasCalled = true;
    };

    textArea.trigger('keyUp', event);
    ok(wasCalled, 'invokes insertNewline method');
  });

  QUnit.test('should call the cancel method when escape key is pressed', function () {
    var wasCalled;
    var event = _emberRuntimeSystemObject.default.create({
      keyCode: 27
    });

    _emberMetalRun_loop.default(function () {
      textArea.append();
    });

    textArea.cancel = function () {
      wasCalled = true;
    };

    textArea.trigger('keyUp', event);
    ok(wasCalled, 'invokes cancel method');
  });
});
enifed('ember-views/tests/views/text_area_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/tests/views');
  test('ember-views/tests/views/text_area_test.js should pass jscs', function () {
    ok(true, 'ember-views/tests/views/text_area_test.js should pass jscs.');
  });
});
enifed('ember-views/tests/views/text_area_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/tests/views');
  QUnit.test('ember-views/tests/views/text_area_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/tests/views/text_area_test.js should pass jshint.');
  });
});
enifed('ember-views/tests/views/text_field_test', ['exports', 'ember-metal/run_loop', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-runtime/system/object', 'ember-views/views/text_field', 'ember-views/system/event_dispatcher', 'ember-views/system/jquery'], function (exports, _emberMetalRun_loop, _emberMetalProperty_get, _emberMetalProperty_set, _emberRuntimeSystemObject, _emberViewsViewsText_field, _emberViewsSystemEvent_dispatcher, _emberViewsSystemJquery) {
  'use strict';

  function K() {
    return this;
  }

  var textField;
  var TestObject;

  var view;

  var appendView = function (view) {
    _emberMetalRun_loop.default(view, 'appendTo', '#qunit-fixture');
  };

  var caretPosition = function (element) {
    var ctrl = element[0];
    var caretPos = 0;

    // IE Support
    if (document.selection) {
      ctrl.focus();
      var selection = document.selection.createRange();

      selection.moveStart('character', -ctrl.value.length);

      caretPos = selection.text.length;
    } else if (ctrl.selectionStart || ctrl.selectionStart === '0') {
      // Firefox support
      caretPos = ctrl.selectionStart;
    }

    return caretPos;
  };

  var setCaretPosition = function (element, pos) {
    var ctrl = element[0];

    if (ctrl.setSelectionRange) {
      ctrl.focus();
      ctrl.setSelectionRange(pos, pos);
    } else if (ctrl.createTextRange) {
      var range = ctrl.createTextRange();
      range.collapse(true);
      range.moveEnd('character', pos);
      range.moveStart('character', pos);
      range.select();
    }
  };

  function set(object, key, value) {
    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(object, key, value);
    });
  }

  function append() {
    _emberMetalRun_loop.default(function () {
      textField.appendTo('#qunit-fixture');
    });
  }

  QUnit.module('Ember.TextField', {
    setup: function () {
      TestObject = window.TestObject = _emberRuntimeSystemObject.default.create({
        value: null
      });

      textField = _emberViewsViewsText_field.default.create();
    },

    teardown: function () {
      _emberMetalRun_loop.default(function () {
        textField.destroy();
      });
      TestObject = window.TestObject = textField = null;
    }
  });

  QUnit.test('should become disabled if the disabled attribute is true before append', function () {
    textField.set('disabled', true);
    append();

    ok(textField.$().is(':disabled'));
  });

  QUnit.test('should become disabled if the disabled attribute is true', function () {
    append();
    ok(textField.$().is(':not(:disabled)'));

    _emberMetalRun_loop.default(function () {
      textField.set('disabled', true);
    });
    ok(textField.$().is(':disabled'));

    _emberMetalRun_loop.default(function () {
      textField.set('disabled', false);
    });
    ok(textField.$().is(':not(:disabled)'));
  });

  QUnit.test('input value is updated when setting value property of view', function () {
    _emberMetalRun_loop.default(function () {
      set(textField, 'value', 'foo');
      textField.append();
    });

    equal(textField.$().val(), 'foo', 'renders text field with value');

    _emberMetalRun_loop.default(function () {
      set(textField, 'value', 'bar');
    });

    equal(textField.$().val(), 'bar', 'updates text field after value changes');
  });

  QUnit.test('input placeholder is updated when setting placeholder property of view', function () {
    _emberMetalRun_loop.default(function () {
      set(textField, 'placeholder', 'foo');
      textField.append();
    });

    equal(textField.$().attr('placeholder'), 'foo', 'renders text field with placeholder');

    _emberMetalRun_loop.default(function () {
      set(textField, 'placeholder', 'bar');
    });

    equal(textField.$().attr('placeholder'), 'bar', 'updates text field after placeholder changes');
  });

  QUnit.test('input name is updated when setting name property of view', function () {
    _emberMetalRun_loop.default(function () {
      set(textField, 'name', 'foo');
      textField.append();
    });

    equal(textField.$().attr('name'), 'foo', 'renders text field with name');

    _emberMetalRun_loop.default(function () {
      set(textField, 'name', 'bar');
    });

    equal(textField.$().attr('name'), 'bar', 'updates text field after name changes');
  });

  QUnit.test('input maxlength is updated when setting maxlength property of view', function () {
    _emberMetalRun_loop.default(function () {
      set(textField, 'maxlength', '30');
      textField.append();
    });

    equal(textField.$().attr('maxlength'), '30', 'renders text field with maxlength');

    _emberMetalRun_loop.default(function () {
      set(textField, 'maxlength', '40');
    });

    equal(textField.$().attr('maxlength'), '40', 'updates text field after maxlength changes');
  });

  QUnit.test('input size is updated when setting size property of view', function () {
    _emberMetalRun_loop.default(function () {
      set(textField, 'size', '30');
      textField.append();
    });

    equal(textField.$().attr('size'), '30', 'renders text field with size');

    _emberMetalRun_loop.default(function () {
      set(textField, 'size', '40');
    });

    equal(textField.$().attr('size'), '40', 'updates text field after size changes');
  });

  QUnit.test('input tabindex is updated when setting tabindex property of view', function () {
    _emberMetalRun_loop.default(function () {
      set(textField, 'tabindex', '5');
      textField.append();
    });

    equal(textField.$().attr('tabindex'), '5', 'renders text field with the tabindex');

    _emberMetalRun_loop.default(function () {
      set(textField, 'tabindex', '3');
    });

    equal(textField.$().attr('tabindex'), '3', 'updates text field after tabindex changes');
  });

  QUnit.test('input title is updated when setting title property of view', function () {
    _emberMetalRun_loop.default(function () {
      set(textField, 'title', 'FooTitle');
      textField.append();
    });

    equal(textField.$().attr('title'), 'FooTitle', 'renders text field with the title');

    _emberMetalRun_loop.default(function () {
      set(textField, 'title', 'BarTitle');
    });

    equal(textField.$().attr('title'), 'BarTitle', 'updates text field after title changes');
  });

  QUnit.test('input type is configurable when creating view', function () {
    _emberMetalRun_loop.default(function () {
      set(textField, 'type', 'password');
      textField.append();
    });

    equal(textField.$().attr('type'), 'password', 'renders text field with type');
  });

  QUnit.test('value binding works properly for inputs that haven\'t been created', function () {

    _emberMetalRun_loop.default(function () {
      textField.destroy(); // destroy existing textField
      textField = _emberViewsViewsText_field.default.create({
        valueBinding: 'TestObject.value'
      });
    });

    equal(_emberMetalProperty_get.get(textField, 'value'), null, 'precond - default value is null');
    equal(textField.$(), undefined, 'precond - view doesn\'t have its layer created yet, thus no input element');

    _emberMetalRun_loop.default(function () {
      set(TestObject, 'value', 'ohai');
    });

    equal(_emberMetalProperty_get.get(textField, 'value'), 'ohai', 'value property was properly updated');

    _emberMetalRun_loop.default(function () {
      textField.append();
    });

    equal(_emberMetalProperty_get.get(textField, 'value'), 'ohai', 'value property remains the same once the view has been appended');
    equal(textField.$().val(), 'ohai', 'value is reflected in the input element once it is created');
  });

  QUnit.test('value binding sets value on the element', function () {
    _emberMetalRun_loop.default(function () {
      textField.destroy(); // destroy existing textField
      textField = _emberViewsViewsText_field.default.create({
        valueBinding: 'TestObject.value'
      });
      textField.append();
    });

    // Set the value via the DOM
    _emberMetalRun_loop.default(function () {
      textField.$().val('via dom');
      // Trigger lets the view know we changed this value (like a real user editing)
      textField.trigger('input', _emberRuntimeSystemObject.default.create({
        type: 'input'
      }));
    });

    equal(_emberMetalProperty_get.get(textField, 'value'), 'via dom', 'value property was properly updated via dom');
    equal(textField.$().val(), 'via dom', 'dom property was properly updated via dom');

    // Now, set it via the binding
    _emberMetalRun_loop.default(function () {
      set(TestObject, 'value', 'via view');
    });

    equal(_emberMetalProperty_get.get(textField, 'value'), 'via view', 'value property was properly updated via view');
    equal(textField.$().val(), 'via view', 'dom property was properly updated via view');
  });

  QUnit.test('should call the insertNewline method when return key is pressed', function () {
    var wasCalled;
    var event = _emberRuntimeSystemObject.default.create({
      keyCode: 13
    });

    _emberMetalRun_loop.default(function () {
      textField.append();
    });

    textField.insertNewline = function () {
      wasCalled = true;
    };

    textField.trigger('keyUp', event);
    ok(wasCalled, 'invokes insertNewline method');
  });

  QUnit.test('should call the cancel method when escape key is pressed', function () {
    var wasCalled;
    var event = _emberRuntimeSystemObject.default.create({
      keyCode: 27
    });

    _emberMetalRun_loop.default(function () {
      textField.append();
    });

    textField.cancel = function () {
      wasCalled = true;
    };

    textField.trigger('keyUp', event);
    ok(wasCalled, 'invokes cancel method');
  });

  QUnit.test('should send an action if one is defined when the return key is pressed', function () {
    expect(2);

    var StubController = _emberRuntimeSystemObject.default.extend({
      send: function (actionName, value, sender) {
        equal(actionName, 'didTriggerAction', 'text field sent correct action name');
        equal(value, 'textFieldValue', 'text field sent its current value as first argument');
      }
    });

    textField.set('action', 'didTriggerAction');
    textField.set('value', 'textFieldValue');
    textField.set('targetObject', StubController.create());

    _emberMetalRun_loop.default(function () {
      textField.append();
    });

    var event = {
      keyCode: 13,
      stopPropagation: K
    };

    textField.trigger('keyUp', event);
  });

  QUnit.test('should send an action on keyPress if one is defined with onEvent=keyPress', function () {
    expect(2);

    var StubController = _emberRuntimeSystemObject.default.extend({
      send: function (actionName, value, sender) {
        equal(actionName, 'didTriggerAction', 'text field sent correct action name');
        equal(value, 'textFieldValue', 'text field sent its current value as first argument');
      }
    });

    textField.set('action', 'didTriggerAction');
    textField.set('onEvent', 'keyPress');
    textField.set('value', 'textFieldValue');
    textField.set('targetObject', StubController.create());

    _emberMetalRun_loop.default(function () {
      textField.append();
    });

    var event = {
      keyCode: 48,
      stopPropagation: K
    };

    textField.trigger('keyPress', event);
  });

  QUnit.test('bubbling of handled actions can be enabled via bubbles property', function () {
    textField.set('bubbles', true);
    textField.set('action', 'didTriggerAction');

    textField.set('controller', _emberRuntimeSystemObject.default.create({
      send: K
    }));

    append();

    var stopPropagationCount = 0;
    var event = {
      keyCode: 13,
      stopPropagation: function () {
        stopPropagationCount++;
      }
    };

    textField.trigger('keyUp', event);
    equal(stopPropagationCount, 0, 'propagation was not prevented if bubbles is true');

    textField.set('bubbles', false);
    textField.trigger('keyUp', event);
    equal(stopPropagationCount, 1, 'propagation was prevented if bubbles is false');
  });

  var dispatcher, StubController;
  QUnit.module('Ember.TextField - Action events', {
    setup: function () {

      dispatcher = _emberViewsSystemEvent_dispatcher.default.create();
      dispatcher.setup();

      StubController = _emberRuntimeSystemObject.default.extend({
        send: function (actionName, value, sender) {
          equal(actionName, 'doSomething', 'text field sent correct action name');
        }
      });
    },

    teardown: function () {
      _emberMetalRun_loop.default(function () {
        dispatcher.destroy();

        if (textField) {
          textField.destroy();
        }

        if (view) {
          view.destroy();
        }
      });
    }
  });

  QUnit.test('when the text field is blurred, the `focus-out` action is sent to the controller', function () {
    expect(1);

    textField = _emberViewsViewsText_field.default.create({
      'focus-out': 'doSomething',
      targetObject: StubController.create({})
    });

    append();

    _emberMetalRun_loop.default(function () {
      textField.$().blur();
    });
  });

  QUnit.test('when the text field is focused, the `focus-in` action is sent to the controller', function () {
    expect(1);

    textField = _emberViewsViewsText_field.default.create({
      'focus-in': 'doSomething',
      targetObject: StubController.create({})
    });

    append();

    _emberMetalRun_loop.default(function () {
      textField.$().focusin();
    });
  });

  QUnit.test('when the user presses a key, the `key-press` action is sent to the controller', function () {
    expect(1);

    textField = _emberViewsViewsText_field.default.create({
      'key-press': 'doSomething',
      targetObject: StubController.create({})
    });

    append();

    _emberMetalRun_loop.default(function () {
      var event = _emberViewsSystemJquery.default.Event('keypress');
      event.keyCode = event.which = 13;
      textField.$().trigger(event);
    });
  });

  QUnit.test('when the user inserts a new line, the `insert-newline` action is sent to the controller', function () {
    expect(1);

    textField = _emberViewsViewsText_field.default.create({
      'insert-newline': 'doSomething',
      targetObject: StubController.create({})
    });

    append();

    _emberMetalRun_loop.default(function () {
      var event = _emberViewsSystemJquery.default.Event('keyup');
      event.keyCode = event.which = 13;
      textField.$().trigger(event);
    });
  });

  QUnit.test('when the user presses the `enter` key, the `enter` action is sent to the controller', function () {
    expect(1);

    textField = _emberViewsViewsText_field.default.create({
      'enter': 'doSomething',
      targetObject: StubController.create({})
    });

    append();

    _emberMetalRun_loop.default(function () {
      var event = _emberViewsSystemJquery.default.Event('keyup');
      event.keyCode = event.which = 13;
      textField.$().trigger(event);
    });
  });

  QUnit.test('when the user hits escape, the `escape-press` action is sent to the controller', function () {
    expect(1);

    textField = _emberViewsViewsText_field.default.create({
      'escape-press': 'doSomething',
      targetObject: StubController.create({})
    });

    append();

    _emberMetalRun_loop.default(function () {
      var event = _emberViewsSystemJquery.default.Event('keyup');
      event.keyCode = event.which = 27;
      textField.$().trigger(event);
    });
  });

  QUnit.test('when the user presses a key, the `key-down` action is sent to the controller', function () {
    expect(3);
    var event;

    textField = _emberViewsViewsText_field.default.create({
      'key-down': 'doSomething',
      targetObject: StubController.create({
        send: function (actionName, value, evt) {
          equal(actionName, 'doSomething', 'text field sent correct action name');
          equal(value, '', 'value was blank in key-down');
          equal(evt, event, 'event was received as param');
        }
      })
    });

    append();

    _emberMetalRun_loop.default(function () {
      event = _emberViewsSystemJquery.default.Event('keydown');
      event.keyCode = event.which = 65;
      textField.$().val('foo');
      textField.$().trigger(event);
    });
  });

  QUnit.test('when the user releases a key, the `key-up` action is sent to the controller', function () {
    expect(3);
    var event;

    textField = _emberViewsViewsText_field.default.create({
      'key-up': 'doSomething',
      targetObject: StubController.create({
        send: function (actionName, value, evt) {
          equal(actionName, 'doSomething', 'text field sent correct action name');
          equal(value, 'bar', 'value was received');
          equal(evt, event, 'event was received as param');
        }
      })
    });

    append();

    _emberMetalRun_loop.default(function () {
      event = _emberViewsSystemJquery.default.Event('keyup');
      event.keyCode = event.which = 65;
      textField.$().val('bar');
      textField.$().trigger(event);
    });
  });

  QUnit.test('should not reset cursor position when text field receives keyUp event', function () {
    view = _emberViewsViewsText_field.default.create({
      value: 'Broseidon, King of the Brocean'
    });

    appendView(view);

    setCaretPosition(view.$(), 5);

    _emberMetalRun_loop.default(function () {
      view.trigger('keyUp', {});
    });

    equal(caretPosition(view.$()), 5, 'The keyUp event should not result in the cursor being reset due to the attribute bindings');
  });

  QUnit.test('an unsupported type defaults to `text`', function () {
    view = _emberViewsViewsText_field.default.create({
      type: 'blahblah'
    });

    equal(_emberMetalProperty_get.get(view, 'type'), 'text', 'should default to text if the type is not a valid type');

    appendView(view);

    equal(view.element.type, 'text');
  });
});
enifed('ember-views/tests/views/text_field_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/tests/views');
  test('ember-views/tests/views/text_field_test.js should pass jscs', function () {
    ok(true, 'ember-views/tests/views/text_field_test.js should pass jscs.');
  });
});
enifed('ember-views/tests/views/text_field_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/tests/views');
  QUnit.test('ember-views/tests/views/text_field_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/tests/views/text_field_test.js should pass jshint.');
  });
});
enifed('ember-views/tests/views/view/actions_test', ['exports', 'ember-metal/run_loop', 'ember-metal/mixin', 'ember-runtime/controllers/controller', 'ember-runtime/system/object', 'ember-views/views/view'], function (exports, _emberMetalRun_loop, _emberMetalMixin, _emberRuntimeControllersController, _emberRuntimeSystemObject, _emberViewsViewsView) {
  'use strict';

  var view;

  QUnit.module('View action handling', {
    teardown: function () {
      _emberMetalRun_loop.default(function () {
        if (view) {
          view.destroy();
        }
      });
    }
  });

  QUnit.test('Action can be handled by a function on actions object', function () {
    expect(1);
    view = _emberViewsViewsView.default.extend({
      actions: {
        poke: function () {
          ok(true, 'poked');
        }
      }
    }).create();
    view.send('poke');
  });

  QUnit.test('A handled action can be bubbled to the target for continued processing', function () {
    expect(2);
    view = _emberViewsViewsView.default.extend({
      actions: {
        poke: function () {
          ok(true, 'poked 1');
          return true;
        }
      },
      target: _emberRuntimeControllersController.default.extend({
        actions: {
          poke: function () {
            ok(true, 'poked 2');
          }
        }
      }).create()
    }).create();
    view.send('poke');
  });

  QUnit.test('Action can be handled by a superclass\' actions object', function () {
    expect(4);

    var SuperView = _emberViewsViewsView.default.extend({
      actions: {
        foo: function () {
          ok(true, 'foo');
        },
        bar: function (msg) {
          equal(msg, 'HELLO');
        }
      }
    });

    var BarViewMixin = _emberMetalMixin.Mixin.create({
      actions: {
        bar: function (msg) {
          equal(msg, 'HELLO');
          this._super(msg);
        }
      }
    });

    var IndexView = SuperView.extend(BarViewMixin, {
      actions: {
        baz: function () {
          ok(true, 'baz');
        }
      }
    });

    view = IndexView.create();
    view.send('foo');
    view.send('bar', 'HELLO');
    view.send('baz');
  });

  QUnit.test('Actions cannot be provided at create time', function () {
    expectAssertion(function () {
      view = _emberViewsViewsView.default.create({
        actions: {
          foo: function () {
            ok(true, 'foo');
          }
        }
      });
    });
    // but should be OK on an object that doesn't mix in Ember.ActionHandler
    _emberRuntimeSystemObject.default.create({
      actions: ['foo']
    });
  });
});
enifed('ember-views/tests/views/view/actions_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/tests/views/view');
  test('ember-views/tests/views/view/actions_test.js should pass jscs', function () {
    ok(true, 'ember-views/tests/views/view/actions_test.js should pass jscs.');
  });
});
enifed('ember-views/tests/views/view/actions_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/tests/views/view');
  QUnit.test('ember-views/tests/views/view/actions_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/tests/views/view/actions_test.js should pass jshint.');
  });
});
enifed('ember-views/tests/views/view/append_to_test', ['exports', 'ember-metal/property_get', 'ember-metal/run_loop', 'ember-views/system/jquery', 'ember-views/views/view', 'ember-views/views/container_view', 'ember-template-compiler/system/compile', 'ember-runtime/tests/utils', 'ember-htmlbars/tests/utils', 'ember-htmlbars/keywords/view'], function (exports, _emberMetalProperty_get, _emberMetalRun_loop, _emberViewsSystemJquery, _emberViewsViewsView, _emberViewsViewsContainer_view, _emberTemplateCompilerSystemCompile, _emberRuntimeTestsUtils, _emberHtmlbarsTestsUtils, _emberHtmlbarsKeywordsView) {
  'use strict';

  var View, view, otherView, willDestroyCalled, childView, originalViewKeyword;

  QUnit.module('EmberView - append() and appendTo()', {
    setup: function () {
      originalViewKeyword = _emberHtmlbarsTestsUtils.registerKeyword('view', _emberHtmlbarsKeywordsView.default);
      View = _emberViewsViewsView.default.extend({});
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(view);
      _emberRuntimeTestsUtils.runDestroy(otherView);
      _emberHtmlbarsTestsUtils.resetKeyword('view', originalViewKeyword);
    }
  });

  QUnit.test('can call `appendTo` for multiple views #11109', function () {
    var elem;
    _emberViewsSystemJquery.default('#qunit-fixture').html('<div id="menu"></div><div id="other-menu"></div>');

    view = View.create();
    otherView = View.create();

    ok(!_emberMetalProperty_get.get(view, 'element'), 'precond - should not have an element');
    ok(!_emberMetalProperty_get.get(otherView, 'element'), 'precond - should not have an element');

    _emberMetalRun_loop.default(function () {
      view.appendTo('#menu');
      otherView.appendTo('#other-menu');
    });

    elem = _emberViewsSystemJquery.default('#menu').children();
    ok(elem.length > 0, 'creates and appends the first view\'s element');

    elem = _emberViewsSystemJquery.default('#other-menu').children();
    ok(elem.length > 0, 'creates and appends the second view\'s element');
  });

  QUnit.test('should be added to the specified element when calling appendTo()', function () {
    _emberViewsSystemJquery.default('#qunit-fixture').html('<div id="menu"></div>');

    view = View.create();

    ok(!_emberMetalProperty_get.get(view, 'element'), 'precond - should not have an element');

    _emberMetalRun_loop.default(function () {
      view.appendTo('#menu');
    });

    var viewElem = _emberViewsSystemJquery.default('#menu').children();
    ok(viewElem.length > 0, 'creates and appends the view\'s element');
  });

  QUnit.test('should be added to the document body when calling append()', function () {
    view = View.create({
      template: _emberTemplateCompilerSystemCompile.default('foo bar baz')
    });

    ok(!_emberMetalProperty_get.get(view, 'element'), 'precond - should not have an element');

    _emberMetalRun_loop.default(function () {
      view.append();
    });

    var viewElem = _emberViewsSystemJquery.default(document.body).find(':contains("foo bar baz")');
    ok(viewElem.length > 0, 'creates and appends the view\'s element');
  });

  QUnit.test('raises an assert when a target does not exist in the DOM', function () {
    view = View.create();

    expectAssertion(function () {
      _emberMetalRun_loop.default(function () {
        view.appendTo('does-not-exist-in-dom');
      });
    });
  });

  QUnit.test('append calls willInsertElement and didInsertElement callbacks', function () {
    var willInsertElementCalled = false;
    var willInsertElementCalledInChild = false;
    var didInsertElementCalled = false;

    var ViewWithCallback = View.extend({
      willInsertElement: function () {
        willInsertElementCalled = true;
      },
      didInsertElement: function () {
        didInsertElementCalled = true;
      },
      childView: _emberViewsViewsView.default.create({
        willInsertElement: function () {
          willInsertElementCalledInChild = true;
        }
      }),
      template: _emberTemplateCompilerSystemCompile.default('{{view view.childView}}')
    });

    view = ViewWithCallback.create();

    _emberMetalRun_loop.default(function () {
      view.append();
    });

    ok(willInsertElementCalled, 'willInsertElement called');
    ok(willInsertElementCalledInChild, 'willInsertElement called in child');
    ok(didInsertElementCalled, 'didInsertElement called');
  });

  QUnit.test('a view calls its children\'s willInsertElement and didInsertElement', function () {
    var parentView;
    var willInsertElementCalled = false;
    var didInsertElementCalled = false;
    var didInsertElementSawElement = false;

    parentView = _emberViewsViewsView.default.create({
      ViewWithCallback: _emberViewsViewsView.default.extend({
        template: _emberTemplateCompilerSystemCompile.default('<div id="do-i-exist"></div>'),

        willInsertElement: function () {
          willInsertElementCalled = true;
        },
        didInsertElement: function () {
          didInsertElementCalled = true;
          didInsertElementSawElement = this.$('div').length === 1;
        }
      }),

      template: _emberTemplateCompilerSystemCompile.default('{{#if view.condition}}{{view view.ViewWithCallback}}{{/if}}'),
      condition: false
    });

    _emberMetalRun_loop.default(function () {
      parentView.append();
    });
    _emberMetalRun_loop.default(function () {
      parentView.set('condition', true);
    });

    ok(willInsertElementCalled, 'willInsertElement called');
    ok(didInsertElementCalled, 'didInsertElement called');
    ok(didInsertElementSawElement, 'didInsertElement saw element');

    _emberMetalRun_loop.default(function () {
      parentView.destroy();
    });
  });

  QUnit.test('replacing a view should invalidate childView elements', function () {
    var elementOnDidInsert;

    view = _emberViewsViewsView.default.create({
      show: false,

      CustomView: _emberViewsViewsView.default.extend({
        init: function () {
          this._super.apply(this, arguments);
          // This will be called in preRender
          // We want it to cache a null value
          // Hopefully it will be invalidated when `show` is toggled
          this.get('element');
        },

        didInsertElement: function () {
          elementOnDidInsert = this.get('element');
        }
      }),

      template: _emberTemplateCompilerSystemCompile.default('{{#if view.show}}{{view view.CustomView}}{{/if}}')
    });

    _emberMetalRun_loop.default(function () {
      view.append();
    });

    _emberMetalRun_loop.default(function () {
      view.set('show', true);
    });

    ok(elementOnDidInsert, 'should have an element on insert');

    _emberMetalRun_loop.default(function () {
      view.destroy();
    });
  });

  QUnit.test('trigger rerender of parent and SimpleBoundView', function () {
    var view = _emberViewsViewsView.default.create({
      show: true,
      foo: 'bar',
      template: _emberTemplateCompilerSystemCompile.default('{{#if view.show}}{{#if view.foo}}{{view.foo}}{{/if}}{{/if}}')
    });

    _emberMetalRun_loop.default(function () {
      view.append();
    });

    equal(view.$().text(), 'bar');

    _emberMetalRun_loop.default(function () {
      view.set('foo', 'baz'); // schedule render of simple bound
      view.set('show', false); // destroy tree
    });

    equal(view.$().text(), '');

    _emberMetalRun_loop.default(function () {
      view.destroy();
    });
  });

  QUnit.test('remove removes an element from the DOM', function () {
    willDestroyCalled = 0;

    view = View.create({
      willDestroyElement: function () {
        willDestroyCalled++;
      }
    });

    ok(!_emberMetalProperty_get.get(view, 'element'), 'precond - should not have an element');

    _emberMetalRun_loop.default(function () {
      view.append();
    });

    ok(_emberViewsSystemJquery.default('#' + _emberMetalProperty_get.get(view, 'elementId')).length === 1, 'precond - element was inserted');

    _emberMetalRun_loop.default(function () {
      view.remove();
    });

    ok(_emberViewsSystemJquery.default('#' + _emberMetalProperty_get.get(view, 'elementId')).length === 0, 'remove removes an element from the DOM');
    ok(_emberViewsViewsView.default.views[_emberMetalProperty_get.get(view, 'elementId')] === undefined, 'remove does not remove the view from the view hash');
    ok(!_emberMetalProperty_get.get(view, 'element'), 'remove nulls out the element');
    equal(willDestroyCalled, 1, 'the willDestroyElement hook was called once');
  });

  QUnit.test('destroy more forcibly removes the view', function () {
    willDestroyCalled = 0;

    view = View.create({
      willDestroyElement: function () {
        willDestroyCalled++;
      }
    });

    ok(!_emberMetalProperty_get.get(view, 'element'), 'precond - should not have an element');

    _emberMetalRun_loop.default(function () {
      view.append();
    });

    ok(_emberViewsSystemJquery.default('#' + _emberMetalProperty_get.get(view, 'elementId')).length === 1, 'precond - element was inserted');

    _emberMetalRun_loop.default(function () {
      view.destroy();
    });

    ok(_emberViewsSystemJquery.default('#' + _emberMetalProperty_get.get(view, 'elementId')).length === 0, 'destroy removes an element from the DOM');
    ok(_emberViewsViewsView.default.views[_emberMetalProperty_get.get(view, 'elementId')] === undefined, 'destroy removes a view from the global views hash');
    equal(_emberMetalProperty_get.get(view, 'isDestroyed'), true, 'the view is marked as destroyed');
    ok(!_emberMetalProperty_get.get(view, 'element'), 'the view no longer has an element');
    equal(willDestroyCalled, 1, 'the willDestroyElement hook was called once');
  });

  QUnit.module('EmberView - append() and appendTo() in a view hierarchy', {
    setup: function () {
      originalViewKeyword = _emberHtmlbarsTestsUtils.registerKeyword('view', _emberHtmlbarsKeywordsView.default);
      expectDeprecation('Setting `childViews` on a Container is deprecated.');

      View = _emberViewsViewsContainer_view.default.extend({
        childViews: ['child'],
        child: _emberViewsViewsView.default.extend({
          elementId: 'child'
        })
      });
    },

    teardown: function () {
      _emberMetalRun_loop.default(function () {
        if (!view.isDestroyed) {
          view.destroy();
        }
      });
      _emberHtmlbarsTestsUtils.resetKeyword('view', originalViewKeyword);
    }
  });

  QUnit.test('should be added to the specified element when calling appendTo()', function () {
    _emberViewsSystemJquery.default('#qunit-fixture').html('<div id="menu"></div>');

    view = View.create();

    ok(!_emberMetalProperty_get.get(view, 'element'), 'precond - should not have an element');

    _emberMetalRun_loop.default(function () {
      view.appendTo('#menu');
    });

    var viewElem = _emberViewsSystemJquery.default('#menu #child');
    ok(viewElem.length > 0, 'creates and appends the view\'s element');
  });

  QUnit.test('should be added to the document body when calling append()', function () {
    _emberViewsSystemJquery.default('#qunit-fixture').html('<div id="menu"></div>');

    view = View.create();

    ok(!_emberMetalProperty_get.get(view, 'element'), 'precond - should not have an element');

    _emberMetalRun_loop.default(function () {
      view.append();
    });

    var viewElem = _emberViewsSystemJquery.default('#child');
    ok(viewElem.length > 0, 'creates and appends the view\'s element');
  });

  QUnit.module('EmberView - removing views in a view hierarchy', {
    setup: function () {
      originalViewKeyword = _emberHtmlbarsTestsUtils.registerKeyword('view', _emberHtmlbarsKeywordsView.default);
      expectDeprecation('Setting `childViews` on a Container is deprecated.');

      willDestroyCalled = 0;

      view = _emberViewsViewsContainer_view.default.create({
        childViews: ['child'],
        child: _emberViewsViewsView.default.create({
          willDestroyElement: function () {
            willDestroyCalled++;
          }
        })
      });

      childView = _emberMetalProperty_get.get(view, 'child');
    },

    teardown: function () {
      _emberMetalRun_loop.default(function () {
        if (!view.isDestroyed) {
          view.destroy();
        }
      });
      _emberHtmlbarsTestsUtils.resetKeyword('view', originalViewKeyword);
    }
  });

  QUnit.test('remove removes child elements from the DOM', function () {
    ok(!_emberMetalProperty_get.get(childView, 'element'), 'precond - should not have an element');

    _emberMetalRun_loop.default(function () {
      view.append();
    });

    ok(_emberViewsSystemJquery.default('#' + _emberMetalProperty_get.get(childView, 'elementId')).length === 1, 'precond - element was inserted');

    // remove parent view
    _emberMetalRun_loop.default(function () {
      view.remove();
    });

    ok(_emberViewsSystemJquery.default('#' + _emberMetalProperty_get.get(childView, 'elementId')).length === 0, 'remove removes child elements the DOM');
    ok(_emberViewsViewsView.default.views[_emberMetalProperty_get.get(childView, 'elementId')] === undefined, 'remove does not remove child views from the view hash');
    ok(!_emberMetalProperty_get.get(childView, 'element'), 'remove nulls out child elements');
    equal(willDestroyCalled, 1, 'the willDestroyElement hook was called once');
  });

  QUnit.test('destroy more forcibly removes child views', function () {
    ok(!_emberMetalProperty_get.get(childView, 'element'), 'precond - should not have an element');

    _emberMetalRun_loop.default(function () {
      view.append();
    });

    ok(_emberViewsSystemJquery.default('#' + _emberMetalProperty_get.get(childView, 'elementId')).length === 1, 'precond - child element was inserted');

    willDestroyCalled = 0;

    _emberMetalRun_loop.default(function () {
      view.destroy();
    });

    ok(_emberViewsSystemJquery.default('#' + _emberMetalProperty_get.get(childView, 'elementId')).length === 0, 'destroy removes child elements from the DOM');
    ok(_emberViewsViewsView.default.views[_emberMetalProperty_get.get(childView, 'elementId')] === undefined, 'destroy removes a child views from the global views hash');
    equal(_emberMetalProperty_get.get(childView, 'isDestroyed'), true, 'child views are marked as destroyed');
    ok(!_emberMetalProperty_get.get(childView, 'element'), 'child views no longer have an element');
    equal(willDestroyCalled, 1, 'the willDestroyElement hook was called once on children');
  });

  QUnit.test('destroy removes a child view from its parent', function () {
    ok(!_emberMetalProperty_get.get(childView, 'element'), 'precond - should not have an element');

    _emberMetalRun_loop.default(function () {
      view.append();
    });

    ok(_emberViewsSystemJquery.default('#' + _emberMetalProperty_get.get(childView, 'elementId')).length === 1, 'precond - child element was inserted');

    _emberMetalRun_loop.default(function () {
      childView.destroy();
    });

    ok(_emberMetalProperty_get.get(view, 'childViews.length') === 0, 'Destroyed child views should be removed from their parent');
  });
});
enifed('ember-views/tests/views/view/append_to_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/tests/views/view');
  test('ember-views/tests/views/view/append_to_test.js should pass jscs', function () {
    ok(true, 'ember-views/tests/views/view/append_to_test.js should pass jscs.');
  });
});
enifed('ember-views/tests/views/view/append_to_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/tests/views/view');
  QUnit.test('ember-views/tests/views/view/append_to_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/tests/views/view/append_to_test.js should pass jshint.');
  });
});
enifed('ember-views/tests/views/view/attribute_bindings_test', ['exports', 'ember-metal/core', 'ember-metal/run_loop', 'ember-metal/observer', 'ember-metal/property_events', 'ember-htmlbars/utils/string', 'ember-views/views/view'], function (exports, _emberMetalCore, _emberMetalRun_loop, _emberMetalObserver, _emberMetalProperty_events, _emberHtmlbarsUtilsString, _emberViewsViewsView) {
  'use strict';

  var originalLookup = _emberMetalCore.default.lookup;
  var lookup, view;

  var appendView = function () {
    _emberMetalRun_loop.default(function () {
      view.appendTo('#qunit-fixture');
    });
  };

  QUnit.module('EmberView - Attribute Bindings', {
    setup: function () {
      _emberMetalCore.default.lookup = lookup = {};
    },
    teardown: function () {
      if (view) {
        _emberMetalRun_loop.default(function () {
          view.destroy();
        });
        view = null;
      }
      _emberMetalCore.default.lookup = originalLookup;
    }
  });

  QUnit.test('should render attribute bindings', function () {
    view = _emberViewsViewsView.default.create({
      attributeBindings: ['type', 'destroyed', 'exists', 'nothing', 'notDefined', 'notNumber', 'explosions'],

      type: 'submit',
      exists: true,
      nothing: null,
      notDefined: undefined
    });

    _emberMetalRun_loop.default(function () {
      view.createElement();
    });

    equal(view.$().attr('type'), 'submit', 'updates type attribute');
    ok(view.$().attr('exists'), 'adds exists attribute when true');
    ok(!view.$().attr('nothing'), 'removes nothing attribute when null');
    equal(view.$().attr('notDefined'), undefined, 'removes notDefined attribute when undefined');
  });

  QUnit.test('should normalize case for attribute bindings', function () {
    view = _emberViewsViewsView.default.create({
      tagName: 'input',
      attributeBindings: ['disAbled'],
      disAbled: true
    });

    _emberMetalRun_loop.default(function () {
      view.createElement();
    });

    ok(view.$().prop('disabled'), 'sets property with correct case');
  });

  QUnit.test('should render attribute bindings on input', function () {
    view = _emberViewsViewsView.default.create({
      tagName: 'input',
      attributeBindings: ['type', 'isDisabled:disabled'],

      type: 'submit',
      isDisabled: true
    });

    _emberMetalRun_loop.default(function () {
      view.createElement();
    });

    equal(view.$().attr('type'), 'submit', 'updates type attribute');
    ok(view.$().prop('disabled'), 'supports customizing attribute name for Boolean values');
  });

  QUnit.test('should update attribute bindings', function () {
    view = _emberViewsViewsView.default.create({
      attributeBindings: ['type', 'color:data-color', 'exploded', 'collapsed', 'times'],
      type: 'reset',
      color: 'red',
      exploded: 'bang',
      collapsed: null,
      times: 15
    });

    _emberMetalRun_loop.default(function () {
      view.createElement();
    });

    equal(view.$().attr('type'), 'reset', 'adds type attribute');
    equal(view.$().attr('data-color'), 'red', 'attr value set with ternary');
    equal(view.$().attr('exploded'), 'bang', 'adds exploded attribute when it has a value');
    ok(!view.$().attr('collapsed'), 'does not add null attribute');
    equal(view.$().attr('times'), '15', 'sets an integer to an attribute');

    _emberMetalRun_loop.default(function () {
      view.set('type', 'submit');
      view.set('color', 'blue');
      view.set('exploded', null);
      view.set('collapsed', 'swish');
      view.set('times', 16);
    });

    equal(view.$().attr('type'), 'submit', 'adds type attribute');
    equal(view.$().attr('data-color'), 'blue', 'attr value set with ternary');
    ok(!view.$().attr('exploded'), 'removed exploded attribute when it is null');
    ok(view.$().attr('collapsed'), 'swish', 'adds an attribute when it has a value');
    equal(view.$().attr('times'), '16', 'updates an integer attribute');
  });

  QUnit.test('should update attribute bindings on input (boolean)', function () {
    view = _emberViewsViewsView.default.create({
      tagName: 'input',
      attributeBindings: ['disabled'],
      disabled: true
    });

    _emberMetalRun_loop.default(function () {
      view.createElement();
    });

    ok(view.$().prop('disabled'), 'adds disabled property when true');

    _emberMetalRun_loop.default(function () {
      view.set('disabled', false);
    });

    ok(!view.$().prop('disabled'), 'updates disabled property when false');
  });

  QUnit.test('should update attribute bindings on input (raw number prop)', function () {
    view = _emberViewsViewsView.default.create({
      tagName: 'input',
      attributeBindings: ['size'],
      size: 20
    });

    _emberMetalRun_loop.default(function () {
      view.createElement();
    });

    equal(view.$().prop('size'), 20, 'adds size property');

    _emberMetalRun_loop.default(function () {
      view.set('size', 10);
    });

    equal(view.$().prop('size'), 10, 'updates size property');
  });

  QUnit.test('should update attribute bindings on input (name)', function () {
    view = _emberViewsViewsView.default.create({
      tagName: 'input',
      attributeBindings: ['name'],
      name: 'bloody-awful'
    });

    _emberMetalRun_loop.default(function () {
      view.createElement();
    });

    equal(view.$().prop('name'), 'bloody-awful', 'adds name property');

    _emberMetalRun_loop.default(function () {
      view.set('name', 'simply-grand');
    });

    equal(view.$().prop('name'), 'simply-grand', 'updates name property');
  });

  QUnit.test('should update attribute bindings with micro syntax', function () {
    view = _emberViewsViewsView.default.create({
      tagName: 'input',
      attributeBindings: ['isDisabled:disabled'],
      type: 'reset',
      isDisabled: true
    });

    _emberMetalRun_loop.default(function () {
      view.createElement();
    });
    ok(view.$().prop('disabled'), 'adds disabled property when true');

    _emberMetalRun_loop.default(function () {
      view.set('isDisabled', false);
    });
    ok(!view.$().prop('disabled'), 'updates disabled property when false');
  });

  QUnit.test('should allow namespaced attributes in micro syntax', function () {
    view = _emberViewsViewsView.default.create({
      attributeBindings: ['xlinkHref:xlink:href'],
      xlinkHref: '/foo.png'
    });

    _emberMetalRun_loop.default(function () {
      view.createElement();
    });
    equal(view.$().attr('xlink:href'), '/foo.png', 'namespaced attribute is set');

    _emberMetalRun_loop.default(function () {
      view.set('xlinkHref', '/bar.png');
    });
    equal(view.$().attr('xlink:href'), '/bar.png', 'namespaced attribute is updated');
  });

  QUnit.test('should update attribute bindings on svg', function () {
    view = _emberViewsViewsView.default.create({
      attributeBindings: ['viewBox'],
      viewBox: null
    });

    _emberMetalRun_loop.default(function () {
      view.createElement();
    });

    equal(view.$().attr('viewBox'), null, 'viewBox can be null');

    _emberMetalRun_loop.default(function () {
      view.set('viewBox', '0 0 100 100');
    });

    equal(view.$().attr('viewBox'), '0 0 100 100', 'viewBox can be updated');
  });

  // This comes into play when using the {{#each}} helper. If the
  // passed array item is a String, it will be converted into a
  // String object instead of a normal string.
  QUnit.test('should allow binding to String objects', function () {
    view = _emberViewsViewsView.default.create({
      attributeBindings: ['foo'],
      // JSHint doesn't like `new String` so we'll create it the same way it gets created in practice
      foo: (function () {
        return this;
      }).call('bar')
    });

    _emberMetalRun_loop.default(function () {
      view.createElement();
    });

    equal(view.$().attr('foo'), 'bar', 'should convert String object to bare string');

    _emberMetalRun_loop.default(function () {
      view.set('foo', null);
    });

    ok(!view.$().attr('foo'), 'removes foo attribute when null');
  });

  QUnit.test('should teardown observers on rerender', function () {
    view = _emberViewsViewsView.default.create({
      attributeBindings: ['foo'],
      classNameBindings: ['foo'],
      foo: 'bar'
    });

    appendView();

    equal(_emberMetalObserver.observersFor(view, 'foo').length, 1, 'observer count after render is one');

    _emberMetalRun_loop.default(function () {
      view.rerender();
    });

    equal(_emberMetalObserver.observersFor(view, 'foo').length, 1, 'observer count after rerender remains one');
  });

  QUnit.test('handles attribute bindings for properties', function () {
    view = _emberViewsViewsView.default.create({
      tagName: 'input',
      attributeBindings: ['checked'],
      checked: null
    });

    appendView();

    equal(!!view.$().prop('checked'), false, 'precond - is not checked');

    _emberMetalRun_loop.default(function () {
      view.set('checked', true);
    });

    equal(view.$().prop('checked'), true, 'changes to checked');

    _emberMetalRun_loop.default(function () {
      view.set('checked', false);
    });

    equal(!!view.$().prop('checked'), false, 'changes to unchecked');
  });

  QUnit.test('handles `undefined` value for properties', function () {
    view = _emberViewsViewsView.default.create({
      tagName: 'input',
      attributeBindings: ['value'],
      value: 'test'
    });

    appendView();

    equal(view.$().prop('value'), 'test', 'value is defined');

    _emberMetalRun_loop.default(function () {
      view.set('value', undefined);
    });

    equal(view.$().prop('value'), '', 'value is blank');
  });

  QUnit.test('handles null value for attributes on text fields', function () {
    view = _emberViewsViewsView.default.create({
      tagName: 'input',
      attributeBindings: ['value']
    });

    appendView();

    view.$().attr('value', 'test');

    equal(view.$().attr('value'), 'test', 'value is defined');

    _emberMetalRun_loop.default(function () {
      view.set('value', null);
    });

    equal(!!view.$().prop('value'), false, 'value is not defined');
  });

  QUnit.test('handles a 0 value attribute on text fields', function () {
    view = _emberViewsViewsView.default.create({
      tagName: 'input',
      attributeBindings: ['value']
    });

    appendView();

    view.$().attr('value', 'test');
    equal(view.$().attr('value'), 'test', 'value is defined');

    _emberMetalRun_loop.default(function () {
      view.set('value', 0);
    });
    strictEqual(view.$().prop('value'), '0', 'value should be 0');
  });

  QUnit.test('attributeBindings should not fail if view has been removed', function () {
    _emberMetalRun_loop.default(function () {
      view = _emberViewsViewsView.default.create({
        attributeBindings: ['checked'],
        checked: true
      });
    });
    _emberMetalRun_loop.default(function () {
      view.createElement();
    });
    var error;
    try {
      _emberMetalRun_loop.default(function () {
        _emberMetalProperty_events.changeProperties(function () {
          view.set('checked', false);
          view.remove();
        });
      });
    } catch (e) {
      error = e;
    }
    ok(!error, error);
  });

  QUnit.test('attributeBindings should not fail if view has been destroyed', function () {
    _emberMetalRun_loop.default(function () {
      view = _emberViewsViewsView.default.create({
        attributeBindings: ['checked'],
        checked: true
      });
    });
    _emberMetalRun_loop.default(function () {
      view.createElement();
    });
    var error;
    try {
      _emberMetalRun_loop.default(function () {
        _emberMetalProperty_events.changeProperties(function () {
          view.set('checked', false);
          view.destroy();
        });
      });
    } catch (e) {
      error = e;
    }
    ok(!error, error);
  });

  QUnit.test('asserts if an attributeBinding is setup on class', function () {
    view = _emberViewsViewsView.default.create({
      attributeBindings: ['class']
    });

    expectAssertion(function () {
      appendView();
    }, 'You cannot use class as an attributeBinding, use classNameBindings instead.');

    // Remove render node to avoid "Render node exists without concomitant env"
    // assertion on teardown.
    view._renderNode = null;
  });

  QUnit.test('blacklists href bindings based on protocol', function () {
    /* jshint scripturl:true */

    view = _emberViewsViewsView.default.create({
      tagName: 'a',
      attributeBindings: ['href'],
      href: 'javascript:alert(\'foo\')'
    });

    appendView();

    equal(view.$().attr('href'), 'unsafe:javascript:alert(\'foo\')', 'value property sanitized');

    _emberMetalRun_loop.default(function () {
      view.set('href', new _emberHtmlbarsUtilsString.SafeString(view.get('href')));
    });

    equal(view.$().attr('href'), 'javascript:alert(\'foo\')', 'value is not defined');
  });

  QUnit.test('attributeBindings should be overridable', function () {
    var ParentView = _emberViewsViewsView.default.extend({
      attributeBindings: ['href'],
      href: 'an href'
    });

    var ChildView = ParentView.extend({
      attributeBindings: ['newHref:href'],
      newHref: 'a new href'
    });

    view = ChildView.create();

    appendView();

    equal(view.$().attr('href'), 'a new href', 'expect value from subclass attribute binding');
  });

  QUnit.test('role attribute is included if provided as ariaRole', function () {
    view = _emberViewsViewsView.default.create({
      ariaRole: 'main'
    });

    appendView();

    equal(view.$().attr('role'), 'main');
  });

  QUnit.test('role attribute is not included if not provided', function () {
    view = _emberViewsViewsView.default.create();

    appendView();

    ok(!view.element.hasAttribute('role'), 'role attribute is not present');
  });

  QUnit.test('can set id initially via attributeBindings', function () {
    view = _emberViewsViewsView.default.create({
      attributeBindings: ['specialSauce:id'],
      specialSauce: 'special-sauces-id'
    });

    appendView();

    equal(view.$().attr('id'), 'special-sauces-id', 'id properly used from attributeBindings');
  });
});
enifed('ember-views/tests/views/view/attribute_bindings_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/tests/views/view');
  test('ember-views/tests/views/view/attribute_bindings_test.js should pass jscs', function () {
    ok(true, 'ember-views/tests/views/view/attribute_bindings_test.js should pass jscs.');
  });
});
enifed('ember-views/tests/views/view/attribute_bindings_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/tests/views/view');
  QUnit.test('ember-views/tests/views/view/attribute_bindings_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/tests/views/view/attribute_bindings_test.js should pass jshint.');
  });
});
enifed('ember-views/tests/views/view/child_views_test', ['exports', 'ember-metal/run_loop', 'ember-metal/core', 'ember-views/views/view', 'ember-views/views/component', 'ember-template-compiler', 'ember-htmlbars/tests/utils', 'ember-htmlbars/keywords/view'], function (exports, _emberMetalRun_loop, _emberMetalCore, _emberViewsViewsView, _emberViewsViewsComponent, _emberTemplateCompiler, _emberHtmlbarsTestsUtils, _emberHtmlbarsKeywordsView) {
  'use strict';

  var originalViewKeyword;
  var parentView, childView;

  QUnit.module('tests/views/view/child_views_tests.js', {
    setup: function () {
      originalViewKeyword = _emberHtmlbarsTestsUtils.registerKeyword('view', _emberHtmlbarsKeywordsView.default);
      childView = _emberViewsViewsView.default.create({
        template: _emberTemplateCompiler.compile('ber')
      });

      parentView = _emberViewsViewsView.default.create({
        template: _emberTemplateCompiler.compile('Em{{view view.childView}}'),
        childView: childView
      });
    },

    teardown: function () {
      _emberMetalRun_loop.default(function () {
        parentView.destroy();
        childView.destroy();
      });
      _emberHtmlbarsTestsUtils.resetKeyword('view', originalViewKeyword);
    }
  });

  // no parent element, buffer, no element
  // parent element

  // no parent element, no buffer, no element
  QUnit.test('should render an inserted child view when the child is inserted before a DOM element is created', function () {
    _emberMetalRun_loop.default(function () {
      parentView.append();
    });

    equal(parentView.$().text(), 'Ember', 'renders the child view after the parent view');
  });

  QUnit.test('should not duplicate childViews when rerendering', function () {

    var InnerView = _emberViewsViewsView.default.extend();
    var InnerView2 = _emberViewsViewsView.default.extend();

    var MiddleView = _emberViewsViewsView.default.extend({
      innerViewClass: InnerView,
      innerView2Class: InnerView2,
      template: _emberTemplateCompiler.compile('{{view view.innerViewClass}}{{view view.innerView2Class}}')
    });

    var outerView = _emberViewsViewsView.default.create({
      middleViewClass: MiddleView,
      template: _emberTemplateCompiler.compile('{{view view.middleViewClass viewName="middle"}}')
    });

    _emberMetalRun_loop.default(function () {
      outerView.append();
    });

    equal(outerView.get('middle.childViews.length'), 2, 'precond middle has 2 child views rendered to buffer');

    _emberMetalRun_loop.default(function () {
      outerView.middle.rerender();
    });

    equal(outerView.get('middle.childViews.length'), 2, 'middle has 2 child views rendered to buffer');

    _emberMetalRun_loop.default(function () {
      outerView.destroy();
    });
  });

  QUnit.test('should remove childViews inside {{if}} on destroy', function () {
    var outerView = _emberViewsViewsView.default.extend({
      component: 'my-thing',
      value: false,
      container: {
        lookup: function () {
          return {
            componentFor: function () {
              return _emberViewsViewsComponent.default.extend();
            },

            layoutFor: function () {
              return null;
            }
          };
        }
      },
      template: _emberTemplateCompiler.compile('\n      {{#if view.value}}\n        {{component view.component value=view.value}}\n      {{/if}}\n    ')
    }).create();

    _emberMetalRun_loop.default(outerView, 'append');
    _emberMetalRun_loop.default(outerView, 'set', 'value', true);

    equal(outerView.get('childViews.length'), 1);

    _emberMetalRun_loop.default(outerView, 'set', 'value', false);

    equal(outerView.get('childViews.length'), 0, 'expected no views to be leaked');

    _emberMetalRun_loop.default(function () {
      outerView.destroy();
    });
  });

  QUnit.test('should remove childViews inside {{each}} on destroy', function () {
    var outerView = _emberViewsViewsView.default.extend({
      component: 'my-thing',
      init: function () {
        this._super.apply(this, arguments);
        this.value = false;
      },
      container: {
        lookup: function () {
          return {
            componentFor: function () {
              return _emberViewsViewsComponent.default.extend();
            },

            layoutFor: function () {
              return null;
            }
          };
        }
      },
      template: _emberTemplateCompiler.compile('\n      {{#if view.value}}\n        {{#each view.data as |item|}}\n          {{component view.component value=item.value}}\n        {{/each}}\n      {{/if}}\n    ')
    }).create();

    _emberMetalRun_loop.default(outerView, 'append');

    equal(outerView.get('childViews.length'), 0);

    _emberMetalRun_loop.default(outerView, 'set', 'data', _emberMetalCore.default.A([{ id: 1, value: new Date() }, { id: 2, value: new Date() }]));

    equal(outerView.get('childViews.length'), 0);

    _emberMetalRun_loop.default(outerView, 'set', 'value', true);
    equal(outerView.get('childViews.length'), 2);

    _emberMetalRun_loop.default(outerView, 'set', 'value', false);

    equal(outerView.get('childViews.length'), 0, 'expected no views to be leaked');

    _emberMetalRun_loop.default(function () {
      outerView.destroy();
    });
  });
});
enifed('ember-views/tests/views/view/child_views_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/tests/views/view');
  test('ember-views/tests/views/view/child_views_test.js should pass jscs', function () {
    ok(true, 'ember-views/tests/views/view/child_views_test.js should pass jscs.');
  });
});
enifed('ember-views/tests/views/view/child_views_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/tests/views/view');
  QUnit.test('ember-views/tests/views/view/child_views_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/tests/views/view/child_views_test.js should pass jshint.');
  });
});
enifed('ember-views/tests/views/view/class_name_bindings_test', ['exports', 'ember-metal/property_set', 'ember-metal/run_loop', 'ember-metal/property_events', 'ember-metal/watching', 'ember-runtime/system/object', 'ember-views/views/view'], function (exports, _emberMetalProperty_set, _emberMetalRun_loop, _emberMetalProperty_events, _emberMetalWatching, _emberRuntimeSystemObject, _emberViewsViewsView) {
  'use strict';

  var view;

  QUnit.module('EmberView - Class Name Bindings', {
    teardown: function () {
      _emberMetalRun_loop.default(function () {
        view.destroy();
      });
    }
  });

  QUnit.test('should apply bound class names to the element', function () {
    view = _emberViewsViewsView.default.create({
      classNameBindings: ['priority', 'isUrgent', 'isClassified:classified', 'canIgnore', 'messages.count', 'messages.resent:is-resent', 'isNumber:is-number', 'isFalsy::is-falsy', 'isTruthy::is-not-truthy', 'isEnabled:enabled:disabled'],

      priority: 'high',
      isUrgent: true,
      isClassified: true,
      canIgnore: false,
      isNumber: 5,
      isFalsy: 0,
      isTruthy: 'abc',
      isEnabled: true,

      messages: {
        count: 'five-messages',
        resent: true
      }
    });

    _emberMetalRun_loop.default(function () {
      view.createElement();
    });

    ok(view.$().hasClass('high'), 'adds string values as class name');
    ok(view.$().hasClass('is-urgent'), 'adds true Boolean values by dasherizing');
    ok(view.$().hasClass('classified'), 'supports customizing class name for Boolean values');
    ok(view.$().hasClass('five-messages'), 'supports paths in bindings');
    ok(view.$().hasClass('is-resent'), 'supports customing class name for paths');
    ok(view.$().hasClass('is-number'), 'supports colon syntax with truthy properties');
    ok(view.$().hasClass('is-falsy'), 'supports colon syntax with falsy properties');
    ok(!view.$().hasClass('abc'), 'does not add values as classes when falsy classes have been specified');
    ok(!view.$().hasClass('is-not-truthy'), 'does not add falsy classes when values are truthy');
    ok(!view.$().hasClass('can-ignore'), 'does not add false Boolean values as class');
    ok(view.$().hasClass('enabled'), 'supports customizing class name for Boolean values with negation');
    ok(!view.$().hasClass('disabled'), 'does not add class name for negated binding');
  });

  QUnit.test('should add, remove, or change class names if changed after element is created', function () {
    view = _emberViewsViewsView.default.create({
      classNameBindings: ['priority', 'isUrgent', 'isClassified:classified', 'canIgnore', 'messages.count', 'messages.resent:is-resent', 'isEnabled:enabled:disabled'],

      priority: 'high',
      isUrgent: true,
      isClassified: true,
      canIgnore: false,
      isEnabled: true,

      messages: _emberRuntimeSystemObject.default.create({
        count: 'five-messages',
        resent: false
      })
    });

    _emberMetalRun_loop.default(function () {
      view.createElement();
      _emberMetalProperty_set.set(view, 'priority', 'orange');
      _emberMetalProperty_set.set(view, 'isUrgent', false);
      _emberMetalProperty_set.set(view, 'canIgnore', true);
      _emberMetalProperty_set.set(view, 'isEnabled', false);
      _emberMetalProperty_set.set(view, 'messages.count', 'six-messages');
      _emberMetalProperty_set.set(view, 'messages.resent', true);
    });

    ok(view.$().hasClass('orange'), 'updates string values');
    ok(!view.$().hasClass('high'), 'removes old string value');

    ok(!view.$().hasClass('is-urgent', 'removes dasherized class when changed from true to false'));
    ok(view.$().hasClass('can-ignore'), 'adds dasherized class when changed from false to true');

    ok(view.$().hasClass('six-messages'), 'adds new value when path changes');
    ok(!view.$().hasClass('five-messages'), 'removes old value when path changes');

    ok(view.$().hasClass('is-resent'), 'adds customized class name when path changes');

    ok(!view.$().hasClass('enabled'), 'updates class name for negated binding');
    ok(view.$().hasClass('disabled'), 'adds negated class name for negated binding');
  });

  QUnit.test(':: class name syntax works with an empty true class', function () {
    view = _emberViewsViewsView.default.create({
      isEnabled: false,
      classNameBindings: ['isEnabled::not-enabled']
    });

    _emberMetalRun_loop.default(function () {
      view.createElement();
    });

    equal(view.$().attr('class'), 'ember-view not-enabled', 'false class is rendered when property is false');

    _emberMetalRun_loop.default(function () {
      view.set('isEnabled', true);
    });

    equal(view.$().attr('class'), 'ember-view', 'no class is added when property is true and the class is empty');
  });

  QUnit.test('uses all provided static class names (issue #11193)', function () {
    view = _emberViewsViewsView.default.create({
      classNameBindings: [':class-one', ':class-two']
    });

    _emberMetalRun_loop.default(function () {
      view.createElement();
    });

    equal(view.$().attr('class'), 'ember-view class-one class-two', 'both classes are added');
  });

  QUnit.test('classNames should not be duplicated on rerender', function () {
    _emberMetalRun_loop.default(function () {
      view = _emberViewsViewsView.default.create({
        classNameBindings: ['priority'],
        priority: 'high'
      });
    });

    _emberMetalRun_loop.default(function () {
      view.createElement();
    });

    equal(view.$().attr('class'), 'ember-view high');

    _emberMetalRun_loop.default(function () {
      view.rerender();
    });

    equal(view.$().attr('class'), 'ember-view high');
  });

  QUnit.test('classNameBindings should work when the binding property is updated and the view has been removed of the DOM', function () {
    _emberMetalRun_loop.default(function () {
      view = _emberViewsViewsView.default.create({
        classNameBindings: ['priority'],
        priority: 'high'
      });
    });

    _emberMetalRun_loop.default(function () {
      view.createElement();
    });

    equal(view.$().attr('class'), 'ember-view high', 'has the high class');

    _emberMetalRun_loop.default(function () {
      view.remove();
    });

    _emberMetalRun_loop.default(function () {
      view.set('priority', 'low');
    });

    _emberMetalRun_loop.default(function () {
      view.append();
    });

    equal(view.$().attr('class'), 'ember-view low', 'has a low class');
  });

  QUnit.test('classNames removed by a classNameBindings observer should not re-appear on rerender', function () {
    view = _emberViewsViewsView.default.create({
      classNameBindings: ['isUrgent'],
      isUrgent: true
    });

    _emberMetalRun_loop.default(function () {
      view.createElement();
    });

    equal(view.$().attr('class'), 'ember-view is-urgent');

    _emberMetalRun_loop.default(function () {
      view.set('isUrgent', false);
    });

    equal(view.$().attr('class'), 'ember-view');

    _emberMetalRun_loop.default(function () {
      view.rerender();
    });

    equal(view.$().attr('class'), 'ember-view');
  });

  QUnit.skip('classNameBindings lifecycle test', function () {
    _emberMetalRun_loop.default(function () {
      view = _emberViewsViewsView.default.create({
        classNameBindings: ['priority'],
        priority: 'high'
      });
    });

    equal(_emberMetalWatching.isWatching(view, 'priority'), false);

    _emberMetalRun_loop.default(function () {
      view.createElement();
    });

    equal(view.$().attr('class'), 'ember-view high');
    equal(_emberMetalWatching.isWatching(view, 'priority'), true);

    _emberMetalRun_loop.default(function () {
      view.remove();
      view.set('priority', 'low');
    });

    equal(_emberMetalWatching.isWatching(view, 'priority'), false);
  });

  QUnit.test('classNameBindings should not fail if view has been removed', function () {
    _emberMetalRun_loop.default(function () {
      view = _emberViewsViewsView.default.create({
        classNameBindings: ['priority'],
        priority: 'high'
      });
    });
    _emberMetalRun_loop.default(function () {
      view.createElement();
    });
    var error;
    try {
      _emberMetalRun_loop.default(function () {
        _emberMetalProperty_events.changeProperties(function () {
          view.set('priority', 'low');
          view.remove();
        });
      });
    } catch (e) {
      error = e;
    }
    ok(!error, error);
  });

  QUnit.test('classNameBindings should not fail if view has been destroyed', function () {
    _emberMetalRun_loop.default(function () {
      view = _emberViewsViewsView.default.create({
        classNameBindings: ['priority'],
        priority: 'high'
      });
    });
    _emberMetalRun_loop.default(function () {
      view.createElement();
    });
    var error;
    try {
      _emberMetalRun_loop.default(function () {
        _emberMetalProperty_events.changeProperties(function () {
          view.set('priority', 'low');
          view.destroy();
        });
      });
    } catch (e) {
      error = e;
    }
    ok(!error, error);
  });

  QUnit.test('Providing a binding with a space in it asserts', function () {
    view = _emberViewsViewsView.default.create({
      classNameBindings: 'i:think:i am:so:clever'
    });

    expectAssertion(function () {
      view.createElement();
    }, /classNameBindings must not have spaces in them/i);

    // Remove render node to avoid "Render node exists without concomitant env"
    // assertion on teardown.
    view._renderNode = null;
  });
});
enifed('ember-views/tests/views/view/class_name_bindings_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/tests/views/view');
  test('ember-views/tests/views/view/class_name_bindings_test.js should pass jscs', function () {
    ok(true, 'ember-views/tests/views/view/class_name_bindings_test.js should pass jscs.');
  });
});
enifed('ember-views/tests/views/view/class_name_bindings_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/tests/views/view');
  QUnit.test('ember-views/tests/views/view/class_name_bindings_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/tests/views/view/class_name_bindings_test.js should pass jshint.');
  });
});
enifed('ember-views/tests/views/view/context_test', ['exports', 'ember-metal/run_loop', 'ember-views/views/view', 'ember-views/views/container_view', 'ember-htmlbars/tests/utils', 'ember-htmlbars/keywords/view'], function (exports, _emberMetalRun_loop, _emberViewsViewsView, _emberViewsViewsContainer_view, _emberHtmlbarsTestsUtils, _emberHtmlbarsKeywordsView) {
  'use strict';

  var originalViewKeyword;

  QUnit.module('EmberView - context property', {
    setup: function () {
      originalViewKeyword = _emberHtmlbarsTestsUtils.registerKeyword('view', _emberHtmlbarsKeywordsView.default);
    },
    teardown: function () {
      _emberHtmlbarsTestsUtils.resetKeyword('view', originalViewKeyword);
    }
  });

  QUnit.test('setting a controller on an inner view should change it context', function () {
    var App = {};
    var a = { name: 'a' };
    var b = { name: 'b' };

    var innerView = _emberViewsViewsView.default.create();
    var middleView = _emberViewsViewsContainer_view.default.create();
    var outerView = App.outerView = _emberViewsViewsContainer_view.default.create({
      controller: a
    });

    _emberMetalRun_loop.default(function () {
      outerView.appendTo('#qunit-fixture');
    });

    _emberMetalRun_loop.default(function () {
      outerView.set('currentView', middleView);
    });

    _emberMetalRun_loop.default(function () {
      innerView.set('controller', b);
      middleView.set('currentView', innerView);
    });

    // assert
    equal(outerView.get('context'), a, 'outer context correct');
    equal(middleView.get('context'), a, 'middle context correct');
    equal(innerView.get('context'), b, 'inner context correct');

    _emberMetalRun_loop.default(function () {
      innerView.destroy();
      middleView.destroy();
      outerView.destroy();
    });
  });
});
enifed('ember-views/tests/views/view/context_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/tests/views/view');
  test('ember-views/tests/views/view/context_test.js should pass jscs', function () {
    ok(true, 'ember-views/tests/views/view/context_test.js should pass jscs.');
  });
});
enifed('ember-views/tests/views/view/context_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/tests/views/view');
  QUnit.test('ember-views/tests/views/view/context_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/tests/views/view/context_test.js should pass jshint.');
  });
});
enifed('ember-views/tests/views/view/controller_test', ['exports', 'ember-metal/run_loop', 'ember-views/views/container_view'], function (exports, _emberMetalRun_loop, _emberViewsViewsContainer_view) {
  'use strict';

  QUnit.module('Ember.View - controller property');

  QUnit.test('controller property should be inherited from nearest ancestor with controller', function () {
    var grandparent = _emberViewsViewsContainer_view.default.create();
    var parent = _emberViewsViewsContainer_view.default.create();
    var child = _emberViewsViewsContainer_view.default.create();
    var grandchild = _emberViewsViewsContainer_view.default.create();

    var grandparentController = {};
    var parentController = {};

    _emberMetalRun_loop.default(function () {
      grandparent.set('controller', grandparentController);
      parent.set('controller', parentController);

      grandparent.pushObject(parent);
      parent.pushObject(child);
    });

    strictEqual(grandparent.get('controller'), grandparentController);
    strictEqual(parent.get('controller'), parentController);
    strictEqual(child.get('controller'), parentController);
    strictEqual(grandchild.get('controller'), null);

    _emberMetalRun_loop.default(function () {
      child.pushObject(grandchild);
    });

    strictEqual(grandchild.get('controller'), parentController);

    var newController = {};
    _emberMetalRun_loop.default(function () {
      parent.set('controller', newController);
    });

    strictEqual(parent.get('controller'), newController);
    strictEqual(child.get('controller'), newController);
    strictEqual(grandchild.get('controller'), newController);

    _emberMetalRun_loop.default(function () {
      grandparent.destroy();
      parent.destroy();
      child.destroy();
      grandchild.destroy();
    });
  });
});
enifed('ember-views/tests/views/view/controller_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/tests/views/view');
  test('ember-views/tests/views/view/controller_test.js should pass jscs', function () {
    ok(true, 'ember-views/tests/views/view/controller_test.js should pass jscs.');
  });
});
enifed('ember-views/tests/views/view/controller_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/tests/views/view');
  QUnit.test('ember-views/tests/views/view/controller_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/tests/views/view/controller_test.js should pass jshint.');
  });
});
enifed('ember-views/tests/views/view/create_child_view_test', ['exports', 'ember-metal/property_get', 'ember-metal/run_loop', 'ember-views/views/view', 'ember-metal/events', 'ember-metal/mixin', 'ember-htmlbars/tests/utils', 'ember-htmlbars/keywords/view'], function (exports, _emberMetalProperty_get, _emberMetalRun_loop, _emberViewsViewsView, _emberMetalEvents, _emberMetalMixin, _emberHtmlbarsTestsUtils, _emberHtmlbarsKeywordsView) {
  'use strict';

  var view, myViewClass, newView, container, originalViewKeyword;

  QUnit.module('EmberView#createChildView', {
    setup: function () {
      originalViewKeyword = _emberHtmlbarsTestsUtils.registerKeyword('view', _emberHtmlbarsKeywordsView.default);
      container = {};

      view = _emberViewsViewsView.default.create({
        container: container
      });

      myViewClass = _emberViewsViewsView.default.extend({ isMyView: true, foo: 'bar' });
    },

    teardown: function () {
      _emberMetalRun_loop.default(function () {
        view.destroy();
        if (newView) {
          newView.destroy();
        }
      });
      _emberHtmlbarsTestsUtils.resetKeyword('view', originalViewKeyword);
    }
  });

  QUnit.test('should create view from class with any passed attributes', function () {
    var attrs = {
      foo: 'baz'
    };

    newView = view.createChildView(myViewClass, attrs);

    equal(newView.container, container, 'expects to share container with parent');
    ok(_emberMetalProperty_get.get(newView, 'isMyView'), 'newView is instance of myView');
    equal(_emberMetalProperty_get.get(newView, 'foo'), 'baz', 'view did get custom attributes');
  });

  QUnit.test('creating a childView, (via createChildView) should make parentView initial state and not emit change events nore helper actions', function () {
    expect(2);

    newView = view.createChildView(_emberViewsViewsView.default.extend({
      init: function () {
        this._super.apply(this, arguments);
        ok(true, 'did init');
      },
      parentViewDidReallyChange: _emberMetalEvents.on('parentViewDidChange', function () {
        ok(false, 'expected to NOT emit parentViewDidChange');
      }),
      controllerDidChange: _emberMetalMixin.observer('controller', function () {
        ok(false, 'expected to NOT expect controller to change');
      }),
      parentViewDidChange: _emberMetalMixin.observer('parentView', function () {
        ok(false, 'expected to NOT expect  parentViewto change');
      })
    }));

    equal(newView.get('parentView'), view, 'expected the correct parentView');
  });

  QUnit.test('should set newView.parentView to receiver', function () {
    newView = view.createChildView(myViewClass);

    equal(newView.container, container, 'expects to share container with parent');
    equal(_emberMetalProperty_get.get(newView, 'parentView'), view, 'newView.parentView == view');
  });

  QUnit.test('should create property on parentView to a childView instance if provided a viewName', function () {
    var attrs = {
      viewName: 'someChildView'
    };

    newView = view.createChildView(myViewClass, attrs);
    equal(newView.container, container, 'expects to share container with parent');

    equal(_emberMetalProperty_get.get(view, 'someChildView'), newView);
  });

  QUnit.test('should update a view instances attributes, including the parentView and container properties', function () {
    var attrs = {
      foo: 'baz'
    };

    var myView = myViewClass.create();
    newView = view.createChildView(myView, attrs);

    equal(newView.container, container, 'expects to share container with parent');
    equal(newView.parentView, view, 'expects to have the correct parent');
    equal(_emberMetalProperty_get.get(newView, 'foo'), 'baz', 'view did get custom attributes');

    deepEqual(newView, myView);
  });

  QUnit.test('should create from string via container lookup', function () {
    var ChildViewClass = _emberViewsViewsView.default.extend();
    var fullName = 'view:bro';

    view.container.lookupFactory = function (viewName) {
      equal(fullName, viewName);

      return ChildViewClass.extend({
        container: container
      });
    };

    newView = view.createChildView('bro');

    equal(newView.container, container, 'expects to share container with parent');
    equal(newView.parentView, view, 'expects to have the correct parent');
  });

  QUnit.test('should assert when trying to create childView from string, but no such view is registered', function () {
    view.container.lookupFactory = function () {};

    expectAssertion(function () {
      view.createChildView('bro');
    });
  });
});
enifed('ember-views/tests/views/view/create_child_view_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/tests/views/view');
  test('ember-views/tests/views/view/create_child_view_test.js should pass jscs', function () {
    ok(true, 'ember-views/tests/views/view/create_child_view_test.js should pass jscs.');
  });
});
enifed('ember-views/tests/views/view/create_child_view_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/tests/views/view');
  QUnit.test('ember-views/tests/views/view/create_child_view_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/tests/views/view/create_child_view_test.js should pass jshint.');
  });
});
enifed('ember-views/tests/views/view/create_element_test', ['exports', 'ember-metal/property_get', 'ember-metal/run_loop', 'ember-views/views/view', 'ember-views/views/container_view', 'ember-views/tests/test-helpers/equal-html', 'ember-template-compiler/system/compile', 'ember-htmlbars/tests/utils', 'ember-htmlbars/keywords/view'], function (exports, _emberMetalProperty_get, _emberMetalRun_loop, _emberViewsViewsView, _emberViewsViewsContainer_view, _emberViewsTestsTestHelpersEqualHtml, _emberTemplateCompilerSystemCompile, _emberHtmlbarsTestsUtils, _emberHtmlbarsKeywordsView) {
  'use strict';

  var view, originalViewKeyword;

  QUnit.module('Ember.View#createElement', {
    setup: function () {
      originalViewKeyword = _emberHtmlbarsTestsUtils.registerKeyword('view', _emberHtmlbarsKeywordsView.default);
    },
    teardown: function () {
      _emberMetalRun_loop.default(function () {
        view.destroy();
      });
      _emberHtmlbarsTestsUtils.resetKeyword('view', originalViewKeyword);
    }
  });

  QUnit.test('returns the receiver', function () {
    var ret;

    view = _emberViewsViewsView.default.create();

    _emberMetalRun_loop.default(function () {
      ret = view.createElement();
    });

    equal(ret, view, 'returns receiver');
  });

  QUnit.test('should assert if `tagName` is an empty string and `classNameBindings` are specified', function () {
    expect(1);

    view = _emberViewsViewsView.default.create({
      tagName: '',
      foo: true,
      classNameBindings: ['foo:is-foo:is-bar']
    });

    expectAssertion(function () {
      _emberMetalRun_loop.default(function () {
        view.createElement();
      });
    }, /You cannot use `classNameBindings` on a tag-less component/);

    // Prevent further assertions
    view._renderNode = null;
  });

  QUnit.test('calls render and turns resultant string into element', function () {
    view = _emberViewsViewsView.default.create({
      tagName: 'span',
      template: _emberTemplateCompilerSystemCompile.default('foo')
    });

    equal(_emberMetalProperty_get.get(view, 'element'), null, 'precondition - has no element');
    _emberMetalRun_loop.default(function () {
      view.createElement();
    });

    var elem = _emberMetalProperty_get.get(view, 'element');
    ok(elem, 'has element now');
    equal(elem.innerHTML, 'foo', 'has innerHTML from context');
    equal(elem.tagName.toString().toLowerCase(), 'span', 'has tagName from view');
  });

  QUnit.test('renders the child view templates in the right context', function () {
    expectDeprecation('Setting `childViews` on a Container is deprecated.');

    view = _emberViewsViewsContainer_view.default.create({
      tagName: 'table',
      childViews: [_emberViewsViewsView.default.create({
        tagName: '',
        template: _emberTemplateCompilerSystemCompile.default('<tr><td>snorfblax</td></tr>')
      })]
    });

    equal(_emberMetalProperty_get.get(view, 'element'), null, 'precondition - has no element');
    _emberMetalRun_loop.default(function () {
      view.createElement();
    });

    var elem = _emberMetalProperty_get.get(view, 'element');
    ok(elem, 'has element now');
    equal(elem.tagName.toString().toLowerCase(), 'table', 'has tagName from view');
    _emberViewsTestsTestHelpersEqualHtml.equalHTML(elem.childNodes, '<tr><td>snorfblax</td></tr>', 'has innerHTML from context');
  });

  QUnit.test('does not wrap many tr children in tbody elements', function () {
    expectDeprecation('Setting `childViews` on a Container is deprecated.');

    view = _emberViewsViewsContainer_view.default.create({
      tagName: 'table',
      childViews: [_emberViewsViewsView.default.create({
        tagName: '',
        template: _emberTemplateCompilerSystemCompile.default('<tr><td>snorfblax</td></tr>')
      }), _emberViewsViewsView.default.create({
        tagName: '',
        template: _emberTemplateCompilerSystemCompile.default('<tr><td>snorfblax</td></tr>')
      })]
    });

    equal(_emberMetalProperty_get.get(view, 'element'), null, 'precondition - has no element');
    _emberMetalRun_loop.default(function () {
      view.createElement();
    });

    var elem = _emberMetalProperty_get.get(view, 'element');
    ok(elem, 'has element now');
    _emberViewsTestsTestHelpersEqualHtml.equalHTML(elem.childNodes, '<tr><td>snorfblax</td></tr><tr><td>snorfblax</td></tr>', 'has innerHTML from context');
    equal(elem.tagName.toString().toLowerCase(), 'table', 'has tagName from view');
  });

  QUnit.test('generated element include HTML from child views as well', function () {
    expectDeprecation('Setting `childViews` on a Container is deprecated.');

    view = _emberViewsViewsContainer_view.default.create({
      childViews: [_emberViewsViewsView.default.create({ elementId: 'foo' })]
    });

    _emberMetalRun_loop.default(function () {
      view.createElement();
    });

    ok(view.$('#foo').length, 'has element with child elementId');
  });
});
enifed('ember-views/tests/views/view/create_element_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/tests/views/view');
  test('ember-views/tests/views/view/create_element_test.js should pass jscs', function () {
    ok(true, 'ember-views/tests/views/view/create_element_test.js should pass jscs.');
  });
});
enifed('ember-views/tests/views/view/create_element_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/tests/views/view');
  QUnit.test('ember-views/tests/views/view/create_element_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/tests/views/view/create_element_test.js should pass jshint.');
  });
});
enifed('ember-views/tests/views/view/destroy_element_test', ['exports', 'ember-metal/property_get', 'ember-metal/run_loop', 'ember-views/views/view', 'ember-views/views/container_view', 'ember-htmlbars/tests/utils', 'ember-htmlbars/keywords/view'], function (exports, _emberMetalProperty_get, _emberMetalRun_loop, _emberViewsViewsView, _emberViewsViewsContainer_view, _emberHtmlbarsTestsUtils, _emberHtmlbarsKeywordsView) {
  'use strict';

  var originalViewKeyword;
  var view;

  QUnit.module('EmberView#destroyElement', {
    setup: function () {
      originalViewKeyword = _emberHtmlbarsTestsUtils.registerKeyword('view', _emberHtmlbarsKeywordsView.default);
    },
    teardown: function () {
      _emberMetalRun_loop.default(function () {
        view.destroy();
      });
      _emberHtmlbarsTestsUtils.resetKeyword('view', originalViewKeyword);
    }
  });

  QUnit.test('if it has no element, does nothing', function () {
    var callCount = 0;
    view = _emberViewsViewsView.default.create({
      willDestroyElement: function () {
        callCount++;
      }
    });

    ok(!_emberMetalProperty_get.get(view, 'element'), 'precond - does NOT have element');

    _emberMetalRun_loop.default(function () {
      view.destroyElement();
    });

    equal(callCount, 0, 'did not invoke callback');
  });

  QUnit.test('if it has a element, calls willDestroyElement on receiver and child views then deletes the element', function () {
    expectDeprecation('Setting `childViews` on a Container is deprecated.');

    var parentCount = 0;
    var childCount = 0;

    view = _emberViewsViewsContainer_view.default.create({
      willDestroyElement: function () {
        parentCount++;
      },
      childViews: [_emberViewsViewsContainer_view.default.extend({
        // no willDestroyElement here... make sure no errors are thrown
        childViews: [_emberViewsViewsView.default.extend({
          willDestroyElement: function () {
            childCount++;
          }
        })]
      })]
    });

    _emberMetalRun_loop.default(function () {
      view.createElement();
    });

    ok(_emberMetalProperty_get.get(view, 'element'), 'precond - view has element');

    _emberMetalRun_loop.default(function () {
      view.destroyElement();
    });

    equal(parentCount, 1, 'invoked destroy element on the parent');
    equal(childCount, 1, 'invoked destroy element on the child');
    ok(!_emberMetalProperty_get.get(view, 'element'), 'view no longer has element');
    ok(!_emberMetalProperty_get.get(_emberMetalProperty_get.get(view, 'childViews').objectAt(0), 'element'), 'child no longer has an element');
  });

  QUnit.test('returns receiver', function () {
    var ret;
    view = _emberViewsViewsView.default.create();

    _emberMetalRun_loop.default(function () {
      view.createElement();
      ret = view.destroyElement();
    });

    equal(ret, view, 'returns receiver');
  });

  QUnit.test('removes element from parentNode if in DOM', function () {
    view = _emberViewsViewsView.default.create();

    _emberMetalRun_loop.default(function () {
      view.append();
    });

    var parent = view.$().parent();

    ok(_emberMetalProperty_get.get(view, 'element'), 'precond - has element');

    _emberMetalRun_loop.default(function () {
      view.destroyElement();
    });

    equal(view.$(), undefined, 'view has no selector');
    ok(!parent.find('#' + view.get('elementId')).length, 'element no longer in parent node');
  });
});
enifed('ember-views/tests/views/view/destroy_element_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/tests/views/view');
  test('ember-views/tests/views/view/destroy_element_test.js should pass jscs', function () {
    ok(true, 'ember-views/tests/views/view/destroy_element_test.js should pass jscs.');
  });
});
enifed('ember-views/tests/views/view/destroy_element_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/tests/views/view');
  QUnit.test('ember-views/tests/views/view/destroy_element_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/tests/views/view/destroy_element_test.js should pass jshint.');
  });
});
enifed('ember-views/tests/views/view/destroy_test', ['exports', 'ember-metal/property_get', 'ember-metal/run_loop', 'ember-views/views/view'], function (exports, _emberMetalProperty_get, _emberMetalRun_loop, _emberViewsViewsView) {
  'use strict';

  QUnit.module('Ember.View#destroy');

  QUnit.test('should teardown viewName on parentView when childView is destroyed', function () {
    var viewName = 'someChildView';
    var parentView = _emberViewsViewsView.default.create();
    var childView = parentView.createChildView(_emberViewsViewsView.default, { viewName: viewName });

    equal(_emberMetalProperty_get.get(parentView, viewName), childView, 'Precond - child view was registered on parent');

    _emberMetalRun_loop.default(function () {
      childView.destroy();
    });

    equal(_emberMetalProperty_get.get(parentView, viewName), null, 'viewName reference was removed on parent');

    _emberMetalRun_loop.default(function () {
      parentView.destroy();
    });
  });
});
enifed('ember-views/tests/views/view/destroy_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/tests/views/view');
  test('ember-views/tests/views/view/destroy_test.js should pass jscs', function () {
    ok(true, 'ember-views/tests/views/view/destroy_test.js should pass jscs.');
  });
});
enifed('ember-views/tests/views/view/destroy_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/tests/views/view');
  QUnit.test('ember-views/tests/views/view/destroy_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/tests/views/view/destroy_test.js should pass jshint.');
  });
});
enifed('ember-views/tests/views/view/element_test', ['exports', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/run_loop', 'ember-views/views/view', 'ember-views/views/container_view'], function (exports, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalRun_loop, _emberViewsViewsView, _emberViewsViewsContainer_view) {
  /*globals EmberDev */

  'use strict';

  var parentView, view;

  QUnit.module('Ember.View#element', {
    teardown: function () {
      _emberMetalRun_loop.default(function () {
        if (parentView) {
          parentView.destroy();
        }
        view.destroy();
      });
    }
  });

  QUnit.test('returns null if the view has no element and no parent view', function () {
    view = _emberViewsViewsView.default.create();
    equal(_emberMetalProperty_get.get(view, 'parentView'), null, 'precond - has no parentView');
    equal(_emberMetalProperty_get.get(view, 'element'), null, 'has no element');
  });

  QUnit.test('returns null if the view has no element and parent view has no element', function () {
    expectDeprecation('Setting `childViews` on a Container is deprecated.');

    parentView = _emberViewsViewsContainer_view.default.create({
      childViews: [_emberViewsViewsView.default.extend()]
    });
    view = _emberMetalProperty_get.get(parentView, 'childViews').objectAt(0);

    equal(_emberMetalProperty_get.get(view, 'parentView'), parentView, 'precond - has parent view');
    equal(_emberMetalProperty_get.get(parentView, 'element'), null, 'parentView has no element');
    equal(_emberMetalProperty_get.get(view, 'element'), null, ' has no element');
  });

  QUnit.test('returns element if you set the value', function () {
    view = _emberViewsViewsView.default.create();
    equal(_emberMetalProperty_get.get(view, 'element'), null, 'precond- has no element');

    var dom = document.createElement('div');
    _emberMetalProperty_set.set(view, 'element', dom);

    equal(_emberMetalProperty_get.get(view, 'element'), dom, 'now has set element');
  });

  if (EmberDev && !EmberDev.runningProdBuild) {
    QUnit.test('should not allow the elementId to be changed after inserted', function () {
      view = _emberViewsViewsView.default.create({
        elementId: 'one'
      });

      _emberMetalRun_loop.default(function () {
        view.appendTo('#qunit-fixture');
      });

      throws(function () {
        view.set('elementId', 'two');
      }, 'raises elementId changed exception');

      equal(view.get('elementId'), 'one', 'elementId is still "one"');
    });
  }
});
enifed('ember-views/tests/views/view/element_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/tests/views/view');
  test('ember-views/tests/views/view/element_test.js should pass jscs', function () {
    ok(true, 'ember-views/tests/views/view/element_test.js should pass jscs.');
  });
});
enifed('ember-views/tests/views/view/element_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/tests/views/view');
  QUnit.test('ember-views/tests/views/view/element_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/tests/views/view/element_test.js should pass jshint.');
  });
});
enifed('ember-views/tests/views/view/evented_test', ['exports', 'ember-metal/run_loop', 'ember-runtime/system/object', 'ember-views/views/view'], function (exports, _emberMetalRun_loop, _emberRuntimeSystemObject, _emberViewsViewsView) {
  'use strict';

  var view;

  QUnit.module('EmberView evented helpers', {
    teardown: function () {
      _emberMetalRun_loop.default(function () {
        view.destroy();
      });
    }
  });

  QUnit.test('fire should call method sharing event name if it exists on the view', function () {
    var eventFired = false;

    view = _emberViewsViewsView.default.create({
      fireMyEvent: function () {
        this.trigger('myEvent');
      },

      myEvent: function () {
        eventFired = true;
      }
    });

    _emberMetalRun_loop.default(function () {
      view.fireMyEvent();
    });

    equal(eventFired, true, 'fired the view method sharing the event name');
  });

  QUnit.test('fire does not require a view method with the same name', function () {
    var eventFired = false;

    view = _emberViewsViewsView.default.create({
      fireMyEvent: function () {
        this.trigger('myEvent');
      }
    });

    var listenObject = _emberRuntimeSystemObject.default.create({
      onMyEvent: function () {
        eventFired = true;
      }
    });

    view.on('myEvent', listenObject, 'onMyEvent');

    _emberMetalRun_loop.default(function () {
      view.fireMyEvent();
    });

    equal(eventFired, true, 'fired the event without a view method sharing its name');

    _emberMetalRun_loop.default(function () {
      listenObject.destroy();
    });
  });
});
enifed('ember-views/tests/views/view/evented_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/tests/views/view');
  test('ember-views/tests/views/view/evented_test.js should pass jscs', function () {
    ok(true, 'ember-views/tests/views/view/evented_test.js should pass jscs.');
  });
});
enifed('ember-views/tests/views/view/evented_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/tests/views/view');
  QUnit.test('ember-views/tests/views/view/evented_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/tests/views/view/evented_test.js should pass jshint.');
  });
});
enifed('ember-views/tests/views/view/init_test', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-metal/run_loop', 'ember-metal/computed', 'ember-views/views/view', 'ember-template-compiler'], function (exports, _emberMetalCore, _emberMetalProperty_get, _emberMetalRun_loop, _emberMetalComputed, _emberViewsViewsView, _emberTemplateCompiler) {
  'use strict';

  var originalLookup = _emberMetalCore.default.lookup;
  var lookup, view;

  QUnit.module('EmberView.create', {
    setup: function () {
      _emberMetalCore.default.lookup = lookup = {};
    },
    teardown: function () {
      _emberMetalRun_loop.default(function () {
        view.destroy();
      });

      _emberMetalCore.default.lookup = originalLookup;
    }
  });

  QUnit.test('registers view in the global views hash using layerId for event targeted', function () {
    view = _emberViewsViewsView.default.create();
    _emberMetalRun_loop.default(function () {
      view.appendTo('#qunit-fixture');
    });
    equal(_emberViewsViewsView.default.views[_emberMetalProperty_get.get(view, 'elementId')], view, 'registers view');
  });

  QUnit.module('EmberView.extend');

  QUnit.test('should warn if a computed property is used for classNames', function () {
    expectAssertion(function () {
      _emberViewsViewsView.default.extend({
        elementId: 'test',
        classNames: _emberMetalComputed.computed(function () {
          return ['className'];
        })
      }).create();
    }, /Only arrays of static class strings.*For dynamic classes/i);
  });

  QUnit.test('should warn if a non-array is used for classNameBindings', function () {
    expectAssertion(function () {
      _emberViewsViewsView.default.extend({
        elementId: 'test',
        classNameBindings: _emberMetalComputed.computed(function () {
          return ['className'];
        })
      }).create();
    }, /Only arrays are allowed/i);
  });

  QUnit.test('creates a renderer if one is not provided', function () {
    var childView;

    childView = _emberViewsViewsView.default.create({
      template: _emberTemplateCompiler.compile('ber')
    });

    view = _emberViewsViewsView.default.create({
      childView: childView,
      template: _emberTemplateCompiler.compile('Em{{view.childView}}')
    });

    _emberMetalRun_loop.default(function () {
      view.append();
    });

    _emberMetalRun_loop.default(function () {
      ok(_emberMetalProperty_get.get(view, 'renderer'), 'view created without container receives a renderer');
      strictEqual(_emberMetalProperty_get.get(view, 'renderer'), _emberMetalProperty_get.get(childView, 'renderer'), 'parent and child share a renderer');
    });

    _emberMetalRun_loop.default(function () {
      view.destroy();
      childView.destroy();
    });
  });
});
enifed('ember-views/tests/views/view/init_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/tests/views/view');
  test('ember-views/tests/views/view/init_test.js should pass jscs', function () {
    ok(true, 'ember-views/tests/views/view/init_test.js should pass jscs.');
  });
});
enifed('ember-views/tests/views/view/init_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/tests/views/view');
  QUnit.test('ember-views/tests/views/view/init_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/tests/views/view/init_test.js should pass jshint.');
  });
});
enifed('ember-views/tests/views/view/inject_test', ['exports', 'ember-runtime/system/service', 'ember-runtime/system/container', 'ember-runtime/inject', 'ember-views/views/view'], function (exports, _emberRuntimeSystemService, _emberRuntimeSystemContainer, _emberRuntimeInject, _emberViewsViewsView) {
  'use strict';

  QUnit.module('EmberView - injected properties');

  QUnit.test('services can be injected into views', function () {
    var registry = new _emberRuntimeSystemContainer.Registry();
    var container = registry.container();

    registry.register('view:application', _emberViewsViewsView.default.extend({
      profilerService: _emberRuntimeInject.default.service('profiler')
    }));

    registry.register('service:profiler', _emberRuntimeSystemService.default.extend());

    var appView = container.lookup('view:application');
    var profilerService = container.lookup('service:profiler');

    equal(profilerService, appView.get('profilerService'), 'service.profiler is injected');
  });
});
enifed('ember-views/tests/views/view/inject_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/tests/views/view');
  test('ember-views/tests/views/view/inject_test.js should pass jscs', function () {
    ok(true, 'ember-views/tests/views/view/inject_test.js should pass jscs.');
  });
});
enifed('ember-views/tests/views/view/inject_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/tests/views/view');
  QUnit.test('ember-views/tests/views/view/inject_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/tests/views/view/inject_test.js should pass jshint.');
  });
});
enifed('ember-views/tests/views/view/is_visible_test', ['exports', 'ember-metal/core', 'ember-metal/property_get', 'ember-metal/property_set', 'ember-metal/run_loop', 'ember-metal/computed', 'ember-views/views/view', 'ember-views/views/container_view', 'ember-htmlbars/tests/utils', 'ember-htmlbars/keywords/view'], function (exports, _emberMetalCore, _emberMetalProperty_get, _emberMetalProperty_set, _emberMetalRun_loop, _emberMetalComputed, _emberViewsViewsView, _emberViewsViewsContainer_view, _emberHtmlbarsTestsUtils, _emberHtmlbarsKeywordsView) {
  'use strict';

  var View, view, parentBecameVisible, childBecameVisible, grandchildBecameVisible;
  var parentBecameHidden, childBecameHidden, grandchildBecameHidden;
  var warnings, originalWarn;
  var originalViewKeyword;

  QUnit.module('EmberView#isVisible', {
    setup: function () {
      originalViewKeyword = _emberHtmlbarsTestsUtils.registerKeyword('view', _emberHtmlbarsKeywordsView.default);
      warnings = [];
      originalWarn = _emberMetalCore.default.warn;
      _emberMetalCore.default.warn = function (message, test) {
        if (!test) {
          warnings.push(message);
        }
      };
    },

    teardown: function () {
      if (view) {
        _emberMetalRun_loop.default(function () {
          view.destroy();
        });
      }
      _emberHtmlbarsTestsUtils.resetKeyword('view', originalViewKeyword);
    }
  });

  QUnit.test('should hide views when isVisible is false', function () {
    view = _emberViewsViewsView.default.create({
      isVisible: false
    });

    _emberMetalRun_loop.default(function () {
      view.append();
    });

    ok(view.$().is(':hidden'), 'the view is hidden');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'isVisible', true);
    });

    ok(view.$().is(':visible'), 'the view is visible');
    _emberMetalRun_loop.default(function () {
      view.remove();
    });

    deepEqual(warnings, [], 'no warnings were triggered');
  });

  QUnit.test('should hide element if isVisible is false before element is created', function () {
    view = _emberViewsViewsView.default.create({
      isVisible: false
    });

    ok(!_emberMetalProperty_get.get(view, 'isVisible'), 'precond - view is not visible');

    _emberMetalProperty_set.set(view, 'template', function () {
      return 'foo';
    });

    _emberMetalRun_loop.default(function () {
      view.append();
    });

    ok(view.$().is(':hidden'), 'should be hidden');

    _emberMetalRun_loop.default(function () {
      view.remove();
    });

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'isVisible', true);
    });

    _emberMetalRun_loop.default(function () {
      view.append();
    });

    ok(view.$().is(':visible'), 'view should be visible');

    _emberMetalRun_loop.default(function () {
      view.remove();
    });

    deepEqual(warnings, [], 'no warnings were triggered');
  });

  QUnit.test('should hide views when isVisible is a CP returning false', function () {
    view = _emberViewsViewsView.default.extend({
      isVisible: _emberMetalComputed.computed(function () {
        return false;
      })
    }).create();

    _emberMetalRun_loop.default(function () {
      view.append();
    });

    ok(view.$().is(':hidden'), 'the view is hidden');

    _emberMetalRun_loop.default(function () {
      _emberMetalProperty_set.set(view, 'isVisible', true);
    });

    ok(view.$().is(':visible'), 'the view is visible');
    _emberMetalRun_loop.default(function () {
      view.remove();
    });

    deepEqual(warnings, [], 'no warnings were triggered');
  });

  QUnit.test('doesn\'t overwrite existing style attribute bindings', function () {
    view = _emberViewsViewsView.default.create({
      isVisible: false,
      attributeBindings: ['style'],
      style: 'color: blue;'
    });

    _emberMetalRun_loop.default(function () {
      view.append();
    });

    equal(view.$().attr('style'), 'color: blue; display: none;', 'has concatenated style attribute');
  });

  QUnit.module('EmberView#isVisible with Container', {
    setup: function () {
      originalViewKeyword = _emberHtmlbarsTestsUtils.registerKeyword('view', _emberHtmlbarsKeywordsView.default);
      expectDeprecation('Setting `childViews` on a Container is deprecated.');

      parentBecameVisible = 0;
      childBecameVisible = 0;
      grandchildBecameVisible = 0;
      parentBecameHidden = 0;
      childBecameHidden = 0;
      grandchildBecameHidden = 0;

      View = _emberViewsViewsContainer_view.default.extend({
        childViews: ['child'],
        becameVisible: function () {
          parentBecameVisible++;
        },
        becameHidden: function () {
          parentBecameHidden++;
        },

        child: _emberViewsViewsContainer_view.default.extend({
          childViews: ['grandchild'],
          becameVisible: function () {
            childBecameVisible++;
          },
          becameHidden: function () {
            childBecameHidden++;
          },

          grandchild: _emberViewsViewsView.default.extend({
            template: function () {
              return 'seems weird bro';
            },
            becameVisible: function () {
              grandchildBecameVisible++;
            },
            becameHidden: function () {
              grandchildBecameHidden++;
            }
          })
        })
      });
    },

    teardown: function () {
      if (view) {
        _emberMetalRun_loop.default(function () {
          view.destroy();
        });
      }
      _emberHtmlbarsTestsUtils.resetKeyword('view', originalViewKeyword);
    }
  });

  QUnit.test('view should be notified after isVisible is set to false and the element has been hidden', function () {
    _emberMetalRun_loop.default(function () {
      view = View.create({ isVisible: false });
      view.append();
    });

    ok(view.$().is(':hidden'), 'precond - view is hidden when appended');

    _emberMetalRun_loop.default(function () {
      view.set('isVisible', true);
    });

    ok(view.$().is(':visible'), 'precond - view is now visible');
    equal(parentBecameVisible, 1);
    equal(childBecameVisible, 1);
    equal(grandchildBecameVisible, 1);
  });

  QUnit.test('view should be notified after isVisible is set to false and the element has been hidden', function () {
    _emberMetalRun_loop.default(function () {
      view = View.create({ isVisible: false });
      view.append();
    });

    ok(view.$().is(':hidden'), 'precond - view is hidden when appended');

    _emberMetalRun_loop.default(function () {
      view.set('isVisible', true);
    });

    ok(view.$().is(':visible'), 'precond - view is now visible');
    equal(parentBecameVisible, 1);
    equal(childBecameVisible, 1);
    equal(grandchildBecameVisible, 1);
  });

  QUnit.test('view should be notified after isVisible is set to false and the element has been hidden', function () {
    view = View.create({ isVisible: true });
    //var childView = view.get('childViews').objectAt(0);

    _emberMetalRun_loop.default(function () {
      view.append();
    });

    ok(view.$().is(':visible'), 'precond - view is visible when appended');

    _emberMetalRun_loop.default(function () {
      view.set('isVisible', false);
    });

    ok(view.$().is(':hidden'), 'precond - view is now hidden');
  });

  QUnit.test('view should be notified after isVisible is set to true and the element has been shown', function () {
    view = View.create({ isVisible: false });

    _emberMetalRun_loop.default(function () {
      view.append();
    });

    ok(view.$().is(':hidden'), 'precond - view is hidden when appended');

    _emberMetalRun_loop.default(function () {
      view.set('isVisible', true);
    });

    ok(view.$().is(':visible'), 'precond - view is now visible');

    equal(parentBecameVisible, 1);
    equal(childBecameVisible, 1);
    equal(grandchildBecameVisible, 1);
  });

  QUnit.test('if a view descends from a hidden view, making isVisible true should not trigger becameVisible', function () {
    view = View.create({ isVisible: true });
    var childView = view.get('childViews').objectAt(0);

    _emberMetalRun_loop.default(function () {
      view.append();
    });

    ok(view.$().is(':visible'), 'precond - view is visible when appended');

    _emberMetalRun_loop.default(function () {
      childView.set('isVisible', false);
    });

    _emberMetalRun_loop.default(function () {
      view.set('isVisible', false);
    });

    childBecameVisible = 0;
    grandchildBecameVisible = 0;

    _emberMetalRun_loop.default(function () {
      childView.set('isVisible', true);
    });

    equal(childBecameVisible, 0, 'the child did not become visible');
    equal(grandchildBecameVisible, 0, 'the grandchild did not become visible');
  });

  QUnit.test('if a child view becomes visible while its parent is hidden, if its parent later becomes visible, it receives a becameVisible callback', function () {
    view = View.create({ isVisible: false });
    var childView = view.get('childViews').objectAt(0);

    _emberMetalRun_loop.default(function () {
      view.append();
    });

    ok(view.$().is(':hidden'), 'precond - view is hidden when appended');

    _emberMetalRun_loop.default(function () {
      childView.set('isVisible', true);
    });

    equal(childBecameVisible, 0, 'child did not become visible since parent is hidden');
    equal(grandchildBecameVisible, 0, 'grandchild did not become visible since parent is hidden');

    _emberMetalRun_loop.default(function () {
      view.set('isVisible', true);
    });

    equal(parentBecameVisible, 1);
    equal(childBecameVisible, 1);
    equal(grandchildBecameVisible, 1);
  });
});
enifed('ember-views/tests/views/view/is_visible_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/tests/views/view');
  test('ember-views/tests/views/view/is_visible_test.js should pass jscs', function () {
    ok(true, 'ember-views/tests/views/view/is_visible_test.js should pass jscs.');
  });
});
enifed('ember-views/tests/views/view/is_visible_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/tests/views/view');
  QUnit.test('ember-views/tests/views/view/is_visible_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/tests/views/view/is_visible_test.js should pass jshint.');
  });
});
enifed('ember-views/tests/views/view/jquery_test', ['exports', 'ember-metal/property_get', 'ember-views/views/view', 'ember-runtime/tests/utils', 'ember-template-compiler/system/compile'], function (exports, _emberMetalProperty_get, _emberViewsViewsView, _emberRuntimeTestsUtils, _emberTemplateCompilerSystemCompile) {
  'use strict';

  var view;
  QUnit.module('EmberView#$', {
    setup: function () {
      view = _emberViewsViewsView.default.extend({
        template: _emberTemplateCompilerSystemCompile.default('<span></span>')
      }).create();

      _emberRuntimeTestsUtils.runAppend(view);
    },

    teardown: function () {
      _emberRuntimeTestsUtils.runDestroy(view);
    }
  });

  QUnit.test('returns undefined if no element', function () {
    var view = _emberViewsViewsView.default.create();
    ok(!_emberMetalProperty_get.get(view, 'element'), 'precond - should have no element');
    equal(view.$(), undefined, 'should return undefined');
    equal(view.$('span'), undefined, 'should undefined if filter passed');

    _emberRuntimeTestsUtils.runDestroy(view);
  });

  QUnit.test('returns jQuery object selecting element if provided', function () {
    ok(_emberMetalProperty_get.get(view, 'element'), 'precond - should have element');

    var jquery = view.$();
    equal(jquery.length, 1, 'view.$() should have one element');
    equal(jquery[0], _emberMetalProperty_get.get(view, 'element'), 'element should be element');
  });

  QUnit.test('returns jQuery object selecting element inside element if provided', function () {
    ok(_emberMetalProperty_get.get(view, 'element'), 'precond - should have element');

    var jquery = view.$('span');
    equal(jquery.length, 1, 'view.$() should have one element');
    equal(jquery[0].parentNode, _emberMetalProperty_get.get(view, 'element'), 'element should be in element');
  });

  QUnit.test('returns empty jQuery object if filter passed that does not match item in parent', function () {
    ok(_emberMetalProperty_get.get(view, 'element'), 'precond - should have element');

    var jquery = view.$('body'); // would normally work if not scoped to view
    equal(jquery.length, 0, 'view.$(body) should have no elements');
  });

  QUnit.test('asserts for tagless views', function () {
    var view = _emberViewsViewsView.default.create({
      tagName: ''
    });

    _emberRuntimeTestsUtils.runAppend(view);

    expectAssertion(function () {
      view.$();
    }, /You cannot access this.\$\(\) on a component with `tagName: \'\'` specified/);

    _emberRuntimeTestsUtils.runDestroy(view);
  });
});
enifed('ember-views/tests/views/view/jquery_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/tests/views/view');
  test('ember-views/tests/views/view/jquery_test.js should pass jscs', function () {
    ok(true, 'ember-views/tests/views/view/jquery_test.js should pass jscs.');
  });
});
enifed('ember-views/tests/views/view/jquery_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/tests/views/view');
  QUnit.test('ember-views/tests/views/view/jquery_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/tests/views/view/jquery_test.js should pass jshint.');
  });
});
enifed('ember-views/tests/views/view/layout_test', ['exports', 'container/registry', 'ember-metal/property_get', 'ember-metal/run_loop', 'ember-views/views/view', 'ember-template-compiler', 'ember-htmlbars/helpers'], function (exports, _containerRegistry, _emberMetalProperty_get, _emberMetalRun_loop, _emberViewsViewsView, _emberTemplateCompiler, _emberHtmlbarsHelpers) {
  'use strict';

  var registry, container, view;

  QUnit.module('EmberView - Layout Functionality', {
    setup: function () {
      registry = new _containerRegistry.default();
      container = registry.container();
      registry.optionsForType('template', { instantiate: false });
    },

    teardown: function () {
      _emberMetalRun_loop.default(function () {
        view.destroy();
        container.destroy();
      });
      registry = container = view = null;
    }
  });

  QUnit.test('Layout views return throw if their layout cannot be found', function () {
    view = _emberViewsViewsView.default.create({
      layoutName: 'cantBeFound',
      container: { lookup: function () {} }
    });

    expectAssertion(function () {
      _emberMetalProperty_get.get(view, 'layout');
    }, /cantBeFound/);
  });

  QUnit.test('should use the template of the associated layout', function () {
    var templateCalled = 0;
    var layoutCalled = 0;

    _emberHtmlbarsHelpers.registerHelper('call-template', function () {
      templateCalled++;
    });

    _emberHtmlbarsHelpers.registerHelper('call-layout', function () {
      layoutCalled++;
    });

    registry.register('template:template', _emberTemplateCompiler.compile('{{call-template}}'));
    registry.register('template:layout', _emberTemplateCompiler.compile('{{call-layout}}'));

    view = _emberViewsViewsView.default.create({
      container: container,
      layoutName: 'layout',
      templateName: 'template'
    });

    _emberMetalRun_loop.default(function () {
      view.createElement();
    });

    equal(templateCalled, 0, 'template is not called when layout is present');
    equal(layoutCalled, 1, 'layout is called when layout is present');
  });

  QUnit.test('should use the associated template with itself as the context', function () {
    registry.register('template:testTemplate', _emberTemplateCompiler.compile('<h1 id=\'twas-called\'>template was called for {{personName}}</h1>'));

    view = _emberViewsViewsView.default.create({
      container: container,
      layoutName: 'testTemplate',

      context: {
        personName: 'Tom DAAAALE'
      }
    });

    _emberMetalRun_loop.default(function () {
      view.createElement();
    });

    equal('template was called for Tom DAAAALE', view.$('#twas-called').text(), 'the named template was called with the view as the data source');
  });

  QUnit.test('should fall back to defaultLayout if neither template nor templateName are provided', function () {
    var View = _emberViewsViewsView.default.extend({
      defaultLayout: _emberTemplateCompiler.compile('used default layout')
    });

    view = View.create();

    _emberMetalRun_loop.default(function () {
      view.createElement();
    });

    equal('used default layout', view.$().text(), 'the named template was called with the view as the data source');
  });

  QUnit.test('should not use defaultLayout if layout is provided', function () {
    var View = _emberViewsViewsView.default.extend({
      layout: _emberTemplateCompiler.compile('used layout'),
      defaultLayout: _emberTemplateCompiler.compile('used default layout')
    });

    view = View.create();
    _emberMetalRun_loop.default(function () {
      view.createElement();
    });

    equal('used layout', view.$().text(), 'default layout was not printed');
  });
});
enifed('ember-views/tests/views/view/layout_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/tests/views/view');
  test('ember-views/tests/views/view/layout_test.js should pass jscs', function () {
    ok(true, 'ember-views/tests/views/view/layout_test.js should pass jscs.');
  });
});
enifed('ember-views/tests/views/view/layout_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/tests/views/view');
  QUnit.test('ember-views/tests/views/view/layout_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/tests/views/view/layout_test.js should pass jshint.');
  });
});
enifed('ember-views/tests/views/view/nearest_of_type_test', ['exports', 'ember-metal/run_loop', 'ember-metal/mixin', 'ember-views/views/view', 'ember-template-compiler/system/compile', 'ember-htmlbars/tests/utils', 'ember-template-compiler/plugins/assert-no-view-and-controller-paths', 'ember-htmlbars/keywords/view'], function (exports, _emberMetalRun_loop, _emberMetalMixin, _emberViewsViewsView, _emberTemplateCompilerSystemCompile, _emberHtmlbarsTestsUtils, _emberTemplateCompilerPluginsAssertNoViewAndControllerPaths, _emberHtmlbarsKeywordsView) {
  'use strict';

  var parentView, view;
  var originalViewKeyword;

  var Mixin, Parent;

  QUnit.module('View#nearest*', {
    setup: function () {
      _emberHtmlbarsTestsUtils.removeAstPlugin(_emberTemplateCompilerPluginsAssertNoViewAndControllerPaths.default);
      originalViewKeyword = _emberHtmlbarsTestsUtils.registerKeyword('view', _emberHtmlbarsKeywordsView.default);
      Mixin = _emberMetalMixin.Mixin.create({});
      Parent = _emberViewsViewsView.default.extend(Mixin, {
        template: _emberTemplateCompilerSystemCompile.default('{{view}}')
      });
    },
    teardown: function () {
      _emberMetalRun_loop.default(function () {
        if (parentView) {
          parentView.destroy();
        }
        if (view) {
          view.destroy();
        }
      });
      _emberHtmlbarsTestsUtils.resetKeyword('view', originalViewKeyword);
      _emberHtmlbarsTestsUtils.registerAstPlugin(_emberTemplateCompilerPluginsAssertNoViewAndControllerPaths.default);
    }
  });

  QUnit.test('nearestOfType should find the closest view by view class', function () {
    var child;

    _emberMetalRun_loop.default(function () {
      parentView = Parent.create();
      parentView.appendTo('#qunit-fixture');
    });

    child = parentView.get('childViews')[0];
    equal(child.nearestOfType(Parent), parentView, 'finds closest view in the hierarchy by class');
  });

  QUnit.test('nearestOfType should find the closest view by mixin', function () {
    var child;

    _emberMetalRun_loop.default(function () {
      parentView = Parent.create();
      parentView.appendTo('#qunit-fixture');
    });

    child = parentView.get('childViews')[0];
    equal(child.nearestOfType(Mixin), parentView, 'finds closest view in the hierarchy by class');
  });

  QUnit.test('nearestWithProperty should search immediate parent', function () {
    var childView;

    view = _emberViewsViewsView.default.create({
      myProp: true,
      template: _emberTemplateCompilerSystemCompile.default('{{view}}')
    });

    _emberMetalRun_loop.default(function () {
      view.appendTo('#qunit-fixture');
    });

    childView = view.get('childViews')[0];
    equal(childView.nearestWithProperty('myProp'), view);
  });

  QUnit.test('nearestChildOf should be deprecated', function () {
    var child;

    _emberMetalRun_loop.default(function () {
      parentView = Parent.create();
      parentView.appendTo('#qunit-fixture');
    });

    child = parentView.get('childViews')[0];
    expectDeprecation(function () {
      child.nearestChildOf(Parent);
    }, 'nearestChildOf has been deprecated.');
  });
});
enifed('ember-views/tests/views/view/nearest_of_type_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/tests/views/view');
  test('ember-views/tests/views/view/nearest_of_type_test.js should pass jscs', function () {
    ok(true, 'ember-views/tests/views/view/nearest_of_type_test.js should pass jscs.');
  });
});
enifed('ember-views/tests/views/view/nearest_of_type_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/tests/views/view');
  QUnit.test('ember-views/tests/views/view/nearest_of_type_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/tests/views/view/nearest_of_type_test.js should pass jshint.');
  });
});
enifed('ember-views/tests/views/view/nested_view_ordering_test', ['exports', 'container/registry', 'ember-metal/run_loop', 'ember-views/views/view', 'ember-template-compiler/system/compile', 'ember-htmlbars/tests/utils', 'ember-htmlbars/keywords/view'], function (exports, _containerRegistry, _emberMetalRun_loop, _emberViewsViewsView, _emberTemplateCompilerSystemCompile, _emberHtmlbarsTestsUtils, _emberHtmlbarsKeywordsView) {
  'use strict';

  var registry, container, view;
  var originalViewKeyword;

  QUnit.module('EmberView - Nested View Ordering', {
    setup: function () {
      originalViewKeyword = _emberHtmlbarsTestsUtils.registerKeyword('view', _emberHtmlbarsKeywordsView.default);
      registry = new _containerRegistry.default();
      container = registry.container();
    },
    teardown: function () {
      _emberMetalRun_loop.default(function () {
        if (view) {
          view.destroy();
        }
        container.destroy();
      });
      _emberHtmlbarsTestsUtils.resetKeyword('view', originalViewKeyword);
      registry = container = view = null;
    }
  });

  QUnit.test('should call didInsertElement on child views before parent', function () {
    var insertedLast;

    view = _emberViewsViewsView.default.create({
      didInsertElement: function () {
        insertedLast = 'outer';
      },
      container: container,
      template: _emberTemplateCompilerSystemCompile.default('{{view "inner"}}')
    });

    registry.register('view:inner', _emberViewsViewsView.default.extend({
      didInsertElement: function () {
        insertedLast = 'inner';
      }
    }));

    _emberMetalRun_loop.default(function () {
      view.append();
    });

    equal(insertedLast, 'outer', 'didInsertElement called on outer view after inner view');
  });
});
enifed('ember-views/tests/views/view/nested_view_ordering_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/tests/views/view');
  test('ember-views/tests/views/view/nested_view_ordering_test.js should pass jscs', function () {
    ok(true, 'ember-views/tests/views/view/nested_view_ordering_test.js should pass jscs.');
  });
});
enifed('ember-views/tests/views/view/nested_view_ordering_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/tests/views/view');
  QUnit.test('ember-views/tests/views/view/nested_view_ordering_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/tests/views/view/nested_view_ordering_test.js should pass jshint.');
  });
});
enifed('ember-views/tests/views/view/remove_test', ['exports', 'ember-metal/property_get', 'ember-metal/run_loop', 'ember-views/system/jquery', 'ember-views/views/view', 'ember-views/views/container_view', 'ember-htmlbars/tests/utils', 'ember-htmlbars/keywords/view'], function (exports, _emberMetalProperty_get, _emberMetalRun_loop, _emberViewsSystemJquery, _emberViewsViewsView, _emberViewsViewsContainer_view, _emberHtmlbarsTestsUtils, _emberHtmlbarsKeywordsView) {
  'use strict';

  // .......................................................
  // removeChild()
  //

  var parentView, child;
  var originalViewKeyword;
  QUnit.module('View#removeChild', {
    setup: function () {
      originalViewKeyword = _emberHtmlbarsTestsUtils.registerKeyword('view', _emberHtmlbarsKeywordsView.default);
      expectDeprecation('Setting `childViews` on a Container is deprecated.');

      parentView = _emberViewsViewsContainer_view.default.create({ childViews: [_emberViewsViewsView.default] });
      child = _emberMetalProperty_get.get(parentView, 'childViews').objectAt(0);
    },
    teardown: function () {
      _emberMetalRun_loop.default(function () {
        parentView.destroy();
        child.destroy();
      });
      _emberHtmlbarsTestsUtils.resetKeyword('view', originalViewKeyword);
    }
  });

  QUnit.test('returns receiver', function () {
    equal(parentView.removeChild(child), parentView, 'receiver');
  });

  QUnit.test('removes child from parent.childViews array', function () {
    ok(_emberMetalProperty_get.get(parentView, 'childViews').indexOf(child) >= 0, 'precond - has child in childViews array before remove');
    parentView.removeChild(child);
    ok(_emberMetalProperty_get.get(parentView, 'childViews').indexOf(child) < 0, 'removed child');
  });

  QUnit.test('sets parentView property to null', function () {
    ok(_emberMetalProperty_get.get(child, 'parentView'), 'precond - has parentView');
    parentView.removeChild(child);
    ok(!_emberMetalProperty_get.get(child, 'parentView'), 'parentView is now null');
  });

  // .......................................................
  // removeAllChildren()
  //
  var view, childViews;
  QUnit.module('View#removeAllChildren', {
    setup: function () {
      originalViewKeyword = _emberHtmlbarsTestsUtils.registerKeyword('view', _emberHtmlbarsKeywordsView.default);
      expectDeprecation('Setting `childViews` on a Container is deprecated.');

      view = _emberViewsViewsContainer_view.default.create({
        childViews: [_emberViewsViewsView.default, _emberViewsViewsView.default, _emberViewsViewsView.default]
      });
      childViews = view.get('childViews');
    },
    teardown: function () {
      _emberMetalRun_loop.default(function () {
        childViews.forEach(function (v) {
          v.destroy();
        });
        view.destroy();
      });
      _emberHtmlbarsTestsUtils.resetKeyword('view', originalViewKeyword);
    }
  });

  QUnit.test('removes all child views', function () {
    equal(_emberMetalProperty_get.get(view, 'childViews.length'), 3, 'precond - has child views');

    view.removeAllChildren();
    equal(_emberMetalProperty_get.get(view, 'childViews.length'), 0, 'removed all children');
  });

  QUnit.test('returns receiver', function () {
    equal(view.removeAllChildren(), view, 'receiver');
  });

  // .......................................................
  // removeFromParent()
  //
  QUnit.module('View#removeFromParent', {
    setup: function () {
      originalViewKeyword = _emberHtmlbarsTestsUtils.registerKeyword('view', _emberHtmlbarsKeywordsView.default);
    },
    teardown: function () {
      _emberMetalRun_loop.default(function () {
        if (parentView) {
          parentView.destroy();
        }
        if (child) {
          child.destroy();
        }
        if (view) {
          view.destroy();
        }
      });
      _emberHtmlbarsTestsUtils.resetKeyword('view', originalViewKeyword);
    }
  });

  QUnit.test('removes view from parent view', function () {
    expectDeprecation('Setting `childViews` on a Container is deprecated.');

    parentView = _emberViewsViewsContainer_view.default.create({ childViews: [_emberViewsViewsView.default] });
    child = _emberMetalProperty_get.get(parentView, 'childViews').objectAt(0);
    ok(_emberMetalProperty_get.get(child, 'parentView'), 'precond - has parentView');

    _emberMetalRun_loop.default(function () {
      parentView.createElement();
    });

    ok(parentView.$('div').length, 'precond - has a child DOM element');

    _emberMetalRun_loop.default(function () {
      child.removeFromParent();
    });

    ok(!_emberMetalProperty_get.get(child, 'parentView'), 'no longer has parentView');
    ok(_emberMetalProperty_get.get(parentView, 'childViews').indexOf(child) < 0, 'no longer in parent childViews');
    equal(parentView.$('div').length, 0, 'removes DOM element from parent');
  });

  QUnit.test('returns receiver', function () {
    expectDeprecation('Setting `childViews` on a Container is deprecated.');

    parentView = _emberViewsViewsContainer_view.default.create({ childViews: [_emberViewsViewsView.default] });
    child = _emberMetalProperty_get.get(parentView, 'childViews').objectAt(0);
    var removed = _emberMetalRun_loop.default(function () {
      return child.removeFromParent();
    });

    equal(removed, child, 'receiver');
  });

  QUnit.test('does nothing if not in parentView', function () {
    child = _emberViewsViewsView.default.create();

    // monkey patch for testing...
    ok(!_emberMetalProperty_get.get(child, 'parentView'), 'precond - has no parent');

    child.removeFromParent();

    _emberMetalRun_loop.default(function () {
      child.destroy();
    });
  });

  QUnit.test('the DOM element is gone after doing append and remove in two separate runloops', function () {
    view = _emberViewsViewsView.default.create();
    _emberMetalRun_loop.default(function () {
      view.append();
    });
    _emberMetalRun_loop.default(function () {
      view.remove();
    });

    var viewElem = _emberViewsSystemJquery.default('#' + _emberMetalProperty_get.get(view, 'elementId'));
    ok(viewElem.length === 0, 'view\'s element doesn\'t exist in DOM');
  });

  QUnit.test('the DOM element is gone after doing append and remove in a single runloop', function () {
    view = _emberViewsViewsView.default.create();
    _emberMetalRun_loop.default(function () {
      view.append();
      view.remove();
    });

    var viewElem = _emberViewsSystemJquery.default('#' + _emberMetalProperty_get.get(view, 'elementId'));
    ok(viewElem.length === 0, 'view\'s element doesn\'t exist in DOM');
  });
});
enifed('ember-views/tests/views/view/remove_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/tests/views/view');
  test('ember-views/tests/views/view/remove_test.js should pass jscs', function () {
    ok(true, 'ember-views/tests/views/view/remove_test.js should pass jscs.');
  });
});
enifed('ember-views/tests/views/view/remove_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/tests/views/view');
  QUnit.test('ember-views/tests/views/view/remove_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/tests/views/view/remove_test.js should pass jshint.');
  });
});
enifed('ember-views/tests/views/view/render_to_element_test', ['exports', 'ember-metal/property_get', 'ember-metal/run_loop', 'ember-views/views/view', 'ember-template-compiler/system/compile'], function (exports, _emberMetalProperty_get, _emberMetalRun_loop, _emberViewsViewsView, _emberTemplateCompilerSystemCompile) {
  'use strict';

  var View, view;

  QUnit.module('EmberView - renderToElement()', {
    setup: function () {
      View = _emberViewsViewsView.default.extend({
        template: _emberTemplateCompilerSystemCompile.default('<h1>hello world</h1> goodbye world')
      });
    },

    teardown: function () {
      _emberMetalRun_loop.default(function () {
        if (!view.isDestroyed) {
          view.destroy();
        }
      });
    }
  });

  QUnit.test('should render into and return a body element', function () {
    view = View.create();

    ok(!_emberMetalProperty_get.get(view, 'element'), 'precond - should not have an element');

    var element;

    _emberMetalRun_loop.default(function () {
      element = view.renderToElement();
    });

    equal(element.tagName, 'BODY', 'returns a body element');
    equal(element.firstChild.tagName, 'DIV', 'renders the view div');
    equal(element.firstChild.firstChild.tagName, 'H1', 'renders the view div');
    equal(element.firstChild.firstChild.nextSibling.nodeValue, ' goodbye world', 'renders the text node');
  });

  QUnit.test('should create and render into an element with a provided tagName', function () {
    view = View.create();

    ok(!_emberMetalProperty_get.get(view, 'element'), 'precond - should not have an element');

    var element;

    _emberMetalRun_loop.default(function () {
      element = view.renderToElement('div');
    });

    equal(element.tagName, 'DIV', 'returns a body element');
    equal(element.firstChild.tagName, 'DIV', 'renders the view div');
    equal(element.firstChild.firstChild.tagName, 'H1', 'renders the view div');
    equal(element.firstChild.firstChild.nextSibling.nodeValue, ' goodbye world', 'renders the text node');
  });
});
enifed('ember-views/tests/views/view/render_to_element_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/tests/views/view');
  test('ember-views/tests/views/view/render_to_element_test.js should pass jscs', function () {
    ok(true, 'ember-views/tests/views/view/render_to_element_test.js should pass jscs.');
  });
});
enifed('ember-views/tests/views/view/render_to_element_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/tests/views/view');
  QUnit.test('ember-views/tests/views/view/render_to_element_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/tests/views/view/render_to_element_test.js should pass jshint.');
  });
});
enifed('ember-views/tests/views/view/replace_in_test', ['exports', 'ember-metal/property_get', 'ember-metal/run_loop', 'ember-views/system/jquery', 'ember-views/views/view', 'ember-views/views/container_view', 'ember-htmlbars/tests/utils', 'ember-htmlbars/keywords/view'], function (exports, _emberMetalProperty_get, _emberMetalRun_loop, _emberViewsSystemJquery, _emberViewsViewsView, _emberViewsViewsContainer_view, _emberHtmlbarsTestsUtils, _emberHtmlbarsKeywordsView) {
  'use strict';

  var View, view;
  var originalViewKeyword;

  QUnit.module('EmberView - replaceIn()', {
    setup: function () {
      originalViewKeyword = _emberHtmlbarsTestsUtils.registerKeyword('view', _emberHtmlbarsKeywordsView.default);
      View = _emberViewsViewsView.default.extend({});
    },

    teardown: function () {
      _emberMetalRun_loop.default(function () {
        view.destroy();
      });
      _emberHtmlbarsTestsUtils.resetKeyword('view', originalViewKeyword);
    }
  });

  QUnit.test('should be added to the specified element when calling replaceIn()', function () {
    _emberViewsSystemJquery.default('#qunit-fixture').html('<div id="menu"></div>');

    view = View.create();

    ok(!_emberMetalProperty_get.get(view, 'element'), 'precond - should not have an element');

    _emberMetalRun_loop.default(function () {
      view.replaceIn('#menu');
    });

    var viewElem = _emberViewsSystemJquery.default('#menu').children();
    ok(viewElem.length > 0, 'creates and replaces the view\'s element');
  });

  QUnit.test('raises an assert when a target does not exist in the DOM', function () {
    view = View.create();

    expectAssertion(function () {
      _emberMetalRun_loop.default(function () {
        view.replaceIn('made-up-target');
      });
    });
  });

  QUnit.test('should remove previous elements when calling replaceIn()', function () {
    _emberViewsSystemJquery.default('#qunit-fixture').html('\n    <div id="menu">\n      <p id="child"></p>\n    </div>\n  ');

    view = View.create();

    var originalChild = _emberViewsSystemJquery.default('#child');
    ok(originalChild.length === 1, 'precond - target starts with child element');

    _emberMetalRun_loop.default(function () {
      view.replaceIn('#menu');
    });

    originalChild = _emberViewsSystemJquery.default('#child');
    ok(originalChild.length === 0, 'target\'s original child was removed');

    var newChild = _emberViewsSystemJquery.default('#menu').children();
    ok(newChild.length === 1, 'target has new child element');
  });

  QUnit.test('should move the view to the inDOM state after replacing', function () {
    _emberViewsSystemJquery.default('#qunit-fixture').html('<div id="menu"></div>');
    view = View.create();

    _emberMetalRun_loop.default(function () {
      view.replaceIn('#menu');
    });

    equal(view.currentState, view._states.inDOM, 'the view is in the inDOM state');
  });

  QUnit.module('EmberView - replaceIn() in a view hierarchy', {
    setup: function () {
      originalViewKeyword = _emberHtmlbarsTestsUtils.registerKeyword('view', _emberHtmlbarsKeywordsView.default);
      expectDeprecation('Setting `childViews` on a Container is deprecated.');

      View = _emberViewsViewsContainer_view.default.extend({
        childViews: ['child'],
        child: _emberViewsViewsView.default.extend({
          elementId: 'child'
        })
      });
    },

    teardown: function () {
      _emberMetalRun_loop.default(function () {
        view.destroy();
      });
      _emberHtmlbarsTestsUtils.resetKeyword('view', originalViewKeyword);
    }
  });

  QUnit.test('should be added to the specified element when calling replaceIn()', function () {
    _emberViewsSystemJquery.default('#qunit-fixture').html('<div id="menu"></div>');

    view = View.create();

    ok(!_emberMetalProperty_get.get(view, 'element'), 'precond - should not have an element');

    _emberMetalRun_loop.default(function () {
      view.replaceIn('#menu');
    });

    var viewElem = _emberViewsSystemJquery.default('#menu #child');
    ok(viewElem.length > 0, 'creates and replaces the view\'s element');
  });
});
enifed('ember-views/tests/views/view/replace_in_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/tests/views/view');
  test('ember-views/tests/views/view/replace_in_test.js should pass jscs', function () {
    ok(true, 'ember-views/tests/views/view/replace_in_test.js should pass jscs.');
  });
});
enifed('ember-views/tests/views/view/replace_in_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/tests/views/view');
  QUnit.test('ember-views/tests/views/view/replace_in_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/tests/views/view/replace_in_test.js should pass jshint.');
  });
});
enifed('ember-views/tests/views/view/template_test', ['exports', 'container/registry', 'ember-metal/property_get', 'ember-metal/run_loop', 'ember-views/views/view', 'ember-template-compiler'], function (exports, _containerRegistry, _emberMetalProperty_get, _emberMetalRun_loop, _emberViewsViewsView, _emberTemplateCompiler) {
  'use strict';

  var registry, container, view;

  QUnit.module('EmberView - Template Functionality', {
    setup: function () {
      registry = new _containerRegistry.default();
      container = registry.container();
      registry.optionsForType('template', { instantiate: false });
    },
    teardown: function () {
      _emberMetalRun_loop.default(function () {
        if (view) {
          view.destroy();
        }
        container.destroy();
        registry = container = view = null;
      });
    }
  });

  QUnit.test('Template views return throw if their template cannot be found', function () {
    view = _emberViewsViewsView.default.create({
      templateName: 'cantBeFound',
      container: { lookup: function () {} }
    });

    expectAssertion(function () {
      _emberMetalProperty_get.get(view, 'template');
    }, /cantBeFound/);
  });

  QUnit.test('should call the function of the associated template', function () {
    registry.register('template:testTemplate', _emberTemplateCompiler.compile('<h1 id=\'twas-called\'>template was called</h1>'));

    view = _emberViewsViewsView.default.create({
      container: container,
      templateName: 'testTemplate'
    });

    _emberMetalRun_loop.default(function () {
      view.createElement();
    });

    ok(view.$('#twas-called').length, 'the named template was called');
  });

  QUnit.test('should call the function of the associated template with itself as the context', function () {
    registry.register('template:testTemplate', _emberTemplateCompiler.compile('<h1 id=\'twas-called\'>template was called for {{personName}}</h1>'));

    view = _emberViewsViewsView.default.create({
      container: container,
      templateName: 'testTemplate',

      context: {
        personName: 'Tom DAAAALE'
      }
    });

    _emberMetalRun_loop.default(function () {
      view.createElement();
    });

    equal('template was called for Tom DAAAALE', view.$('#twas-called').text(), 'the named template was called with the view as the data source');
  });

  QUnit.test('should fall back to defaultTemplate if neither template nor templateName are provided', function () {
    var View;

    View = _emberViewsViewsView.default.extend({
      defaultTemplate: _emberTemplateCompiler.compile('<h1 id=\'twas-called\'>template was called for {{personName}}</h1>')
    });

    view = View.create({
      context: {
        personName: 'Tom DAAAALE'
      }
    });

    _emberMetalRun_loop.default(function () {
      view.createElement();
    });

    equal('template was called for Tom DAAAALE', view.$('#twas-called').text(), 'the named template was called with the view as the data source');
  });

  QUnit.test('should not use defaultTemplate if template is provided', function () {
    var View = _emberViewsViewsView.default.extend({
      template: _emberTemplateCompiler.compile('foo'),
      defaultTemplate: _emberTemplateCompiler.compile('<h1 id=\'twas-called\'>template was called for {{personName}}</h1>')
    });

    view = View.create();
    _emberMetalRun_loop.default(function () {
      view.createElement();
    });

    equal('foo', view.$().text(), 'default template was not printed');
  });

  QUnit.test('should not use defaultTemplate if template is provided', function () {
    registry.register('template:foobar', _emberTemplateCompiler.compile('foo'));

    var View = _emberViewsViewsView.default.extend({
      container: container,
      templateName: 'foobar',
      defaultTemplate: _emberTemplateCompiler.compile('<h1 id=\'twas-called\'>template was called for {{personName}}</h1>')
    });

    view = View.create();
    _emberMetalRun_loop.default(function () {
      view.createElement();
    });

    equal('foo', view.$().text(), 'default template was not printed');
  });

  QUnit.test('should render an empty element if no template is specified', function () {
    view = _emberViewsViewsView.default.create();
    _emberMetalRun_loop.default(function () {
      view.createElement();
    });

    equal(view.$().text(), '', 'view div should be empty');
  });

  QUnit.test('should throw an assertion if no container has been set', function () {
    expect(1);
    var View;

    View = _emberViewsViewsView.default.extend({
      templateName: 'foobar'
    });

    throws(function () {
      view = View.create();
      _emberMetalRun_loop.default(function () {
        view.createElement();
      });
    }, /Container was not found when looking up a views template./);

    view._renderNode = null;
  });
});
enifed('ember-views/tests/views/view/template_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/tests/views/view');
  test('ember-views/tests/views/view/template_test.js should pass jscs', function () {
    ok(true, 'ember-views/tests/views/view/template_test.js should pass jscs.');
  });
});
enifed('ember-views/tests/views/view/template_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/tests/views/view');
  QUnit.test('ember-views/tests/views/view/template_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/tests/views/view/template_test.js should pass jshint.');
  });
});
enifed('ember-views/tests/views/view/transition_to_deprecation_test', ['exports', 'ember-views/views/view', 'ember-metal/run_loop'], function (exports, _emberViewsViewsView, _emberMetalRun_loop) {
  'use strict';

  var view;

  QUnit.module('views/view/transition_to_deprecation', {
    setup: function () {
      view = _emberViewsViewsView.default.create();
    },
    teardown: function () {
      _emberMetalRun_loop.default(view, 'destroy');
    }
  });

  QUnit.test('deprecates when calling transitionTo', function () {
    expect(1);

    view = _emberViewsViewsView.default.create();

    expectDeprecation(function () {
      view.transitionTo('preRender');
    }, '');
  });

  QUnit.test('doesn\'t deprecate when calling _transitionTo', function () {
    expect(1);

    view = _emberViewsViewsView.default.create();
    view._transitionTo('preRender');
    ok(true);
  });
});
enifed('ember-views/tests/views/view/transition_to_deprecation_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/tests/views/view');
  test('ember-views/tests/views/view/transition_to_deprecation_test.js should pass jscs', function () {
    ok(true, 'ember-views/tests/views/view/transition_to_deprecation_test.js should pass jscs.');
  });
});
enifed('ember-views/tests/views/view/transition_to_deprecation_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/tests/views/view');
  QUnit.test('ember-views/tests/views/view/transition_to_deprecation_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/tests/views/view/transition_to_deprecation_test.js should pass jshint.');
  });
});
enifed('ember-views/tests/views/view/view_lifecycle_test', ['exports', 'ember-metal/core', 'ember-metal/run_loop', 'ember-runtime/system/object', 'ember-views/system/jquery', 'ember-views/views/view', 'ember-template-compiler', 'ember-htmlbars/helpers', 'ember-htmlbars/tests/utils', 'ember-htmlbars/keywords/view'], function (exports, _emberMetalCore, _emberMetalRun_loop, _emberRuntimeSystemObject, _emberViewsSystemJquery, _emberViewsViewsView, _emberTemplateCompiler, _emberHtmlbarsHelpers, _emberHtmlbarsTestsUtils, _emberHtmlbarsKeywordsView) {
  'use strict';

  var originalLookup = _emberMetalCore.default.lookup;
  var originalViewKeyword;
  var lookup, view;

  QUnit.module('views/view/view_lifecycle_test - pre-render', {
    setup: function () {
      originalViewKeyword = _emberHtmlbarsTestsUtils.registerKeyword('view', _emberHtmlbarsKeywordsView.default);
      _emberMetalCore.default.lookup = lookup = {};
    },

    teardown: function () {
      if (view) {
        _emberMetalRun_loop.default(function () {
          view.destroy();
        });
      }
      _emberMetalCore.default.lookup = originalLookup;
      _emberHtmlbarsTestsUtils.resetKeyword('view', originalViewKeyword);
    }
  });

  QUnit.test('should create and append a DOM element after bindings have synced', function () {
    var ViewTest;

    lookup.ViewTest = ViewTest = {};

    _emberMetalRun_loop.default(function () {
      ViewTest.fakeController = _emberRuntimeSystemObject.default.create({
        fakeThing: 'controllerPropertyValue'
      });

      view = _emberViewsViewsView.default.create({
        fooBinding: 'ViewTest.fakeController.fakeThing',
        template: _emberTemplateCompiler.compile('{{view.foo}}')
      });

      ok(!view.get('element'), 'precond - does not have an element before appending');

      // the actual render happens in the `render` queue, which is after the `sync`
      // queue where the binding is synced.
      view.append();
    });

    equal(view.$().text(), 'controllerPropertyValue', 'renders and appends after bindings have synced');
  });

  QUnit.test('should throw an exception if trying to append a child before rendering has begun', function () {
    _emberMetalRun_loop.default(function () {
      view = _emberViewsViewsView.default.create();
    });

    throws(function () {
      view.appendChild(_emberViewsViewsView.default, {});
    }, null, 'throws an error when calling appendChild()');
  });

  QUnit.test('should not affect rendering if rerender is called before initial render happens', function () {
    _emberMetalRun_loop.default(function () {
      view = _emberViewsViewsView.default.create({
        template: _emberTemplateCompiler.compile('Rerender me!')
      });

      view.rerender();
      view.append();
    });

    equal(view.$().text(), 'Rerender me!', 'renders correctly if rerender is called first');
  });

  QUnit.test('should not affect rendering if destroyElement is called before initial render happens', function () {
    _emberMetalRun_loop.default(function () {
      view = _emberViewsViewsView.default.create({
        template: _emberTemplateCompiler.compile('Don\'t destroy me!')
      });

      view.destroyElement();
      view.append();
    });

    equal(view.$().text(), 'Don\'t destroy me!', 'renders correctly if destroyElement is called first');
  });

  QUnit.module('views/view/view_lifecycle_test - in render', {
    setup: function () {
      originalViewKeyword = _emberHtmlbarsTestsUtils.registerKeyword('view', _emberHtmlbarsKeywordsView.default);
    },
    teardown: function () {
      if (view) {
        _emberMetalRun_loop.default(function () {
          view.destroy();
        });
      }
      _emberHtmlbarsTestsUtils.resetKeyword('view', originalViewKeyword);
    }
  });

  QUnit.test('rerender of top level view during rendering should throw', function () {
    _emberHtmlbarsHelpers.registerHelper('throw', function () {
      view.rerender();
    });
    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompiler.compile('{{throw}}')
    });
    throws(function () {
      _emberMetalRun_loop.default(view, view.appendTo, '#qunit-fixture');
    }, /Something you did caused a view to re-render after it rendered but before it was inserted into the DOM./, 'expected error was not raised');
  });

  QUnit.test('rerender of non-top level view during rendering should throw', function () {
    var innerView = _emberViewsViewsView.default.create({
      template: _emberTemplateCompiler.compile('{{throw}}')
    });
    _emberHtmlbarsHelpers.registerHelper('throw', function () {
      innerView.rerender();
    });
    view = _emberViewsViewsView.default.create({
      template: _emberTemplateCompiler.compile('{{view view.innerView}}'),
      innerView: innerView
    });
    throws(function () {
      _emberMetalRun_loop.default(view, view.appendTo, '#qunit-fixture');
    }, /Something you did caused a view to re-render after it rendered but before it was inserted into the DOM./, 'expected error was not raised');
  });

  QUnit.module('views/view/view_lifecycle_test - hasElement', {
    teardown: function () {
      if (view) {
        _emberMetalRun_loop.default(function () {
          view.destroy();
        });
      }
    }
  });

  QUnit.test('createElement puts the view into the hasElement state', function () {
    var hasCalledInsertElement = false;
    view = _emberViewsViewsView.default.create({
      didInsertElement: function () {
        hasCalledInsertElement = true;
      }
    });

    _emberMetalRun_loop.default(function () {
      view.createElement();
    });

    ok(!hasCalledInsertElement, 'didInsertElement is not called');
    equal(view.element.tagName, 'DIV', 'content is rendered');
  });

  QUnit.test('trigger rerender on a view in the hasElement state doesn\'t change its state to inDOM', function () {
    var hasCalledInsertElement = false;
    view = _emberViewsViewsView.default.create({
      didInsertElement: function () {
        hasCalledInsertElement = true;
      }
    });

    _emberMetalRun_loop.default(function () {
      view.createElement();
      view.rerender();
    });

    ok(!hasCalledInsertElement, 'didInsertElement is not called');
    equal(view.element.tagName, 'DIV', 'content is rendered');
  });

  QUnit.module('views/view/view_lifecycle_test - in DOM', {
    teardown: function () {
      if (view) {
        _emberMetalRun_loop.default(function () {
          view.destroy();
        });
      }
    }
  });

  QUnit.test('should throw an exception when calling appendChild when DOM element exists', function () {
    _emberMetalRun_loop.default(function () {
      view = _emberViewsViewsView.default.create({
        template: _emberTemplateCompiler.compile('Wait for the kick')
      });

      view.append();
    });

    throws(function () {
      view.appendChild(_emberViewsViewsView.default, {
        template: _emberTemplateCompiler.compile('Ah ah ah! You didn\'t say the magic word!')
      });
    }, null, 'throws an exception when calling appendChild after element is created');
  });

  QUnit.test('should replace DOM representation if rerender() is called after element is created', function () {
    _emberMetalRun_loop.default(function () {
      view = _emberViewsViewsView.default.extend({
        rerender: function () {
          this._super.apply(this, arguments);
        }
      }).create({
        template: _emberTemplateCompiler.compile('Do not taunt happy fun {{unbound view.shape}}'),
        shape: 'sphere'
      });

      view.volatileProp = view.get('context.shape');
      view.append();
    });

    equal(view.$().text(), 'Do not taunt happy fun sphere', 'precond - creates DOM element');

    view.shape = 'ball';

    equal(view.$().text(), 'Do not taunt happy fun sphere', 'precond - keeps DOM element');

    _emberMetalRun_loop.default(function () {
      view.rerender();
    });

    equal(view.$().text(), 'Do not taunt happy fun ball', 'rerenders DOM element when rerender() is called');
  });

  QUnit.test('should destroy DOM representation when destroyElement is called', function () {
    _emberMetalRun_loop.default(function () {
      view = _emberViewsViewsView.default.create({
        template: _emberTemplateCompiler.compile('Don\'t fear the reaper')
      });

      view.append();
    });

    ok(view.get('element'), 'precond - generates a DOM element');

    _emberMetalRun_loop.default(function () {
      view.destroyElement();
    });

    ok(!view.get('element'), 'destroys view when destroyElement() is called');
  });

  QUnit.test('should destroy DOM representation when destroy is called', function () {
    _emberMetalRun_loop.default(function () {
      view = _emberViewsViewsView.default.create({
        template: _emberTemplateCompiler.compile('<div id=\'warning\'>Don\'t fear the reaper</div>')
      });

      view.append();
    });

    ok(view.get('element'), 'precond - generates a DOM element');

    _emberMetalRun_loop.default(function () {
      view.destroy();
    });

    ok(_emberViewsSystemJquery.default('#warning').length === 0, 'destroys element when destroy() is called');
  });

  QUnit.test('should throw an exception if trying to append an element that is already in DOM', function () {
    _emberMetalRun_loop.default(function () {
      view = _emberViewsViewsView.default.create({
        template: _emberTemplateCompiler.compile('Broseidon, King of the Brocean')
      });

      view.append();
    });

    ok(view.get('element'), 'precond - creates DOM element');

    throws(function () {
      _emberMetalRun_loop.default(function () {
        view.append();
      });
    }, null, 'raises an exception on second append');
  });

  QUnit.module('views/view/view_lifecycle_test - destroyed');

  QUnit.test('should throw an exception when calling appendChild after view is destroyed', function () {
    _emberMetalRun_loop.default(function () {
      view = _emberViewsViewsView.default.create({
        template: _emberTemplateCompiler.compile('Wait for the kick')
      });

      view.append();
    });

    _emberMetalRun_loop.default(function () {
      view.destroy();
    });

    throws(function () {
      view.appendChild(_emberViewsViewsView.default, {
        template: _emberTemplateCompiler.compile('Ah ah ah! You didn\'t say the magic word!')
      });
    }, null, 'throws an exception when calling appendChild');
  });

  QUnit.test('should throw an exception when rerender is called after view is destroyed', function () {
    _emberMetalRun_loop.default(function () {
      view = _emberViewsViewsView.default.create({
        template: _emberTemplateCompiler.compile('foo')
      });

      view.append();
    });

    _emberMetalRun_loop.default(function () {
      view.destroy();
    });

    throws(function () {
      view.rerender();
    }, null, 'throws an exception when calling rerender');
  });

  QUnit.test('should throw an exception when destroyElement is called after view is destroyed', function () {
    _emberMetalRun_loop.default(function () {
      view = _emberViewsViewsView.default.create({
        template: _emberTemplateCompiler.compile('foo')
      });

      view.append();
    });

    _emberMetalRun_loop.default(function () {
      view.destroy();
    });

    throws(function () {
      view.destroyElement();
    }, null, 'throws an exception when calling destroyElement');
  });

  QUnit.test('trigger rerender on a view in the inDOM state keeps its state as inDOM', function () {
    _emberMetalRun_loop.default(function () {
      view = _emberViewsViewsView.default.create({
        template: _emberTemplateCompiler.compile('foo')
      });

      view.append();
    });

    _emberMetalRun_loop.default(function () {
      view.rerender();
    });

    equal(view.currentState, view._states.inDOM, 'the view is still in the inDOM state');

    _emberMetalRun_loop.default(function () {
      view.destroy();
    });
  });
});
enifed('ember-views/tests/views/view/view_lifecycle_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/tests/views/view');
  test('ember-views/tests/views/view/view_lifecycle_test.js should pass jscs', function () {
    ok(true, 'ember-views/tests/views/view/view_lifecycle_test.js should pass jscs.');
  });
});
enifed('ember-views/tests/views/view/view_lifecycle_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/tests/views/view');
  QUnit.test('ember-views/tests/views/view/view_lifecycle_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/tests/views/view/view_lifecycle_test.js should pass jshint.');
  });
});
enifed('ember-views/tests/views/view_test', ['exports', 'ember-metal/core', 'ember-metal/computed', 'ember-metal/run_loop', 'ember-views/system/jquery', 'ember-views/views/view', 'ember-template-compiler', 'ember-htmlbars/tests/utils', 'ember-htmlbars/keywords/view'], function (exports, _emberMetalCore, _emberMetalComputed, _emberMetalRun_loop, _emberViewsSystemJquery, _emberViewsViewsView, _emberTemplateCompiler, _emberHtmlbarsTestsUtils, _emberHtmlbarsKeywordsView) {
  'use strict';

  var view, originalViewKeyword;

  QUnit.module('Ember.View', {
    setup: function () {
      originalViewKeyword = _emberHtmlbarsTestsUtils.registerKeyword('view', _emberHtmlbarsKeywordsView.default);
    },
    teardown: function () {
      _emberMetalRun_loop.default(function () {
        view.destroy();
      });
      _emberHtmlbarsTestsUtils.resetKeyword('view', originalViewKeyword);
    }
  });

  QUnit.test('should add ember-view to views', function () {
    view = _emberViewsViewsView.default.create();

    _emberMetalRun_loop.default(function () {
      view.createElement();
    });

    ok(view.$().hasClass('ember-view'), 'the view has ember-view');
  });

  QUnit.test('should not add role attribute unless one is specified', function () {
    view = _emberViewsViewsView.default.create();

    _emberMetalRun_loop.default(function () {
      view.createElement();
    });

    ok(view.$().attr('role') === undefined, 'does not have a role attribute');
  });

  QUnit.test('should allow tagName to be a computed property [DEPRECATED]', function () {
    view = _emberViewsViewsView.default.extend({
      tagName: _emberMetalComputed.computed(function () {
        return 'span';
      })
    }).create();

    expectDeprecation(function () {
      _emberMetalRun_loop.default(function () {
        view.createElement();
      });
    }, /using a computed property to define tagName will not be permitted/);

    equal(view.element.tagName, 'SPAN', 'the view has was created with the correct element');

    _emberMetalRun_loop.default(function () {
      view.set('tagName', 'div');
    });

    equal(view.element.tagName, 'SPAN', 'the tagName cannot be changed after initial render');
  });

  QUnit.test('should re-render if the context is changed', function () {
    view = _emberViewsViewsView.default.create({
      elementId: 'template-context-test',
      context: { foo: 'bar' },
      template: _emberTemplateCompiler.compile('{{foo}}')
    });

    _emberMetalRun_loop.default(function () {
      view.appendTo('#qunit-fixture');
    });

    equal(_emberViewsSystemJquery.default('#qunit-fixture #template-context-test').text(), 'bar', 'precond - renders the view with the initial value');

    _emberMetalRun_loop.default(function () {
      view.set('context', {
        foo: 'bang baz'
      });
    });

    equal(_emberViewsSystemJquery.default('#qunit-fixture #template-context-test').text(), 'bang baz', 're-renders the view with the updated context');
  });

  QUnit.test('renders a contained view with omitted start tag and tagless parent view context', function () {
    view = _emberViewsViewsView.default.create({
      tagName: 'table',
      template: _emberTemplateCompiler.compile('{{view view.pivot}}'),
      pivot: _emberViewsViewsView.default.extend({
        tagName: '',
        template: _emberTemplateCompiler.compile('{{view view.row}}'),
        row: _emberViewsViewsView.default.extend({
          tagName: 'tr'
        })
      })
    });

    _emberMetalRun_loop.default(view, view.append);

    equal(view.element.tagName, 'TABLE', 'container view is table');
    ok(view.$('tr').length, 'inner view is tr');

    _emberMetalRun_loop.default(view, view.rerender);

    equal(view.element.tagName, 'TABLE', 'container view is table');
    ok(view.$('tr').length, 'inner view is tr');
  });

  QUnit.test('propagates dependent-key invalidated sets upstream', function () {
    view = _emberViewsViewsView.default.create({
      parentProp: 'parent-value',
      template: _emberTemplateCompiler.compile('{{view view.childView childProp=view.parentProp}}'),
      childView: _emberViewsViewsView.default.create({
        template: _emberTemplateCompiler.compile('child template'),
        childProp: 'old-value'
      })
    });

    _emberMetalRun_loop.default(view, view.append);

    equal(view.get('parentProp'), 'parent-value', 'precond - parent value is there');
    var childView = view.get('childView');

    _emberMetalRun_loop.default(function () {
      childView.set('childProp', 'new-value');
    });

    equal(view.get('parentProp'), 'new-value', 'new value is propagated across template');
  });

  QUnit.test('propagates dependent-key invalidated bindings upstream', function () {
    view = _emberViewsViewsView.default.create({
      parentProp: 'parent-value',
      template: _emberTemplateCompiler.compile('{{view view.childView childProp=view.parentProp}}'),
      childView: _emberViewsViewsView.default.extend({
        template: _emberTemplateCompiler.compile('child template'),
        childProp: _emberMetalCore.default.computed('dependencyProp', {
          get: function (key) {
            return this.get('dependencyProp');
          },
          set: function (key, value) {
            // Avoid getting stomped by the template attrs
            return this.get('dependencyProp');
          }
        }),
        dependencyProp: 'old-value'
      }).create()
    });

    _emberMetalRun_loop.default(view, view.append);

    equal(view.get('parentProp'), 'parent-value', 'precond - parent value is there');
    var childView = view.get('childView');
    _emberMetalRun_loop.default(function () {
      return childView.set('dependencyProp', 'new-value');
    });
    equal(childView.get('childProp'), 'new-value', 'pre-cond - new value is propagated to CP');
    equal(view.get('parentProp'), 'new-value', 'new value is propagated across template');
  });

  QUnit.module('DeprecatedView');

  QUnit.test('calling reopen on DeprecatedView delegates to View', function () {
    expect(2);
    var originalReopen = _emberViewsViewsView.default.reopen;
    var obj = {};

    _emberViewsViewsView.default.reopen = function (arg) {
      ok(arg === obj);
    };

    expectNoDeprecation();
    _emberViewsViewsView.DeprecatedView.reopen(obj);

    _emberViewsViewsView.default.reopen = originalReopen;
  });
});
enifed('ember-views/tests/views/view_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/tests/views');
  test('ember-views/tests/views/view_test.js should pass jscs', function () {
    ok(true, 'ember-views/tests/views/view_test.js should pass jscs.');
  });
});
enifed('ember-views/tests/views/view_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/tests/views');
  QUnit.test('ember-views/tests/views/view_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/tests/views/view_test.js should pass jshint.');
  });
});
enifed('ember-views/views/checkbox.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/views');
  test('ember-views/views/checkbox.js should pass jscs', function () {
    ok(true, 'ember-views/views/checkbox.js should pass jscs.');
  });
});
enifed('ember-views/views/checkbox.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/views');
  QUnit.test('ember-views/views/checkbox.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/views/checkbox.js should pass jshint.');
  });
});
enifed('ember-views/views/collection_view.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/views');
  test('ember-views/views/collection_view.js should pass jscs', function () {
    ok(true, 'ember-views/views/collection_view.js should pass jscs.');
  });
});
enifed('ember-views/views/collection_view.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/views');
  QUnit.test('ember-views/views/collection_view.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/views/collection_view.js should pass jshint.');
  });
});
enifed('ember-views/views/component.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/views');
  test('ember-views/views/component.js should pass jscs', function () {
    ok(true, 'ember-views/views/component.js should pass jscs.');
  });
});
enifed('ember-views/views/component.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/views');
  QUnit.test('ember-views/views/component.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/views/component.js should pass jshint.');
  });
});
enifed('ember-views/views/container_view.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/views');
  test('ember-views/views/container_view.js should pass jscs', function () {
    ok(true, 'ember-views/views/container_view.js should pass jscs.');
  });
});
enifed('ember-views/views/container_view.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/views');
  QUnit.test('ember-views/views/container_view.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/views/container_view.js should pass jshint.');
  });
});
enifed('ember-views/views/core_view.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/views');
  test('ember-views/views/core_view.js should pass jscs', function () {
    ok(true, 'ember-views/views/core_view.js should pass jscs.');
  });
});
enifed('ember-views/views/core_view.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/views');
  QUnit.test('ember-views/views/core_view.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/views/core_view.js should pass jshint.');
  });
});
enifed('ember-views/views/legacy_each_view.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/views');
  test('ember-views/views/legacy_each_view.js should pass jscs', function () {
    ok(true, 'ember-views/views/legacy_each_view.js should pass jscs.');
  });
});
enifed('ember-views/views/legacy_each_view.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/views');
  QUnit.test('ember-views/views/legacy_each_view.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/views/legacy_each_view.js should pass jshint.');
  });
});
enifed('ember-views/views/select.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/views');
  test('ember-views/views/select.js should pass jscs', function () {
    ok(true, 'ember-views/views/select.js should pass jscs.');
  });
});
enifed('ember-views/views/select.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/views');
  QUnit.test('ember-views/views/select.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/views/select.js should pass jshint.');
  });
});
enifed('ember-views/views/states.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/views');
  test('ember-views/views/states.js should pass jscs', function () {
    ok(true, 'ember-views/views/states.js should pass jscs.');
  });
});
enifed('ember-views/views/states.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/views');
  QUnit.test('ember-views/views/states.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/views/states.js should pass jshint.');
  });
});
enifed('ember-views/views/states/default.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/views/states');
  test('ember-views/views/states/default.js should pass jscs', function () {
    ok(true, 'ember-views/views/states/default.js should pass jscs.');
  });
});
enifed('ember-views/views/states/default.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/views/states');
  QUnit.test('ember-views/views/states/default.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/views/states/default.js should pass jshint.');
  });
});
enifed('ember-views/views/states/destroying.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/views/states');
  test('ember-views/views/states/destroying.js should pass jscs', function () {
    ok(true, 'ember-views/views/states/destroying.js should pass jscs.');
  });
});
enifed('ember-views/views/states/destroying.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/views/states');
  QUnit.test('ember-views/views/states/destroying.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/views/states/destroying.js should pass jshint.');
  });
});
enifed('ember-views/views/states/has_element.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/views/states');
  test('ember-views/views/states/has_element.js should pass jscs', function () {
    ok(true, 'ember-views/views/states/has_element.js should pass jscs.');
  });
});
enifed('ember-views/views/states/has_element.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/views/states');
  QUnit.test('ember-views/views/states/has_element.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/views/states/has_element.js should pass jshint.');
  });
});
enifed('ember-views/views/states/in_dom.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/views/states');
  test('ember-views/views/states/in_dom.js should pass jscs', function () {
    ok(true, 'ember-views/views/states/in_dom.js should pass jscs.');
  });
});
enifed('ember-views/views/states/in_dom.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/views/states');
  QUnit.test('ember-views/views/states/in_dom.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/views/states/in_dom.js should pass jshint.');
  });
});
enifed('ember-views/views/states/pre_render.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/views/states');
  test('ember-views/views/states/pre_render.js should pass jscs', function () {
    ok(true, 'ember-views/views/states/pre_render.js should pass jscs.');
  });
});
enifed('ember-views/views/states/pre_render.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/views/states');
  QUnit.test('ember-views/views/states/pre_render.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/views/states/pre_render.js should pass jshint.');
  });
});
enifed('ember-views/views/text_area.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/views');
  test('ember-views/views/text_area.js should pass jscs', function () {
    ok(true, 'ember-views/views/text_area.js should pass jscs.');
  });
});
enifed('ember-views/views/text_area.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/views');
  QUnit.test('ember-views/views/text_area.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/views/text_area.js should pass jshint.');
  });
});
enifed('ember-views/views/text_field.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/views');
  test('ember-views/views/text_field.js should pass jscs', function () {
    ok(true, 'ember-views/views/text_field.js should pass jscs.');
  });
});
enifed('ember-views/views/text_field.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/views');
  QUnit.test('ember-views/views/text_field.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/views/text_field.js should pass jshint.');
  });
});
enifed('ember-views/views/view.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember-views/views');
  test('ember-views/views/view.js should pass jscs', function () {
    ok(true, 'ember-views/views/view.js should pass jscs.');
  });
});
enifed('ember-views/views/view.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember-views/views');
  QUnit.test('ember-views/views/view.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember-views/views/view.js should pass jshint.');
  });
});
enifed('ember.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - .');
  test('ember.js should pass jscs', function () {
    ok(true, 'ember.js should pass jscs.');
  });
});
enifed('ember.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - .');
  QUnit.test('ember.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember.js should pass jshint.');
  });
});
enifed('ember/tests/application_lifecycle_test', ['exports', 'ember', 'ember-metal/core', 'ember-metal/features'], function (exports, _ember, _emberMetalCore, _emberMetalFeatures) {
  'use strict';

  var compile = _emberMetalCore.default.HTMLBars.compile;

  var ApplicationSubclass, App, container, router;

  function setupApp() {
    _emberMetalCore.default.run(function () {
      App = ApplicationSubclass.create({
        rootElement: '#qunit-fixture'
      });

      App.Router = App.Router.extend({
        location: 'none'
      });

      App.deferReadiness();

      container = App.__container__;
    });
  }

  QUnit.module('Application Lifecycle', {
    setup: function () {
      ApplicationSubclass = _emberMetalCore.default.Application.extend();

      setupApp();
    },

    teardown: function () {
      router = null;
      _emberMetalCore.default.run(App, 'destroy');
      _emberMetalCore.default.TEMPLATES = {};
    }
  });

  function handleURL(path) {
    router = container.lookup('router:main');
    return _emberMetalCore.default.run(function () {
      return router.handleURL(path).then(function (value) {
        ok(true, 'url: `' + path + '` was handled');
        return value;
      }, function (reason) {
        ok(false, reason);
        throw reason;
      });
    });
  }

  QUnit.test('Resetting the application allows controller properties to be set when a route deactivates', function () {
    App.Router.map(function () {
      this.route('home', { path: '/' });
    });

    App.HomeRoute = _emberMetalCore.default.Route.extend({
      setupController: function () {
        this.controllerFor('home').set('selectedMenuItem', 'home');
      },
      deactivate: function () {
        this.controllerFor('home').set('selectedMenuItem', null);
      }
    });
    App.ApplicationRoute = _emberMetalCore.default.Route.extend({
      setupController: function () {
        this.controllerFor('application').set('selectedMenuItem', 'home');
      },
      deactivate: function () {
        this.controllerFor('application').set('selectedMenuItem', null);
      }
    });

    container.lookup('router:main');

    _emberMetalCore.default.run(App, 'advanceReadiness');

    handleURL('/');

    equal(_emberMetalCore.default.controllerFor(container, 'home').get('selectedMenuItem'), 'home');
    equal(_emberMetalCore.default.controllerFor(container, 'application').get('selectedMenuItem'), 'home');

    App.reset();

    equal(_emberMetalCore.default.controllerFor(container, 'home').get('selectedMenuItem'), null);
    equal(_emberMetalCore.default.controllerFor(container, 'application').get('selectedMenuItem'), null);
  });

  QUnit.test('Destroying the application resets the router before the container is destroyed', function () {
    App.Router.map(function () {
      this.route('home', { path: '/' });
    });

    App.HomeRoute = _emberMetalCore.default.Route.extend({
      setupController: function () {
        this.controllerFor('home').set('selectedMenuItem', 'home');
      },
      deactivate: function () {
        this.controllerFor('home').set('selectedMenuItem', null);
      }
    });
    App.ApplicationRoute = _emberMetalCore.default.Route.extend({
      setupController: function () {
        this.controllerFor('application').set('selectedMenuItem', 'home');
      },
      deactivate: function () {
        this.controllerFor('application').set('selectedMenuItem', null);
      }
    });

    container.lookup('router:main');

    _emberMetalCore.default.run(App, 'advanceReadiness');

    handleURL('/');

    equal(_emberMetalCore.default.controllerFor(container, 'home').get('selectedMenuItem'), 'home');
    equal(_emberMetalCore.default.controllerFor(container, 'application').get('selectedMenuItem'), 'home');

    _emberMetalCore.default.run(App, 'destroy');

    equal(_emberMetalCore.default.controllerFor(container, 'home').get('selectedMenuItem'), null);
    equal(_emberMetalCore.default.controllerFor(container, 'application').get('selectedMenuItem'), null);
  });

  QUnit.test('initializers can augment an applications customEvents hash', function (assert) {
    assert.expect(1);

    _emberMetalCore.default.run(App, 'destroy');

    if (_emberMetalFeatures.default('ember-registry-container-reform')) {
      ApplicationSubclass.initializer({
        name: 'customize-things',
        initialize: function (application) {
          application.customEvents = {
            wowza: 'wowza'
          };
        }
      });
    } else {
      ApplicationSubclass.initializer({
        name: 'customize-things',
        initialize: function (registry, application) {
          application.customEvents = {
            wowza: 'wowza'
          };
        }
      });
    }

    setupApp();

    App.FooBarComponent = _emberMetalCore.default.Component.extend({
      wowza: function () {
        assert.ok(true, 'fired the event!');
      }
    });

    _emberMetalCore.default.TEMPLATES['application'] = compile('{{foo-bar}}');
    _emberMetalCore.default.TEMPLATES['components/foo-bar'] = compile('<div id=\'wowza-thingy\'></div>');

    _emberMetalCore.default.run(App, 'advanceReadiness');

    _emberMetalCore.default.run(function () {
      _emberMetalCore.default.$('#wowza-thingy').trigger('wowza');
    });
  });
});
enifed('ember/tests/application_lifecycle_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember/tests');
  test('ember/tests/application_lifecycle_test.js should pass jscs', function () {
    ok(true, 'ember/tests/application_lifecycle_test.js should pass jscs.');
  });
});
enifed('ember/tests/application_lifecycle_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember/tests');
  QUnit.test('ember/tests/application_lifecycle_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember/tests/application_lifecycle_test.js should pass jshint.');
  });
});
enifed('ember/tests/component_registration_test', ['exports', 'ember', 'ember-metal/core', 'ember-metal/keys', 'ember-template-compiler/system/compile', 'ember-htmlbars/helpers', 'ember-routing-views/views/outlet'], function (exports, _ember, _emberMetalCore, _emberMetalKeys, _emberTemplateCompilerSystemCompile, _emberHtmlbarsHelpers, _emberRoutingViewsViewsOutlet) {
  'use strict';

  var App, registry, container;
  var originalHelpers;

  function prepare() {
    _emberMetalCore.default.TEMPLATES['components/expand-it'] = _emberTemplateCompilerSystemCompile.default('<p>hello {{yield}}</p>');
    _emberMetalCore.default.TEMPLATES.application = _emberTemplateCompilerSystemCompile.default('Hello world {{#expand-it}}world{{/expand-it}}');

    originalHelpers = _emberMetalCore.default.A(_emberMetalKeys.default(_emberHtmlbarsHelpers.default));
  }

  function cleanup() {
    _emberMetalCore.default.run(function () {
      if (App) {
        App.destroy();
      }
      App = null;
      _emberMetalCore.default.TEMPLATES = {};

      cleanupHelpers();
    });
  }

  function cleanupHelpers() {
    var currentHelpers = _emberMetalCore.default.A(_emberMetalKeys.default(_emberHtmlbarsHelpers.default));

    currentHelpers.forEach(function (name) {
      if (!originalHelpers.contains(name)) {
        delete _emberHtmlbarsHelpers.default[name];
      }
    });
  }

  QUnit.module('Application Lifecycle - Component Registration', {
    setup: prepare,
    teardown: cleanup
  });

  function boot(callback) {
    var startURL = arguments.length <= 1 || arguments[1] === undefined ? '/' : arguments[1];

    _emberMetalCore.default.run(function () {
      App = _emberMetalCore.default.Application.create({
        name: 'App',
        rootElement: '#qunit-fixture'
      });

      App.deferReadiness();

      App.Router = _emberMetalCore.default.Router.extend({
        location: 'none'
      });

      registry = App.registry;
      container = App.__container__;

      if (callback) {
        callback();
      }
    });

    var router = container.lookup('router:main');

    _emberMetalCore.default.run(App, 'advanceReadiness');
    _emberMetalCore.default.run(function () {
      router.handleURL(startURL);
    });
  }

  QUnit.test('The helper becomes the body of the component', function () {
    boot();
    equal(_emberMetalCore.default.$('div.ember-view > div.ember-view', '#qunit-fixture').text(), 'hello world', 'The component is composed correctly');
  });

  QUnit.test('If a component is registered, it is used', function () {
    boot(function () {
      registry.register('component:expand-it', _emberMetalCore.default.Component.extend({
        classNames: 'testing123'
      }));
    });

    equal(_emberMetalCore.default.$('div.testing123', '#qunit-fixture').text(), 'hello world', 'The component is composed correctly');
  });

  QUnit.test('Late-registered components can be rendered with custom `layout` property', function () {
    _emberMetalCore.default.TEMPLATES.application = _emberTemplateCompilerSystemCompile.default('<div id=\'wrapper\'>there goes {{my-hero}}</div>');

    boot(function () {
      registry.register('component:my-hero', _emberMetalCore.default.Component.extend({
        classNames: 'testing123',
        layout: _emberTemplateCompilerSystemCompile.default('watch him as he GOES')
      }));
    });

    equal(_emberMetalCore.default.$('#wrapper').text(), 'there goes watch him as he GOES', 'The component is composed correctly');
    ok(!_emberHtmlbarsHelpers.default['my-hero'], 'Component wasn\'t saved to global helpers hash');
  });

  QUnit.test('Late-registered components can be rendered with template registered on the container', function () {

    _emberMetalCore.default.TEMPLATES.application = _emberTemplateCompilerSystemCompile.default('<div id=\'wrapper\'>hello world {{sally-rutherford}}-{{#sally-rutherford}}!!!{{/sally-rutherford}}</div>');

    boot(function () {
      registry.register('template:components/sally-rutherford', _emberTemplateCompilerSystemCompile.default('funkytowny{{yield}}'));
      registry.register('component:sally-rutherford', _emberMetalCore.default.Component);
    });

    equal(_emberMetalCore.default.$('#wrapper').text(), 'hello world funkytowny-funkytowny!!!', 'The component is composed correctly');
    ok(!_emberHtmlbarsHelpers.default['sally-rutherford'], 'Component wasn\'t saved to global helpers hash');
  });

  QUnit.test('Late-registered components can be rendered with ONLY the template registered on the container', function () {

    _emberMetalCore.default.TEMPLATES.application = _emberTemplateCompilerSystemCompile.default('<div id=\'wrapper\'>hello world {{borf-snorlax}}-{{#borf-snorlax}}!!!{{/borf-snorlax}}</div>');

    boot(function () {
      registry.register('template:components/borf-snorlax', _emberTemplateCompilerSystemCompile.default('goodfreakingTIMES{{yield}}'));
    });

    equal(_emberMetalCore.default.$('#wrapper').text(), 'hello world goodfreakingTIMES-goodfreakingTIMES!!!', 'The component is composed correctly');
    ok(!_emberHtmlbarsHelpers.default['borf-snorlax'], 'Component wasn\'t saved to global helpers hash');
  });

  QUnit.test('Component-like invocations are treated as bound paths if neither template nor component are registered on the container', function () {

    _emberMetalCore.default.TEMPLATES.application = _emberTemplateCompilerSystemCompile.default('<div id=\'wrapper\'>{{user-name}} hello {{api-key}} world</div>');

    boot(function () {
      registry.register('controller:application', _emberMetalCore.default.Controller.extend({
        'user-name': 'machty'
      }));
    });

    equal(_emberMetalCore.default.$('#wrapper').text(), 'machty hello  world', 'The component is composed correctly');
  });

  QUnit.test('Assigning templateName to a component should setup the template as a layout', function () {
    expect(1);

    _emberMetalCore.default.TEMPLATES.application = _emberTemplateCompilerSystemCompile.default('<div id=\'wrapper\'>{{#my-component}}{{text}}{{/my-component}}</div>');
    _emberMetalCore.default.TEMPLATES['foo-bar-baz'] = _emberTemplateCompilerSystemCompile.default('{{text}}-{{yield}}');

    boot(function () {
      registry.register('controller:application', _emberMetalCore.default.Controller.extend({
        'text': 'outer'
      }));

      registry.register('component:my-component', _emberMetalCore.default.Component.extend({
        text: 'inner',
        layoutName: 'foo-bar-baz'
      }));
    });

    equal(_emberMetalCore.default.$('#wrapper').text(), 'inner-outer', 'The component is composed correctly');
  });

  QUnit.test('Using name of component that does not exist', function () {
    _emberMetalCore.default.TEMPLATES.application = _emberTemplateCompilerSystemCompile.default('<div id=\'wrapper\'>{{#no-good}} {{/no-good}}</div>');

    expectAssertion(function () {
      boot();
    }, /A helper named 'no-good' could not be found/);
  });

  QUnit.module('Application Lifecycle - Component Context', {
    setup: prepare,
    teardown: cleanup
  });

  QUnit.test('Components with a block should have the proper content when a template is provided', function () {
    _emberMetalCore.default.TEMPLATES.application = _emberTemplateCompilerSystemCompile.default('<div id=\'wrapper\'>{{#my-component}}{{text}}{{/my-component}}</div>');
    _emberMetalCore.default.TEMPLATES['components/my-component'] = _emberTemplateCompilerSystemCompile.default('{{text}}-{{yield}}');

    boot(function () {
      registry.register('controller:application', _emberMetalCore.default.Controller.extend({
        'text': 'outer'
      }));

      registry.register('component:my-component', _emberMetalCore.default.Component.extend({
        text: 'inner'
      }));
    });

    equal(_emberMetalCore.default.$('#wrapper').text(), 'inner-outer', 'The component is composed correctly');
  });

  QUnit.test('Components with a block should yield the proper content without a template provided', function () {
    _emberMetalCore.default.TEMPLATES.application = _emberTemplateCompilerSystemCompile.default('<div id=\'wrapper\'>{{#my-component}}{{text}}{{/my-component}}</div>');

    boot(function () {
      registry.register('controller:application', _emberMetalCore.default.Controller.extend({
        'text': 'outer'
      }));

      registry.register('component:my-component', _emberMetalCore.default.Component.extend({
        text: 'inner'
      }));
    });

    equal(_emberMetalCore.default.$('#wrapper').text(), 'outer', 'The component is composed correctly');
  });

  QUnit.test('Components without a block should have the proper content when a template is provided', function () {
    _emberMetalCore.default.TEMPLATES.application = _emberTemplateCompilerSystemCompile.default('<div id=\'wrapper\'>{{my-component}}</div>');
    _emberMetalCore.default.TEMPLATES['components/my-component'] = _emberTemplateCompilerSystemCompile.default('{{text}}');

    boot(function () {
      registry.register('controller:application', _emberMetalCore.default.Controller.extend({
        'text': 'outer'
      }));

      registry.register('component:my-component', _emberMetalCore.default.Component.extend({
        text: 'inner'
      }));
    });

    equal(_emberMetalCore.default.$('#wrapper').text(), 'inner', 'The component is composed correctly');
  });

  QUnit.test('Components without a block should have the proper content', function () {
    _emberMetalCore.default.TEMPLATES.application = _emberTemplateCompilerSystemCompile.default('<div id=\'wrapper\'>{{my-component}}</div>');

    boot(function () {
      registry.register('controller:application', _emberMetalCore.default.Controller.extend({
        'text': 'outer'
      }));

      registry.register('component:my-component', _emberMetalCore.default.Component.extend({
        didInsertElement: function () {
          this.$().html('Some text inserted by jQuery');
        }
      }));
    });

    equal(_emberMetalCore.default.$('#wrapper').text(), 'Some text inserted by jQuery', 'The component is composed correctly');
  });

  // The test following this one is the non-deprecated version
  QUnit.test('properties of a component without a template should not collide with internal structures [DEPRECATED]', function () {
    _emberMetalCore.default.TEMPLATES.application = _emberTemplateCompilerSystemCompile.default('<div id=\'wrapper\'>{{my-component data=foo}}</div>');

    boot(function () {
      registry.register('controller:application', _emberMetalCore.default.Controller.extend({
        'text': 'outer',
        'foo': 'Some text inserted by jQuery'
      }));

      registry.register('component:my-component', _emberMetalCore.default.Component.extend({
        didInsertElement: function () {
          this.$().html(this.get('data'));
        }
      }));
    });

    equal(_emberMetalCore.default.$('#wrapper').text(), 'Some text inserted by jQuery', 'The component is composed correctly');
  });

  QUnit.test('attrs property of a component without a template should not collide with internal structures', function () {
    _emberMetalCore.default.TEMPLATES.application = _emberTemplateCompilerSystemCompile.default('<div id=\'wrapper\'>{{my-component attrs=foo}}</div>');

    boot(function () {
      registry.register('controller:application', _emberMetalCore.default.Controller.extend({
        'text': 'outer',
        'foo': 'Some text inserted by jQuery'
      }));

      registry.register('component:my-component', _emberMetalCore.default.Component.extend({
        didInsertElement: function () {
          // FIXME: I'm unsure if this is even the right way to access attrs
          this.$().html(this.get('attrs.attrs.value'));
        }
      }));
    });

    equal(_emberMetalCore.default.$('#wrapper').text(), 'Some text inserted by jQuery', 'The component is composed correctly');
  });

  QUnit.test('Components trigger actions in the parents context when called from within a block', function () {
    _emberMetalCore.default.TEMPLATES.application = _emberTemplateCompilerSystemCompile.default('<div id=\'wrapper\'>{{#my-component}}<a href=\'#\' id=\'fizzbuzz\' {{action \'fizzbuzz\'}}>Fizzbuzz</a>{{/my-component}}</div>');

    boot(function () {
      registry.register('controller:application', _emberMetalCore.default.Controller.extend({
        actions: {
          fizzbuzz: function () {
            ok(true, 'action triggered on parent');
          }
        }
      }));

      registry.register('component:my-component', _emberMetalCore.default.Component.extend());
    });

    _emberMetalCore.default.run(function () {
      _emberMetalCore.default.$('#fizzbuzz', '#wrapper').click();
    });
  });

  QUnit.test('Components trigger actions in the components context when called from within its template', function () {
    _emberMetalCore.default.TEMPLATES.application = _emberTemplateCompilerSystemCompile.default('<div id=\'wrapper\'>{{#my-component}}{{text}}{{/my-component}}</div>');
    _emberMetalCore.default.TEMPLATES['components/my-component'] = _emberTemplateCompilerSystemCompile.default('<a href=\'#\' id=\'fizzbuzz\' {{action \'fizzbuzz\'}}>Fizzbuzz</a>');

    boot(function () {
      registry.register('controller:application', _emberMetalCore.default.Controller.extend({
        actions: {
          fizzbuzz: function () {
            ok(false, 'action triggered on the wrong context');
          }
        }
      }));

      registry.register('component:my-component', _emberMetalCore.default.Component.extend({
        actions: {
          fizzbuzz: function () {
            ok(true, 'action triggered on component');
          }
        }
      }));
    });

    _emberMetalCore.default.$('#fizzbuzz', '#wrapper').click();
  });

  QUnit.test('Components receive the top-level view as their ownerView', function (assert) {
    _emberMetalCore.default.TEMPLATES.application = _emberTemplateCompilerSystemCompile.default('{{outlet}}');
    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompilerSystemCompile.default('{{my-component}}');
    _emberMetalCore.default.TEMPLATES['components/my-component'] = _emberTemplateCompilerSystemCompile.default('<div></div>');

    var component = undefined;

    boot(function () {
      registry.register('component:my-component', _emberMetalCore.default.Component.extend({
        init: function () {
          this._super();
          component = this;
        }
      }));
    });

    // Theses tests are intended to catch a regression where the owner view was
    // not configured properly. Future refactors may break these tests, which
    // should not be considered a breaking change to public APIs.
    var ownerView = component.ownerView;
    assert.ok(ownerView, 'owner view was set');
    assert.ok(ownerView instanceof _emberRoutingViewsViewsOutlet.OutletView, 'owner view has no parent view');
    assert.notStrictEqual(component, ownerView, 'owner view is not itself');

    assert.ok(ownerView._outlets, 'owner view has an internal array of outlets');
  });
});
enifed('ember/tests/component_registration_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember/tests');
  test('ember/tests/component_registration_test.js should pass jscs', function () {
    ok(true, 'ember/tests/component_registration_test.js should pass jscs.');
  });
});
enifed('ember/tests/component_registration_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember/tests');
  QUnit.test('ember/tests/component_registration_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember/tests/component_registration_test.js should pass jshint.');
  });
});
enifed('ember/tests/controller_test', ['exports', 'ember', 'ember-metal/core', 'ember-template-compiler', 'ember-views/views/view', 'ember-template-compiler/plugins', 'ember-template-compiler/plugins/transform-each-into-collection'], function (exports, _ember, _emberMetalCore, _emberTemplateCompiler, _emberViewsViewsView, _emberTemplateCompilerPlugins, _emberTemplateCompilerPluginsTransformEachIntoCollection) {
  'use strict';

  /*
   In Ember 1.x, controllers subtly affect things like template scope
   and action targets in exciting and often inscrutable ways. This test
   file contains integration tests that verify the correct behavior of
   the many parts of the system that change and rely upon controller scope,
   from the runtime up to the templating layer.
  */

  var App, $fixture, templates;

  var originalAstPlugins = undefined;

  QUnit.module('Template scoping examples', {
    setup: function () {
      originalAstPlugins = _emberTemplateCompilerPlugins.default['ast'].slice(0);
      _emberTemplateCompilerPlugins.registerPlugin('ast', _emberTemplateCompilerPluginsTransformEachIntoCollection.default);

      _emberMetalCore.default.run(function () {
        templates = _emberMetalCore.default.TEMPLATES;
        App = _emberMetalCore.default.Application.create({
          name: 'App',
          rootElement: '#qunit-fixture'
        });
        App.deferReadiness();

        App.Router.reopen({
          location: 'none'
        });

        App.LoadingRoute = _emberMetalCore.default.Route.extend();
      });

      $fixture = _emberMetalCore.default.$('#qunit-fixture');
    },

    teardown: function () {
      _emberMetalCore.default.run(function () {
        App.destroy();
      });

      App = null;

      _emberMetalCore.default.TEMPLATES = {};

      _emberTemplateCompilerPlugins.default['ast'] = originalAstPlugins;
    }
  });

  QUnit.test('Actions inside an outlet go to the associated controller', function () {
    expect(1);

    templates.index = _emberTemplateCompiler.compile('{{component-with-action action=\'componentAction\'}}');

    App.IndexController = _emberMetalCore.default.Controller.extend({
      actions: {
        componentAction: function () {
          ok(true, 'received the click');
        }
      }
    });

    App.ComponentWithActionComponent = _emberMetalCore.default.Component.extend({
      classNames: ['component-with-action'],
      click: function () {
        this.sendAction();
      }
    });

    bootApp();

    $fixture.find('.component-with-action').click();
  });

  QUnit.test('the controller property is provided to route driven views', function () {
    var applicationController, applicationViewController;

    App.ApplicationController = _emberMetalCore.default.Controller.extend({
      init: function () {
        this._super.apply(this, arguments);
        applicationController = this;
      }
    });

    App.ApplicationView = _emberViewsViewsView.default.extend({
      init: function () {
        this._super.apply(this, arguments);
        applicationViewController = this.get('controller');
      }
    });

    bootApp();

    equal(applicationViewController, applicationController, 'application view should get its controller set properly');
  });

  // This test caught a regression where {{#each}}s used directly in a template
  // (i.e., not inside a view or component) did not have access to a container and
  // would raise an exception.
  QUnit.test('{{#each}} inside outlet can have an itemController', function (assert) {
    expectDeprecation(function () {
      templates.index = _emberTemplateCompiler.compile('\n      {{#each model itemController=\'thing\'}}\n        <p>hi</p>\n      {{/each}}\n    ');
    }, 'Using \'itemController\' with \'{{each}}\' (L2:C20) is deprecated.  Please refactor to a component.');

    App.IndexController = _emberMetalCore.default.Controller.extend({
      model: _emberMetalCore.default.A([1, 2, 3])
    });

    App.ThingController = _emberMetalCore.default.Controller.extend();

    bootApp();

    assert.equal($fixture.find('p').length, 3, 'the {{#each}} rendered without raising an exception');
  });

  function bootApp() {
    _emberMetalCore.default.run(App, 'advanceReadiness');
  }
});
enifed('ember/tests/controller_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember/tests');
  test('ember/tests/controller_test.js should pass jscs', function () {
    ok(true, 'ember/tests/controller_test.js should pass jscs.');
  });
});
enifed('ember/tests/controller_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember/tests');
  QUnit.test('ember/tests/controller_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember/tests/controller_test.js should pass jshint.');
  });
});
enifed('ember/tests/default_initializers_test', ['exports', 'ember-application/system/application', 'ember-views/views/text_field', 'ember-views/views/checkbox', 'ember-metal/run_loop'], function (exports, _emberApplicationSystemApplication, _emberViewsViewsText_field, _emberViewsViewsCheckbox, _emberMetalRun_loop) {
  'use strict';

  var App;

  QUnit.module('Default Registry', {
    setup: function () {
      _emberMetalRun_loop.default(function () {
        App = _emberApplicationSystemApplication.default.create({
          rootElement: '#qunit-fixture'
        });

        App.deferReadiness();
      });
    },

    teardown: function () {
      _emberMetalRun_loop.default(App, 'destroy');
    }
  });

  QUnit.test('Default objects are registered', function (assert) {
    App.instanceInitializer({
      name: 'test',
      initialize: function (instance) {
        var registry = instance.registry;

        assert.strictEqual(registry.resolve('component:-text-field'), _emberViewsViewsText_field.default, 'TextField was registered');
        assert.strictEqual(registry.resolve('component:-checkbox'), _emberViewsViewsCheckbox.default, 'Checkbox was registered');
      }
    });

    _emberMetalRun_loop.default(function () {
      App.advanceReadiness();
    });
  });
});
enifed('ember/tests/default_initializers_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember/tests');
  test('ember/tests/default_initializers_test.js should pass jscs', function () {
    ok(true, 'ember/tests/default_initializers_test.js should pass jscs.');
  });
});
enifed('ember/tests/default_initializers_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember/tests');
  QUnit.test('ember/tests/default_initializers_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember/tests/default_initializers_test.js should pass jshint.');
  });
});
enifed('ember/tests/global-api-test', ['exports', 'ember', 'ember-metal/features', 'ember-runtime/utils'], function (exports, _ember, _emberMetalFeatures, _emberRuntimeUtils) {
  /*globals Ember */
  'use strict';

  QUnit.module('Global API Tests');

  function confirmExport(property, internal) {
    QUnit.test('confirm ' + property + ' is exported', function () {
      var theExport = Ember.get(window, property);
      ok(theExport + ' is exported');
      if (internal !== undefined) {
        equal(theExport, internal, theExport + ' is exported properly');
      }
    });
  }

  confirmExport('Ember.DefaultResolver');
  confirmExport('Ember.generateController');

  confirmExport('Ember.Helper');
  confirmExport('Ember.Helper.helper');

  confirmExport('Ember.isArray', _emberRuntimeUtils.isArray);
});
enifed('ember/tests/global-api-test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember/tests');
  test('ember/tests/global-api-test.js should pass jscs', function () {
    ok(true, 'ember/tests/global-api-test.js should pass jscs.');
  });
});
enifed('ember/tests/global-api-test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember/tests');
  QUnit.test('ember/tests/global-api-test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember/tests/global-api-test.js should pass jshint.');
  });
});
enifed('ember/tests/helpers/helper_registration_test', ['exports', 'ember', 'ember-metal/core', 'ember-metal/features', 'ember-htmlbars/helpers', 'ember-template-compiler', 'ember-htmlbars/helper', 'ember-htmlbars/tests/utils', 'ember-htmlbars/keywords/view'], function (exports, _ember, _emberMetalCore, _emberMetalFeatures, _emberHtmlbarsHelpers, _emberTemplateCompiler, _emberHtmlbarsHelper, _emberHtmlbarsTestsUtils, _emberHtmlbarsKeywordsView) {
  'use strict';

  var App, registry, container, originalViewKeyword;

  QUnit.module('Application Lifecycle - Helper Registration', {
    setup: function () {
      originalViewKeyword = _emberHtmlbarsTestsUtils.registerKeyword('view', _emberHtmlbarsKeywordsView.default);
    },
    teardown: function () {
      _emberMetalCore.default.run(function () {
        if (App) {
          App.destroy();
        }

        App = null;
        _emberMetalCore.default.TEMPLATES = {};
      });
      delete _emberHtmlbarsHelpers.default['foo-bar-baz-widget'];
      _emberHtmlbarsTestsUtils.resetKeyword('view', originalViewKeyword);
    }
  });

  var boot = function (callback) {
    _emberMetalCore.default.run(function () {
      App = _emberMetalCore.default.Application.create({
        name: 'App',
        rootElement: '#qunit-fixture'
      });

      App.deferReadiness();

      App.Router = _emberMetalCore.default.Router.extend({
        location: 'none'
      });

      registry = App.registry;
      container = App.__container__;

      if (callback) {
        callback();
      }
    });

    var router = container.lookup('router:main');

    _emberMetalCore.default.run(App, 'advanceReadiness');
    _emberMetalCore.default.run(function () {
      router.handleURL('/');
    });
  };

  QUnit.test('Unbound dashed helpers registered on the container can be late-invoked', function () {
    _emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('<div id=\'wrapper\'>{{x-borf}} {{x-borf \'YES\'}}</div>');
    var myHelper = _emberHtmlbarsHelper.helper(function (params) {
      return params[0] || 'BORF';
    });

    boot(function () {
      registry.register('helper:x-borf', myHelper);
    });

    equal(_emberMetalCore.default.$('#wrapper').text(), 'BORF YES', 'The helper was invoked from the container');
    ok(!_emberHtmlbarsHelpers.default['x-borf'], 'Container-registered helper doesn\'t wind up on global helpers hash');
  });

  QUnit.test('Bound helpers registered on the container can be late-invoked', function () {
    _emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('<div id=\'wrapper\'>{{x-reverse}} {{x-reverse foo}}</div>');

    boot(function () {
      registry.register('controller:application', _emberMetalCore.default.Controller.extend({
        foo: 'alex'
      }));

      registry.register('helper:x-reverse', _emberHtmlbarsHelper.helper(function (_ref) {
        var value = _ref[0];

        return value ? value.split('').reverse().join('') : '--';
      }));
    });

    equal(_emberMetalCore.default.$('#wrapper').text(), '-- xela', 'The bound helper was invoked from the container');
    ok(!_emberHtmlbarsHelpers.default['x-reverse'], 'Container-registered helper doesn\'t wind up on global helpers hash');
  });

  QUnit.test('Undashed helpers registered on the container can be invoked', function () {
    _emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('<div id=\'wrapper\'>{{omg}}|{{yorp \'boo\'}}|{{yorp \'ya\'}}</div>');

    boot(function () {
      registry.register('helper:omg', _emberHtmlbarsHelper.helper(function () {
        return 'OMG';
      }));

      registry.register('helper:yorp', _emberHtmlbarsHelper.helper(function (_ref2) {
        var value = _ref2[0];

        return value;
      }));
    });

    equal(_emberMetalCore.default.$('#wrapper').text(), 'OMG|boo|ya', 'The helper was invoked from the container');
  });

  QUnit.test('Helpers can receive injections', function () {
    _emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('<div id=\'wrapper\'>{{full-name}}</div>');

    var serviceCalled = false;
    boot(function () {
      registry.register('service:name-builder', _emberMetalCore.default.Service.extend({
        build: function () {
          serviceCalled = true;
        }
      }));
      registry.register('helper:full-name', _emberHtmlbarsHelper.default.extend({
        nameBuilder: _emberMetalCore.default.inject.service('name-builder'),
        compute: function () {
          this.get('nameBuilder').build();
        }
      }));
    });

    ok(serviceCalled, 'service was injected, method called');
  });
});

// Note: the reason we're not allowing undashed helpers is to avoid
// a possible perf hit in hot code paths, i.e. _triageMustache.
// We only presently perform container lookups if prop.indexOf('-') >= 0
enifed('ember/tests/helpers/helper_registration_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember/tests/helpers');
  test('ember/tests/helpers/helper_registration_test.js should pass jscs', function () {
    ok(true, 'ember/tests/helpers/helper_registration_test.js should pass jscs.');
  });
});
enifed('ember/tests/helpers/helper_registration_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember/tests/helpers');
  QUnit.test('ember/tests/helpers/helper_registration_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember/tests/helpers/helper_registration_test.js should pass jshint.');
  });
});
enifed('ember/tests/helpers/link_to_test', ['exports', 'ember', 'ember-metal/core', 'ember-views/component_lookup', 'ember-metal/features', 'ember-template-compiler', 'ember-views/views/view'], function (exports, _ember, _emberMetalCore, _emberViewsComponent_lookup, _emberMetalFeatures, _emberTemplateCompiler, _emberViewsViewsView) {
  'use strict';

  var Router, App, AppView, router, registry, container;
  var set = _emberMetalCore.default.set;

  function bootApplication() {
    router = container.lookup('router:main');
    _emberMetalCore.default.run(App, 'advanceReadiness');
  }

  // IE includes the host name
  function normalizeUrl(url) {
    return url.replace(/https?:\/\/[^\/]+/, '');
  }

  function shouldNotBeActive(selector) {
    checkActive(selector, false);
  }

  function shouldBeActive(selector) {
    checkActive(selector, true);
  }

  function checkActive(selector, active) {
    var classList = _emberMetalCore.default.$(selector, '#qunit-fixture')[0].className;
    equal(classList.indexOf('active') > -1, active, selector + ' active should be ' + active.toString());
  }

  var updateCount, replaceCount;

  function sharedSetup() {
    App = _emberMetalCore.default.Application.create({
      name: 'App',
      rootElement: '#qunit-fixture'
    });

    App.deferReadiness();

    updateCount = replaceCount = 0;
    App.Router.reopen({
      location: _emberMetalCore.default.NoneLocation.create({
        setURL: function (path) {
          updateCount++;
          set(this, 'path', path);
        },

        replaceURL: function (path) {
          replaceCount++;
          set(this, 'path', path);
        }
      })
    });

    Router = App.Router;
    registry = App.registry;
    container = App.__container__;
  }

  function sharedTeardown() {
    _emberMetalCore.default.run(function () {
      App.destroy();
    });
    _emberMetalCore.default.TEMPLATES = {};
  }

  QUnit.module('The {{link-to}} helper', {
    setup: function () {
      _emberMetalCore.default.run(function () {

        sharedSetup();

        _emberMetalCore.default.TEMPLATES.app = _emberTemplateCompiler.compile('{{outlet}}');
        _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('<h3>Home</h3>{{#link-to \'about\' id=\'about-link\'}}About{{/link-to}}{{#link-to \'index\' id=\'self-link\'}}Self{{/link-to}}');
        _emberMetalCore.default.TEMPLATES.about = _emberTemplateCompiler.compile('<h3>About</h3>{{#link-to \'index\' id=\'home-link\'}}Home{{/link-to}}{{#link-to \'about\' id=\'self-link\'}}Self{{/link-to}}');
        _emberMetalCore.default.TEMPLATES.item = _emberTemplateCompiler.compile('<h3>Item</h3><p>{{model.name}}</p>{{#link-to \'index\' id=\'home-link\'}}Home{{/link-to}}');

        AppView = _emberViewsViewsView.default.extend({
          templateName: 'app'
        });

        registry.register('view:app', AppView);

        registry.unregister('router:main');
        registry.register('router:main', Router);
      });
    },

    teardown: sharedTeardown
  });

  // These two tests are designed to simulate the context of an ember-qunit/ember-test-helpers component integration test,
  // so the container is available but it does not boot the entire app
  QUnit.test('Using {{link-to}} does not cause an exception if it is rendered before the router has started routing', function (assert) {
    Router.map(function () {
      this.route('about');
    });

    registry.register('component-lookup:main', _emberViewsComponent_lookup.default);

    var component = _emberMetalCore.default.Component.extend({
      layout: _emberTemplateCompiler.compile('{{#link-to "about"}}Go to About{{/link-to}}'),
      container: container
    }).create();

    var router = container.lookup('router:main');
    router.setupRouter();

    _emberMetalCore.default.run(function () {
      component.appendTo('#qunit-fixture');
    });

    assert.strictEqual(component.$('a').length, 1, 'the link is rendered');
  });

  QUnit.test('Using {{link-to}} does not cause an exception if it is rendered without a router.js instance', function (assert) {
    registry.register('component-lookup:main', _emberViewsComponent_lookup.default);

    var component = _emberMetalCore.default.Component.extend({
      layout: _emberTemplateCompiler.compile('{{#link-to "nonexistent"}}Does not work.{{/link-to}}'),
      container: container
    }).create();

    _emberMetalCore.default.run(function () {
      component.appendTo('#qunit-fixture');
    });

    assert.strictEqual(component.$('a').length, 1, 'the link is rendered');
  });

  QUnit.test('The {{link-to}} helper moves into the named route', function () {
    Router.map(function (match) {
      this.route('about');
    });

    bootApplication();

    _emberMetalCore.default.run(function () {
      router.handleURL('/');
    });

    equal(_emberMetalCore.default.$('h3:contains(Home)', '#qunit-fixture').length, 1, 'The home template was rendered');
    equal(_emberMetalCore.default.$('#self-link.active', '#qunit-fixture').length, 1, 'The self-link was rendered with active class');
    equal(_emberMetalCore.default.$('#about-link:not(.active)', '#qunit-fixture').length, 1, 'The other link was rendered without active class');

    _emberMetalCore.default.run(function () {
      _emberMetalCore.default.$('#about-link', '#qunit-fixture').click();
    });

    equal(_emberMetalCore.default.$('h3:contains(About)', '#qunit-fixture').length, 1, 'The about template was rendered');
    equal(_emberMetalCore.default.$('#self-link.active', '#qunit-fixture').length, 1, 'The self-link was rendered with active class');
    equal(_emberMetalCore.default.$('#home-link:not(.active)', '#qunit-fixture').length, 1, 'The other link was rendered without active class');
  });

  QUnit.test('The {{link-to}} helper supports URL replacement', function () {

    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('<h3>Home</h3>{{#link-to \'about\' id=\'about-link\' replace=true}}About{{/link-to}}');

    Router.map(function () {
      this.route('about');
    });

    bootApplication();

    _emberMetalCore.default.run(function () {
      router.handleURL('/');
    });

    equal(updateCount, 0, 'precond: setURL has not been called');
    equal(replaceCount, 0, 'precond: replaceURL has not been called');

    _emberMetalCore.default.run(function () {
      _emberMetalCore.default.$('#about-link', '#qunit-fixture').click();
    });

    equal(updateCount, 0, 'setURL should not be called');
    equal(replaceCount, 1, 'replaceURL should be called once');
  });

  QUnit.test('the {{link-to}} helper doesn\'t add an href when the tagName isn\'t \'a\'', function () {
    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('{{#link-to \'about\' id=\'about-link\' tagName=\'div\'}}About{{/link-to}}');

    Router.map(function () {
      this.route('about');
    });

    bootApplication();

    _emberMetalCore.default.run(function () {
      router.handleURL('/');
    });

    equal(_emberMetalCore.default.$('#about-link').attr('href'), undefined, 'there is no href attribute');
  });

  QUnit.test('the {{link-to}} applies a \'disabled\' class when disabled', function () {
    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('{{#link-to "about" id="about-link" disabledWhen="shouldDisable"}}About{{/link-to}}');
    App.IndexController = _emberMetalCore.default.Controller.extend({
      shouldDisable: true
    });

    Router.map(function () {
      this.route('about');
    });

    bootApplication();

    _emberMetalCore.default.run(function () {
      router.handleURL('/');
    });

    equal(_emberMetalCore.default.$('#about-link.disabled', '#qunit-fixture').length, 1, 'The link is disabled when its disabledWhen is true');
  });

  QUnit.test('the {{link-to}} doesn\'t apply a \'disabled\' class if disabledWhen is not provided', function () {
    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('{{#link-to "about" id="about-link"}}About{{/link-to}}');

    Router.map(function () {
      this.route('about');
    });

    bootApplication();

    _emberMetalCore.default.run(function () {
      router.handleURL('/');
    });

    ok(!_emberMetalCore.default.$('#about-link', '#qunit-fixture').hasClass('disabled'), 'The link is not disabled if disabledWhen not provided');
  });

  QUnit.test('the {{link-to}} helper supports a custom disabledClass', function () {
    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('{{#link-to "about" id="about-link" disabledWhen=true disabledClass="do-not-want"}}About{{/link-to}}');

    Router.map(function () {
      this.route('about');
    });

    bootApplication();

    _emberMetalCore.default.run(function () {
      router.handleURL('/');
    });

    equal(_emberMetalCore.default.$('#about-link.do-not-want', '#qunit-fixture').length, 1, 'The link can apply a custom disabled class');
  });

  QUnit.test('the {{link-to}} helper does not respond to clicks when disabled', function () {
    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('{{#link-to "about" id="about-link" disabledWhen=true}}About{{/link-to}}');

    Router.map(function () {
      this.route('about');
    });

    bootApplication();

    _emberMetalCore.default.run(function () {
      router.handleURL('/');
    });

    _emberMetalCore.default.run(function () {
      _emberMetalCore.default.$('#about-link', '#qunit-fixture').click();
    });

    equal(_emberMetalCore.default.$('h3:contains(About)', '#qunit-fixture').length, 0, 'Transitioning did not occur');
  });

  QUnit.test('The {{link-to}} helper supports a custom activeClass', function () {
    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('<h3>Home</h3>{{#link-to \'about\' id=\'about-link\'}}About{{/link-to}}{{#link-to \'index\' id=\'self-link\' activeClass=\'zomg-active\'}}Self{{/link-to}}');

    Router.map(function () {
      this.route('about');
    });

    bootApplication();

    _emberMetalCore.default.run(function () {
      router.handleURL('/');
    });

    equal(_emberMetalCore.default.$('h3:contains(Home)', '#qunit-fixture').length, 1, 'The home template was rendered');
    equal(_emberMetalCore.default.$('#self-link.zomg-active', '#qunit-fixture').length, 1, 'The self-link was rendered with active class');
    equal(_emberMetalCore.default.$('#about-link:not(.active)', '#qunit-fixture').length, 1, 'The other link was rendered without active class');
  });

  QUnit.test('The {{link-to}} helper supports \'classNameBindings\' with custom values [GH #11699]', function () {
    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('<h3>Home</h3>{{#link-to \'about\' id=\'about-link\' classNameBindings=\'foo:foo-is-true:foo-is-false\'}}About{{/link-to}}');

    Router.map(function () {
      this.route('about');
    });

    App.IndexController = _emberMetalCore.default.Controller.extend({
      foo: false
    });

    bootApplication();

    _emberMetalCore.default.run(function () {
      router.handleURL('/');
    });

    equal(_emberMetalCore.default.$('#about-link.foo-is-false', '#qunit-fixture').length, 1, 'The about-link was rendered with the falsy class');

    var controller = container.lookup('controller:index');
    _emberMetalCore.default.run(function () {
      controller.set('foo', true);
    });

    equal(_emberMetalCore.default.$('#about-link.foo-is-true', '#qunit-fixture').length, 1, 'The about-link was rendered with the truthy class after toggling the property');
  });

  QUnit.test('The {{link-to}} helper supports leaving off .index for nested routes', function () {
    Router.map(function () {
      this.route('about', function () {
        this.route('item');
      });
    });

    _emberMetalCore.default.TEMPLATES.about = _emberTemplateCompiler.compile('<h1>About</h1>{{outlet}}');
    _emberMetalCore.default.TEMPLATES['about/index'] = _emberTemplateCompiler.compile('<div id=\'index\'>Index</div>');
    _emberMetalCore.default.TEMPLATES['about/item'] = _emberTemplateCompiler.compile('<div id=\'item\'>{{#link-to \'about\'}}About{{/link-to}}</div>');

    bootApplication();

    _emberMetalCore.default.run(router, 'handleURL', '/about/item');

    equal(normalizeUrl(_emberMetalCore.default.$('#item a', '#qunit-fixture').attr('href')), '/about');
  });

  QUnit.test('The {{link-to}} helper supports currentWhen (DEPRECATED)', function () {
    expectDeprecation('Usage of `currentWhen` is deprecated, use `current-when` instead.');

    Router.map(function (match) {
      this.route('index', { path: '/' }, function () {
        this.route('about');
      });

      this.route('item');
    });

    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('<h3>Home</h3>{{outlet}}');
    _emberMetalCore.default.TEMPLATES['index/about'] = _emberTemplateCompiler.compile('{{#link-to \'item\' id=\'other-link\' currentWhen=\'index\'}}ITEM{{/link-to}}');

    bootApplication();

    _emberMetalCore.default.run(function () {
      router.handleURL('/about');
    });

    equal(_emberMetalCore.default.$('#other-link.active', '#qunit-fixture').length, 1, 'The link is active since current-when is a parent route');
  });

  QUnit.test('The {{link-to}} helper supports custom, nested, current-when', function () {
    Router.map(function (match) {
      this.route('index', { path: '/' }, function () {
        this.route('about');
      });

      this.route('item');
    });

    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('<h3>Home</h3>{{outlet}}');
    _emberMetalCore.default.TEMPLATES['index/about'] = _emberTemplateCompiler.compile('{{#link-to \'item\' id=\'other-link\' current-when=\'index\'}}ITEM{{/link-to}}');

    bootApplication();

    _emberMetalCore.default.run(function () {
      router.handleURL('/about');
    });

    equal(_emberMetalCore.default.$('#other-link.active', '#qunit-fixture').length, 1, 'The link is active since current-when is a parent route');
  });

  QUnit.test('The {{link-to}} helper does not disregard current-when when it is given explicitly for a route', function () {
    Router.map(function (match) {
      this.route('index', { path: '/' }, function () {
        this.route('about');
      });

      this.route('items', function () {
        this.route('item');
      });
    });

    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('<h3>Home</h3>{{outlet}}');
    _emberMetalCore.default.TEMPLATES['index/about'] = _emberTemplateCompiler.compile('{{#link-to \'items\' id=\'other-link\' current-when=\'index\'}}ITEM{{/link-to}}');

    bootApplication();

    _emberMetalCore.default.run(function () {
      router.handleURL('/about');
    });

    equal(_emberMetalCore.default.$('#other-link.active', '#qunit-fixture').length, 1, 'The link is active when current-when is given for explicitly for a route');
  });

  QUnit.test('The {{link-to}} helper supports multiple current-when routes', function () {
    Router.map(function (match) {
      this.route('index', { path: '/' }, function () {
        this.route('about');
      });
      this.route('item');
      this.route('foo');
    });

    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('<h3>Home</h3>{{outlet}}');
    _emberMetalCore.default.TEMPLATES['index/about'] = _emberTemplateCompiler.compile('{{#link-to \'item\' id=\'link1\' current-when=\'item index\'}}ITEM{{/link-to}}');
    _emberMetalCore.default.TEMPLATES['item'] = _emberTemplateCompiler.compile('{{#link-to \'item\' id=\'link2\' current-when=\'item index\'}}ITEM{{/link-to}}');
    _emberMetalCore.default.TEMPLATES['foo'] = _emberTemplateCompiler.compile('{{#link-to \'item\' id=\'link3\' current-when=\'item index\'}}ITEM{{/link-to}}');

    bootApplication();

    _emberMetalCore.default.run(function () {
      router.handleURL('/about');
    });

    equal(_emberMetalCore.default.$('#link1.active', '#qunit-fixture').length, 1, 'The link is active since current-when contains the parent route');

    _emberMetalCore.default.run(function () {
      router.handleURL('/item');
    });

    equal(_emberMetalCore.default.$('#link2.active', '#qunit-fixture').length, 1, 'The link is active since you are on the active route');

    _emberMetalCore.default.run(function () {
      router.handleURL('/foo');
    });

    equal(_emberMetalCore.default.$('#link3.active', '#qunit-fixture').length, 0, 'The link is not active since current-when does not contain the active route');
  });

  QUnit.test('The {{link-to}} helper defaults to bubbling', function () {
    _emberMetalCore.default.TEMPLATES.about = _emberTemplateCompiler.compile('<div {{action \'hide\'}}>{{#link-to \'about.contact\' id=\'about-contact\'}}About{{/link-to}}</div>{{outlet}}');
    _emberMetalCore.default.TEMPLATES['about/contact'] = _emberTemplateCompiler.compile('<h1 id=\'contact\'>Contact</h1>');

    Router.map(function () {
      this.route('about', function () {
        this.route('contact');
      });
    });

    var hidden = 0;

    App.AboutRoute = _emberMetalCore.default.Route.extend({
      actions: {
        hide: function () {
          hidden++;
        }
      }
    });

    bootApplication();

    _emberMetalCore.default.run(function () {
      router.handleURL('/about');
    });

    _emberMetalCore.default.run(function () {
      _emberMetalCore.default.$('#about-contact', '#qunit-fixture').click();
    });

    equal(_emberMetalCore.default.$('#contact', '#qunit-fixture').text(), 'Contact', 'precond - the link worked');

    equal(hidden, 1, 'The link bubbles');
  });

  QUnit.test('The {{link-to}} helper supports bubbles=false', function () {
    _emberMetalCore.default.TEMPLATES.about = _emberTemplateCompiler.compile('<div {{action \'hide\'}}>{{#link-to \'about.contact\' id=\'about-contact\' bubbles=false}}About{{/link-to}}</div>{{outlet}}');
    _emberMetalCore.default.TEMPLATES['about/contact'] = _emberTemplateCompiler.compile('<h1 id=\'contact\'>Contact</h1>');

    Router.map(function () {
      this.route('about', function () {
        this.route('contact');
      });
    });

    var hidden = 0;

    App.AboutRoute = _emberMetalCore.default.Route.extend({
      actions: {
        hide: function () {
          hidden++;
        }
      }
    });

    bootApplication();

    _emberMetalCore.default.run(function () {
      router.handleURL('/about');
    });

    _emberMetalCore.default.run(function () {
      _emberMetalCore.default.$('#about-contact', '#qunit-fixture').click();
    });

    equal(_emberMetalCore.default.$('#contact', '#qunit-fixture').text(), 'Contact', 'precond - the link worked');

    equal(hidden, 0, 'The link didn\'t bubble');
  });

  QUnit.test('The {{link-to}} helper moves into the named route with context', function () {
    Router.map(function (match) {
      this.route('about');
      this.route('item', { path: '/item/:id' });
    });

    _emberMetalCore.default.TEMPLATES.about = _emberTemplateCompiler.compile('<h3>List</h3><ul>{{#each model as |person|}}<li>{{#link-to \'item\' person}}{{person.name}}{{/link-to}}</li>{{/each}}</ul>{{#link-to \'index\' id=\'home-link\'}}Home{{/link-to}}');

    App.AboutRoute = _emberMetalCore.default.Route.extend({
      model: function () {
        return _emberMetalCore.default.A([{ id: 'yehuda', name: 'Yehuda Katz' }, { id: 'tom', name: 'Tom Dale' }, { id: 'erik', name: 'Erik Brynroflsson' }]);
      }
    });

    App.ItemRoute = _emberMetalCore.default.Route.extend({
      serialize: function (object) {
        return { id: object.id };
      }
    });

    bootApplication();

    _emberMetalCore.default.run(function () {
      router.handleURL('/about');
    });

    equal(_emberMetalCore.default.$('h3:contains(List)', '#qunit-fixture').length, 1, 'The home template was rendered');
    equal(normalizeUrl(_emberMetalCore.default.$('#home-link').attr('href')), '/', 'The home link points back at /');

    _emberMetalCore.default.run(function () {
      _emberMetalCore.default.$('li a:contains(Yehuda)', '#qunit-fixture').click();
    });

    equal(_emberMetalCore.default.$('h3:contains(Item)', '#qunit-fixture').length, 1, 'The item template was rendered');
    equal(_emberMetalCore.default.$('p', '#qunit-fixture').text(), 'Yehuda Katz', 'The name is correct');

    _emberMetalCore.default.run(function () {
      _emberMetalCore.default.$('#home-link').click();
    });
    _emberMetalCore.default.run(function () {
      _emberMetalCore.default.$('#about-link').click();
    });

    equal(normalizeUrl(_emberMetalCore.default.$('li a:contains(Yehuda)').attr('href')), '/item/yehuda');
    equal(normalizeUrl(_emberMetalCore.default.$('li a:contains(Tom)').attr('href')), '/item/tom');
    equal(normalizeUrl(_emberMetalCore.default.$('li a:contains(Erik)').attr('href')), '/item/erik');

    _emberMetalCore.default.run(function () {
      _emberMetalCore.default.$('li a:contains(Erik)', '#qunit-fixture').click();
    });

    equal(_emberMetalCore.default.$('h3:contains(Item)', '#qunit-fixture').length, 1, 'The item template was rendered');
    equal(_emberMetalCore.default.$('p', '#qunit-fixture').text(), 'Erik Brynroflsson', 'The name is correct');
  });

  QUnit.test('The {{link-to}} helper binds some anchor html tag common attributes', function () {
    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('<h3>Home</h3>{{#link-to \'index\' id=\'self-link\' title=\'title-attr\' rel=\'rel-attr\' tabindex=\'-1\'}}Self{{/link-to}}');
    bootApplication();

    _emberMetalCore.default.run(function () {
      router.handleURL('/');
    });

    var link = _emberMetalCore.default.$('#self-link', '#qunit-fixture');
    equal(link.attr('title'), 'title-attr', 'The self-link contains title attribute');
    equal(link.attr('rel'), 'rel-attr', 'The self-link contains rel attribute');
    equal(link.attr('tabindex'), '-1', 'The self-link contains tabindex attribute');
  });

  QUnit.test('The {{link-to}} helper supports `target` attribute', function () {
    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('<h3>Home</h3>{{#link-to \'index\' id=\'self-link\' target=\'_blank\'}}Self{{/link-to}}');
    bootApplication();

    _emberMetalCore.default.run(function () {
      router.handleURL('/');
    });

    var link = _emberMetalCore.default.$('#self-link', '#qunit-fixture');
    equal(link.attr('target'), '_blank', 'The self-link contains `target` attribute');
  });

  QUnit.test('The {{link-to}} helper does not call preventDefault if `target` attribute is provided', function () {
    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('<h3>Home</h3>{{#link-to \'index\' id=\'self-link\' target=\'_blank\'}}Self{{/link-to}}');
    bootApplication();

    _emberMetalCore.default.run(function () {
      router.handleURL('/');
    });

    var event = _emberMetalCore.default.$.Event('click');
    _emberMetalCore.default.$('#self-link', '#qunit-fixture').trigger(event);

    equal(event.isDefaultPrevented(), false, 'should not preventDefault when target attribute is specified');
  });

  QUnit.test('The {{link-to}} helper should preventDefault when `target = _self`', function () {
    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('<h3>Home</h3>{{#link-to \'index\' id=\'self-link\' target=\'_self\'}}Self{{/link-to}}');
    bootApplication();

    _emberMetalCore.default.run(function () {
      router.handleURL('/');
    });

    var event = _emberMetalCore.default.$.Event('click');
    _emberMetalCore.default.$('#self-link', '#qunit-fixture').trigger(event);

    equal(event.isDefaultPrevented(), true, 'should preventDefault when target attribute is `_self`');
  });

  QUnit.test('The {{link-to}} helper should not transition if target is not equal to _self or empty', function () {
    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('{{#link-to \'about\' id=\'about-link\' replace=true target=\'_blank\'}}About{{/link-to}}');

    Router.map(function () {
      this.route('about');
    });

    bootApplication();

    _emberMetalCore.default.run(function () {
      router.handleURL('/');
    });

    _emberMetalCore.default.run(function () {
      _emberMetalCore.default.$('#about-link', '#qunit-fixture').click();
    });

    notEqual(container.lookup('controller:application').get('currentRouteName'), 'about', 'link-to should not transition if target is not equal to _self or empty');
  });

  QUnit.test('The {{link-to}} helper accepts string/numeric arguments', function () {
    Router.map(function () {
      this.route('filter', { path: '/filters/:filter' });
      this.route('post', { path: '/post/:post_id' });
      this.route('repo', { path: '/repo/:owner/:name' });
    });

    App.FilterController = _emberMetalCore.default.Controller.extend({
      filter: 'unpopular',
      repo: _emberMetalCore.default.Object.create({ owner: 'ember', name: 'ember.js' }),
      post_id: 123
    });
    _emberMetalCore.default.TEMPLATES.filter = _emberTemplateCompiler.compile('<p>{{filter}}</p>{{#link-to "filter" "unpopular" id="link"}}Unpopular{{/link-to}}{{#link-to "filter" filter id="path-link"}}Unpopular{{/link-to}}{{#link-to "post" post_id id="post-path-link"}}Post{{/link-to}}{{#link-to "post" 123 id="post-number-link"}}Post{{/link-to}}{{#link-to "repo" repo id="repo-object-link"}}Repo{{/link-to}}');

    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile(' ');

    bootApplication();

    _emberMetalCore.default.run(function () {
      router.handleURL('/filters/popular');
    });

    equal(normalizeUrl(_emberMetalCore.default.$('#link', '#qunit-fixture').attr('href')), '/filters/unpopular');
    equal(normalizeUrl(_emberMetalCore.default.$('#path-link', '#qunit-fixture').attr('href')), '/filters/unpopular');
    equal(normalizeUrl(_emberMetalCore.default.$('#post-path-link', '#qunit-fixture').attr('href')), '/post/123');
    equal(normalizeUrl(_emberMetalCore.default.$('#post-number-link', '#qunit-fixture').attr('href')), '/post/123');
    equal(normalizeUrl(_emberMetalCore.default.$('#repo-object-link', '#qunit-fixture').attr('href')), '/repo/ember/ember.js');
  });

  QUnit.test('Issue 4201 - Shorthand for route.index shouldn\'t throw errors about context arguments', function () {
    expect(2);
    Router.map(function () {
      this.route('lobby', function () {
        this.route('index', { path: ':lobby_id' });
        this.route('list');
      });
    });

    App.LobbyIndexRoute = _emberMetalCore.default.Route.extend({
      model: function (params) {
        equal(params.lobby_id, 'foobar');
        return params.lobby_id;
      }
    });

    _emberMetalCore.default.TEMPLATES['lobby/index'] = _emberTemplateCompiler.compile('{{#link-to \'lobby\' \'foobar\' id=\'lobby-link\'}}Lobby{{/link-to}}');
    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('');
    _emberMetalCore.default.TEMPLATES['lobby/list'] = _emberTemplateCompiler.compile('{{#link-to \'lobby\' \'foobar\' id=\'lobby-link\'}}Lobby{{/link-to}}');
    bootApplication();
    _emberMetalCore.default.run(router, 'handleURL', '/lobby/list');
    _emberMetalCore.default.run(_emberMetalCore.default.$('#lobby-link'), 'click');
    shouldBeActive('#lobby-link');
  });

  QUnit.test('The {{link-to}} helper unwraps controllers', function () {
    expect(5);

    Router.map(function () {
      this.route('filter', { path: '/filters/:filter' });
    });

    var indexObject = { filter: 'popular' };

    App.FilterRoute = _emberMetalCore.default.Route.extend({
      model: function (params) {
        return indexObject;
      },

      serialize: function (passedObject) {
        equal(passedObject, indexObject, 'The unwrapped object is passed');
        return { filter: 'popular' };
      }
    });

    App.IndexRoute = _emberMetalCore.default.Route.extend({
      model: function () {
        return indexObject;
      }
    });

    _emberMetalCore.default.TEMPLATES.filter = _emberTemplateCompiler.compile('<p>{{model.filter}}</p>');
    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('{{#link-to "filter" this id="link"}}Filter{{/link-to}}');

    expectDeprecation(function () {
      bootApplication();
    }, /Providing `{{link-to}}` with a param that is wrapped in a controller is deprecated./);

    _emberMetalCore.default.run(function () {
      router.handleURL('/');
    });

    _emberMetalCore.default.$('#link', '#qunit-fixture').trigger('click');
  });

  QUnit.test('The {{link-to}} helper doesn\'t change view context', function () {
    App.IndexView = _emberViewsViewsView.default.extend({
      elementId: 'index',
      name: 'test',
      isTrue: true
    });

    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('{{view.name}}-{{#link-to \'index\' id=\'self-link\'}}Link: {{view.name}}-{{#if view.isTrue}}{{view.name}}{{/if}}{{/link-to}}');

    bootApplication();

    _emberMetalCore.default.run(function () {
      router.handleURL('/');
    });

    equal(_emberMetalCore.default.$('#index', '#qunit-fixture').text(), 'test-Link: test-test', 'accesses correct view');
  });

  QUnit.test('Quoteless route param performs property lookup', function () {
    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('{{#link-to \'index\' id=\'string-link\'}}string{{/link-to}}{{#link-to foo id=\'path-link\'}}path{{/link-to}}{{#link-to view.foo id=\'view-link\'}}{{view.foo}}{{/link-to}}');

    function assertEquality(href) {
      equal(normalizeUrl(_emberMetalCore.default.$('#string-link', '#qunit-fixture').attr('href')), '/');
      equal(normalizeUrl(_emberMetalCore.default.$('#path-link', '#qunit-fixture').attr('href')), href);
      equal(normalizeUrl(_emberMetalCore.default.$('#view-link', '#qunit-fixture').attr('href')), href);
    }

    App.IndexView = _emberViewsViewsView.default.extend({
      foo: 'index',
      elementId: 'index-view'
    });

    App.IndexController = _emberMetalCore.default.Controller.extend({
      foo: 'index'
    });

    App.Router.map(function () {
      this.route('about');
    });

    bootApplication();

    _emberMetalCore.default.run(router, 'handleURL', '/');

    assertEquality('/');

    var controller = container.lookup('controller:index');
    var view = _emberViewsViewsView.default.views['index-view'];
    _emberMetalCore.default.run(function () {
      controller.set('foo', 'about');
      view.set('foo', 'about');
    });

    assertEquality('/about');
  });

  QUnit.test('link-to with null/undefined dynamic parameters are put in a loading state', function () {

    expect(19);

    var oldWarn = _emberMetalCore.default.Logger.warn;
    var warnCalled = false;
    _emberMetalCore.default.Logger.warn = function () {
      warnCalled = true;
    };
    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('{{#link-to destinationRoute routeContext loadingClass=\'i-am-loading\' id=\'context-link\'}}string{{/link-to}}{{#link-to secondRoute loadingClass=\'i-am-loading\' id=\'static-link\'}}string{{/link-to}}');

    var thing = _emberMetalCore.default.Object.create({ id: 123 });

    App.IndexController = _emberMetalCore.default.Controller.extend({
      destinationRoute: null,
      routeContext: null
    });

    App.AboutRoute = _emberMetalCore.default.Route.extend({
      activate: function () {
        ok(true, 'About was entered');
      }
    });

    App.Router.map(function () {
      this.route('thing', { path: '/thing/:thing_id' });
      this.route('about');
    });

    bootApplication();

    _emberMetalCore.default.run(router, 'handleURL', '/');

    function assertLinkStatus($link, url) {
      if (url) {
        equal(normalizeUrl($link.attr('href')), url, 'loaded link-to has expected href');
        ok(!$link.hasClass('i-am-loading'), 'loaded linkComponent has no loadingClass');
      } else {
        equal(normalizeUrl($link.attr('href')), '#', 'unloaded link-to has href=\'#\'');
        ok($link.hasClass('i-am-loading'), 'loading linkComponent has loadingClass');
      }
    }

    var $contextLink = _emberMetalCore.default.$('#context-link', '#qunit-fixture');
    var $staticLink = _emberMetalCore.default.$('#static-link', '#qunit-fixture');
    var controller = container.lookup('controller:index');

    assertLinkStatus($contextLink);
    assertLinkStatus($staticLink);

    _emberMetalCore.default.run(function () {
      warnCalled = false;
      $contextLink.click();
      ok(warnCalled, 'Logger.warn was called from clicking loading link');
    });

    // Set the destinationRoute (context is still null).
    _emberMetalCore.default.run(controller, 'set', 'destinationRoute', 'thing');
    assertLinkStatus($contextLink);

    // Set the routeContext to an id
    _emberMetalCore.default.run(controller, 'set', 'routeContext', '456');
    assertLinkStatus($contextLink, '/thing/456');

    // Test that 0 isn't interpreted as falsy.
    _emberMetalCore.default.run(controller, 'set', 'routeContext', 0);
    assertLinkStatus($contextLink, '/thing/0');

    // Set the routeContext to an object
    _emberMetalCore.default.run(controller, 'set', 'routeContext', thing);
    assertLinkStatus($contextLink, '/thing/123');

    // Set the destinationRoute back to null.
    _emberMetalCore.default.run(controller, 'set', 'destinationRoute', null);
    assertLinkStatus($contextLink);

    _emberMetalCore.default.run(function () {
      warnCalled = false;
      $staticLink.click();
      ok(warnCalled, 'Logger.warn was called from clicking loading link');
    });

    _emberMetalCore.default.run(controller, 'set', 'secondRoute', 'about');
    assertLinkStatus($staticLink, '/about');

    // Click the now-active link
    _emberMetalCore.default.run($staticLink, 'click');

    _emberMetalCore.default.Logger.warn = oldWarn;
  });

  QUnit.test('The {{link-to}} helper refreshes href element when one of params changes', function () {
    Router.map(function () {
      this.route('post', { path: '/posts/:post_id' });
    });

    var post = _emberMetalCore.default.Object.create({ id: '1' });
    var secondPost = _emberMetalCore.default.Object.create({ id: '2' });

    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('{{#link-to "post" post id="post"}}post{{/link-to}}');

    App.IndexController = _emberMetalCore.default.Controller.extend();
    var indexController = container.lookup('controller:index');

    _emberMetalCore.default.run(function () {
      indexController.set('post', post);
    });

    bootApplication();

    _emberMetalCore.default.run(function () {
      router.handleURL('/');
    });

    equal(normalizeUrl(_emberMetalCore.default.$('#post', '#qunit-fixture').attr('href')), '/posts/1', 'precond - Link has rendered href attr properly');

    _emberMetalCore.default.run(function () {
      indexController.set('post', secondPost);
    });

    equal(_emberMetalCore.default.$('#post', '#qunit-fixture').attr('href'), '/posts/2', 'href attr was updated after one of the params had been changed');

    _emberMetalCore.default.run(function () {
      indexController.set('post', null);
    });

    equal(_emberMetalCore.default.$('#post', '#qunit-fixture').attr('href'), '#', 'href attr becomes # when one of the arguments in nullified');
  });

  QUnit.test('The {{link-to}} helper is active when a route is active', function () {
    Router.map(function () {
      this.route('about', function () {
        this.route('item');
      });
    });

    _emberMetalCore.default.TEMPLATES.about = _emberTemplateCompiler.compile('<div id=\'about\'>{{#link-to \'about\' id=\'about-link\'}}About{{/link-to}} {{#link-to \'about.item\' id=\'item-link\'}}Item{{/link-to}} {{outlet}}</div>');
    _emberMetalCore.default.TEMPLATES['about/item'] = _emberTemplateCompiler.compile(' ');
    _emberMetalCore.default.TEMPLATES['about/index'] = _emberTemplateCompiler.compile(' ');

    bootApplication();

    _emberMetalCore.default.run(router, 'handleURL', '/about');

    equal(_emberMetalCore.default.$('#about-link.active', '#qunit-fixture').length, 1, 'The about route link is active');
    equal(_emberMetalCore.default.$('#item-link.active', '#qunit-fixture').length, 0, 'The item route link is inactive');

    _emberMetalCore.default.run(router, 'handleURL', '/about/item');

    equal(_emberMetalCore.default.$('#about-link.active', '#qunit-fixture').length, 1, 'The about route link is active');
    equal(_emberMetalCore.default.$('#item-link.active', '#qunit-fixture').length, 1, 'The item route link is active');
  });

  QUnit.test('The {{link-to}} helper works in an #each\'d array of string route names', function () {
    Router.map(function () {
      this.route('foo');
      this.route('bar');
      this.route('rar');
    });

    App.IndexController = _emberMetalCore.default.Controller.extend({
      routeNames: _emberMetalCore.default.A(['foo', 'bar', 'rar']),
      route1: 'bar',
      route2: 'foo'
    });

    _emberMetalCore.default.TEMPLATES = {
      index: _emberTemplateCompiler.compile('{{#each routeNames as |routeName|}}{{#link-to routeName}}{{routeName}}{{/link-to}}{{/each}}{{#each routeNames as |r|}}{{#link-to r}}{{r}}{{/link-to}}{{/each}}{{#link-to route1}}a{{/link-to}}{{#link-to route2}}b{{/link-to}}')
    };

    bootApplication();

    function linksEqual($links, expected) {
      equal($links.length, expected.length, 'Has correct number of links');

      var idx;
      for (idx = 0; idx < $links.length; idx++) {
        var href = _emberMetalCore.default.$($links[idx]).attr('href');
        // Old IE includes the whole hostname as well
        equal(href.slice(-expected[idx].length), expected[idx], 'Expected link to be \'' + expected[idx] + '\', but was \'' + href + '\'');
      }
    }

    linksEqual(_emberMetalCore.default.$('a', '#qunit-fixture'), ['/foo', '/bar', '/rar', '/foo', '/bar', '/rar', '/bar', '/foo']);

    var indexController = container.lookup('controller:index');
    _emberMetalCore.default.run(indexController, 'set', 'route1', 'rar');

    linksEqual(_emberMetalCore.default.$('a', '#qunit-fixture'), ['/foo', '/bar', '/rar', '/foo', '/bar', '/rar', '/rar', '/foo']);

    _emberMetalCore.default.run(indexController.routeNames, 'shiftObject');

    linksEqual(_emberMetalCore.default.$('a', '#qunit-fixture'), ['/bar', '/rar', '/bar', '/rar', '/rar', '/foo']);
  });

  QUnit.test('The non-block form {{link-to}} helper moves into the named route', function () {
    expect(3);
    Router.map(function (match) {
      this.route('contact');
    });

    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('<h3>Home</h3>{{link-to \'Contact us\' \'contact\' id=\'contact-link\'}}{{#link-to \'index\' id=\'self-link\'}}Self{{/link-to}}');
    _emberMetalCore.default.TEMPLATES.contact = _emberTemplateCompiler.compile('<h3>Contact</h3>{{link-to \'Home\' \'index\' id=\'home-link\'}}{{link-to \'Self\' \'contact\' id=\'self-link\'}}');

    bootApplication();

    _emberMetalCore.default.run(function () {
      _emberMetalCore.default.$('#contact-link', '#qunit-fixture').click();
    });

    equal(_emberMetalCore.default.$('h3:contains(Contact)', '#qunit-fixture').length, 1, 'The contact template was rendered');
    equal(_emberMetalCore.default.$('#self-link.active', '#qunit-fixture').length, 1, 'The self-link was rendered with active class');
    equal(_emberMetalCore.default.$('#home-link:not(.active)', '#qunit-fixture').length, 1, 'The other link was rendered without active class');
  });

  QUnit.test('The non-block form {{link-to}} helper updates the link text when it is a binding', function () {
    expect(8);
    Router.map(function (match) {
      this.route('contact');
    });

    App.IndexController = _emberMetalCore.default.Controller.extend({
      contactName: 'Jane'
    });

    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('<h3>Home</h3>{{link-to contactName \'contact\' id=\'contact-link\'}}{{#link-to \'index\' id=\'self-link\'}}Self{{/link-to}}');
    _emberMetalCore.default.TEMPLATES.contact = _emberTemplateCompiler.compile('<h3>Contact</h3>{{link-to \'Home\' \'index\' id=\'home-link\'}}{{link-to \'Self\' \'contact\' id=\'self-link\'}}');

    bootApplication();

    _emberMetalCore.default.run(function () {
      router.handleURL('/');
    });
    var controller = container.lookup('controller:index');

    equal(_emberMetalCore.default.$('#contact-link:contains(Jane)', '#qunit-fixture').length, 1, 'The link title is correctly resolved');

    _emberMetalCore.default.run(function () {
      controller.set('contactName', 'Joe');
    });
    equal(_emberMetalCore.default.$('#contact-link:contains(Joe)', '#qunit-fixture').length, 1, 'The link title is correctly updated when the bound property changes');

    _emberMetalCore.default.run(function () {
      controller.set('contactName', 'Robert');
    });
    equal(_emberMetalCore.default.$('#contact-link:contains(Robert)', '#qunit-fixture').length, 1, 'The link title is correctly updated when the bound property changes a second time');

    _emberMetalCore.default.run(function () {
      _emberMetalCore.default.$('#contact-link', '#qunit-fixture').click();
    });

    equal(_emberMetalCore.default.$('h3:contains(Contact)', '#qunit-fixture').length, 1, 'The contact template was rendered');
    equal(_emberMetalCore.default.$('#self-link.active', '#qunit-fixture').length, 1, 'The self-link was rendered with active class');
    equal(_emberMetalCore.default.$('#home-link:not(.active)', '#qunit-fixture').length, 1, 'The other link was rendered without active class');

    _emberMetalCore.default.run(function () {
      _emberMetalCore.default.$('#home-link', '#qunit-fixture').click();
    });

    equal(_emberMetalCore.default.$('h3:contains(Home)', '#qunit-fixture').length, 1, 'The index template was rendered');
    equal(_emberMetalCore.default.$('#contact-link:contains(Robert)', '#qunit-fixture').length, 1, 'The link title is correctly updated when the route changes');
  });

  QUnit.test('The non-block form {{link-to}} helper moves into the named route with context', function () {
    expect(5);
    Router.map(function (match) {
      this.route('item', { path: '/item/:id' });
    });

    App.IndexRoute = _emberMetalCore.default.Route.extend({
      model: function () {
        return _emberMetalCore.default.A([{ id: 'yehuda', name: 'Yehuda Katz' }, { id: 'tom', name: 'Tom Dale' }, { id: 'erik', name: 'Erik Brynroflsson' }]);
      }
    });

    App.ItemRoute = _emberMetalCore.default.Route.extend({
      serialize: function (object) {
        return { id: object.id };
      }
    });

    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('<h3>Home</h3><ul>{{#each model as |person|}}<li>{{link-to person.name \'item\' person}}</li>{{/each}}</ul>');
    _emberMetalCore.default.TEMPLATES.item = _emberTemplateCompiler.compile('<h3>Item</h3><p>{{model.name}}</p>{{#link-to \'index\' id=\'home-link\'}}Home{{/link-to}}');

    bootApplication();

    _emberMetalCore.default.run(function () {
      _emberMetalCore.default.$('li a:contains(Yehuda)', '#qunit-fixture').click();
    });

    equal(_emberMetalCore.default.$('h3:contains(Item)', '#qunit-fixture').length, 1, 'The item template was rendered');
    equal(_emberMetalCore.default.$('p', '#qunit-fixture').text(), 'Yehuda Katz', 'The name is correct');

    _emberMetalCore.default.run(function () {
      _emberMetalCore.default.$('#home-link').click();
    });

    equal(normalizeUrl(_emberMetalCore.default.$('li a:contains(Yehuda)').attr('href')), '/item/yehuda');
    equal(normalizeUrl(_emberMetalCore.default.$('li a:contains(Tom)').attr('href')), '/item/tom');
    equal(normalizeUrl(_emberMetalCore.default.$('li a:contains(Erik)').attr('href')), '/item/erik');
  });

  QUnit.test('The non-block form {{link-to}} performs property lookup', function () {
    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('{{link-to \'string\' \'index\' id=\'string-link\'}}{{link-to path foo id=\'path-link\'}}{{link-to view.foo view.foo id=\'view-link\'}}');

    function assertEquality(href) {
      equal(normalizeUrl(_emberMetalCore.default.$('#string-link', '#qunit-fixture').attr('href')), '/');
      equal(normalizeUrl(_emberMetalCore.default.$('#path-link', '#qunit-fixture').attr('href')), href);
      equal(normalizeUrl(_emberMetalCore.default.$('#view-link', '#qunit-fixture').attr('href')), href);
    }

    App.IndexView = _emberViewsViewsView.default.extend({
      foo: 'index',
      elementId: 'index-view'
    });

    App.IndexController = _emberMetalCore.default.Controller.extend({
      foo: 'index'
    });

    App.Router.map(function () {
      this.route('about');
    });

    bootApplication();

    _emberMetalCore.default.run(router, 'handleURL', '/');

    assertEquality('/');

    var controller = container.lookup('controller:index');
    var view = _emberViewsViewsView.default.views['index-view'];
    _emberMetalCore.default.run(function () {
      controller.set('foo', 'about');
      view.set('foo', 'about');
    });

    assertEquality('/about');
  });

  QUnit.test('The non-block form {{link-to}} protects against XSS', function () {
    _emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('{{link-to display \'index\' id=\'link\'}}');

    App.ApplicationController = _emberMetalCore.default.Controller.extend({
      display: 'blahzorz'
    });

    bootApplication();

    _emberMetalCore.default.run(router, 'handleURL', '/');

    var controller = container.lookup('controller:application');

    equal(_emberMetalCore.default.$('#link', '#qunit-fixture').text(), 'blahzorz');
    _emberMetalCore.default.run(function () {
      controller.set('display', '<b>BLAMMO</b>');
    });

    equal(_emberMetalCore.default.$('#link', '#qunit-fixture').text(), '<b>BLAMMO</b>');
    equal(_emberMetalCore.default.$('b', '#qunit-fixture').length, 0);
  });

  QUnit.test('the {{link-to}} helper calls preventDefault', function () {
    Router.map(function () {
      this.route('about');
    });

    bootApplication();

    _emberMetalCore.default.run(router, 'handleURL', '/');

    var event = _emberMetalCore.default.$.Event('click');
    _emberMetalCore.default.$('#about-link', '#qunit-fixture').trigger(event);

    equal(event.isDefaultPrevented(), true, 'should preventDefault');
  });

  QUnit.test('the {{link-to}} helper does not call preventDefault if `preventDefault=false` is passed as an option', function () {
    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('{{#link-to \'about\' id=\'about-link\' preventDefault=false}}About{{/link-to}}');

    Router.map(function () {
      this.route('about');
    });

    bootApplication();

    _emberMetalCore.default.run(router, 'handleURL', '/');

    var event = _emberMetalCore.default.$.Event('click');
    _emberMetalCore.default.$('#about-link', '#qunit-fixture').trigger(event);

    equal(event.isDefaultPrevented(), false, 'should not preventDefault');
  });

  QUnit.test('the {{link-to}} helper does not throw an error if its route has exited', function () {
    expect(0);

    _emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('{{#link-to \'index\' id=\'home-link\'}}Home{{/link-to}}{{#link-to \'post\' defaultPost id=\'default-post-link\'}}Default Post{{/link-to}}{{#if currentPost}}{{#link-to \'post\' id=\'post-link\'}}Post{{/link-to}}{{/if}}');

    App.ApplicationController = _emberMetalCore.default.Controller.extend({
      postController: _emberMetalCore.default.inject.controller('post'),
      currentPost: _emberMetalCore.default.computed.alias('postController.model')
    });

    App.PostController = _emberMetalCore.default.Controller.extend({
      model: { id: 1 }
    });

    Router.map(function () {
      this.route('post', { path: 'post/:post_id' });
    });

    bootApplication();

    _emberMetalCore.default.run(router, 'handleURL', '/');

    _emberMetalCore.default.run(function () {
      _emberMetalCore.default.$('#default-post-link', '#qunit-fixture').click();
    });

    _emberMetalCore.default.run(function () {
      _emberMetalCore.default.$('#home-link', '#qunit-fixture').click();
    });
  });

  QUnit.test('{{link-to}} active property respects changing parent route context', function () {
    _emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('{{link-to \'OMG\' \'things\' \'omg\' id=\'omg-link\'}} ' + '{{link-to \'LOL\' \'things\' \'lol\' id=\'lol-link\'}} ');

    Router.map(function () {
      this.route('things', { path: '/things/:name' }, function () {
        this.route('other');
      });
    });

    bootApplication();

    _emberMetalCore.default.run(router, 'handleURL', '/things/omg');
    shouldBeActive('#omg-link');
    shouldNotBeActive('#lol-link');

    _emberMetalCore.default.run(router, 'handleURL', '/things/omg/other');
    shouldBeActive('#omg-link');
    shouldNotBeActive('#lol-link');
  });

  QUnit.test('{{link-to}} populates href with default query param values even without query-params object', function () {
    App.IndexController = _emberMetalCore.default.Controller.extend({
      queryParams: ['foo'],
      foo: '123'
    });

    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('{{#link-to \'index\' id=\'the-link\'}}Index{{/link-to}}');
    bootApplication();
    equal(_emberMetalCore.default.$('#the-link').attr('href'), '/', 'link has right href');
  });

  QUnit.test('{{link-to}} populates href with default query param values with empty query-params object', function () {
    App.IndexController = _emberMetalCore.default.Controller.extend({
      queryParams: ['foo'],
      foo: '123'
    });

    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('{{#link-to \'index\' (query-params) id=\'the-link\'}}Index{{/link-to}}');
    bootApplication();
    equal(_emberMetalCore.default.$('#the-link').attr('href'), '/', 'link has right href');
  });

  QUnit.test('{{link-to}} populates href with supplied query param values', function () {
    App.IndexController = _emberMetalCore.default.Controller.extend({
      queryParams: ['foo'],
      foo: '123'
    });

    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('{{#link-to \'index\' (query-params foo=\'456\') id=\'the-link\'}}Index{{/link-to}}');
    bootApplication();
    equal(_emberMetalCore.default.$('#the-link').attr('href'), '/?foo=456', 'link has right href');
  });

  QUnit.test('{{link-to}} populates href with partially supplied query param values', function () {
    App.IndexController = _emberMetalCore.default.Controller.extend({
      queryParams: ['foo'],
      foo: '123',
      bar: 'yes'
    });

    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('{{#link-to \'index\' (query-params foo=\'456\') id=\'the-link\'}}Index{{/link-to}}');
    bootApplication();
    equal(_emberMetalCore.default.$('#the-link').attr('href'), '/?foo=456', 'link has right href');
  });

  QUnit.test('{{link-to}} populates href with partially supplied query param values, but omits if value is default value', function () {
    App.IndexController = _emberMetalCore.default.Controller.extend({
      queryParams: ['foo'],
      foo: '123'
    });

    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('{{#link-to \'index\' (query-params foo=\'123\') id=\'the-link\'}}Index{{/link-to}}');
    bootApplication();
    equal(_emberMetalCore.default.$('#the-link').attr('href'), '/', 'link has right href');
  });

  QUnit.test('{{link-to}} populates href with fully supplied query param values', function () {
    App.IndexController = _emberMetalCore.default.Controller.extend({
      queryParams: ['foo', 'bar'],
      foo: '123',
      bar: 'yes'
    });

    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('{{#link-to \'index\' (query-params foo=\'456\' bar=\'NAW\') id=\'the-link\'}}Index{{/link-to}}');
    bootApplication();
    equal(_emberMetalCore.default.$('#the-link').attr('href'), '/?bar=NAW&foo=456', 'link has right href');
  });

  QUnit.test('{{link-to}} with only query-params and a block updates when route changes', function () {
    Router.map(function () {
      this.route('about');
    });

    App.ApplicationController = _emberMetalCore.default.Controller.extend({
      queryParams: ['foo', 'bar'],
      foo: '123',
      bar: 'yes'
    });

    _emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('{{#link-to (query-params foo=\'456\' bar=\'NAW\') id=\'the-link\'}}Index{{/link-to}}');
    bootApplication();
    equal(_emberMetalCore.default.$('#the-link').attr('href'), '/?bar=NAW&foo=456', 'link has right href');

    _emberMetalCore.default.run(function () {
      router.handleURL('/about');
    });
    equal(_emberMetalCore.default.$('#the-link').attr('href'), '/about?bar=NAW&foo=456', 'link has right href');
  });

  QUnit.test('Block-less {{link-to}} with only query-params updates when route changes', function () {
    Router.map(function () {
      this.route('about');
    });

    App.ApplicationController = _emberMetalCore.default.Controller.extend({
      queryParams: ['foo', 'bar'],
      foo: '123',
      bar: 'yes'
    });

    _emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('{{link-to "Index" (query-params foo=\'456\' bar=\'NAW\') id=\'the-link\'}}');
    bootApplication();
    equal(_emberMetalCore.default.$('#the-link').attr('href'), '/?bar=NAW&foo=456', 'link has right href');

    _emberMetalCore.default.run(function () {
      router.handleURL('/about');
    });
    equal(_emberMetalCore.default.$('#the-link').attr('href'), '/about?bar=NAW&foo=456', 'link has right href');
  });
});
enifed('ember/tests/helpers/link_to_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember/tests/helpers');
  test('ember/tests/helpers/link_to_test.js should pass jscs', function () {
    ok(true, 'ember/tests/helpers/link_to_test.js should pass jscs.');
  });
});
enifed('ember/tests/helpers/link_to_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember/tests/helpers');
  QUnit.test('ember/tests/helpers/link_to_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember/tests/helpers/link_to_test.js should pass jshint.');
  });
});
enifed('ember/tests/helpers/link_to_test/link_to_transitioning_classes_test', ['exports', 'ember', 'ember-metal/core', 'ember-metal/features', 'ember-template-compiler'], function (exports, _ember, _emberMetalCore, _emberMetalFeatures, _emberTemplateCompiler) {
  'use strict';

  var Router, App, router, registry, container;
  var set = _emberMetalCore.default.set;

  var aboutDefer, otherDefer;

  function basicEagerURLUpdateTest(setTagName) {
    expect(6);

    if (setTagName) {
      _emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('{{outlet}}{{link-to \'Index\' \'index\' id=\'index-link\'}}{{link-to \'About\' \'about\' id=\'about-link\' tagName=\'span\'}}');
    }

    bootApplication();
    equal(updateCount, 0);
    _emberMetalCore.default.run(_emberMetalCore.default.$('#about-link'), 'click');

    // URL should be eagerly updated now
    equal(updateCount, 1);
    equal(router.get('location.path'), '/about');

    // Resolve the promise.
    _emberMetalCore.default.run(aboutDefer, 'resolve');
    equal(router.get('location.path'), '/about');

    // Shouldn't have called update url again.
    equal(updateCount, 1);
    equal(router.get('location.path'), '/about');
  }

  function bootApplication() {
    router = container.lookup('router:main');
    _emberMetalCore.default.run(App, 'advanceReadiness');
  }

  var updateCount, replaceCount;

  function sharedSetup() {
    App = _emberMetalCore.default.Application.create({
      name: 'App',
      rootElement: '#qunit-fixture'
    });

    App.deferReadiness();

    updateCount = replaceCount = 0;
    App.Router.reopen({
      location: _emberMetalCore.default.NoneLocation.create({
        setURL: function (path) {
          updateCount++;
          set(this, 'path', path);
        },

        replaceURL: function (path) {
          replaceCount++;
          set(this, 'path', path);
        }
      })
    });

    Router = App.Router;
    registry = App.registry;
    container = App.__container__;
  }

  function sharedTeardown() {
    _emberMetalCore.default.run(function () {
      App.destroy();
    });
    _emberMetalCore.default.TEMPLATES = {};
  }

  QUnit.module('The {{link-to}} helper: .transitioning-in .transitioning-out CSS classes', {
    setup: function () {
      _emberMetalCore.default.run(function () {
        sharedSetup();

        registry.unregister('router:main');
        registry.register('router:main', Router);

        Router.map(function () {
          this.route('about');
          this.route('other');
        });

        App.AboutRoute = _emberMetalCore.default.Route.extend({
          model: function () {
            aboutDefer = _emberMetalCore.default.RSVP.defer();
            return aboutDefer.promise;
          }
        });

        App.OtherRoute = _emberMetalCore.default.Route.extend({
          model: function () {
            otherDefer = _emberMetalCore.default.RSVP.defer();
            return otherDefer.promise;
          }
        });

        _emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('{{outlet}}{{link-to \'Index\' \'index\' id=\'index-link\'}}{{link-to \'About\' \'about\' id=\'about-link\'}}{{link-to \'Other\' \'other\' id=\'other-link\'}}');
      });
    },

    teardown: function () {
      sharedTeardown();
      aboutDefer = null;
    }
  });

  QUnit.test('while a transition is underway', function () {
    expect(18);
    bootApplication();

    function assertHasClass(className) {
      var i = 1;
      while (i < arguments.length) {
        var $a = arguments[i];
        var shouldHaveClass = arguments[i + 1];
        equal($a.hasClass(className), shouldHaveClass, $a.attr('id') + ' should ' + (shouldHaveClass ? '' : 'not ') + 'have class ' + className);
        i += 2;
      }
    }

    var $index = _emberMetalCore.default.$('#index-link');
    var $about = _emberMetalCore.default.$('#about-link');
    var $other = _emberMetalCore.default.$('#other-link');

    _emberMetalCore.default.run($about, 'click');

    assertHasClass('active', $index, true, $about, false, $other, false);
    assertHasClass('ember-transitioning-in', $index, false, $about, true, $other, false);
    assertHasClass('ember-transitioning-out', $index, true, $about, false, $other, false);

    _emberMetalCore.default.run(aboutDefer, 'resolve');

    assertHasClass('active', $index, false, $about, true, $other, false);
    assertHasClass('ember-transitioning-in', $index, false, $about, false, $other, false);
    assertHasClass('ember-transitioning-out', $index, false, $about, false, $other, false);
  });

  QUnit.test('while a transition is underway with nested link-to\'s', function () {
    expect(54);

    Router.map(function () {
      this.route('parent-route', function () {
        this.route('about');
        this.route('other');
      });
    });

    App.ParentRouteAboutRoute = _emberMetalCore.default.Route.extend({
      model: function () {
        aboutDefer = _emberMetalCore.default.RSVP.defer();
        return aboutDefer.promise;
      }
    });

    App.ParentRouteOtherRoute = _emberMetalCore.default.Route.extend({
      model: function () {
        otherDefer = _emberMetalCore.default.RSVP.defer();
        return otherDefer.promise;
      }
    });

    _emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('\n      {{outlet}}\n      {{#link-to \'index\' tagName=\'li\'}}\n        {{link-to \'Index\' \'index\' id=\'index-link\'}}\n      {{/link-to}}\n      {{#link-to \'parent-route.about\' tagName=\'li\'}}\n        {{link-to \'About\' \'parent-route.about\' id=\'about-link\'}}\n      {{/link-to}}\n      {{#link-to \'parent-route.other\' tagName=\'li\'}}\n        {{link-to \'Other\' \'parent-route.other\' id=\'other-link\'}}\n      {{/link-to}}\n    ');

    bootApplication();

    function assertHasClass(className) {
      var i = 1;
      while (i < arguments.length) {
        var $a = arguments[i];
        var shouldHaveClass = arguments[i + 1];
        equal($a.hasClass(className), shouldHaveClass, $a.attr('id') + ' should ' + (shouldHaveClass ? '' : 'not ') + 'have class ' + className);
        i += 2;
      }
    }

    var $index = _emberMetalCore.default.$('#index-link');
    var $about = _emberMetalCore.default.$('#about-link');
    var $other = _emberMetalCore.default.$('#other-link');

    _emberMetalCore.default.run($about, 'click');

    assertHasClass('active', $index, true, $about, false, $other, false);
    assertHasClass('ember-transitioning-in', $index, false, $about, true, $other, false);
    assertHasClass('ember-transitioning-out', $index, true, $about, false, $other, false);

    _emberMetalCore.default.run(aboutDefer, 'resolve');

    assertHasClass('active', $index, false, $about, true, $other, false);
    assertHasClass('ember-transitioning-in', $index, false, $about, false, $other, false);
    assertHasClass('ember-transitioning-out', $index, false, $about, false, $other, false);

    _emberMetalCore.default.run($other, 'click');

    assertHasClass('active', $index, false, $about, true, $other, false);
    assertHasClass('ember-transitioning-in', $index, false, $about, false, $other, true);
    assertHasClass('ember-transitioning-out', $index, false, $about, true, $other, false);

    _emberMetalCore.default.run(otherDefer, 'resolve');

    assertHasClass('active', $index, false, $about, false, $other, true);
    assertHasClass('ember-transitioning-in', $index, false, $about, false, $other, false);
    assertHasClass('ember-transitioning-out', $index, false, $about, false, $other, false);

    _emberMetalCore.default.run($about, 'click');

    assertHasClass('active', $index, false, $about, false, $other, true);
    assertHasClass('ember-transitioning-in', $index, false, $about, true, $other, false);
    assertHasClass('ember-transitioning-out', $index, false, $about, false, $other, true);

    _emberMetalCore.default.run(aboutDefer, 'resolve');

    assertHasClass('active', $index, false, $about, true, $other, false);
    assertHasClass('ember-transitioning-in', $index, false, $about, false, $other, false);
    assertHasClass('ember-transitioning-out', $index, false, $about, false, $other, false);
  });
});

// HistoryLocation is the only Location class that will cause rootURL to be
// prepended to link-to href's right now

// Don't actually touch the URL

// href should have rootURL prepended

// Actual path provided to Location class should NOT have rootURL

// Shouldn't have called update url.

// Shouldn't have called update url.
enifed('ember/tests/helpers/link_to_test/link_to_transitioning_classes_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember/tests/helpers/link_to_test');
  test('ember/tests/helpers/link_to_test/link_to_transitioning_classes_test.js should pass jscs', function () {
    ok(true, 'ember/tests/helpers/link_to_test/link_to_transitioning_classes_test.js should pass jscs.');
  });
});
enifed('ember/tests/helpers/link_to_test/link_to_transitioning_classes_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember/tests/helpers/link_to_test');
  QUnit.test('ember/tests/helpers/link_to_test/link_to_transitioning_classes_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember/tests/helpers/link_to_test/link_to_transitioning_classes_test.js should pass jshint.');
  });
});
enifed('ember/tests/helpers/link_to_test/link_to_with_query_params_test', ['exports', 'ember', 'ember-metal/core', 'ember-metal/features', 'ember-template-compiler'], function (exports, _ember, _emberMetalCore, _emberMetalFeatures, _emberTemplateCompiler) {
  'use strict';

  var Router, App, router, registry, container;
  var set = _emberMetalCore.default.set;

  function bootApplication() {
    router = container.lookup('router:main');
    _emberMetalCore.default.run(App, 'advanceReadiness');
  }

  function shouldNotBeActive(selector) {
    checkActive(selector, false);
  }

  function shouldBeActive(selector) {
    checkActive(selector, true);
  }

  function checkActive(selector, active) {
    var classList = _emberMetalCore.default.$(selector, '#qunit-fixture')[0].className;
    equal(classList.indexOf('active') > -1, active, selector + ' active should be ' + active.toString());
  }

  var updateCount, replaceCount;

  function sharedSetup() {
    App = _emberMetalCore.default.Application.create({
      name: 'App',
      rootElement: '#qunit-fixture'
    });

    App.deferReadiness();

    updateCount = replaceCount = 0;
    App.Router.reopen({
      location: _emberMetalCore.default.NoneLocation.create({
        setURL: function (path) {
          updateCount++;
          set(this, 'path', path);
        },

        replaceURL: function (path) {
          replaceCount++;
          set(this, 'path', path);
        }
      })
    });

    Router = App.Router;
    registry = App.registry;
    container = App.__container__;
  }

  function sharedTeardown() {
    _emberMetalCore.default.run(function () {
      App.destroy();
    });
    _emberMetalCore.default.TEMPLATES = {};
  }

  QUnit.module('The {{link-to}} helper: invoking with query params', {
    setup: function () {
      _emberMetalCore.default.run(function () {
        sharedSetup();

        App.IndexController = _emberMetalCore.default.Controller.extend({
          queryParams: ['foo', 'bar', 'abool'],
          foo: '123',
          bar: 'abc',
          boundThing: 'OMG',
          abool: true
        });

        App.AboutController = _emberMetalCore.default.Controller.extend({
          queryParams: ['baz', 'bat'],
          baz: 'alex',
          bat: 'borf'
        });

        registry.unregister('router:main');
        registry.register('router:main', Router);
      });
    },

    teardown: sharedTeardown
  });

  QUnit.test('doesn\'t update controller QP properties on current route when invoked', function () {
    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('{{#link-to \'index\' id=\'the-link\'}}Index{{/link-to}}');
    bootApplication();

    _emberMetalCore.default.run(_emberMetalCore.default.$('#the-link'), 'click');
    var indexController = container.lookup('controller:index');
    deepEqual(indexController.getProperties('foo', 'bar'), { foo: '123', bar: 'abc' }, 'controller QP properties not');
  });

  QUnit.test('doesn\'t update controller QP properties on current route when invoked (empty query-params obj)', function () {
    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('{{#link-to \'index\' (query-params) id=\'the-link\'}}Index{{/link-to}}');
    bootApplication();

    _emberMetalCore.default.run(_emberMetalCore.default.$('#the-link'), 'click');
    var indexController = container.lookup('controller:index');
    deepEqual(indexController.getProperties('foo', 'bar'), { foo: '123', bar: 'abc' }, 'controller QP properties not');
  });

  QUnit.test('link-to with no params throws', function () {
    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('{{#link-to id=\'the-link\'}}Index{{/link-to}}');
    expectAssertion(function () {
      bootApplication();
    }, /one or more/);
  });

  QUnit.test('doesn\'t update controller QP properties on current route when invoked (empty query-params obj, inferred route)', function () {
    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('{{#link-to (query-params) id=\'the-link\'}}Index{{/link-to}}');
    bootApplication();

    _emberMetalCore.default.run(_emberMetalCore.default.$('#the-link'), 'click');
    var indexController = container.lookup('controller:index');
    deepEqual(indexController.getProperties('foo', 'bar'), { foo: '123', bar: 'abc' }, 'controller QP properties not');
  });

  QUnit.test('updates controller QP properties on current route when invoked', function () {
    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('{{#link-to \'index\' (query-params foo=\'456\') id=\'the-link\'}}Index{{/link-to}}');
    bootApplication();

    _emberMetalCore.default.run(_emberMetalCore.default.$('#the-link'), 'click');
    var indexController = container.lookup('controller:index');
    deepEqual(indexController.getProperties('foo', 'bar'), { foo: '456', bar: 'abc' }, 'controller QP properties updated');
  });

  QUnit.test('updates controller QP properties on current route when invoked (inferred route)', function () {
    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('{{#link-to (query-params foo=\'456\') id=\'the-link\'}}Index{{/link-to}}');
    bootApplication();

    _emberMetalCore.default.run(_emberMetalCore.default.$('#the-link'), 'click');
    var indexController = container.lookup('controller:index');
    deepEqual(indexController.getProperties('foo', 'bar'), { foo: '456', bar: 'abc' }, 'controller QP properties updated');
  });

  QUnit.test('updates controller QP properties on other route after transitioning to that route', function () {
    Router.map(function () {
      this.route('about');
    });

    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('{{#link-to \'about\' (query-params baz=\'lol\') id=\'the-link\'}}About{{/link-to}}');
    bootApplication();

    equal(_emberMetalCore.default.$('#the-link').attr('href'), '/about?baz=lol');
    _emberMetalCore.default.run(_emberMetalCore.default.$('#the-link'), 'click');
    var aboutController = container.lookup('controller:about');
    deepEqual(aboutController.getProperties('baz', 'bat'), { baz: 'lol', bat: 'borf' }, 'about controller QP properties updated');

    equal(container.lookup('controller:application').get('currentPath'), 'about');
  });

  QUnit.test('supplied QP properties can be bound', function () {
    var indexController = container.lookup('controller:index');
    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('{{#link-to (query-params foo=boundThing) id=\'the-link\'}}Index{{/link-to}}');

    bootApplication();

    equal(_emberMetalCore.default.$('#the-link').attr('href'), '/?foo=OMG');
    _emberMetalCore.default.run(indexController, 'set', 'boundThing', 'ASL');
    equal(_emberMetalCore.default.$('#the-link').attr('href'), '/?foo=ASL');
  });

  QUnit.test('supplied QP properties can be bound (booleans)', function () {
    var indexController = container.lookup('controller:index');
    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('{{#link-to (query-params abool=boundThing) id=\'the-link\'}}Index{{/link-to}}');

    bootApplication();

    equal(_emberMetalCore.default.$('#the-link').attr('href'), '/?abool=OMG');
    _emberMetalCore.default.run(indexController, 'set', 'boundThing', false);
    equal(_emberMetalCore.default.$('#the-link').attr('href'), '/?abool=false');

    _emberMetalCore.default.run(_emberMetalCore.default.$('#the-link'), 'click');

    deepEqual(indexController.getProperties('foo', 'bar', 'abool'), { foo: '123', bar: 'abc', abool: false });
  });

  QUnit.test('href updates when unsupplied controller QP props change', function () {
    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('{{#link-to (query-params foo=\'lol\') id=\'the-link\'}}Index{{/link-to}}');

    bootApplication();
    var indexController = container.lookup('controller:index');

    equal(_emberMetalCore.default.$('#the-link').attr('href'), '/?foo=lol');
    _emberMetalCore.default.run(indexController, 'set', 'bar', 'BORF');
    equal(_emberMetalCore.default.$('#the-link').attr('href'), '/?bar=BORF&foo=lol');
    _emberMetalCore.default.run(indexController, 'set', 'foo', 'YEAH');
    equal(_emberMetalCore.default.$('#the-link').attr('href'), '/?bar=BORF&foo=lol');
  });

  QUnit.test('The {{link-to}} with only query params always transitions to the current route with the query params applied', function () {
    // Test harness for bug #12033

    _emberMetalCore.default.TEMPLATES.cars = _emberTemplateCompiler.compile('{{#link-to \'cars.create\' id=\'create-link\'}}Create new car{{/link-to}} ' + '{{#link-to (query-params page=\'2\') id=\'page2-link\'}}Page 2{{/link-to}}' + '{{outlet}}');

    _emberMetalCore.default.TEMPLATES['cars/create'] = _emberTemplateCompiler.compile('{{#link-to \'cars\' id=\'close-link\'}}Close create form{{/link-to}}');

    Router.map(function () {
      this.route('cars', function () {
        this.route('create');
      });
    });

    App.CarsController = _emberMetalCore.default.Controller.extend({
      queryParams: ['page'],
      page: 1
    });

    bootApplication();

    var carsController = container.lookup('controller:cars');

    _emberMetalCore.default.run(function () {
      router.handleURL('/cars/create');
    });

    _emberMetalCore.default.run(function () {
      equal(router.currentRouteName, 'cars.create');
      _emberMetalCore.default.$('#close-link').click();
    });

    _emberMetalCore.default.run(function () {
      equal(router.currentRouteName, 'cars.index');
      equal(router.get('url'), '/cars');
      equal(carsController.get('page'), 1, 'The page query-param is 1');
      _emberMetalCore.default.$('#page2-link').click();
    });

    _emberMetalCore.default.run(function () {
      equal(router.currentRouteName, 'cars.index', 'The active route is still cars');
      equal(router.get('url'), '/cars?page=2', 'The url has been updated');
      equal(carsController.get('page'), 2, 'The query params have been updated');
    });
  });

  QUnit.test('The {{link-to}} applies activeClass when query params are not changed', function () {
    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('{{#link-to (query-params foo=\'cat\') id=\'cat-link\'}}Index{{/link-to}} ' + '{{#link-to (query-params foo=\'dog\') id=\'dog-link\'}}Index{{/link-to}} ' + '{{#link-to \'index\' id=\'change-nothing\'}}Index{{/link-to}}');

    _emberMetalCore.default.TEMPLATES.search = _emberTemplateCompiler.compile('{{#link-to (query-params search=\'same\') id=\'same-search\'}}Index{{/link-to}} ' + '{{#link-to (query-params search=\'change\') id=\'change-search\'}}Index{{/link-to}} ' + '{{#link-to (query-params search=\'same\' archive=true) id=\'same-search-add-archive\'}}Index{{/link-to}} ' + '{{#link-to (query-params archive=true) id=\'only-add-archive\'}}Index{{/link-to}} ' + '{{#link-to (query-params search=\'same\' archive=true) id=\'both-same\'}}Index{{/link-to}} ' + '{{#link-to (query-params search=\'different\' archive=true) id=\'change-one\'}}Index{{/link-to}} ' + '{{#link-to (query-params search=\'different\' archive=false) id=\'remove-one\'}}Index{{/link-to}} ' + '{{outlet}}');

    _emberMetalCore.default.TEMPLATES['search/results'] = _emberTemplateCompiler.compile('{{#link-to (query-params sort=\'title\') id=\'same-sort-child-only\'}}Index{{/link-to}} ' + '{{#link-to (query-params search=\'same\') id=\'same-search-parent-only\'}}Index{{/link-to}} ' + '{{#link-to (query-params search=\'change\') id=\'change-search-parent-only\'}}Index{{/link-to}} ' + '{{#link-to (query-params search=\'same\' sort=\'title\') id=\'same-search-same-sort-child-and-parent\'}}Index{{/link-to}} ' + '{{#link-to (query-params search=\'same\' sort=\'author\') id=\'same-search-different-sort-child-and-parent\'}}Index{{/link-to}} ' + '{{#link-to (query-params search=\'change\' sort=\'title\') id=\'change-search-same-sort-child-and-parent\'}}Index{{/link-to}} ' + '{{#link-to (query-params foo=\'dog\') id=\'dog-link\'}}Index{{/link-to}} ');

    Router.map(function () {
      this.route('search', function () {
        this.route('results');
      });
    });

    App.SearchController = _emberMetalCore.default.Controller.extend({
      queryParams: ['search', 'archive'],
      search: '',
      archive: false
    });

    App.SearchResultsController = _emberMetalCore.default.Controller.extend({
      queryParams: ['sort', 'showDetails'],
      sort: 'title',
      showDetails: true
    });

    bootApplication();

    //Basic tests
    shouldNotBeActive('#cat-link');
    shouldNotBeActive('#dog-link');
    _emberMetalCore.default.run(router, 'handleURL', '/?foo=cat');
    shouldBeActive('#cat-link');
    shouldNotBeActive('#dog-link');
    _emberMetalCore.default.run(router, 'handleURL', '/?foo=dog');
    shouldBeActive('#dog-link');
    shouldNotBeActive('#cat-link');
    shouldBeActive('#change-nothing');

    //Multiple params
    _emberMetalCore.default.run(function () {
      router.handleURL('/search?search=same');
    });
    shouldBeActive('#same-search');
    shouldNotBeActive('#change-search');
    shouldNotBeActive('#same-search-add-archive');
    shouldNotBeActive('#only-add-archive');
    shouldNotBeActive('#remove-one');

    _emberMetalCore.default.run(function () {
      router.handleURL('/search?search=same&archive=true');
    });
    shouldBeActive('#both-same');
    shouldNotBeActive('#change-one');

    //Nested Controllers
    _emberMetalCore.default.run(function () {
      // Note: this is kind of a strange case; sort's default value is 'title',
      // so this URL shouldn't have been generated in the first place, but
      // we should also be able to gracefully handle these cases.
      router.handleURL('/search/results?search=same&sort=title&showDetails=true');
    });
    //shouldBeActive('#same-sort-child-only');
    shouldBeActive('#same-search-parent-only');
    shouldNotBeActive('#change-search-parent-only');
    shouldBeActive('#same-search-same-sort-child-and-parent');
    shouldNotBeActive('#same-search-different-sort-child-and-parent');
    shouldNotBeActive('#change-search-same-sort-child-and-parent');
  });

  QUnit.test('The {{link-to}} applies active class when query-param is number', function () {
    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('{{#link-to (query-params page=pageNumber) id=\'page-link\'}}Index{{/link-to}} ');

    App.IndexController = _emberMetalCore.default.Controller.extend({
      queryParams: ['page'],
      page: 1,
      pageNumber: 5
    });

    bootApplication();

    shouldNotBeActive('#page-link');
    _emberMetalCore.default.run(router, 'handleURL', '/?page=5');
    shouldBeActive('#page-link');
  });

  QUnit.test('The {{link-to}} applies active class when query-param is array', function () {
    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('{{#link-to (query-params pages=pagesArray) id=\'array-link\'}}Index{{/link-to}} ' + '{{#link-to (query-params pages=biggerArray) id=\'bigger-link\'}}Index{{/link-to}} ' + '{{#link-to (query-params pages=emptyArray) id=\'empty-link\'}}Index{{/link-to}} ');

    App.IndexController = _emberMetalCore.default.Controller.extend({
      queryParams: ['pages'],
      pages: [],
      pagesArray: [1, 2],
      biggerArray: [1, 2, 3],
      emptyArray: []
    });

    bootApplication();

    shouldNotBeActive('#array-link');
    _emberMetalCore.default.run(router, 'handleURL', '/?pages=%5B1%2C2%5D');
    shouldBeActive('#array-link');
    shouldNotBeActive('#bigger-link');
    shouldNotBeActive('#empty-link');
    _emberMetalCore.default.run(router, 'handleURL', '/?pages=%5B2%2C1%5D');
    shouldNotBeActive('#array-link');
    shouldNotBeActive('#bigger-link');
    shouldNotBeActive('#empty-link');
    _emberMetalCore.default.run(router, 'handleURL', '/?pages=%5B1%2C2%2C3%5D');
    shouldBeActive('#bigger-link');
    shouldNotBeActive('#array-link');
    shouldNotBeActive('#empty-link');
  });

  QUnit.test('The {{link-to}} helper applies active class to parent route', function () {
    App.Router.map(function () {
      this.route('parent', function () {
        this.route('child');
      });
    });

    _emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('{{#link-to \'parent\' id=\'parent-link\'}}Parent{{/link-to}} ' + '{{#link-to \'parent.child\' id=\'parent-child-link\'}}Child{{/link-to}} ' + '{{#link-to \'parent\' (query-params foo=cat) id=\'parent-link-qp\'}}Parent{{/link-to}} ' + '{{outlet}}');

    App.ParentChildController = _emberMetalCore.default.Controller.extend({
      queryParams: ['foo'],
      foo: 'bar'
    });

    bootApplication();
    shouldNotBeActive('#parent-link');
    shouldNotBeActive('#parent-child-link');
    shouldNotBeActive('#parent-link-qp');
    _emberMetalCore.default.run(router, 'handleURL', '/parent/child?foo=dog');
    shouldBeActive('#parent-link');
    shouldNotBeActive('#parent-link-qp');
  });

  QUnit.test('The {{link-to}} helper disregards query-params in activeness computation when current-when specified', function () {
    App.Router.map(function () {
      this.route('parent');
    });

    _emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('{{#link-to \'parent\' (query-params page=1) current-when=\'parent\' id=\'app-link\'}}Parent{{/link-to}} {{outlet}}');
    _emberMetalCore.default.TEMPLATES.parent = _emberTemplateCompiler.compile('{{#link-to \'parent\' (query-params page=1) current-when=\'parent\' id=\'parent-link\'}}Parent{{/link-to}} {{outlet}}');

    App.ParentController = _emberMetalCore.default.Controller.extend({
      queryParams: ['page'],
      page: 1
    });

    bootApplication();
    equal(_emberMetalCore.default.$('#app-link').attr('href'), '/parent');
    shouldNotBeActive('#app-link');

    _emberMetalCore.default.run(router, 'handleURL', '/parent?page=2');
    equal(_emberMetalCore.default.$('#app-link').attr('href'), '/parent');
    shouldBeActive('#app-link');
    equal(_emberMetalCore.default.$('#parent-link').attr('href'), '/parent');
    shouldBeActive('#parent-link');

    var parentController = container.lookup('controller:parent');
    equal(parentController.get('page'), 2);
    _emberMetalCore.default.run(parentController, 'set', 'page', 3);
    equal(router.get('location.path'), '/parent?page=3');
    shouldBeActive('#app-link');
    shouldBeActive('#parent-link');

    _emberMetalCore.default.$('#app-link').click();
    equal(router.get('location.path'), '/parent');
  });
});

// Test harness for bug #12033

//Basic tests

//Multiple params

//Nested Controllers

// Note: this is kind of a strange case; sort's default value is 'title',
// so this URL shouldn't have been generated in the first place, but
// we should also be able to gracefully handle these cases.

//shouldBeActive('#same-sort-child-only');
enifed('ember/tests/helpers/link_to_test/link_to_with_query_params_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember/tests/helpers/link_to_test');
  test('ember/tests/helpers/link_to_test/link_to_with_query_params_test.js should pass jscs', function () {
    ok(true, 'ember/tests/helpers/link_to_test/link_to_with_query_params_test.js should pass jscs.');
  });
});
enifed('ember/tests/helpers/link_to_test/link_to_with_query_params_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember/tests/helpers/link_to_test');
  QUnit.test('ember/tests/helpers/link_to_test/link_to_with_query_params_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember/tests/helpers/link_to_test/link_to_with_query_params_test.js should pass jshint.');
  });
});
enifed('ember/tests/homepage_example_test', ['exports', 'ember', 'ember-metal/core', 'ember-template-compiler'], function (exports, _ember, _emberMetalCore, _emberTemplateCompiler) {
  'use strict';

  var App, $fixture;

  function setupExample() {
    // setup templates
    _emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('{{outlet}}');
    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('<h1>People</h1><ul>{{#each model as |person|}}<li>Hello, <b>{{person.fullName}}</b>!</li>{{/each}}</ul>');

    App.Person = _emberMetalCore.default.Object.extend({
      firstName: null,
      lastName: null,

      fullName: _emberMetalCore.default.computed('firstName', 'lastName', function () {
        return this.get('firstName') + ' ' + this.get('lastName');
      })
    });

    App.IndexRoute = _emberMetalCore.default.Route.extend({
      model: function () {
        var people = _emberMetalCore.default.A([App.Person.create({
          firstName: 'Tom',
          lastName: 'Dale'
        }), App.Person.create({
          firstName: 'Yehuda',
          lastName: 'Katz'
        })]);
        return people;
      }
    });
  }

  QUnit.module('Homepage Example', {
    setup: function () {
      _emberMetalCore.default.run(function () {
        App = _emberMetalCore.default.Application.create({
          name: 'App',
          rootElement: '#qunit-fixture'
        });
        App.deferReadiness();

        App.Router.reopen({
          location: 'none'
        });

        App.LoadingRoute = _emberMetalCore.default.Route.extend();
      });

      $fixture = _emberMetalCore.default.$('#qunit-fixture');
      setupExample();
    },

    teardown: function () {
      _emberMetalCore.default.run(function () {
        App.destroy();
      });

      App = null;

      _emberMetalCore.default.TEMPLATES = {};
    }
  });

  QUnit.test('The example renders correctly', function () {
    _emberMetalCore.default.run(App, 'advanceReadiness');

    equal($fixture.find('h1:contains(People)').length, 1);
    equal($fixture.find('li').length, 2);
    equal($fixture.find('li:nth-of-type(1)').text(), 'Hello, Tom Dale!');
    equal($fixture.find('li:nth-of-type(2)').text(), 'Hello, Yehuda Katz!');
  });
});
enifed('ember/tests/homepage_example_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember/tests');
  test('ember/tests/homepage_example_test.js should pass jscs', function () {
    ok(true, 'ember/tests/homepage_example_test.js should pass jscs.');
  });
});
enifed('ember/tests/homepage_example_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember/tests');
  QUnit.test('ember/tests/homepage_example_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember/tests/homepage_example_test.js should pass jshint.');
  });
});
enifed('ember/tests/integration/multiple-app-test', ['exports', 'ember-metal/core', 'ember-metal/run_loop', 'ember-template-compiler/system/compile'], function (exports, _emberMetalCore, _emberMetalRun_loop, _emberTemplateCompilerSystemCompile) {
  'use strict';

  var App1, App2, actions;

  function startApp(rootElement) {
    var application;

    _emberMetalRun_loop.default(function () {
      application = _emberMetalCore.default.Application.create({
        rootElement: rootElement
      });
      application.deferReadiness();

      application.Router.reopen({
        location: 'none'
      });

      var registry = application.__container__._registry;

      registry.register('component:special-button', _emberMetalCore.default.Component.extend({
        actions: {
          doStuff: function () {
            actions.push(rootElement);
          }
        }
      }));
      registry.register('template:application', _emberTemplateCompilerSystemCompile.default('{{outlet}}', { moduleName: 'application' }));
      registry.register('template:index', _emberTemplateCompilerSystemCompile.default('<h1>Node 1</h1>{{special-button}}', { moduleName: 'index' }));
      registry.register('template:components/special-button', _emberTemplateCompilerSystemCompile.default('<button class=\'do-stuff\' {{action \'doStuff\'}}>Button</button>', { moduleName: 'components/special-button' }));
    });

    return application;
  }

  function handleURL(application, path) {
    var router = application.__container__.lookup('router:main');
    return _emberMetalRun_loop.default(router, 'handleURL', path);
  }

  QUnit.module('View Integration', {
    setup: function () {
      actions = [];
      _emberMetalCore.default.$('#qunit-fixture').html('<div id="app-1"></div><div id="app-2"></div>');
      App1 = startApp('#app-1');
      App2 = startApp('#app-2');
    },

    teardown: function () {
      _emberMetalRun_loop.default(App1, 'destroy');
      _emberMetalRun_loop.default(App2, 'destroy');
      App1 = App2 = null;
    }
  });

  QUnit.test('booting multiple applications can properly handle events', function (assert) {
    _emberMetalRun_loop.default(App1, 'advanceReadiness');
    _emberMetalRun_loop.default(App2, 'advanceReadiness');

    handleURL(App1, '/');
    handleURL(App2, '/');

    _emberMetalCore.default.$('#app-2 .do-stuff').click();
    _emberMetalCore.default.$('#app-1 .do-stuff').click();

    assert.deepEqual(actions, ['#app-2', '#app-1']);
  });
});
enifed('ember/tests/integration/multiple-app-test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember/tests/integration');
  test('ember/tests/integration/multiple-app-test.js should pass jscs', function () {
    ok(true, 'ember/tests/integration/multiple-app-test.js should pass jscs.');
  });
});
enifed('ember/tests/integration/multiple-app-test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember/tests/integration');
  QUnit.test('ember/tests/integration/multiple-app-test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember/tests/integration/multiple-app-test.js should pass jshint.');
  });
});
enifed('ember/tests/integration/view_test', ['exports', 'ember-metal/core', 'ember-metal/run_loop', 'ember-views/views/view', 'ember-template-compiler/system/compile', 'ember-htmlbars/tests/utils', 'ember-htmlbars/keywords/view'], function (exports, _emberMetalCore, _emberMetalRun_loop, _emberViewsViewsView, _emberTemplateCompilerSystemCompile, _emberHtmlbarsTestsUtils, _emberHtmlbarsKeywordsView) {
  'use strict';

  var App, registry, originalViewKeyword;

  function setupExample() {
    // setup templates
    _emberMetalCore.default.TEMPLATES.application = _emberTemplateCompilerSystemCompile.default('{{outlet}}', { moduleName: 'application' });
    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompilerSystemCompile.default('<h1>Node 1</h1>', { moduleName: 'index' });
    _emberMetalCore.default.TEMPLATES.posts = _emberTemplateCompilerSystemCompile.default('<h1>Node 1</h1>', { moduleName: 'posts' });

    App.Router.map(function () {
      this.route('posts');
    });
  }

  function handleURL(path) {
    var router = App.__container__.lookup('router:main');
    return _emberMetalRun_loop.default(router, 'handleURL', path);
  }

  QUnit.module('View Integration', {
    setup: function () {
      originalViewKeyword = _emberHtmlbarsTestsUtils.registerKeyword('view', _emberHtmlbarsKeywordsView.default);
      _emberMetalRun_loop.default(function () {
        App = _emberMetalCore.default.Application.create({
          rootElement: '#qunit-fixture'
        });
        App.deferReadiness();

        App.Router.reopen({
          location: 'none'
        });

        registry = App.__container__._registry;
      });

      setupExample();
    },

    teardown: function () {
      _emberMetalRun_loop.default(App, 'destroy');
      _emberHtmlbarsTestsUtils.resetKeyword('view', originalViewKeyword);
      App = null;
      _emberMetalCore.default.TEMPLATES = {};
    }
  });

  QUnit.test('invoking `{{view}} from a non-view backed (aka only template) template provides the correct controller to the view instance`', function (assert) {
    var controllerInMyFoo, indexController;

    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompilerSystemCompile.default('{{view "my-foo"}}', { moduleName: 'my-foo' });

    registry.register('view:my-foo', _emberViewsViewsView.default.extend({
      init: function () {
        this._super.apply(this, arguments);

        controllerInMyFoo = this.get('controller');
      }
    }));

    registry.register('controller:index', _emberMetalCore.default.Controller.extend({
      init: function () {
        this._super.apply(this, arguments);

        indexController = this;
      }
    }));

    _emberMetalRun_loop.default(App, 'advanceReadiness');
    handleURL('/');

    assert.strictEqual(controllerInMyFoo, indexController, 'controller is provided to `{{view}}`');
  });
});
enifed('ember/tests/integration/view_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember/tests/integration');
  test('ember/tests/integration/view_test.js should pass jscs', function () {
    ok(true, 'ember/tests/integration/view_test.js should pass jscs.');
  });
});
enifed('ember/tests/integration/view_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember/tests/integration');
  QUnit.test('ember/tests/integration/view_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember/tests/integration/view_test.js should pass jshint.');
  });
});
enifed('ember/tests/routing/basic_test',['exports','ember','ember-metal/core','ember-metal/features','ember-metal/property_get','ember-metal/property_set','ember-views/system/action_manager','ember-views/views/view','ember-template-compiler'],function(exports,_ember,_emberMetalCore,_emberMetalFeatures,_emberMetalProperty_get,_emberMetalProperty_set,_emberViewsSystemAction_manager,_emberViewsViewsView,_emberTemplateCompiler){'use strict';var trim=_emberMetalCore.default.$.trim;var Router,App,router,registry,container,originalLoggerError;function bootApplication(){router = container.lookup('router:main');_emberMetalCore.default.run(App,'advanceReadiness');}function handleURL(path){return _emberMetalCore.default.run(function(){return router.handleURL(path).then(function(value){ok(true,'url: `' + path + '` was handled');return value;},function(reason){ok(false,'failed to visit:`' + path + '` reason: `' + QUnit.jsDump.parse(reason));throw reason;});});}function handleURLAborts(path){_emberMetalCore.default.run(function(){router.handleURL(path).then(function(value){ok(false,'url: `' + path + '` was NOT to be handled');},function(reason){ok(reason && reason.message === 'TransitionAborted','url: `' + path + '` was to be aborted');});});}function handleURLRejectsWith(path,expectedReason){_emberMetalCore.default.run(function(){router.handleURL(path).then(function(value){ok(false,'expected handleURLing: `' + path + '` to fail');},function(reason){equal(expectedReason,reason);});});}QUnit.module('Basic Routing',{setup:function(){_emberMetalCore.default.run(function(){App = _emberMetalCore.default.Application.create({name:'App',rootElement:'#qunit-fixture'});App.deferReadiness();App.Router.reopen({location:'none'});Router = App.Router;App.LoadingRoute = _emberMetalCore.default.Route.extend({});registry = App.registry;container = App.__container__;_emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('{{outlet}}');_emberMetalCore.default.TEMPLATES.home = _emberTemplateCompiler.compile('<h3>Hours</h3>');_emberMetalCore.default.TEMPLATES.homepage = _emberTemplateCompiler.compile('<h3>Megatroll</h3><p>{{model.home}}</p>');_emberMetalCore.default.TEMPLATES.camelot = _emberTemplateCompiler.compile('<section><h3>Is a silly place</h3></section>');originalLoggerError = _emberMetalCore.default.Logger.error;});},teardown:function(){_emberMetalCore.default.run(function(){App.destroy();App = null;_emberMetalCore.default.TEMPLATES = {};_emberMetalCore.default.Logger.error = originalLoggerError;});}});QUnit.test('warn on URLs not included in the route set',function(){Router.map(function(){this.route('home',{path:'/'});});bootApplication();expectAssertion(function(){_emberMetalCore.default.run(function(){router.handleURL('/what-is-this-i-dont-even');});},'The URL \'/what-is-this-i-dont-even\' did not match any routes in your application');});QUnit.test('The Homepage',function(){Router.map(function(){this.route('home',{path:'/'});});App.HomeRoute = _emberMetalCore.default.Route.extend({});var currentPath;App.ApplicationController = _emberMetalCore.default.Controller.extend({currentPathDidChange:_emberMetalCore.default.observer('currentPath',function(){currentPath = _emberMetalProperty_get.get(this,'currentPath');})});bootApplication();equal(currentPath,'home');equal(_emberMetalCore.default.$('h3:contains(Hours)','#qunit-fixture').length,1,'The home template was rendered');});QUnit.test('The Home page and the Camelot page with multiple Router.map calls',function(){Router.map(function(){this.route('home',{path:'/'});});Router.map(function(){this.route('camelot',{path:'/camelot'});});App.HomeRoute = _emberMetalCore.default.Route.extend({});App.CamelotRoute = _emberMetalCore.default.Route.extend({});var currentPath;App.ApplicationController = _emberMetalCore.default.Controller.extend({currentPathDidChange:_emberMetalCore.default.observer('currentPath',function(){currentPath = _emberMetalProperty_get.get(this,'currentPath');})});App.CamelotController = _emberMetalCore.default.Controller.extend({currentPathDidChange:_emberMetalCore.default.observer('currentPath',function(){currentPath = _emberMetalProperty_get.get(this,'currentPath');})});bootApplication();handleURL('/camelot');equal(currentPath,'camelot');equal(_emberMetalCore.default.$('h3:contains(silly)','#qunit-fixture').length,1,'The camelot template was rendered');handleURL('/');equal(currentPath,'home');equal(_emberMetalCore.default.$('h3:contains(Hours)','#qunit-fixture').length,1,'The home template was rendered');});QUnit.test('The Homepage with explicit template name in renderTemplate',function(){Router.map(function(){this.route('home',{path:'/'});});App.HomeRoute = _emberMetalCore.default.Route.extend({renderTemplate:function(){this.render('homepage');}});bootApplication();equal(_emberMetalCore.default.$('h3:contains(Megatroll)','#qunit-fixture').length,1,'The homepage template was rendered');});QUnit.test('An alternate template will pull in an alternate controller',function(){Router.map(function(){this.route('home',{path:'/'});});App.HomeRoute = _emberMetalCore.default.Route.extend({renderTemplate:function(){this.render('homepage');}});App.HomepageController = _emberMetalCore.default.Controller.extend({model:{home:'Comes from homepage'}});bootApplication();equal(_emberMetalCore.default.$('h3:contains(Megatroll) + p:contains(Comes from homepage)','#qunit-fixture').length,1,'The homepage template was rendered');});QUnit.test('An alternate template will pull in an alternate controller instead of controllerName',function(){Router.map(function(){this.route('home',{path:'/'});});App.HomeRoute = _emberMetalCore.default.Route.extend({controllerName:'foo',renderTemplate:function(){this.render('homepage');}});App.FooController = _emberMetalCore.default.Controller.extend({model:{home:'Comes from Foo'}});App.HomepageController = _emberMetalCore.default.Controller.extend({model:{home:'Comes from homepage'}});bootApplication();equal(_emberMetalCore.default.$('h3:contains(Megatroll) + p:contains(Comes from homepage)','#qunit-fixture').length,1,'The homepage template was rendered');});QUnit.test('The template will pull in an alternate controller via key/value',function(){Router.map(function(){this.route('homepage',{path:'/'});});App.HomepageRoute = _emberMetalCore.default.Route.extend({renderTemplate:function(){this.render({controller:'home'});}});App.HomeController = _emberMetalCore.default.Controller.extend({model:{home:'Comes from home.'}});bootApplication();equal(_emberMetalCore.default.$('h3:contains(Megatroll) + p:contains(Comes from home.)','#qunit-fixture').length,1,'The homepage template was rendered from data from the HomeController');});QUnit.test('The Homepage with explicit template name in renderTemplate and controller',function(){Router.map(function(){this.route('home',{path:'/'});});App.HomeController = _emberMetalCore.default.Controller.extend({model:{home:'YES I AM HOME'}});App.HomeRoute = _emberMetalCore.default.Route.extend({renderTemplate:function(){this.render('homepage');}});bootApplication();equal(_emberMetalCore.default.$('h3:contains(Megatroll) + p:contains(YES I AM HOME)','#qunit-fixture').length,1,'The homepage template was rendered');});QUnit.test('Model passed via renderTemplate model is set as controller\'s model',function(){_emberMetalCore.default.TEMPLATES['bio'] = _emberTemplateCompiler.compile('<p>{{model.name}}</p>');App.BioController = _emberMetalCore.default.Controller.extend();Router.map(function(){this.route('home',{path:'/'});});App.HomeRoute = _emberMetalCore.default.Route.extend({renderTemplate:function(){this.render('bio',{model:{name:'emberjs'}});}});bootApplication();equal(_emberMetalCore.default.$('p:contains(emberjs)','#qunit-fixture').length,1,'Passed model was set as controllers model');});QUnit.test('Renders correct view with slash notation',function(){_emberMetalCore.default.TEMPLATES['home/page'] = _emberTemplateCompiler.compile('<p>{{view.name}}</p>');Router.map(function(){this.route('home',{path:'/'});});App.HomeRoute = _emberMetalCore.default.Route.extend({renderTemplate:function(){this.render('home/page');}});App.HomePageView = _emberViewsViewsView.default.extend({name:'Home/Page'});bootApplication();equal(_emberMetalCore.default.$('p:contains(Home/Page)','#qunit-fixture').length,1,'The homepage template was rendered');});QUnit.test('Renders the view given in the view option',function(){_emberMetalCore.default.TEMPLATES['home'] = _emberTemplateCompiler.compile('<p>{{view.name}}</p>');Router.map(function(){this.route('home',{path:'/'});});App.HomeRoute = _emberMetalCore.default.Route.extend({renderTemplate:function(){this.render({view:'homePage'});}});App.HomePageView = _emberViewsViewsView.default.extend({name:'Home/Page'});bootApplication();equal(_emberMetalCore.default.$('p:contains(Home/Page)','#qunit-fixture').length,1,'The homepage view was rendered');});QUnit.test('render does not replace templateName if user provided',function(){Router.map(function(){this.route('home',{path:'/'});});_emberMetalCore.default.TEMPLATES.the_real_home_template = _emberTemplateCompiler.compile('<p>THIS IS THE REAL HOME</p>');App.HomeView = _emberViewsViewsView.default.extend({templateName:'the_real_home_template'});App.HomeController = _emberMetalCore.default.Controller.extend();App.HomeRoute = _emberMetalCore.default.Route.extend();bootApplication();equal(_emberMetalCore.default.$('p','#qunit-fixture').text(),'THIS IS THE REAL HOME','The homepage template was rendered');});QUnit.test('render does not replace template if user provided',function(){Router.map(function(){this.route('home',{path:'/'});});App.HomeView = _emberViewsViewsView.default.extend({template:_emberTemplateCompiler.compile('<p>THIS IS THE REAL HOME</p>')});App.HomeController = _emberMetalCore.default.Controller.extend();App.HomeRoute = _emberMetalCore.default.Route.extend();bootApplication();_emberMetalCore.default.run(function(){router.handleURL('/');});equal(_emberMetalCore.default.$('p','#qunit-fixture').text(),'THIS IS THE REAL HOME','The homepage template was rendered');});QUnit.test('render uses templateName from route',function(){Router.map(function(){this.route('home',{path:'/'});});_emberMetalCore.default.TEMPLATES.the_real_home_template = _emberTemplateCompiler.compile('<p>THIS IS THE REAL HOME</p>');App.HomeController = _emberMetalCore.default.Controller.extend();App.HomeRoute = _emberMetalCore.default.Route.extend({templateName:'the_real_home_template'});bootApplication();equal(_emberMetalCore.default.$('p','#qunit-fixture').text(),'THIS IS THE REAL HOME','The homepage template was rendered');});QUnit.test('defining templateName allows other templates to be rendered',function(){Router.map(function(){this.route('home',{path:'/'});});_emberMetalCore.default.TEMPLATES.alert = _emberTemplateCompiler.compile('<div class=\'alert-box\'>Invader!</div>');_emberMetalCore.default.TEMPLATES.the_real_home_template = _emberTemplateCompiler.compile('<p>THIS IS THE REAL HOME</p>{{outlet \'alert\'}}');App.HomeController = _emberMetalCore.default.Controller.extend();App.HomeRoute = _emberMetalCore.default.Route.extend({templateName:'the_real_home_template',actions:{showAlert:function(){this.render('alert',{into:'home',outlet:'alert'});}}});bootApplication();equal(_emberMetalCore.default.$('p','#qunit-fixture').text(),'THIS IS THE REAL HOME','The homepage template was rendered');_emberMetalCore.default.run(function(){router.send('showAlert');});equal(_emberMetalCore.default.$('.alert-box','#qunit-fixture').text(),'Invader!','Template for alert was render into outlet');});QUnit.test('Specifying a name to render should have precedence over everything else',function(){Router.map(function(){this.route('home',{path:'/'});});App.HomeController = _emberMetalCore.default.Controller.extend();App.HomeRoute = _emberMetalCore.default.Route.extend({templateName:'home',controllerName:'home',viewName:'home',renderTemplate:function(){this.render('homepage');}});App.HomeView = _emberViewsViewsView.default.extend({template:_emberTemplateCompiler.compile('<h3>This should not be rendered</h3><p>{{model.home}}</p>')});App.HomepageController = _emberMetalCore.default.Controller.extend({model:{home:'Tinytroll'}});App.HomepageView = _emberViewsViewsView.default.extend({layout:_emberTemplateCompiler.compile('<span>Outer</span>{{yield}}<span>troll</span>'),templateName:'homepage'});bootApplication();equal(_emberMetalCore.default.$('h3','#qunit-fixture').text(),'Megatroll','The homepage template was rendered');equal(_emberMetalCore.default.$('p','#qunit-fixture').text(),'Tinytroll','The homepage controller was used');equal(_emberMetalCore.default.$('span','#qunit-fixture').text(),'Outertroll','The homepage view was used');});QUnit.test('The Homepage with a `setupController` hook',function(){Router.map(function(){this.route('home',{path:'/'});});App.HomeRoute = _emberMetalCore.default.Route.extend({setupController:function(controller){_emberMetalProperty_set.set(controller,'hours',_emberMetalCore.default.A(['Monday through Friday: 9am to 5pm','Saturday: Noon to Midnight','Sunday: Noon to 6pm']));}});_emberMetalCore.default.TEMPLATES.home = _emberTemplateCompiler.compile('<ul>{{#each hours as |entry|}}<li>{{entry}}</li>{{/each}}</ul>');bootApplication();equal(_emberMetalCore.default.$('ul li','#qunit-fixture').eq(2).text(),'Sunday: Noon to 6pm','The template was rendered with the hours context');});QUnit.test('The route controller is still set when overriding the setupController hook',function(){Router.map(function(){this.route('home',{path:'/'});});App.HomeRoute = _emberMetalCore.default.Route.extend({setupController:function(controller){ // no-op
// importantly, we are not calling  this._super here
}});registry.register('controller:home',_emberMetalCore.default.Controller.extend());bootApplication();deepEqual(container.lookup('route:home').controller,container.lookup('controller:home'),'route controller is the home controller');});QUnit.test('The route controller can be specified via controllerName',function(){Router.map(function(){this.route('home',{path:'/'});});_emberMetalCore.default.TEMPLATES.home = _emberTemplateCompiler.compile('<p>{{myValue}}</p>');App.HomeRoute = _emberMetalCore.default.Route.extend({controllerName:'myController'});registry.register('controller:myController',_emberMetalCore.default.Controller.extend({myValue:'foo'}));bootApplication();deepEqual(container.lookup('route:home').controller,container.lookup('controller:myController'),'route controller is set by controllerName');equal(_emberMetalCore.default.$('p','#qunit-fixture').text(),'foo','The homepage template was rendered with data from the custom controller');});QUnit.test('The route controller specified via controllerName is used in render',function(){Router.map(function(){this.route('home',{path:'/'});});_emberMetalCore.default.TEMPLATES.alternative_home = _emberTemplateCompiler.compile('<p>alternative home: {{myValue}}</p>');App.HomeRoute = _emberMetalCore.default.Route.extend({controllerName:'myController',renderTemplate:function(){this.render('alternative_home');}});registry.register('controller:myController',_emberMetalCore.default.Controller.extend({myValue:'foo'}));bootApplication();deepEqual(container.lookup('route:home').controller,container.lookup('controller:myController'),'route controller is set by controllerName');equal(_emberMetalCore.default.$('p','#qunit-fixture').text(),'alternative home: foo','The homepage template was rendered with data from the custom controller');});QUnit.test('The route controller specified via controllerName is used in render even when a controller with the routeName is available',function(){Router.map(function(){this.route('home',{path:'/'});});_emberMetalCore.default.TEMPLATES.home = _emberTemplateCompiler.compile('<p>home: {{myValue}}</p>');App.HomeRoute = _emberMetalCore.default.Route.extend({controllerName:'myController'});registry.register('controller:home',_emberMetalCore.default.Controller.extend({myValue:'home'}));registry.register('controller:myController',_emberMetalCore.default.Controller.extend({myValue:'myController'}));bootApplication();deepEqual(container.lookup('route:home').controller,container.lookup('controller:myController'),'route controller is set by controllerName');equal(_emberMetalCore.default.$('p','#qunit-fixture').text(),'home: myController','The homepage template was rendered with data from the custom controller');});QUnit.test('The Homepage with a `setupController` hook modifying other controllers',function(){Router.map(function(){this.route('home',{path:'/'});});App.HomeRoute = _emberMetalCore.default.Route.extend({setupController:function(controller){_emberMetalProperty_set.set(this.controllerFor('home'),'hours',_emberMetalCore.default.A(['Monday through Friday: 9am to 5pm','Saturday: Noon to Midnight','Sunday: Noon to 6pm']));}});_emberMetalCore.default.TEMPLATES.home = _emberTemplateCompiler.compile('<ul>{{#each hours as |entry|}}<li>{{entry}}</li>{{/each}}</ul>');bootApplication();equal(_emberMetalCore.default.$('ul li','#qunit-fixture').eq(2).text(),'Sunday: Noon to 6pm','The template was rendered with the hours context');});QUnit.test('The Homepage with a computed context that does not get overridden',function(){Router.map(function(){this.route('home',{path:'/'});});App.HomeController = _emberMetalCore.default.Controller.extend({model:_emberMetalCore.default.computed(function(){return _emberMetalCore.default.A(['Monday through Friday: 9am to 5pm','Saturday: Noon to Midnight','Sunday: Noon to 6pm']);})});_emberMetalCore.default.TEMPLATES.home = _emberTemplateCompiler.compile('<ul>{{#each model as |passage|}}<li>{{passage}}</li>{{/each}}</ul>');bootApplication();equal(_emberMetalCore.default.$('ul li','#qunit-fixture').eq(2).text(),'Sunday: Noon to 6pm','The template was rendered with the context intact');});QUnit.test('The Homepage getting its controller context via model',function(){Router.map(function(){this.route('home',{path:'/'});});App.HomeRoute = _emberMetalCore.default.Route.extend({model:function(){return _emberMetalCore.default.A(['Monday through Friday: 9am to 5pm','Saturday: Noon to Midnight','Sunday: Noon to 6pm']);},setupController:function(controller,model){equal(this.controllerFor('home'),controller);_emberMetalProperty_set.set(this.controllerFor('home'),'hours',model);}});_emberMetalCore.default.TEMPLATES.home = _emberTemplateCompiler.compile('<ul>{{#each hours as |entry|}}<li>{{entry}}</li>{{/each}}</ul>');bootApplication();equal(_emberMetalCore.default.$('ul li','#qunit-fixture').eq(2).text(),'Sunday: Noon to 6pm','The template was rendered with the hours context');});QUnit.test('The Specials Page getting its controller context by deserializing the params hash',function(){Router.map(function(){this.route('home',{path:'/'});this.route('special',{path:'/specials/:menu_item_id'});});App.SpecialRoute = _emberMetalCore.default.Route.extend({model:function(params){return _emberMetalCore.default.Object.create({menuItemId:params.menu_item_id});},setupController:function(controller,model){_emberMetalProperty_set.set(controller,'model',model);}});_emberMetalCore.default.TEMPLATES.special = _emberTemplateCompiler.compile('<p>{{model.menuItemId}}</p>');bootApplication();registry.register('controller:special',_emberMetalCore.default.Controller.extend());handleURL('/specials/1');equal(_emberMetalCore.default.$('p','#qunit-fixture').text(),'1','The model was used to render the template');});QUnit.test('The Specials Page defaults to looking models up via `find`',function(){Router.map(function(){this.route('home',{path:'/'});this.route('special',{path:'/specials/:menu_item_id'});});App.MenuItem = _emberMetalCore.default.Object.extend();App.MenuItem.reopenClass({find:function(id){return App.MenuItem.create({id:id});}});App.SpecialRoute = _emberMetalCore.default.Route.extend({setupController:function(controller,model){_emberMetalProperty_set.set(controller,'model',model);}});_emberMetalCore.default.TEMPLATES.special = _emberTemplateCompiler.compile('<p>{{model.id}}</p>');bootApplication();registry.register('controller:special',_emberMetalCore.default.Controller.extend());handleURL('/specials/1');equal(_emberMetalCore.default.$('p','#qunit-fixture').text(),'1','The model was used to render the template');});QUnit.test('The Special Page returning a promise puts the app into a loading state until the promise is resolved',function(){Router.map(function(){this.route('home',{path:'/'});this.route('special',{path:'/specials/:menu_item_id'});});var menuItem,resolve;App.MenuItem = _emberMetalCore.default.Object.extend();App.MenuItem.reopenClass({find:function(id){menuItem = App.MenuItem.create({id:id});return new _emberMetalCore.default.RSVP.Promise(function(res){resolve = res;});}});App.LoadingRoute = _emberMetalCore.default.Route.extend({});App.SpecialRoute = _emberMetalCore.default.Route.extend({setupController:function(controller,model){_emberMetalProperty_set.set(controller,'model',model);}});_emberMetalCore.default.TEMPLATES.special = _emberTemplateCompiler.compile('<p>{{model.id}}</p>');_emberMetalCore.default.TEMPLATES.loading = _emberTemplateCompiler.compile('<p>LOADING!</p>');bootApplication();registry.register('controller:special',_emberMetalCore.default.Controller.extend());handleURL('/specials/1');equal(_emberMetalCore.default.$('p','#qunit-fixture').text(),'LOADING!','The app is in the loading state');_emberMetalCore.default.run(function(){resolve(menuItem);});equal(_emberMetalCore.default.$('p','#qunit-fixture').text(),'1','The app is now in the specials state');});QUnit.test('The loading state doesn\'t get entered for promises that resolve on the same run loop',function(){Router.map(function(){this.route('home',{path:'/'});this.route('special',{path:'/specials/:menu_item_id'});});App.MenuItem = _emberMetalCore.default.Object.extend();App.MenuItem.reopenClass({find:function(id){return {id:id};}});App.LoadingRoute = _emberMetalCore.default.Route.extend({enter:function(){ok(false,'LoadingRoute shouldn\'t have been entered.');}});App.SpecialRoute = _emberMetalCore.default.Route.extend({setupController:function(controller,model){_emberMetalProperty_set.set(controller,'model',model);}});_emberMetalCore.default.TEMPLATES.special = _emberTemplateCompiler.compile('<p>{{model.id}}</p>');_emberMetalCore.default.TEMPLATES.loading = _emberTemplateCompiler.compile('<p>LOADING!</p>');bootApplication();registry.register('controller:special',_emberMetalCore.default.Controller.extend());handleURL('/specials/1');equal(_emberMetalCore.default.$('p','#qunit-fixture').text(),'1','The app is now in the specials state');}); /*
asyncTest("The Special page returning an error fires the error hook on SpecialRoute", function() {
  Router.map(function() {
    this.route("home", { path: "/" });
    this.route("special", { path: "/specials/:menu_item_id" });
  });

  var menuItem;

  App.MenuItem = Ember.Object.extend(Ember.DeferredMixin);
  App.MenuItem.reopenClass({
    find: function(id) {
      menuItem = App.MenuItem.create({ id: id });
      Ember.run.later(function() { menuItem.resolve(menuItem); }, 1);
      return menuItem;
    }
  });

  App.SpecialRoute = Ember.Route.extend({
    setup: function() {
      throw 'Setup error';
    },
    actions: {
      error: function(reason) {
        equal(reason, 'Setup error');
        QUnit.start();
      }
    }
  });

  bootApplication();

  handleURLRejectsWith('/specials/1', 'Setup error');
});
*/QUnit.test('The Special page returning an error invokes SpecialRoute\'s error handler',function(){Router.map(function(){this.route('home',{path:'/'});this.route('special',{path:'/specials/:menu_item_id'});});var menuItem,promise,resolve;App.MenuItem = _emberMetalCore.default.Object.extend();App.MenuItem.reopenClass({find:function(id){menuItem = App.MenuItem.create({id:id});promise = new _emberMetalCore.default.RSVP.Promise(function(res){resolve = res;});return promise;}});App.SpecialRoute = _emberMetalCore.default.Route.extend({setup:function(){throw 'Setup error';},actions:{error:function(reason){equal(reason,'Setup error','SpecialRoute#error received the error thrown from setup');}}});bootApplication();handleURLRejectsWith('/specials/1','Setup error');_emberMetalCore.default.run(function(){resolve(menuItem);});});function testOverridableErrorHandler(handlersName){expect(2);Router.map(function(){this.route('home',{path:'/'});this.route('special',{path:'/specials/:menu_item_id'});});var menuItem,resolve;App.MenuItem = _emberMetalCore.default.Object.extend();App.MenuItem.reopenClass({find:function(id){menuItem = App.MenuItem.create({id:id});return new _emberMetalCore.default.RSVP.Promise(function(res){resolve = res;});}});var attrs={};attrs[handlersName] = {error:function(reason){equal(reason,'Setup error','error was correctly passed to custom ApplicationRoute handler');}};App.ApplicationRoute = _emberMetalCore.default.Route.extend(attrs);App.SpecialRoute = _emberMetalCore.default.Route.extend({setup:function(){throw 'Setup error';}});bootApplication();handleURLRejectsWith('/specials/1','Setup error');_emberMetalCore.default.run(function(){resolve(menuItem);});}QUnit.test('ApplicationRoute\'s default error handler can be overridden',function(){testOverridableErrorHandler('actions');});asyncTest('Moving from one page to another triggers the correct callbacks',function(){expect(3);Router.map(function(){this.route('home',{path:'/'});this.route('special',{path:'/specials/:menu_item_id'});});App.MenuItem = _emberMetalCore.default.Object.extend();App.SpecialRoute = _emberMetalCore.default.Route.extend({setupController:function(controller,model){_emberMetalProperty_set.set(controller,'model',model);}});_emberMetalCore.default.TEMPLATES.home = _emberTemplateCompiler.compile('<h3>Home</h3>');_emberMetalCore.default.TEMPLATES.special = _emberTemplateCompiler.compile('<p>{{model.id}}</p>');bootApplication();registry.register('controller:special',_emberMetalCore.default.Controller.extend());var transition=handleURL('/');_emberMetalCore.default.run(function(){transition.then(function(){equal(_emberMetalCore.default.$('h3','#qunit-fixture').text(),'Home','The app is now in the initial state');var promiseContext=App.MenuItem.create({id:1});_emberMetalCore.default.run.later(function(){_emberMetalCore.default.RSVP.resolve(promiseContext);},1);return router.transitionTo('special',promiseContext);}).then(function(result){deepEqual(router.location.path,'/specials/1');QUnit.start();});});});asyncTest('Nested callbacks are not exited when moving to siblings',function(){Router.map(function(){this.route('root',{path:'/'},function(){this.route('special',{path:'/specials/:menu_item_id',resetNamespace:true});});});var currentPath;App.ApplicationController = _emberMetalCore.default.Controller.extend({currentPathDidChange:_emberMetalCore.default.observer('currentPath',function(){currentPath = _emberMetalProperty_get.get(this,'currentPath');})});var menuItem;App.MenuItem = _emberMetalCore.default.Object.extend();App.MenuItem.reopenClass({find:function(id){menuItem = App.MenuItem.create({id:id});return menuItem;}});App.LoadingRoute = _emberMetalCore.default.Route.extend({});App.RootRoute = _emberMetalCore.default.Route.extend({model:function(){rootModel++;return this._super.apply(this,arguments);},serialize:function(){rootSerialize++;return this._super.apply(this,arguments);},setupController:function(){rootSetup++;},renderTemplate:function(){rootRender++;}});App.HomeRoute = _emberMetalCore.default.Route.extend({});App.SpecialRoute = _emberMetalCore.default.Route.extend({setupController:function(controller,model){_emberMetalProperty_set.set(controller,'model',model);}});_emberMetalCore.default.TEMPLATES['root/index'] = _emberTemplateCompiler.compile('<h3>Home</h3>');_emberMetalCore.default.TEMPLATES.special = _emberTemplateCompiler.compile('<p>{{model.id}}</p>');_emberMetalCore.default.TEMPLATES.loading = _emberTemplateCompiler.compile('<p>LOADING!</p>');var rootSetup=0;var rootRender=0;var rootModel=0;var rootSerialize=0;bootApplication();registry.register('controller:special',_emberMetalCore.default.Controller.extend());equal(_emberMetalCore.default.$('h3','#qunit-fixture').text(),'Home','The app is now in the initial state');equal(rootSetup,1,'The root setup was triggered');equal(rootRender,1,'The root render was triggered');equal(rootSerialize,0,'The root serialize was not called');equal(rootModel,1,'The root model was called');router = container.lookup('router:main');_emberMetalCore.default.run(function(){var menuItem=App.MenuItem.create({id:1});_emberMetalCore.default.run.later(function(){_emberMetalCore.default.RSVP.resolve(menuItem);},1);router.transitionTo('special',menuItem).then(function(result){equal(rootSetup,1,'The root setup was not triggered again');equal(rootRender,1,'The root render was not triggered again');equal(rootSerialize,0,'The root serialize was not called'); // TODO: Should this be changed?
equal(rootModel,1,'The root model was called again');deepEqual(router.location.path,'/specials/1');equal(currentPath,'root.special');QUnit.start();});});});QUnit.asyncTest('Events are triggered on the controller if a matching action name is implemented',function(){Router.map(function(){this.route('home',{path:'/'});});var model={name:'Tom Dale'};var stateIsNotCalled=true;App.HomeRoute = _emberMetalCore.default.Route.extend({model:function(){return model;},actions:{showStuff:function(obj){stateIsNotCalled = false;}}});_emberMetalCore.default.TEMPLATES.home = _emberTemplateCompiler.compile('<a {{action \'showStuff\' model}}>{{name}}</a>');var controller=_emberMetalCore.default.Controller.extend({actions:{showStuff:function(context){ok(stateIsNotCalled,'an event on the state is not triggered');deepEqual(context,{name:'Tom Dale'},'an event with context is passed');QUnit.start();}}});registry.register('controller:home',controller);bootApplication();var actionId=_emberMetalCore.default.$('#qunit-fixture a').data('ember-action');var _ActionManager$registeredActions$actionId=_emberViewsSystemAction_manager.default.registeredActions[actionId];var action=_ActionManager$registeredActions$actionId[0];var event=new _emberMetalCore.default.$.Event('click');action.handler(event);});QUnit.asyncTest('Events are triggered on the current state when defined in `actions` object',function(){Router.map(function(){this.route('home',{path:'/'});});var model={name:'Tom Dale'};App.HomeRoute = _emberMetalCore.default.Route.extend({model:function(){return model;},actions:{showStuff:function(obj){ok(this instanceof App.HomeRoute,'the handler is an App.HomeRoute'); // Using Ember.copy removes any private Ember vars which older IE would be confused by
deepEqual(_emberMetalCore.default.copy(obj,true),{name:'Tom Dale'},'the context is correct');QUnit.start();}}});_emberMetalCore.default.TEMPLATES.home = _emberTemplateCompiler.compile('<a {{action \'showStuff\' model}}>{{model.name}}</a>');bootApplication();var actionId=_emberMetalCore.default.$('#qunit-fixture a').data('ember-action');var _ActionManager$registeredActions$actionId2=_emberViewsSystemAction_manager.default.registeredActions[actionId];var action=_ActionManager$registeredActions$actionId2[0];var event=new _emberMetalCore.default.$.Event('click');action.handler(event);});QUnit.asyncTest('Events defined in `actions` object are triggered on the current state when routes are nested',function(){Router.map(function(){this.route('root',{path:'/'},function(){this.route('index',{path:'/'});});});var model={name:'Tom Dale'};App.RootRoute = _emberMetalCore.default.Route.extend({actions:{showStuff:function(obj){ok(this instanceof App.RootRoute,'the handler is an App.HomeRoute'); // Using Ember.copy removes any private Ember vars which older IE would be confused by
deepEqual(_emberMetalCore.default.copy(obj,true),{name:'Tom Dale'},'the context is correct');QUnit.start();}}});App.RootIndexRoute = _emberMetalCore.default.Route.extend({model:function(){return model;}});_emberMetalCore.default.TEMPLATES['root/index'] = _emberTemplateCompiler.compile('<a {{action \'showStuff\' model}}>{{model.name}}</a>');bootApplication();var actionId=_emberMetalCore.default.$('#qunit-fixture a').data('ember-action');var _ActionManager$registeredActions$actionId3=_emberViewsSystemAction_manager.default.registeredActions[actionId];var action=_ActionManager$registeredActions$actionId3[0];var event=new _emberMetalCore.default.$.Event('click');action.handler(event);});QUnit.test('Events can be handled by inherited event handlers',function(){expect(4);App.SuperRoute = _emberMetalCore.default.Route.extend({actions:{foo:function(){ok(true,'foo');},bar:function(msg){equal(msg,'HELLO');}}});App.RouteMixin = _emberMetalCore.default.Mixin.create({actions:{bar:function(msg){equal(msg,'HELLO');this._super(msg);}}});App.IndexRoute = App.SuperRoute.extend(App.RouteMixin,{actions:{baz:function(){ok(true,'baz');}}});bootApplication();router.send('foo');router.send('bar','HELLO');router.send('baz');});QUnit.asyncTest('Actions are not triggered on the controller if a matching action name is implemented as a method',function(){Router.map(function(){this.route('home',{path:'/'});});var model={name:'Tom Dale'};var stateIsNotCalled=true;App.HomeRoute = _emberMetalCore.default.Route.extend({model:function(){return model;},actions:{showStuff:function(context){ok(stateIsNotCalled,'an event on the state is not triggered');deepEqual(context,{name:'Tom Dale'},'an event with context is passed');QUnit.start();}}});_emberMetalCore.default.TEMPLATES.home = _emberTemplateCompiler.compile('<a {{action \'showStuff\' model}}>{{name}}</a>');var controller=_emberMetalCore.default.Controller.extend({showStuff:function(context){stateIsNotCalled = false;ok(stateIsNotCalled,'an event on the state is not triggered');}});registry.register('controller:home',controller);bootApplication();var actionId=_emberMetalCore.default.$('#qunit-fixture a').data('ember-action');var _ActionManager$registeredActions$actionId4=_emberViewsSystemAction_manager.default.registeredActions[actionId];var action=_ActionManager$registeredActions$actionId4[0];var event=new _emberMetalCore.default.$.Event('click');action.handler(event);});QUnit.asyncTest('actions can be triggered with multiple arguments',function(){Router.map(function(){this.route('root',{path:'/'},function(){this.route('index',{path:'/'});});});var model1={name:'Tilde'};var model2={name:'Tom Dale'};App.RootRoute = _emberMetalCore.default.Route.extend({actions:{showStuff:function(obj1,obj2){ok(this instanceof App.RootRoute,'the handler is an App.HomeRoute'); // Using Ember.copy removes any private Ember vars which older IE would be confused by
deepEqual(_emberMetalCore.default.copy(obj1,true),{name:'Tilde'},'the first context is correct');deepEqual(_emberMetalCore.default.copy(obj2,true),{name:'Tom Dale'},'the second context is correct');QUnit.start();}}});App.RootIndexController = _emberMetalCore.default.Controller.extend({model1:model1,model2:model2});_emberMetalCore.default.TEMPLATES['root/index'] = _emberTemplateCompiler.compile('<a {{action \'showStuff\' model1 model2}}>{{model1.name}}</a>');bootApplication();var actionId=_emberMetalCore.default.$('#qunit-fixture a').data('ember-action');var _ActionManager$registeredActions$actionId5=_emberViewsSystemAction_manager.default.registeredActions[actionId];var action=_ActionManager$registeredActions$actionId5[0];var event=new _emberMetalCore.default.$.Event('click');action.handler(event);});QUnit.test('transitioning multiple times in a single run loop only sets the URL once',function(){Router.map(function(){this.route('root',{path:'/'});this.route('foo');this.route('bar');});bootApplication();var urlSetCount=0;router.get('location').setURL = function(path){urlSetCount++;_emberMetalProperty_set.set(this,'path',path);};equal(urlSetCount,0);_emberMetalCore.default.run(function(){router.transitionTo('foo');router.transitionTo('bar');});equal(urlSetCount,1);equal(router.get('location').getURL(),'/bar');});QUnit.test('navigating away triggers a url property change',function(){expect(3);Router.map(function(){this.route('root',{path:'/'});this.route('foo',{path:'/foo'});this.route('bar',{path:'/bar'});});bootApplication();_emberMetalCore.default.run(function(){_emberMetalCore.default.addObserver(router,'url',function(){ok(true,'url change event was fired');});});['foo','bar','/foo'].forEach(function(destination){_emberMetalCore.default.run(router,'transitionTo',destination);});});QUnit.test('using replaceWith calls location.replaceURL if available',function(){var setCount=0;var replaceCount=0;Router.reopen({location:_emberMetalCore.default.NoneLocation.create({setURL:function(path){setCount++;_emberMetalProperty_set.set(this,'path',path);},replaceURL:function(path){replaceCount++;_emberMetalProperty_set.set(this,'path',path);}})});Router.map(function(){this.route('root',{path:'/'});this.route('foo');});bootApplication();equal(setCount,0);equal(replaceCount,0);_emberMetalCore.default.run(function(){router.replaceWith('foo');});equal(setCount,0,'should not call setURL');equal(replaceCount,1,'should call replaceURL once');equal(router.get('location').getURL(),'/foo');});QUnit.test('using replaceWith calls setURL if location.replaceURL is not defined',function(){var setCount=0;Router.reopen({location:_emberMetalCore.default.NoneLocation.create({setURL:function(path){setCount++;_emberMetalProperty_set.set(this,'path',path);}})});Router.map(function(){this.route('root',{path:'/'});this.route('foo');});bootApplication();equal(setCount,0);_emberMetalCore.default.run(function(){router.replaceWith('foo');});equal(setCount,1,'should call setURL once');equal(router.get('location').getURL(),'/foo');});QUnit.test('Route inherits model from parent route',function(){expect(9);Router.map(function(){this.route('the_post',{path:'/posts/:post_id'},function(){this.route('comments');this.route('shares',{path:'/shares/:share_id',resetNamespace:true},function(){this.route('share');});});});var post1={};var post2={};var post3={};var currentPost;var share1={};var share2={};var share3={};var posts={1:post1,2:post2,3:post3};var shares={1:share1,2:share2,3:share3};App.ThePostRoute = _emberMetalCore.default.Route.extend({model:function(params){return posts[params.post_id];}});App.ThePostCommentsRoute = _emberMetalCore.default.Route.extend({afterModel:function(post,transition){var parent_model=this.modelFor('thePost');equal(post,parent_model);}});App.SharesRoute = _emberMetalCore.default.Route.extend({model:function(params){return shares[params.share_id];}});App.SharesShareRoute = _emberMetalCore.default.Route.extend({afterModel:function(share,transition){var parent_model=this.modelFor('shares');equal(share,parent_model);}});bootApplication();currentPost = post1;handleURL('/posts/1/comments');handleURL('/posts/1/shares/1');currentPost = post2;handleURL('/posts/2/comments');handleURL('/posts/2/shares/2');currentPost = post3;handleURL('/posts/3/comments');handleURL('/posts/3/shares/3');});QUnit.test('Routes with { resetNamespace: true } inherits model from parent route',function(){expect(6);Router.map(function(){this.route('the_post',{path:'/posts/:post_id'},function(){this.route('comments',{resetNamespace:true},function(){});});});var post1={};var post2={};var post3={};var currentPost;var posts={1:post1,2:post2,3:post3};App.ThePostRoute = _emberMetalCore.default.Route.extend({model:function(params){return posts[params.post_id];}});App.CommentsRoute = _emberMetalCore.default.Route.extend({afterModel:function(post,transition){var parent_model=this.modelFor('thePost');equal(post,parent_model);}});bootApplication();currentPost = post1;handleURL('/posts/1/comments');currentPost = post2;handleURL('/posts/2/comments');currentPost = post3;handleURL('/posts/3/comments');});QUnit.test('It is possible to get the model from a parent route',function(){expect(9);Router.map(function(){this.route('the_post',{path:'/posts/:post_id'},function(){this.route('comments',{resetNamespace:true});});});var post1={};var post2={};var post3={};var currentPost;var posts={1:post1,2:post2,3:post3};App.ThePostRoute = _emberMetalCore.default.Route.extend({model:function(params){return posts[params.post_id];}});App.CommentsRoute = _emberMetalCore.default.Route.extend({model:function(){ // Allow both underscore / camelCase format.
equal(this.modelFor('thePost'),currentPost);equal(this.modelFor('the_post'),currentPost);}});bootApplication();currentPost = post1;handleURL('/posts/1/comments');currentPost = post2;handleURL('/posts/2/comments');currentPost = post3;handleURL('/posts/3/comments');});QUnit.test('A redirection hook is provided',function(){Router.map(function(){this.route('choose',{path:'/'});this.route('home');});var chooseFollowed=0;var destination;App.ChooseRoute = _emberMetalCore.default.Route.extend({redirect:function(){if(destination){this.transitionTo(destination);}},setupController:function(){chooseFollowed++;}});destination = 'home';bootApplication();equal(chooseFollowed,0,'The choose route wasn\'t entered since a transition occurred');equal(_emberMetalCore.default.$('h3:contains(Hours)','#qunit-fixture').length,1,'The home template was rendered');equal(router.container.lookup('controller:application').get('currentPath'),'home');});QUnit.test('Redirecting from the middle of a route aborts the remainder of the routes',function(){expect(3);Router.map(function(){this.route('home');this.route('foo',function(){this.route('bar',{resetNamespace:true},function(){this.route('baz');});});});App.BarRoute = _emberMetalCore.default.Route.extend({redirect:function(){this.transitionTo('home');},setupController:function(){ok(false,'Should transition before setupController');}});App.BarBazRoute = _emberMetalCore.default.Route.extend({enter:function(){ok(false,'Should abort transition getting to next route');}});bootApplication();handleURLAborts('/foo/bar/baz');equal(router.container.lookup('controller:application').get('currentPath'),'home');equal(router.get('location').getURL(),'/home');});QUnit.test('Redirecting to the current target in the middle of a route does not abort initial routing',function(){expect(5);Router.map(function(){this.route('home');this.route('foo',function(){this.route('bar',{resetNamespace:true},function(){this.route('baz');});});});var successCount=0;App.BarRoute = _emberMetalCore.default.Route.extend({redirect:function(){this.transitionTo('bar.baz').then(function(){successCount++;});},setupController:function(){ok(true,'Should still invoke bar\'s setupController');}});App.BarBazRoute = _emberMetalCore.default.Route.extend({setupController:function(){ok(true,'Should still invoke bar.baz\'s setupController');}});bootApplication();handleURL('/foo/bar/baz');equal(router.container.lookup('controller:application').get('currentPath'),'foo.bar.baz');equal(successCount,1,'transitionTo success handler was called once');});QUnit.test('Redirecting to the current target with a different context aborts the remainder of the routes',function(){expect(4);Router.map(function(){this.route('home');this.route('foo',function(){this.route('bar',{path:'bar/:id',resetNamespace:true},function(){this.route('baz');});});});var model={id:2};var count=0;App.BarRoute = _emberMetalCore.default.Route.extend({afterModel:function(context){if(count++ > 10){ok(false,'infinite loop');}else {this.transitionTo('bar.baz',model);}},serialize:function(params){return params;}});App.BarBazRoute = _emberMetalCore.default.Route.extend({setupController:function(){ok(true,'Should still invoke setupController');}});bootApplication();handleURLAborts('/foo/bar/1/baz');equal(router.container.lookup('controller:application').get('currentPath'),'foo.bar.baz');equal(router.get('location').getURL(),'/foo/bar/2/baz');});QUnit.test('Transitioning from a parent event does not prevent currentPath from being set',function(){Router.map(function(){this.route('foo',function(){this.route('bar',{resetNamespace:true},function(){this.route('baz');});this.route('qux');});});App.FooRoute = _emberMetalCore.default.Route.extend({actions:{goToQux:function(){this.transitionTo('foo.qux');}}});bootApplication();var applicationController=router.container.lookup('controller:application');handleURL('/foo/bar/baz');equal(applicationController.get('currentPath'),'foo.bar.baz');_emberMetalCore.default.run(function(){router.send('goToQux');});equal(applicationController.get('currentPath'),'foo.qux');equal(router.get('location').getURL(),'/foo/qux');});QUnit.test('Generated names can be customized when providing routes with dot notation',function(){expect(4);_emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('<div>Index</div>');_emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('<h1>Home</h1><div class=\'main\'>{{outlet}}</div>');_emberMetalCore.default.TEMPLATES.foo = _emberTemplateCompiler.compile('<div class=\'middle\'>{{outlet}}</div>');_emberMetalCore.default.TEMPLATES.bar = _emberTemplateCompiler.compile('<div class=\'bottom\'>{{outlet}}</div>');_emberMetalCore.default.TEMPLATES['bar/baz'] = _emberTemplateCompiler.compile('<p>{{name}}Bottom!</p>');Router.map(function(){this.route('foo',{path:'/top'},function(){this.route('bar',{path:'/middle',resetNamespace:true},function(){this.route('baz',{path:'/bottom'});});});});App.FooRoute = _emberMetalCore.default.Route.extend({renderTemplate:function(){ok(true,'FooBarRoute was called');return this._super.apply(this,arguments);}});App.BarBazRoute = _emberMetalCore.default.Route.extend({renderTemplate:function(){ok(true,'BarBazRoute was called');return this._super.apply(this,arguments);}});App.BarController = _emberMetalCore.default.Controller.extend({name:'Bar'});App.BarBazController = _emberMetalCore.default.Controller.extend({name:'BarBaz'});bootApplication();handleURL('/top/middle/bottom');equal(_emberMetalCore.default.$('.main .middle .bottom p','#qunit-fixture').text(),'BarBazBottom!','The templates were rendered into their appropriate parents');});QUnit.test('Child routes render into their parent route\'s template by default',function(){_emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('<div>Index</div>');_emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('<h1>Home</h1><div class=\'main\'>{{outlet}}</div>');_emberMetalCore.default.TEMPLATES.top = _emberTemplateCompiler.compile('<div class=\'middle\'>{{outlet}}</div>');_emberMetalCore.default.TEMPLATES.middle = _emberTemplateCompiler.compile('<div class=\'bottom\'>{{outlet}}</div>');_emberMetalCore.default.TEMPLATES['middle/bottom'] = _emberTemplateCompiler.compile('<p>Bottom!</p>');Router.map(function(){this.route('top',function(){this.route('middle',{resetNamespace:true},function(){this.route('bottom');});});});bootApplication();handleURL('/top/middle/bottom');equal(_emberMetalCore.default.$('.main .middle .bottom p','#qunit-fixture').text(),'Bottom!','The templates were rendered into their appropriate parents');});QUnit.test('Child routes render into specified template',function(){_emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('<div>Index</div>');_emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('<h1>Home</h1><div class=\'main\'>{{outlet}}</div>');_emberMetalCore.default.TEMPLATES.top = _emberTemplateCompiler.compile('<div class=\'middle\'>{{outlet}}</div>');_emberMetalCore.default.TEMPLATES.middle = _emberTemplateCompiler.compile('<div class=\'bottom\'>{{outlet}}</div>');_emberMetalCore.default.TEMPLATES['middle/bottom'] = _emberTemplateCompiler.compile('<p>Bottom!</p>');Router.map(function(){this.route('top',function(){this.route('middle',{resetNamespace:true},function(){this.route('bottom');});});});App.MiddleBottomRoute = _emberMetalCore.default.Route.extend({renderTemplate:function(){this.render('middle/bottom',{into:'top'});}});bootApplication();handleURL('/top/middle/bottom');equal(_emberMetalCore.default.$('.main .middle .bottom p','#qunit-fixture').length,0,'should not render into the middle template');equal(_emberMetalCore.default.$('.main .middle > p','#qunit-fixture').text(),'Bottom!','The template was rendered into the top template');});QUnit.test('Rendering into specified template with slash notation',function(){_emberMetalCore.default.TEMPLATES['person/profile'] = _emberTemplateCompiler.compile('profile {{outlet}}');_emberMetalCore.default.TEMPLATES['person/details'] = _emberTemplateCompiler.compile('details!');Router.map(function(){this.route('home',{path:'/'});});App.HomeRoute = _emberMetalCore.default.Route.extend({renderTemplate:function(){this.render('person/profile');this.render('person/details',{into:'person/profile'});}});bootApplication();equal(_emberMetalCore.default.$('#qunit-fixture:contains(profile details!)').length,1,'The templates were rendered');});QUnit.test('Parent route context change',function(){var editCount=0;var editedPostIds=_emberMetalCore.default.A();_emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('{{outlet}}');_emberMetalCore.default.TEMPLATES.posts = _emberTemplateCompiler.compile('{{outlet}}');_emberMetalCore.default.TEMPLATES.post = _emberTemplateCompiler.compile('{{outlet}}');_emberMetalCore.default.TEMPLATES['post/index'] = _emberTemplateCompiler.compile('showing');_emberMetalCore.default.TEMPLATES['post/edit'] = _emberTemplateCompiler.compile('editing');Router.map(function(){this.route('posts',function(){this.route('post',{path:'/:postId',resetNamespace:true},function(){this.route('edit');});});});App.PostsRoute = _emberMetalCore.default.Route.extend({actions:{showPost:function(context){this.transitionTo('post',context);}}});App.PostRoute = _emberMetalCore.default.Route.extend({model:function(params){return {id:params.postId};},actions:{editPost:function(context){this.transitionTo('post.edit');}}});App.PostEditRoute = _emberMetalCore.default.Route.extend({model:function(params){var postId=this.modelFor('post').id;editedPostIds.push(postId);return null;},setup:function(){this._super.apply(this,arguments);editCount++;}});bootApplication();handleURL('/posts/1');_emberMetalCore.default.run(function(){router.send('editPost');});_emberMetalCore.default.run(function(){router.send('showPost',{id:'2'});});_emberMetalCore.default.run(function(){router.send('editPost');});equal(editCount,2,'set up the edit route twice without failure');deepEqual(editedPostIds,['1','2'],'modelFor posts.post returns the right context');});QUnit.test('Router accounts for rootURL on page load when using history location',function(){var rootURL=window.location.pathname + '/app';var postsTemplateRendered=false;var setHistory,HistoryTestLocation;setHistory = function(obj,path){obj.set('history',{state:{path:path}});}; // Create new implementation that extends HistoryLocation
// and set current location to rootURL + '/posts'
HistoryTestLocation = _emberMetalCore.default.HistoryLocation.extend({initState:function(){var path=rootURL + '/posts';setHistory(this,path);this.set('location',{pathname:path,href:'http://localhost/' + path});},replaceState:function(path){setHistory(this,path);},pushState:function(path){setHistory(this,path);}});registry.register('location:historyTest',HistoryTestLocation);Router.reopen({location:'historyTest',rootURL:rootURL});Router.map(function(){this.route('posts',{path:'/posts'});});App.PostsRoute = _emberMetalCore.default.Route.extend({model:function(){},renderTemplate:function(){postsTemplateRendered = true;}});bootApplication();ok(postsTemplateRendered,'Posts route successfully stripped from rootURL');});QUnit.test('The rootURL is passed properly to the location implementation',function(){expect(1);var rootURL='/blahzorz';var HistoryTestLocation;HistoryTestLocation = _emberMetalCore.default.HistoryLocation.extend({rootURL:'this is not the URL you are looking for',initState:function(){equal(this.get('rootURL'),rootURL);}});registry.register('location:history-test',HistoryTestLocation);Router.reopen({location:'history-test',rootURL:rootURL, // if we transition in this test we will receive failures
// if the tests are run from a static file
_doURLTransition:function(){}});bootApplication();});QUnit.test('Only use route rendered into main outlet for default into property on child',function(){_emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('{{outlet \'menu\'}}{{outlet}}');_emberMetalCore.default.TEMPLATES.posts = _emberTemplateCompiler.compile('{{outlet}}');_emberMetalCore.default.TEMPLATES['posts/index'] = _emberTemplateCompiler.compile('postsIndex');_emberMetalCore.default.TEMPLATES['posts/menu'] = _emberTemplateCompiler.compile('postsMenu');Router.map(function(){this.route('posts',function(){});});App.PostsMenuView = _emberViewsViewsView.default.extend({tagName:'div',templateName:'posts/menu',classNames:['posts-menu']});App.PostsIndexView = _emberViewsViewsView.default.extend({tagName:'p',classNames:['posts-index']});App.PostsRoute = _emberMetalCore.default.Route.extend({renderTemplate:function(){this.render();this.render('postsMenu',{into:'application',outlet:'menu'});}});bootApplication();handleURL('/posts');equal(_emberMetalCore.default.$('div.posts-menu:contains(postsMenu)','#qunit-fixture').length,1,'The posts/menu template was rendered');equal(_emberMetalCore.default.$('p.posts-index:contains(postsIndex)','#qunit-fixture').length,1,'The posts/index template was rendered');});QUnit.test('Generating a URL should not affect currentModel',function(){Router.map(function(){this.route('post',{path:'/posts/:post_id'});});var posts={1:{id:1},2:{id:2}};App.PostRoute = _emberMetalCore.default.Route.extend({model:function(params){return posts[params.post_id];}});bootApplication();handleURL('/posts/1');var route=container.lookup('route:post');equal(route.modelFor('post'),posts[1]);var url=router.generate('post',posts[2]);equal(url,'/posts/2');equal(route.modelFor('post'),posts[1]);});QUnit.test('Generated route should be an instance of App.Route if provided',function(){var generatedRoute;Router.map(function(){this.route('posts');});App.Route = _emberMetalCore.default.Route.extend();bootApplication();handleURL('/posts');generatedRoute = container.lookup('route:posts');ok(generatedRoute instanceof App.Route,'should extend the correct route');});QUnit.test('Nested index route is not overriden by parent\'s implicit index route',function(){Router.map(function(){this.route('posts',function(){this.route('index',{path:':category'});});});App.Route = _emberMetalCore.default.Route.extend({serialize:function(model){return {category:model.category};}});bootApplication();_emberMetalCore.default.run(function(){router.transitionTo('posts',{category:'emberjs'});});deepEqual(router.location.path,'/posts/emberjs');});QUnit.test('Application template does not duplicate when re-rendered',function(){_emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('<h3>I Render Once</h3>{{outlet}}');Router.map(function(){this.route('posts');});App.ApplicationRoute = _emberMetalCore.default.Route.extend({model:function(){return _emberMetalCore.default.A();}});bootApplication(); // should cause application template to re-render
handleURL('/posts');equal(_emberMetalCore.default.$('h3:contains(I Render Once)').size(),1);});QUnit.test('Child routes should render inside the application template if the application template causes a redirect',function(){_emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('<h3>App</h3> {{outlet}}');_emberMetalCore.default.TEMPLATES.posts = _emberTemplateCompiler.compile('posts');Router.map(function(){this.route('posts');this.route('photos');});App.ApplicationRoute = _emberMetalCore.default.Route.extend({afterModel:function(){this.transitionTo('posts');}});bootApplication();equal(_emberMetalCore.default.$('#qunit-fixture > div').text(),'App posts');});QUnit.test('The template is not re-rendered when the route\'s context changes',function(){Router.map(function(){this.route('page',{path:'/page/:name'});});App.PageRoute = _emberMetalCore.default.Route.extend({model:function(params){return _emberMetalCore.default.Object.create({name:params.name});}});var insertionCount=0;App.PageView = _emberViewsViewsView.default.extend({didInsertElement:function(){insertionCount += 1;}});_emberMetalCore.default.TEMPLATES.page = _emberTemplateCompiler.compile('<p>{{model.name}}</p>');bootApplication();handleURL('/page/first');equal(_emberMetalCore.default.$('p','#qunit-fixture').text(),'first');equal(insertionCount,1);handleURL('/page/second');equal(_emberMetalCore.default.$('p','#qunit-fixture').text(),'second');equal(insertionCount,1,'view should have inserted only once');_emberMetalCore.default.run(function(){router.transitionTo('page',_emberMetalCore.default.Object.create({name:'third'}));});equal(_emberMetalCore.default.$('p','#qunit-fixture').text(),'third');equal(insertionCount,1,'view should still have inserted only once');});QUnit.test('The template is not re-rendered when two routes present the exact same template, view, & controller',function(){Router.map(function(){this.route('first');this.route('second');this.route('third');this.route('fourth');});App.SharedRoute = _emberMetalCore.default.Route.extend({viewName:'shared',setupController:function(controller){this.controllerFor('shared').set('message','This is the ' + this.routeName + ' message');},renderTemplate:function(controller,context){this.render({controller:'shared'});}});App.FirstRoute = App.SharedRoute.extend();App.SecondRoute = App.SharedRoute.extend();App.ThirdRoute = App.SharedRoute.extend();App.FourthRoute = App.SharedRoute.extend({viewName:'fourth'});App.SharedController = _emberMetalCore.default.Controller.extend();var insertionCount=0;App.SharedView = _emberViewsViewsView.default.extend({templateName:'shared',didInsertElement:function(){insertionCount += 1;}}); // Extending, in essence, creates a different view
App.FourthView = App.SharedView.extend();_emberMetalCore.default.TEMPLATES.shared = _emberTemplateCompiler.compile('<p>{{message}}</p>');bootApplication();handleURL('/first');equal(_emberMetalCore.default.$('p','#qunit-fixture').text(),'This is the first message');equal(insertionCount,1,'expected one assertion'); // Transition by URL
handleURL('/second');equal(_emberMetalCore.default.$('p','#qunit-fixture').text(),'This is the second message');equal(insertionCount,1,'view should have inserted only once'); // Then transition directly by route name
_emberMetalCore.default.run(function(){router.transitionTo('third').then(function(value){ok(true,'expected transition');},function(reason){ok(false,'unexpected transition failure: ',QUnit.jsDump.parse(reason));});});equal(_emberMetalCore.default.$('p','#qunit-fixture').text(),'This is the third message');equal(insertionCount,1,'view should still have inserted only once'); // Lastly transition to a different view, with the same controller and template
handleURL('/fourth');equal(_emberMetalCore.default.$('p','#qunit-fixture').text(),'This is the fourth message');equal(insertionCount,2,'view should have inserted a second time');});QUnit.test('ApplicationRoute with model does not proxy the currentPath',function(){var model={};var currentPath;App.ApplicationRoute = _emberMetalCore.default.Route.extend({model:function(){return model;}});App.ApplicationController = _emberMetalCore.default.Controller.extend({currentPathDidChange:_emberMetalCore.default.observer('currentPath',function(){currentPath = _emberMetalProperty_get.get(this,'currentPath');})});bootApplication();equal(currentPath,'index','currentPath is index');equal('currentPath' in model,false,'should have defined currentPath on controller');});QUnit.test('Promises encountered on app load put app into loading state until resolved',function(){expect(2);var deferred=_emberMetalCore.default.RSVP.defer();App.IndexRoute = _emberMetalCore.default.Route.extend({model:function(){return deferred.promise;}});_emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('<p>INDEX</p>');_emberMetalCore.default.TEMPLATES.loading = _emberTemplateCompiler.compile('<p>LOADING</p>');bootApplication();equal(_emberMetalCore.default.$('p','#qunit-fixture').text(),'LOADING','The loading state is displaying.');_emberMetalCore.default.run(deferred.resolve);equal(_emberMetalCore.default.$('p','#qunit-fixture').text(),'INDEX','The index route is display.');});QUnit.test('Route should tear down multiple outlets',function(){_emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('{{outlet \'menu\'}}{{outlet}}{{outlet \'footer\'}}');_emberMetalCore.default.TEMPLATES.posts = _emberTemplateCompiler.compile('{{outlet}}');_emberMetalCore.default.TEMPLATES.users = _emberTemplateCompiler.compile('users');_emberMetalCore.default.TEMPLATES['posts/index'] = _emberTemplateCompiler.compile('postsIndex');_emberMetalCore.default.TEMPLATES['posts/menu'] = _emberTemplateCompiler.compile('postsMenu');_emberMetalCore.default.TEMPLATES['posts/footer'] = _emberTemplateCompiler.compile('postsFooter');Router.map(function(){this.route('posts',function(){});this.route('users',function(){});});App.PostsMenuView = _emberViewsViewsView.default.extend({tagName:'div',templateName:'posts/menu',classNames:['posts-menu']});App.PostsIndexView = _emberViewsViewsView.default.extend({tagName:'p',classNames:['posts-index']});App.PostsFooterView = _emberViewsViewsView.default.extend({tagName:'div',templateName:'posts/footer',classNames:['posts-footer']});App.PostsRoute = _emberMetalCore.default.Route.extend({renderTemplate:function(){this.render('postsMenu',{into:'application',outlet:'menu'});this.render();this.render('postsFooter',{into:'application',outlet:'footer'});}});bootApplication();handleURL('/posts');equal(_emberMetalCore.default.$('div.posts-menu:contains(postsMenu)','#qunit-fixture').length,1,'The posts/menu template was rendered');equal(_emberMetalCore.default.$('p.posts-index:contains(postsIndex)','#qunit-fixture').length,1,'The posts/index template was rendered');equal(_emberMetalCore.default.$('div.posts-footer:contains(postsFooter)','#qunit-fixture').length,1,'The posts/footer template was rendered');handleURL('/users');equal(_emberMetalCore.default.$('div.posts-menu:contains(postsMenu)','#qunit-fixture').length,0,'The posts/menu template was removed');equal(_emberMetalCore.default.$('p.posts-index:contains(postsIndex)','#qunit-fixture').length,0,'The posts/index template was removed');equal(_emberMetalCore.default.$('div.posts-footer:contains(postsFooter)','#qunit-fixture').length,0,'The posts/footer template was removed');});QUnit.test('Route will assert if you try to explicitly render {into: ...} a missing template',function(){Router.map(function(){this.route('home',{path:'/'});});App.HomeRoute = _emberMetalCore.default.Route.extend({renderTemplate:function(){this.render({into:'nonexistent'});}});expectAssertion(function(){bootApplication();},'You attempted to render into \'nonexistent\' but it was not found');});QUnit.test('Route supports clearing outlet explicitly',function(){_emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('{{outlet}}{{outlet \'modal\'}}');_emberMetalCore.default.TEMPLATES.posts = _emberTemplateCompiler.compile('{{outlet}}');_emberMetalCore.default.TEMPLATES.users = _emberTemplateCompiler.compile('users');_emberMetalCore.default.TEMPLATES['posts/index'] = _emberTemplateCompiler.compile('postsIndex {{outlet}}');_emberMetalCore.default.TEMPLATES['posts/modal'] = _emberTemplateCompiler.compile('postsModal');_emberMetalCore.default.TEMPLATES['posts/extra'] = _emberTemplateCompiler.compile('postsExtra');Router.map(function(){this.route('posts',function(){});this.route('users',function(){});});App.PostsIndexView = _emberViewsViewsView.default.extend({classNames:['posts-index']});App.PostsModalView = _emberViewsViewsView.default.extend({templateName:'posts/modal',classNames:['posts-modal']});App.PostsExtraView = _emberViewsViewsView.default.extend({templateName:'posts/extra',classNames:['posts-extra']});App.PostsRoute = _emberMetalCore.default.Route.extend({actions:{showModal:function(){this.render('postsModal',{into:'application',outlet:'modal'});},hideModal:function(){this.disconnectOutlet({outlet:'modal',parentView:'application'});}}});App.PostsIndexRoute = _emberMetalCore.default.Route.extend({actions:{showExtra:function(){this.render('postsExtra',{into:'posts/index'});},hideExtra:function(){this.disconnectOutlet({parentView:'posts/index'});}}});bootApplication();handleURL('/posts');equal(_emberMetalCore.default.$('div.posts-index:contains(postsIndex)','#qunit-fixture').length,1,'The posts/index template was rendered');_emberMetalCore.default.run(function(){router.send('showModal');});equal(_emberMetalCore.default.$('div.posts-modal:contains(postsModal)','#qunit-fixture').length,1,'The posts/modal template was rendered');_emberMetalCore.default.run(function(){router.send('showExtra');});equal(_emberMetalCore.default.$('div.posts-extra:contains(postsExtra)','#qunit-fixture').length,1,'The posts/extra template was rendered');_emberMetalCore.default.run(function(){router.send('hideModal');});equal(_emberMetalCore.default.$('div.posts-modal:contains(postsModal)','#qunit-fixture').length,0,'The posts/modal template was removed');_emberMetalCore.default.run(function(){router.send('hideExtra');});equal(_emberMetalCore.default.$('div.posts-extra:contains(postsExtra)','#qunit-fixture').length,0,'The posts/extra template was removed');handleURL('/users');equal(_emberMetalCore.default.$('div.posts-index:contains(postsIndex)','#qunit-fixture').length,0,'The posts/index template was removed');equal(_emberMetalCore.default.$('div.posts-modal:contains(postsModal)','#qunit-fixture').length,0,'The posts/modal template was removed');equal(_emberMetalCore.default.$('div.posts-extra:contains(postsExtra)','#qunit-fixture').length,0,'The posts/extra template was removed');});QUnit.test('Route supports clearing outlet using string parameter',function(){_emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('{{outlet}}{{outlet \'modal\'}}');_emberMetalCore.default.TEMPLATES.posts = _emberTemplateCompiler.compile('{{outlet}}');_emberMetalCore.default.TEMPLATES.users = _emberTemplateCompiler.compile('users');_emberMetalCore.default.TEMPLATES['posts/index'] = _emberTemplateCompiler.compile('postsIndex {{outlet}}');_emberMetalCore.default.TEMPLATES['posts/modal'] = _emberTemplateCompiler.compile('postsModal');Router.map(function(){this.route('posts',function(){});this.route('users',function(){});});App.PostsIndexView = _emberViewsViewsView.default.extend({classNames:['posts-index']});App.PostsModalView = _emberViewsViewsView.default.extend({templateName:'posts/modal',classNames:['posts-modal']});App.PostsRoute = _emberMetalCore.default.Route.extend({actions:{showModal:function(){this.render('postsModal',{into:'application',outlet:'modal'});},hideModal:function(){this.disconnectOutlet('modal');}}});bootApplication();handleURL('/posts');equal(_emberMetalCore.default.$('div.posts-index:contains(postsIndex)','#qunit-fixture').length,1,'The posts/index template was rendered');_emberMetalCore.default.run(function(){router.send('showModal');});equal(_emberMetalCore.default.$('div.posts-modal:contains(postsModal)','#qunit-fixture').length,1,'The posts/modal template was rendered');_emberMetalCore.default.run(function(){router.send('hideModal');});equal(_emberMetalCore.default.$('div.posts-modal:contains(postsModal)','#qunit-fixture').length,0,'The posts/modal template was removed');handleURL('/users');equal(_emberMetalCore.default.$('div.posts-index:contains(postsIndex)','#qunit-fixture').length,0,'The posts/index template was removed');equal(_emberMetalCore.default.$('div.posts-modal:contains(postsModal)','#qunit-fixture').length,0,'The posts/modal template was removed');});QUnit.test('Route silently fails when cleaning an outlet from an inactive view',function(){expect(1); // handleURL
_emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('{{outlet}}');_emberMetalCore.default.TEMPLATES.posts = _emberTemplateCompiler.compile('{{outlet \'modal\'}}');_emberMetalCore.default.TEMPLATES.modal = _emberTemplateCompiler.compile('A Yo.');Router.map(function(){this.route('posts');});App.PostsRoute = _emberMetalCore.default.Route.extend({actions:{hideSelf:function(){this.disconnectOutlet({outlet:'main',parentView:'application'});},showModal:function(){this.render('modal',{into:'posts',outlet:'modal'});},hideModal:function(){this.disconnectOutlet({outlet:'modal',parentView:'posts'});}}});bootApplication();handleURL('/posts');_emberMetalCore.default.run(function(){router.send('showModal');});_emberMetalCore.default.run(function(){router.send('hideSelf');});_emberMetalCore.default.run(function(){router.send('hideModal');});});QUnit.test('Router `willTransition` hook passes in cancellable transition',function(){ // Should hit willTransition 3 times, once for the initial route, and then 2 more times
// for the two handleURL calls below
expect(3);Router.map(function(){this.route('nork');this.route('about');});Router.reopen({init:function(){this._super();this.on('willTransition',this.testWillTransitionHook);},testWillTransitionHook:function(transition,url){ok(true,'willTransition was called ' + url);transition.abort();}});App.LoadingRoute = _emberMetalCore.default.Route.extend({activate:function(){ok(false,'LoadingRoute was not entered');}});App.NorkRoute = _emberMetalCore.default.Route.extend({activate:function(){ok(false,'NorkRoute was not entered');}});App.AboutRoute = _emberMetalCore.default.Route.extend({activate:function(){ok(false,'AboutRoute was not entered');}});bootApplication(); // Attempted transitions out of index should abort.
_emberMetalCore.default.run(router,'handleURL','/nork');_emberMetalCore.default.run(router,'handleURL','/about');});QUnit.test('Aborting/redirecting the transition in `willTransition` prevents LoadingRoute from being entered',function(){expect(8);Router.map(function(){this.route('nork');this.route('about');});var redirect=false;App.IndexRoute = _emberMetalCore.default.Route.extend({actions:{willTransition:function(transition){ok(true,'willTransition was called');if(redirect){ // router.js won't refire `willTransition` for this redirect
this.transitionTo('about');}else {transition.abort();}}}});var deferred=null;App.LoadingRoute = _emberMetalCore.default.Route.extend({activate:function(){ok(deferred,'LoadingRoute should be entered at this time');},deactivate:function(){ok(true,'LoadingRoute was exited');}});App.NorkRoute = _emberMetalCore.default.Route.extend({activate:function(){ok(true,'NorkRoute was entered');}});App.AboutRoute = _emberMetalCore.default.Route.extend({activate:function(){ok(true,'AboutRoute was entered');},model:function(){if(deferred){return deferred.promise;}}});bootApplication(); // Attempted transitions out of index should abort.
_emberMetalCore.default.run(router,'transitionTo','nork');_emberMetalCore.default.run(router,'handleURL','/nork'); // Attempted transitions out of index should redirect to about
redirect = true;_emberMetalCore.default.run(router,'transitionTo','nork');_emberMetalCore.default.run(router,'transitionTo','index'); // Redirected transitions out of index to a route with a
// promise model should pause the transition and
// activate LoadingRoute
deferred = _emberMetalCore.default.RSVP.defer();_emberMetalCore.default.run(router,'transitionTo','nork');_emberMetalCore.default.run(deferred.resolve);});QUnit.test('`didTransition` event fires on the router',function(){expect(3);Router.map(function(){this.route('nork');});router = container.lookup('router:main');router.one('didTransition',function(){ok(true,'didTransition fired on initial routing');});bootApplication();router.one('didTransition',function(){ok(true,'didTransition fired on the router');equal(router.get('url'),'/nork','The url property is updated by the time didTransition fires');});_emberMetalCore.default.run(router,'transitionTo','nork');});QUnit.test('`didTransition` can be reopened',function(){expect(1);Router.map(function(){this.route('nork');});Router.reopen({didTransition:function(){this._super.apply(this,arguments);ok(true,'reopened didTransition was called');}});bootApplication();});QUnit.test('`activate` event fires on the route',function(){expect(2);var eventFired=0;Router.map(function(){this.route('nork');});App.NorkRoute = _emberMetalCore.default.Route.extend({init:function(){this._super.apply(this,arguments);this.on('activate',function(){equal(++eventFired,1,'activate event is fired once');});},activate:function(){ok(true,'activate hook is called');}});bootApplication();_emberMetalCore.default.run(router,'transitionTo','nork');});QUnit.test('`deactivate` event fires on the route',function(){expect(2);var eventFired=0;Router.map(function(){this.route('nork');this.route('dork');});App.NorkRoute = _emberMetalCore.default.Route.extend({init:function(){this._super.apply(this,arguments);this.on('deactivate',function(){equal(++eventFired,1,'deactivate event is fired once');});},deactivate:function(){ok(true,'deactivate hook is called');}});bootApplication();_emberMetalCore.default.run(router,'transitionTo','nork');_emberMetalCore.default.run(router,'transitionTo','dork');});QUnit.test('Actions can be handled by inherited action handlers',function(){expect(4);App.SuperRoute = _emberMetalCore.default.Route.extend({actions:{foo:function(){ok(true,'foo');},bar:function(msg){equal(msg,'HELLO');}}});App.RouteMixin = _emberMetalCore.default.Mixin.create({actions:{bar:function(msg){equal(msg,'HELLO');this._super(msg);}}});App.IndexRoute = App.SuperRoute.extend(App.RouteMixin,{actions:{baz:function(){ok(true,'baz');}}});bootApplication();router.send('foo');router.send('bar','HELLO');router.send('baz');});QUnit.test('currentRouteName is a property installed on ApplicationController that can be used in transitionTo',function(){expect(24);Router.map(function(){this.route('be',function(){this.route('excellent',{resetNamespace:true},function(){this.route('to',{resetNamespace:true},function(){this.route('each',{resetNamespace:true},function(){this.route('other');});});});});});bootApplication();var appController=router.container.lookup('controller:application');function transitionAndCheck(path,expectedPath,expectedRouteName){if(path){_emberMetalCore.default.run(router,'transitionTo',path);}equal(appController.get('currentPath'),expectedPath);equal(appController.get('currentRouteName'),expectedRouteName);}transitionAndCheck(null,'index','index');transitionAndCheck('/be','be.index','be.index');transitionAndCheck('/be/excellent','be.excellent.index','excellent.index');transitionAndCheck('/be/excellent/to','be.excellent.to.index','to.index');transitionAndCheck('/be/excellent/to/each','be.excellent.to.each.index','each.index');transitionAndCheck('/be/excellent/to/each/other','be.excellent.to.each.other','each.other');transitionAndCheck('index','index','index');transitionAndCheck('be','be.index','be.index');transitionAndCheck('excellent','be.excellent.index','excellent.index');transitionAndCheck('to.index','be.excellent.to.index','to.index');transitionAndCheck('each','be.excellent.to.each.index','each.index');transitionAndCheck('each.other','be.excellent.to.each.other','each.other');});QUnit.test('Route model hook finds the same model as a manual find',function(){var Post;App.Post = _emberMetalCore.default.Object.extend();App.Post.reopenClass({find:function(){Post = this;return {};}});Router.map(function(){this.route('post',{path:'/post/:post_id'});});bootApplication();handleURL('/post/1');equal(App.Post,Post);});QUnit.test('Routes can refresh themselves causing their model hooks to be re-run',function(){Router.map(function(){this.route('parent',{path:'/parent/:parent_id'},function(){this.route('child');});});var appcount=0;App.ApplicationRoute = _emberMetalCore.default.Route.extend({model:function(){++appcount;}});var parentcount=0;App.ParentRoute = _emberMetalCore.default.Route.extend({model:function(params){equal(params.parent_id,'123');++parentcount;},actions:{refreshParent:function(){this.refresh();}}});var childcount=0;App.ParentChildRoute = _emberMetalCore.default.Route.extend({model:function(){++childcount;}});bootApplication();equal(appcount,1);equal(parentcount,0);equal(childcount,0);_emberMetalCore.default.run(router,'transitionTo','parent.child','123');equal(appcount,1);equal(parentcount,1);equal(childcount,1);_emberMetalCore.default.run(router,'send','refreshParent');equal(appcount,1);equal(parentcount,2);equal(childcount,2);});QUnit.test('Specifying non-existent controller name in route#render throws',function(){expect(1);Router.map(function(){this.route('home',{path:'/'});});App.HomeRoute = _emberMetalCore.default.Route.extend({renderTemplate:function(){try{this.render('homepage',{controller:'stefanpenneristhemanforme'});}catch(e) {equal(e.message,'You passed `controller: \'stefanpenneristhemanforme\'` into the `render` method, but no such controller could be found.');}}});bootApplication();});QUnit.test('Redirecting with null model doesn\'t error out',function(){Router.map(function(){this.route('home',{path:'/'});this.route('about',{path:'/about/:hurhurhur'});});App.HomeRoute = _emberMetalCore.default.Route.extend({beforeModel:function(){this.transitionTo('about',null);}});App.AboutRoute = _emberMetalCore.default.Route.extend({serialize:function(model){if(model === null){return {hurhurhur:'TreeklesMcGeekles'};}}});bootApplication();equal(router.get('location.path'),'/about/TreeklesMcGeekles');});QUnit.test('rejecting the model hooks promise with a non-error prints the `message` property',function(){var rejectedMessage='OMG!! SOOOOOO BAD!!!!';var rejectedStack='Yeah, buddy: stack gets printed too.';Router.map(function(){this.route('yippie',{path:'/'});});_emberMetalCore.default.Logger.error = function(initialMessage,errorMessage,errorStack){equal(initialMessage,'Error while processing route: yippie','a message with the current route name is printed');equal(errorMessage,rejectedMessage,'the rejected reason\'s message property is logged');equal(errorStack,rejectedStack,'the rejected reason\'s stack property is logged');};App.YippieRoute = _emberMetalCore.default.Route.extend({model:function(){return _emberMetalCore.default.RSVP.reject({message:rejectedMessage,stack:rejectedStack});}});bootApplication();});QUnit.test('rejecting the model hooks promise with an error with `errorThrown` property prints `errorThrown.message` property',function(){var rejectedMessage='OMG!! SOOOOOO BAD!!!!';var rejectedStack='Yeah, buddy: stack gets printed too.';Router.map(function(){this.route('yippie',{path:'/'});});_emberMetalCore.default.Logger.error = function(initialMessage,errorMessage,errorStack){equal(initialMessage,'Error while processing route: yippie','a message with the current route name is printed');equal(errorMessage,rejectedMessage,'the rejected reason\'s message property is logged');equal(errorStack,rejectedStack,'the rejected reason\'s stack property is logged');};App.YippieRoute = _emberMetalCore.default.Route.extend({model:function(){return _emberMetalCore.default.RSVP.reject({errorThrown:{message:rejectedMessage,stack:rejectedStack}});}});bootApplication();});QUnit.test('rejecting the model hooks promise with no reason still logs error',function(){Router.map(function(){this.route('wowzers',{path:'/'});});_emberMetalCore.default.Logger.error = function(initialMessage){equal(initialMessage,'Error while processing route: wowzers','a message with the current route name is printed');};App.WowzersRoute = _emberMetalCore.default.Route.extend({model:function(){return _emberMetalCore.default.RSVP.reject();}});bootApplication();});QUnit.test('rejecting the model hooks promise with a string shows a good error',function(){var originalLoggerError=_emberMetalCore.default.Logger.error;var rejectedMessage='Supercalifragilisticexpialidocious';Router.map(function(){this.route('yondo',{path:'/'});});_emberMetalCore.default.Logger.error = function(initialMessage,errorMessage){equal(initialMessage,'Error while processing route: yondo','a message with the current route name is printed');equal(errorMessage,rejectedMessage,'the rejected reason\'s message property is logged');};App.YondoRoute = _emberMetalCore.default.Route.extend({model:function(){return _emberMetalCore.default.RSVP.reject(rejectedMessage);}});bootApplication();_emberMetalCore.default.Logger.error = originalLoggerError;});QUnit.test('willLeave, willChangeContext, willChangeModel actions don\'t fire unless feature flag enabled',function(){expect(1);App.Router.map(function(){this.route('about');});function shouldNotFire(){ok(false,'this action shouldn\'t have been received');}App.IndexRoute = _emberMetalCore.default.Route.extend({actions:{willChangeModel:shouldNotFire,willChangeContext:shouldNotFire,willLeave:shouldNotFire}});App.AboutRoute = _emberMetalCore.default.Route.extend({setupController:function(){ok(true,'about route was entered');}});bootApplication();_emberMetalCore.default.run(router,'transitionTo','about');});QUnit.test('Errors in transitionTo within redirect hook are logged',function(){expect(3);var actual=[];Router.map(function(){this.route('yondo',{path:'/'});this.route('stink-bomb');});App.YondoRoute = _emberMetalCore.default.Route.extend({redirect:function(){this.transitionTo('stink-bomb',{something:'goes boom'});}});_emberMetalCore.default.Logger.error = function(){ // push the arguments onto an array so we can detect if the error gets logged twice
actual.push(arguments);};bootApplication();equal(actual.length,1,'the error is only logged once');equal(actual[0][0],'Error while processing route: yondo','source route is printed');ok(actual[0][1].match(/More context objects were passed than there are dynamic segments for the route: stink-bomb/),'the error is printed');});QUnit.test('Errors in transition show error template if available',function(){_emberMetalCore.default.TEMPLATES.error = _emberTemplateCompiler.compile('<div id=\'error\'>Error!</div>');Router.map(function(){this.route('yondo',{path:'/'});this.route('stink-bomb');});App.YondoRoute = _emberMetalCore.default.Route.extend({redirect:function(){this.transitionTo('stink-bomb',{something:'goes boom'});}});bootApplication();equal(_emberMetalCore.default.$('#error').length,1,'Error template was rendered.');});QUnit.test('Route#resetController gets fired when changing models and exiting routes',function(){expect(4);Router.map(function(){this.route('a',function(){this.route('b',{path:'/b/:id',resetNamespace:true},function(){});this.route('c',{path:'/c/:id',resetNamespace:true},function(){});});this.route('out');});var calls=[];var SpyRoute=_emberMetalCore.default.Route.extend({setupController:function(controller,model,transition){calls.push(['setup',this.routeName]);},resetController:function(controller){calls.push(['reset',this.routeName]);}});App.ARoute = SpyRoute.extend();App.BRoute = SpyRoute.extend();App.CRoute = SpyRoute.extend();App.OutRoute = SpyRoute.extend();bootApplication();deepEqual(calls,[]);_emberMetalCore.default.run(router,'transitionTo','b','b-1');deepEqual(calls,[['setup','a'],['setup','b']]);calls.length = 0;_emberMetalCore.default.run(router,'transitionTo','c','c-1');deepEqual(calls,[['reset','b'],['setup','c']]);calls.length = 0;_emberMetalCore.default.run(router,'transitionTo','out');deepEqual(calls,[['reset','c'],['reset','a'],['setup','out']]);});QUnit.test('Exception during initialization of non-initial route is not swallowed',function(){Router.map(function(){this.route('boom');});App.BoomRoute = _emberMetalCore.default.Route.extend({init:function(){throw new Error('boom!');}});bootApplication();throws(function(){_emberMetalCore.default.run(router,'transitionTo','boom');},/\bboom\b/);});QUnit.test('Exception during load of non-initial route is not swallowed',function(){Router.map(function(){this.route('boom');});var lookup=container.lookup;container.lookup = function(){if(arguments[0] === 'route:boom'){throw new Error('boom!');}return lookup.apply(this,arguments);};App.BoomRoute = _emberMetalCore.default.Route.extend({init:function(){throw new Error('boom!');}});bootApplication();throws(function(){_emberMetalCore.default.run(router,'transitionTo','boom');});});QUnit.test('Exception during initialization of initial route is not swallowed',function(){Router.map(function(){this.route('boom',{path:'/'});});App.BoomRoute = _emberMetalCore.default.Route.extend({init:function(){throw new Error('boom!');}});throws(function(){bootApplication();},/\bboom\b/);});QUnit.test('Exception during load of initial route is not swallowed',function(){Router.map(function(){this.route('boom',{path:'/'});});var lookup=container.lookup;container.lookup = function(){if(arguments[0] === 'route:boom'){throw new Error('boom!');}return lookup.apply(this,arguments);};App.BoomRoute = _emberMetalCore.default.Route.extend({init:function(){throw new Error('boom!');}});throws(function(){bootApplication();},/\bboom\b/);});QUnit.test('{{outlet}} works when created after initial render',function(){_emberMetalCore.default.TEMPLATES.sample = _emberTemplateCompiler.compile('Hi{{#if showTheThing}}{{outlet}}{{/if}}Bye');_emberMetalCore.default.TEMPLATES['sample/inner'] = _emberTemplateCompiler.compile('Yay');_emberMetalCore.default.TEMPLATES['sample/inner2'] = _emberTemplateCompiler.compile('Boo');Router.map(function(){this.route('sample',{path:'/'},function(){this.route('inner',{path:'/'});this.route('inner2',{path:'/2'});});});bootApplication();equal(_emberMetalCore.default.$('#qunit-fixture').text(),'HiBye','initial render');_emberMetalCore.default.run(function(){container.lookup('controller:sample').set('showTheThing',true);});equal(_emberMetalCore.default.$('#qunit-fixture').text(),'HiYayBye','second render');handleURL('/2');equal(_emberMetalCore.default.$('#qunit-fixture').text(),'HiBooBye','third render');});QUnit.test('Can rerender application view multiple times when it contains an outlet',function(){_emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('App{{outlet}}');_emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('Hello world');registry.register('view:application',_emberViewsViewsView.default.extend({elementId:'im-special'}));bootApplication();equal(_emberMetalCore.default.$('#qunit-fixture').text(),'AppHello world','initial render');_emberMetalCore.default.run(function(){_emberViewsViewsView.default.views['im-special'].rerender();});equal(_emberMetalCore.default.$('#qunit-fixture').text(),'AppHello world','second render');_emberMetalCore.default.run(function(){_emberViewsViewsView.default.views['im-special'].rerender();});equal(_emberMetalCore.default.$('#qunit-fixture').text(),'AppHello world','third render');});QUnit.test('Can render into a named outlet at the top level',function(){_emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('A-{{outlet}}-B-{{outlet "other"}}-C');_emberMetalCore.default.TEMPLATES.modal = _emberTemplateCompiler.compile('Hello world');_emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('The index');registry.register('route:application',_emberMetalCore.default.Route.extend({renderTemplate:function(){this.render();this.render('modal',{into:'application',outlet:'other'});}}));bootApplication();equal(_emberMetalCore.default.$('#qunit-fixture').text(),'A-The index-B-Hello world-C','initial render');});QUnit.test('Can disconnect a named outlet at the top level',function(){_emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('A-{{outlet}}-B-{{outlet "other"}}-C');_emberMetalCore.default.TEMPLATES.modal = _emberTemplateCompiler.compile('Hello world');_emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('The index');registry.register('route:application',_emberMetalCore.default.Route.extend({renderTemplate:function(){this.render();this.render('modal',{into:'application',outlet:'other'});},actions:{banish:function(){this.disconnectOutlet({parentView:'application',outlet:'other'});}}}));bootApplication();equal(_emberMetalCore.default.$('#qunit-fixture').text(),'A-The index-B-Hello world-C','initial render');_emberMetalCore.default.run(router,'send','banish');equal(_emberMetalCore.default.$('#qunit-fixture').text(),'A-The index-B--C','second render');});QUnit.test('Can render into a named outlet at the top level, with empty main outlet',function(){_emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('A-{{outlet}}-B-{{outlet "other"}}-C');_emberMetalCore.default.TEMPLATES.modal = _emberTemplateCompiler.compile('Hello world');Router.map(function(){this.route('hasNoTemplate',{path:'/'});});registry.register('route:application',_emberMetalCore.default.Route.extend({renderTemplate:function(){this.render();this.render('modal',{into:'application',outlet:'other'});}}));bootApplication();equal(_emberMetalCore.default.$('#qunit-fixture').text(),'A--B-Hello world-C','initial render');});QUnit.test('Can render into a named outlet at the top level, later',function(){_emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('A-{{outlet}}-B-{{outlet "other"}}-C');_emberMetalCore.default.TEMPLATES.modal = _emberTemplateCompiler.compile('Hello world');_emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('The index');registry.register('route:application',_emberMetalCore.default.Route.extend({actions:{launch:function(){this.render('modal',{into:'application',outlet:'other'});}}}));bootApplication();equal(_emberMetalCore.default.$('#qunit-fixture').text(),'A-The index-B--C','initial render');_emberMetalCore.default.run(router,'send','launch');equal(_emberMetalCore.default.$('#qunit-fixture').text(),'A-The index-B-Hello world-C','second render');});QUnit.test('Can render routes with no \'main\' outlet and their children',function(){_emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('<div id="application">{{outlet "app"}}</div>');_emberMetalCore.default.TEMPLATES.app = _emberTemplateCompiler.compile('<div id="app-common">{{outlet "common"}}</div><div id="app-sub">{{outlet "sub"}}</div>');_emberMetalCore.default.TEMPLATES.common = _emberTemplateCompiler.compile('<div id="common"></div>');_emberMetalCore.default.TEMPLATES.sub = _emberTemplateCompiler.compile('<div id="sub"></div>');Router.map(function(){this.route('app',{path:'/app'},function(){this.route('sub',{path:'/sub',resetNamespace:true});});});App.AppRoute = _emberMetalCore.default.Route.extend({renderTemplate:function(){this.render('app',{outlet:'app',into:'application'});this.render('common',{outlet:'common',into:'app'});}});App.SubRoute = _emberMetalCore.default.Route.extend({renderTemplate:function(){this.render('sub',{outlet:'sub',into:'app'});}});bootApplication();handleURL('/app');equal(_emberMetalCore.default.$('#app-common #common').length,1,'Finds common while viewing /app');handleURL('/app/sub');equal(_emberMetalCore.default.$('#app-common #common').length,1,'Finds common while viewing /app/sub');equal(_emberMetalCore.default.$('#app-sub #sub').length,1,'Finds sub while viewing /app/sub');});QUnit.test('Tolerates stacked renders',function(){_emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('{{outlet}}{{outlet "modal"}}');_emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('hi');_emberMetalCore.default.TEMPLATES.layer = _emberTemplateCompiler.compile('layer');App.ApplicationRoute = _emberMetalCore.default.Route.extend({actions:{openLayer:function(){this.render('layer',{into:'application',outlet:'modal'});},close:function(){this.disconnectOutlet({outlet:'modal',parentView:'application'});}}});bootApplication();equal(trim(_emberMetalCore.default.$('#qunit-fixture').text()),'hi');_emberMetalCore.default.run(router,'send','openLayer');equal(trim(_emberMetalCore.default.$('#qunit-fixture').text()),'hilayer');_emberMetalCore.default.run(router,'send','openLayer');equal(trim(_emberMetalCore.default.$('#qunit-fixture').text()),'hilayer');_emberMetalCore.default.run(router,'send','close');equal(trim(_emberMetalCore.default.$('#qunit-fixture').text()),'hi');});QUnit.test('Renders child into parent with non-default template name',function(){_emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('<div class="a">{{outlet}}</div>');_emberMetalCore.default.TEMPLATES['exports/root'] = _emberTemplateCompiler.compile('<div class="b">{{outlet}}</div>');_emberMetalCore.default.TEMPLATES['exports/index'] = _emberTemplateCompiler.compile('<div class="c"></div>');Router.map(function(){this.route('root',function(){});});App.RootRoute = _emberMetalCore.default.Route.extend({renderTemplate:function(){this.render('exports/root');}});App.RootIndexRoute = _emberMetalCore.default.Route.extend({renderTemplate:function(){this.render('exports/index');}});bootApplication();handleURL('/root');equal(_emberMetalCore.default.$('#qunit-fixture .a .b .c').length,1);});QUnit.test('Allows any route to disconnectOutlet another route\'s templates',function(){_emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('{{outlet}}{{outlet "modal"}}');_emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('hi');_emberMetalCore.default.TEMPLATES.layer = _emberTemplateCompiler.compile('layer');App.ApplicationRoute = _emberMetalCore.default.Route.extend({actions:{openLayer:function(){this.render('layer',{into:'application',outlet:'modal'});}}});App.IndexRoute = _emberMetalCore.default.Route.extend({actions:{close:function(){this.disconnectOutlet({parentView:'application',outlet:'modal'});}}});bootApplication();equal(trim(_emberMetalCore.default.$('#qunit-fixture').text()),'hi');_emberMetalCore.default.run(router,'send','openLayer');equal(trim(_emberMetalCore.default.$('#qunit-fixture').text()),'hilayer');_emberMetalCore.default.run(router,'send','close');equal(trim(_emberMetalCore.default.$('#qunit-fixture').text()),'hi');});QUnit.test('Can this.render({into:...}) the render helper',function(){_emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('{{render "foo"}}');_emberMetalCore.default.TEMPLATES.foo = _emberTemplateCompiler.compile('<div class="foo">{{outlet}}</div>');_emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('other');_emberMetalCore.default.TEMPLATES.bar = _emberTemplateCompiler.compile('bar');App.IndexRoute = _emberMetalCore.default.Route.extend({renderTemplate:function(){this.render({into:'foo'});},actions:{changeToBar:function(){this.disconnectOutlet({parentView:'foo',outlet:'main'});this.render('bar',{into:'foo'});}}});bootApplication();equal(_emberMetalCore.default.$('#qunit-fixture .foo').text(),'other');_emberMetalCore.default.run(router,'send','changeToBar');equal(_emberMetalCore.default.$('#qunit-fixture .foo').text(),'bar');});QUnit.test('Can disconnect from the render helper',function(){_emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('{{render "foo"}}');_emberMetalCore.default.TEMPLATES.foo = _emberTemplateCompiler.compile('<div class="foo">{{outlet}}</div>');_emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('other');App.IndexRoute = _emberMetalCore.default.Route.extend({renderTemplate:function(){this.render({into:'foo'});},actions:{disconnect:function(){this.disconnectOutlet({parentView:'foo',outlet:'main'});}}});bootApplication();equal(_emberMetalCore.default.$('#qunit-fixture .foo').text(),'other');_emberMetalCore.default.run(router,'send','disconnect');equal(_emberMetalCore.default.$('#qunit-fixture .foo').text(),'');});QUnit.test('Can this.render({into:...}) the render helper\'s children',function(){_emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('{{render "foo"}}');_emberMetalCore.default.TEMPLATES.foo = _emberTemplateCompiler.compile('<div class="foo">{{outlet}}</div>');_emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('<div class="index">{{outlet}}</div>');_emberMetalCore.default.TEMPLATES.other = _emberTemplateCompiler.compile('other');_emberMetalCore.default.TEMPLATES.bar = _emberTemplateCompiler.compile('bar');App.IndexRoute = _emberMetalCore.default.Route.extend({renderTemplate:function(){this.render({into:'foo'});this.render('other',{into:'index'});},actions:{changeToBar:function(){this.disconnectOutlet({parentView:'index',outlet:'main'});this.render('bar',{into:'index'});}}});bootApplication();equal(_emberMetalCore.default.$('#qunit-fixture .foo .index').text(),'other');_emberMetalCore.default.run(router,'send','changeToBar');equal(_emberMetalCore.default.$('#qunit-fixture .foo .index').text(),'bar');});QUnit.test('Can disconnect from the render helper\'s children',function(){_emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('{{render "foo"}}');_emberMetalCore.default.TEMPLATES.foo = _emberTemplateCompiler.compile('<div class="foo">{{outlet}}</div>');_emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('<div class="index">{{outlet}}</div>');_emberMetalCore.default.TEMPLATES.other = _emberTemplateCompiler.compile('other');App.IndexRoute = _emberMetalCore.default.Route.extend({renderTemplate:function(){this.render({into:'foo'});this.render('other',{into:'index'});},actions:{disconnect:function(){this.disconnectOutlet({parentView:'index',outlet:'main'});}}});bootApplication();equal(_emberMetalCore.default.$('#qunit-fixture .foo .index').text(),'other');_emberMetalCore.default.run(router,'send','disconnect');equal(_emberMetalCore.default.$('#qunit-fixture .foo .index').text(),'');});QUnit.test('Can this.render({into:...}) nested render helpers',function(){_emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('{{render "foo"}}');_emberMetalCore.default.TEMPLATES.foo = _emberTemplateCompiler.compile('<div class="foo">{{render "bar"}}</div>');_emberMetalCore.default.TEMPLATES.bar = _emberTemplateCompiler.compile('<div class="bar">{{outlet}}</div>');_emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('other');_emberMetalCore.default.TEMPLATES.baz = _emberTemplateCompiler.compile('baz');App.IndexRoute = _emberMetalCore.default.Route.extend({renderTemplate:function(){this.render({into:'bar'});},actions:{changeToBaz:function(){this.disconnectOutlet({parentView:'bar',outlet:'main'});this.render('baz',{into:'bar'});}}});bootApplication();equal(_emberMetalCore.default.$('#qunit-fixture .bar').text(),'other');_emberMetalCore.default.run(router,'send','changeToBaz');equal(_emberMetalCore.default.$('#qunit-fixture .bar').text(),'baz');});QUnit.test('Can disconnect from nested render helpers',function(){_emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('{{render "foo"}}');_emberMetalCore.default.TEMPLATES.foo = _emberTemplateCompiler.compile('<div class="foo">{{render "bar"}}</div>');_emberMetalCore.default.TEMPLATES.bar = _emberTemplateCompiler.compile('<div class="bar">{{outlet}}</div>');_emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('other');App.IndexRoute = _emberMetalCore.default.Route.extend({renderTemplate:function(){this.render({into:'bar'});},actions:{disconnect:function(){this.disconnectOutlet({parentView:'bar',outlet:'main'});}}});bootApplication();equal(_emberMetalCore.default.$('#qunit-fixture .bar').text(),'other');_emberMetalCore.default.run(router,'send','disconnect');equal(_emberMetalCore.default.$('#qunit-fixture .bar').text(),'');});QUnit.test('Can render with layout',function(){_emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('{{outlet}}');_emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('index-template');_emberMetalCore.default.TEMPLATES['my-layout'] = _emberTemplateCompiler.compile('my-layout [{{yield}}]');App.IndexView = _emberViewsViewsView.default.extend({layoutName:'my-layout'});bootApplication();equal(_emberMetalCore.default.$('#qunit-fixture').text(),'my-layout [index-template]');});QUnit.test('Components inside an outlet have their didInsertElement hook invoked when the route is displayed',function(assert){_emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('{{#if showFirst}}{{my-component}}{{else}}{{other-component}}{{/if}}');var myComponentCounter=0;var otherComponentCounter=0;var indexController;App.IndexController = _emberMetalCore.default.Controller.extend({showFirst:true});App.IndexRoute = _emberMetalCore.default.Route.extend({setupController:function(controller){indexController = controller;}});App.MyComponentComponent = _emberMetalCore.default.Component.extend({didInsertElement:function(){myComponentCounter++;}});App.OtherComponentComponent = _emberMetalCore.default.Component.extend({didInsertElement:function(){otherComponentCounter++;}});bootApplication();assert.strictEqual(myComponentCounter,1,'didInsertElement invoked on displayed component');assert.strictEqual(otherComponentCounter,0,'didInsertElement not invoked on displayed component');_emberMetalCore.default.run(function(){indexController.set('showFirst',false);});assert.strictEqual(myComponentCounter,1,'didInsertElement not invoked on displayed component');assert.strictEqual(otherComponentCounter,1,'didInsertElement invoked on displayed component');});QUnit.test('Exception if outlet name is undefined in render and disconnectOutlet',function(assert){App.ApplicationRoute = _emberMetalCore.default.Route.extend({actions:{showModal:function(){this.render({outlet:undefined,parentView:'application'});},hideModal:function(){this.disconnectOutlet({outlet:undefined,parentView:'application'});}}});bootApplication();throws(function(){_emberMetalCore.default.run(function(){router.send('showModal');});},/You passed undefined as the outlet name/);throws(function(){_emberMetalCore.default.run(function(){router.send('hideModal');});},/You passed undefined as the outlet name/);});});
enifed('ember/tests/routing/basic_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember/tests/routing');
  test('ember/tests/routing/basic_test.js should pass jscs', function () {
    ok(true, 'ember/tests/routing/basic_test.js should pass jscs.');
  });
});
enifed('ember/tests/routing/basic_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember/tests/routing');
  QUnit.test('ember/tests/routing/basic_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember/tests/routing/basic_test.js should pass jshint.');
  });
});
enifed('ember/tests/routing/query_params_test', ['exports', 'ember', 'ember-metal/core', 'ember-metal/features', 'ember-metal/computed', 'ember-template-compiler'], function (exports, _ember, _emberMetalCore, _emberMetalFeatures, _emberMetalComputed, _emberTemplateCompiler) {
  'use strict';

  var Router, App, router, registry, container;
  var get = _emberMetalCore.default.get;

  function bootApplication() {
    router = container.lookup('router:main');
    _emberMetalCore.default.run(App, 'advanceReadiness');
  }

  function handleURL(path) {
    return _emberMetalCore.default.run(function () {
      return router.handleURL(path).then(function (value) {
        ok(true, 'url: `' + path + '` was handled');
        return value;
      }, function (reason) {
        ok(false, 'failed to visit:`' + path + '` reason: `' + QUnit.jsDump.parse(reason));
        throw reason;
      });
    });
  }

  var startingURL = '';
  var expectedReplaceURL, expectedPushURL;

  function setAndFlush(obj, prop, value) {
    _emberMetalCore.default.run(obj, 'set', prop, value);
  }

  var TestLocation = _emberMetalCore.default.NoneLocation.extend({
    initState: function () {
      this.set('path', startingURL);
    },

    setURL: function (path) {
      if (expectedReplaceURL) {
        ok(false, 'pushState occurred but a replaceState was expected');
      }
      if (expectedPushURL) {
        equal(path, expectedPushURL, 'an expected pushState occurred');
        expectedPushURL = null;
      }
      this.set('path', path);
    },

    replaceURL: function (path) {
      if (expectedPushURL) {
        ok(false, 'replaceState occurred but a pushState was expected');
      }
      if (expectedReplaceURL) {
        equal(path, expectedReplaceURL, 'an expected replaceState occurred');
        expectedReplaceURL = null;
      }
      this.set('path', path);
    }
  });

  function sharedSetup() {
    _emberMetalCore.default.run(function () {
      App = _emberMetalCore.default.Application.create({
        name: 'App',
        rootElement: '#qunit-fixture'
      });

      App.deferReadiness();

      registry = App.registry;
      container = App.__container__;

      registry.register('location:test', TestLocation);

      startingURL = expectedReplaceURL = expectedPushURL = '';

      App.Router.reopen({
        location: 'test'
      });

      Router = App.Router;

      App.LoadingRoute = _emberMetalCore.default.Route.extend({});

      _emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('{{outlet}}');
      _emberMetalCore.default.TEMPLATES.home = _emberTemplateCompiler.compile('<h3>Hours</h3>');
    });
  }

  function sharedTeardown() {
    _emberMetalCore.default.run(function () {
      App.destroy();
      App = null;

      _emberMetalCore.default.TEMPLATES = {};
    });
  }

  QUnit.module('Routing with Query Params', {
    setup: function () {
      sharedSetup();
    },

    teardown: function () {
      sharedTeardown();
    }
  });

  QUnit.test('Single query params can be set on the controller [DEPRECATED]', function () {
    Router.map(function () {
      this.route('home', { path: '/' });
    });

    App.HomeController = _emberMetalCore.default.Controller.extend({
      queryParams: ['foo'],
      foo: '123'
    });

    bootApplication();

    var controller = container.lookup('controller:home');

    setAndFlush(controller, 'foo', '456');

    equal(router.get('location.path'), '/?foo=456');

    setAndFlush(controller, 'foo', '987');
    equal(router.get('location.path'), '/?foo=987');
  });

  QUnit.test('Single query params can be set on the controller [DEPRECATED]', function () {
    Router.map(function () {
      this.route('home', { path: '/' });
    });

    App.HomeController = _emberMetalCore.default.Controller.extend({
      queryParams: ['foo'],
      foo: '123'
    });

    bootApplication();

    var controller = container.lookup('controller:home');

    setAndFlush(controller, 'foo', '456');

    equal(router.get('location.path'), '/?foo=456');

    setAndFlush(controller, 'foo', '987');
    equal(router.get('location.path'), '/?foo=987');
  });

  QUnit.test('Query params can map to different url keys configured on the controller [DEPRECATED]', function () {
    App.IndexController = _emberMetalCore.default.Controller.extend({
      queryParams: [{ foo: 'other_foo', bar: { as: 'other_bar' } }],
      foo: 'FOO',
      bar: 'BAR'
    });

    bootApplication();
    equal(router.get('location.path'), '');

    var controller = container.lookup('controller:index');
    setAndFlush(controller, 'foo', 'LEX');

    equal(router.get('location.path'), '/?other_foo=LEX');
    setAndFlush(controller, 'foo', 'WOO');
    equal(router.get('location.path'), '/?other_foo=WOO');

    _emberMetalCore.default.run(router, 'transitionTo', '/?other_foo=NAW');
    equal(controller.get('foo'), 'NAW');

    setAndFlush(controller, 'bar', 'NERK');
    _emberMetalCore.default.run(router, 'transitionTo', '/?other_bar=NERK&other_foo=NAW');
  });

  QUnit.test('Routes have overridable serializeQueryParamKey hook', function () {
    App.IndexRoute = _emberMetalCore.default.Route.extend({
      serializeQueryParamKey: _emberMetalCore.default.String.dasherize
    });

    App.IndexController = _emberMetalCore.default.Controller.extend({
      queryParams: 'funTimes',
      funTimes: ''
    });

    bootApplication();
    equal(router.get('location.path'), '');

    var controller = container.lookup('controller:index');
    setAndFlush(controller, 'funTimes', 'woot');

    equal(router.get('location.path'), '/?fun-times=woot');
  });

  QUnit.test('No replaceURL occurs on startup because default values don\'t show up in URL', function () {
    expect(0);

    App.IndexController = _emberMetalCore.default.Controller.extend({
      queryParams: ['foo'],
      foo: '123'
    });

    expectedReplaceURL = '/?foo=123';

    bootApplication();
  });

  QUnit.test('Can override inherited QP behavior by specifying queryParams as a computed property', function () {
    expect(0);
    var SharedMixin = _emberMetalCore.default.Mixin.create({
      queryParams: ['a'],
      a: 0
    });

    App.IndexController = _emberMetalCore.default.Controller.extend(SharedMixin, {
      queryParams: _emberMetalComputed.computed(function () {
        return ['c'];
      }),
      c: true
    });

    bootApplication();
    var indexController = container.lookup('controller:index');

    expectedReplaceURL = 'not gonna happen';
    _emberMetalCore.default.run(indexController, 'set', 'a', 1);
  });

  QUnit.test('model hooks receives query params', function () {
    App.IndexController = _emberMetalCore.default.Controller.extend({
      queryParams: ['omg'],
      omg: 'lol'
    });

    App.IndexRoute = _emberMetalCore.default.Route.extend({
      model: function (params) {
        deepEqual(params, { omg: 'lol' });
      }
    });

    bootApplication();

    equal(router.get('location.path'), '');
  });

  QUnit.test('controllers won\'t be eagerly instantiated by internal query params logic', function () {
    expect(10);
    Router.map(function () {
      this.route('cats', function () {
        this.route('index', { path: '/' });
      });
      this.route('home', { path: '/' });
      this.route('about');
    });

    _emberMetalCore.default.TEMPLATES.home = _emberTemplateCompiler.compile('<h3>{{link-to \'About\' \'about\' (query-params lol=\'wat\') id=\'link-to-about\'}}</h3>');
    _emberMetalCore.default.TEMPLATES.about = _emberTemplateCompiler.compile('<h3>{{link-to \'Home\' \'home\'  (query-params foo=\'naw\')}}</h3>');
    _emberMetalCore.default.TEMPLATES['cats/index'] = _emberTemplateCompiler.compile('<h3>{{link-to \'Cats\' \'cats\'  (query-params name=\'domino\') id=\'cats-link\'}}</h3>');

    var homeShouldBeCreated = false;
    var aboutShouldBeCreated = false;
    var catsIndexShouldBeCreated = false;

    App.HomeRoute = _emberMetalCore.default.Route.extend({
      setup: function () {
        homeShouldBeCreated = true;
        this._super.apply(this, arguments);
      }
    });

    App.HomeController = _emberMetalCore.default.Controller.extend({
      queryParams: ['foo'],
      foo: '123',
      init: function () {
        this._super.apply(this, arguments);
        ok(homeShouldBeCreated, 'HomeController should be created at this time');
      }
    });

    App.AboutRoute = _emberMetalCore.default.Route.extend({
      setup: function () {
        aboutShouldBeCreated = true;
        this._super.apply(this, arguments);
      }
    });

    App.AboutController = _emberMetalCore.default.Controller.extend({
      queryParams: ['lol'],
      lol: 'haha',
      init: function () {
        this._super.apply(this, arguments);
        ok(aboutShouldBeCreated, 'AboutController should be created at this time');
      }
    });

    App.CatsIndexRoute = _emberMetalCore.default.Route.extend({
      model: function () {
        return [];
      },
      setup: function () {
        catsIndexShouldBeCreated = true;
        this._super.apply(this, arguments);
      },
      setupController: function (controller, context) {
        controller.set('model', context);
      }
    });

    App.CatsIndexController = _emberMetalCore.default.Controller.extend({
      queryParams: ['breed', 'name'],
      breed: 'Golden',
      name: null,
      init: function () {
        this._super.apply(this, arguments);
        ok(catsIndexShouldBeCreated, 'CatsIndexController should be created at this time');
      }
    });

    bootApplication();

    equal(router.get('location.path'), '', 'url is correct');
    var controller = container.lookup('controller:home');
    setAndFlush(controller, 'foo', '456');
    equal(router.get('location.path'), '/?foo=456', 'url is correct');
    equal(_emberMetalCore.default.$('#link-to-about').attr('href'), '/about?lol=wat', 'link to about is correct');

    _emberMetalCore.default.run(router, 'transitionTo', 'about');
    equal(router.get('location.path'), '/about', 'url is correct');

    _emberMetalCore.default.run(router, 'transitionTo', 'cats');

    equal(router.get('location.path'), '/cats', 'url is correct');
    equal(_emberMetalCore.default.$('#cats-link').attr('href'), '/cats?name=domino', 'link to cats is correct');
    _emberMetalCore.default.run(_emberMetalCore.default.$('#cats-link'), 'click');
    equal(router.get('location.path'), '/cats?name=domino', 'url is correct');
  });

  QUnit.test('query params have been set by the time setupController is called', function () {
    expect(1);

    App.ApplicationController = _emberMetalCore.default.Controller.extend({
      queryParams: ['foo'],
      foo: 'wat'
    });

    App.ApplicationRoute = _emberMetalCore.default.Route.extend({
      setupController: function (controller) {
        equal(controller.get('foo'), 'YEAH', 'controller\'s foo QP property set before setupController called');
      }
    });

    startingURL = '/?foo=YEAH';
    bootApplication();
  });

  QUnit.test('model hooks receives query params (overridden by incoming url value)', function () {
    App.IndexController = _emberMetalCore.default.Controller.extend({
      queryParams: ['omg'],
      omg: 'lol'
    });

    App.IndexRoute = _emberMetalCore.default.Route.extend({
      model: function (params) {
        deepEqual(params, { omg: 'yes' });
      }
    });

    startingURL = '/?omg=yes';
    bootApplication();

    equal(router.get('location.path'), '/?omg=yes');
  });

  QUnit.test('Route#paramsFor fetches query params', function () {
    expect(1);

    Router.map(function () {
      this.route('index', { path: '/:something' });
    });

    App.IndexController = _emberMetalCore.default.Controller.extend({
      queryParams: ['foo'],
      foo: 'fooapp'
    });

    App.IndexRoute = _emberMetalCore.default.Route.extend({
      model: function (params, transition) {
        deepEqual(this.paramsFor('index'), { something: 'omg', foo: 'fooapp' }, 'could retrieve params for index');
      }
    });

    startingURL = '/omg';
    bootApplication();
  });

  QUnit.test('model hook can query prefix-less application params (overridden by incoming url value)', function () {
    App.ApplicationController = _emberMetalCore.default.Controller.extend({
      queryParams: ['appomg'],
      appomg: 'applol'
    });

    App.IndexController = _emberMetalCore.default.Controller.extend({
      queryParams: ['omg'],
      omg: 'lol'
    });

    App.ApplicationRoute = _emberMetalCore.default.Route.extend({
      model: function (params) {
        deepEqual(params, { appomg: 'appyes' });
      }
    });

    App.IndexRoute = _emberMetalCore.default.Route.extend({
      model: function (params) {
        deepEqual(params, { omg: 'yes' });
        deepEqual(this.paramsFor('application'), { appomg: 'appyes' });
      }
    });

    startingURL = '/?appomg=appyes&omg=yes';
    bootApplication();

    equal(router.get('location.path'), '/?appomg=appyes&omg=yes');
  });

  QUnit.test('Route#paramsFor fetches falsy query params', function () {
    expect(1);

    App.IndexController = _emberMetalCore.default.Controller.extend({
      queryParams: ['foo'],
      foo: true
    });

    App.IndexRoute = _emberMetalCore.default.Route.extend({
      model: function (params, transition) {
        equal(params.foo, false);
      }
    });

    startingURL = '/?foo=false';
    bootApplication();
  });

  QUnit.test('model hook can query prefix-less application params', function () {
    App.ApplicationController = _emberMetalCore.default.Controller.extend({
      queryParams: ['appomg'],
      appomg: 'applol'
    });

    App.IndexController = _emberMetalCore.default.Controller.extend({
      queryParams: ['omg'],
      omg: 'lol'
    });

    App.ApplicationRoute = _emberMetalCore.default.Route.extend({
      model: function (params) {
        deepEqual(params, { appomg: 'applol' });
      }
    });

    App.IndexRoute = _emberMetalCore.default.Route.extend({
      model: function (params) {
        deepEqual(params, { omg: 'lol' });
        deepEqual(this.paramsFor('application'), { appomg: 'applol' });
      }
    });

    bootApplication();

    equal(router.get('location.path'), '');
  });

  QUnit.test('can opt into full transition by setting refreshModel in route queryParams', function () {
    expect(6);
    App.ApplicationController = _emberMetalCore.default.Controller.extend({
      queryParams: ['appomg'],
      appomg: 'applol'
    });

    App.IndexController = _emberMetalCore.default.Controller.extend({
      queryParams: ['omg'],
      omg: 'lol'
    });

    var appModelCount = 0;
    App.ApplicationRoute = _emberMetalCore.default.Route.extend({
      model: function (params) {
        appModelCount++;
      }
    });

    var indexModelCount = 0;
    App.IndexRoute = _emberMetalCore.default.Route.extend({
      queryParams: {
        omg: {
          refreshModel: true
        }
      },
      model: function (params) {
        indexModelCount++;

        if (indexModelCount === 1) {
          deepEqual(params, { omg: 'lol' });
        } else if (indexModelCount === 2) {
          deepEqual(params, { omg: 'lex' });
        }
      }
    });

    bootApplication();

    equal(appModelCount, 1);
    equal(indexModelCount, 1);

    var indexController = container.lookup('controller:index');
    setAndFlush(indexController, 'omg', 'lex');

    equal(appModelCount, 1);
    equal(indexModelCount, 2);
  });

  QUnit.test('Use Ember.get to retrieve query params \'refreshModel\' configuration', function () {
    expect(6);
    App.ApplicationController = _emberMetalCore.default.Controller.extend({
      queryParams: ['appomg'],
      appomg: 'applol'
    });

    App.IndexController = _emberMetalCore.default.Controller.extend({
      queryParams: ['omg'],
      omg: 'lol'
    });

    var appModelCount = 0;
    App.ApplicationRoute = _emberMetalCore.default.Route.extend({
      model: function (params) {
        appModelCount++;
      }
    });

    var indexModelCount = 0;
    App.IndexRoute = _emberMetalCore.default.Route.extend({
      queryParams: _emberMetalCore.default.Object.create({
        unknownProperty: function (keyName) {
          return { refreshModel: true };
        }
      }),
      model: function (params) {
        indexModelCount++;

        if (indexModelCount === 1) {
          deepEqual(params, { omg: 'lol' });
        } else if (indexModelCount === 2) {
          deepEqual(params, { omg: 'lex' });
        }
      }
    });

    bootApplication();

    equal(appModelCount, 1);
    equal(indexModelCount, 1);

    var indexController = container.lookup('controller:index');
    setAndFlush(indexController, 'omg', 'lex');

    equal(appModelCount, 1);
    equal(indexModelCount, 2);
  });

  QUnit.test('can use refreshModel even w URL changes that remove QPs from address bar', function () {
    expect(4);

    App.IndexController = _emberMetalCore.default.Controller.extend({
      queryParams: ['omg'],
      omg: 'lol'
    });

    var indexModelCount = 0;
    App.IndexRoute = _emberMetalCore.default.Route.extend({
      queryParams: {
        omg: {
          refreshModel: true
        }
      },
      model: function (params) {
        indexModelCount++;

        var data;
        if (indexModelCount === 1) {
          data = 'foo';
        } else if (indexModelCount === 2) {
          data = 'lol';
        }

        deepEqual(params, { omg: data }, 'index#model receives right data');
      }
    });

    startingURL = '/?omg=foo';
    bootApplication();
    handleURL('/');

    var indexController = container.lookup('controller:index');
    equal(indexController.get('omg'), 'lol');
  });

  QUnit.test('can opt into a replace query by specifying replace:true in the Router config hash', function () {
    expect(2);
    App.ApplicationController = _emberMetalCore.default.Controller.extend({
      queryParams: ['alex'],
      alex: 'matchneer'
    });

    App.ApplicationRoute = _emberMetalCore.default.Route.extend({
      queryParams: {
        alex: {
          replace: true
        }
      }
    });

    bootApplication();

    equal(router.get('location.path'), '');

    var appController = container.lookup('controller:application');
    expectedReplaceURL = '/?alex=wallace';
    setAndFlush(appController, 'alex', 'wallace');
  });

  QUnit.test('Route query params config can be configured using property name instead of URL key', function () {
    expect(2);
    App.ApplicationController = _emberMetalCore.default.Controller.extend({
      queryParams: [{ commitBy: 'commit_by' }]
    });

    App.ApplicationRoute = _emberMetalCore.default.Route.extend({
      queryParams: {
        commitBy: {
          replace: true
        }
      }
    });

    bootApplication();

    equal(router.get('location.path'), '');

    var appController = container.lookup('controller:application');
    expectedReplaceURL = '/?commit_by=igor_seb';
    setAndFlush(appController, 'commitBy', 'igor_seb');
  });

  QUnit.test('An explicit replace:false on a changed QP always wins and causes a pushState', function () {
    expect(3);
    App.ApplicationController = _emberMetalCore.default.Controller.extend({
      queryParams: ['alex', 'steely'],
      alex: 'matchneer',
      steely: 'dan'
    });

    App.ApplicationRoute = _emberMetalCore.default.Route.extend({
      queryParams: {
        alex: {
          replace: true
        },
        steely: {
          replace: false
        }
      }
    });

    bootApplication();

    var appController = container.lookup('controller:application');
    expectedPushURL = '/?alex=wallace&steely=jan';
    _emberMetalCore.default.run(appController, 'setProperties', { alex: 'wallace', steely: 'jan' });

    expectedPushURL = '/?alex=wallace&steely=fran';
    _emberMetalCore.default.run(appController, 'setProperties', { steely: 'fran' });

    expectedReplaceURL = '/?alex=sriracha&steely=fran';
    _emberMetalCore.default.run(appController, 'setProperties', { alex: 'sriracha' });
  });

  QUnit.test('can opt into full transition by setting refreshModel in route queryParams when transitioning from child to parent', function () {
    _emberMetalCore.default.TEMPLATES.parent = _emberTemplateCompiler.compile('{{outlet}}');
    _emberMetalCore.default.TEMPLATES['parent/child'] = _emberTemplateCompiler.compile('{{link-to \'Parent\' \'parent\' (query-params foo=\'change\') id=\'parent-link\'}}');

    App.Router.map(function () {
      this.route('parent', function () {
        this.route('child');
      });
    });

    var parentModelCount = 0;
    App.ParentRoute = _emberMetalCore.default.Route.extend({
      model: function () {
        parentModelCount++;
      },
      queryParams: {
        foo: {
          refreshModel: true
        }
      }
    });

    App.ParentController = _emberMetalCore.default.Controller.extend({
      queryParams: ['foo'],
      foo: 'abc'
    });

    startingURL = '/parent/child?foo=lol';
    bootApplication();

    equal(parentModelCount, 1);

    container.lookup('controller:parent');

    _emberMetalCore.default.run(_emberMetalCore.default.$('#parent-link'), 'click');

    equal(parentModelCount, 2);
  });

  QUnit.test('Use Ember.get to retrieve query params \'replace\' configuration', function () {
    expect(2);
    App.ApplicationController = _emberMetalCore.default.Controller.extend({
      queryParams: ['alex'],
      alex: 'matchneer'
    });

    App.ApplicationRoute = _emberMetalCore.default.Route.extend({
      queryParams: _emberMetalCore.default.Object.create({
        unknownProperty: function (keyName) {
          // We are simulating all qps requiring refresh
          return { replace: true };
        }
      })
    });

    bootApplication();

    equal(router.get('location.path'), '');

    var appController = container.lookup('controller:application');
    expectedReplaceURL = '/?alex=wallace';
    setAndFlush(appController, 'alex', 'wallace');
  });

  QUnit.test('can override incoming QP values in setupController', function () {
    expect(3);

    App.Router.map(function () {
      this.route('about');
    });

    App.IndexController = _emberMetalCore.default.Controller.extend({
      queryParams: ['omg'],
      omg: 'lol'
    });

    App.IndexRoute = _emberMetalCore.default.Route.extend({
      setupController: function (controller) {
        ok(true, 'setupController called');
        controller.set('omg', 'OVERRIDE');
      },
      actions: {
        queryParamsDidChange: function () {
          ok(false, 'queryParamsDidChange shouldn\'t fire');
        }
      }
    });

    startingURL = '/about';
    bootApplication();
    equal(router.get('location.path'), '/about');
    _emberMetalCore.default.run(router, 'transitionTo', 'index');
    equal(router.get('location.path'), '/?omg=OVERRIDE');
  });

  QUnit.test('can override incoming QP array values in setupController', function () {
    expect(3);

    App.Router.map(function () {
      this.route('about');
    });

    App.IndexController = _emberMetalCore.default.Controller.extend({
      queryParams: ['omg'],
      omg: ['lol']
    });

    App.IndexRoute = _emberMetalCore.default.Route.extend({
      setupController: function (controller) {
        ok(true, 'setupController called');
        controller.set('omg', ['OVERRIDE']);
      },
      actions: {
        queryParamsDidChange: function () {
          ok(false, 'queryParamsDidChange shouldn\'t fire');
        }
      }
    });

    startingURL = '/about';
    bootApplication();
    equal(router.get('location.path'), '/about');
    _emberMetalCore.default.run(router, 'transitionTo', 'index');
    equal(router.get('location.path'), '/?omg=' + encodeURIComponent(JSON.stringify(['OVERRIDE'])));
  });

  QUnit.test('URL transitions that remove QPs still register as QP changes', function () {
    expect(2);

    App.IndexController = _emberMetalCore.default.Controller.extend({
      queryParams: ['omg'],
      omg: 'lol'
    });

    startingURL = '/?omg=borf';
    bootApplication();

    var indexController = container.lookup('controller:index');
    equal(indexController.get('omg'), 'borf');
    _emberMetalCore.default.run(router, 'transitionTo', '/');
    equal(indexController.get('omg'), 'lol');
  });

  QUnit.test('Subresource naming style is supported', function () {

    Router.map(function () {
      this.route('abc.def', { path: '/abcdef' }, function () {
        this.route('zoo');
      });
    });

    _emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('{{link-to \'A\' \'abc.def\' (query-params foo=\'123\') id=\'one\'}}{{link-to \'B\' \'abc.def.zoo\' (query-params foo=\'123\' bar=\'456\') id=\'two\'}}{{outlet}}');

    App.AbcDefController = _emberMetalCore.default.Controller.extend({
      queryParams: ['foo'],
      foo: 'lol'
    });

    App.AbcDefZooController = _emberMetalCore.default.Controller.extend({
      queryParams: ['bar'],
      bar: 'haha'
    });

    bootApplication();
    equal(router.get('location.path'), '');
    equal(_emberMetalCore.default.$('#one').attr('href'), '/abcdef?foo=123');
    equal(_emberMetalCore.default.$('#two').attr('href'), '/abcdef/zoo?bar=456&foo=123');

    _emberMetalCore.default.run(_emberMetalCore.default.$('#one'), 'click');
    equal(router.get('location.path'), '/abcdef?foo=123');
    _emberMetalCore.default.run(_emberMetalCore.default.$('#two'), 'click');
    equal(router.get('location.path'), '/abcdef/zoo?bar=456&foo=123');
  });

  QUnit.test('transitionTo supports query params', function () {
    App.IndexController = _emberMetalCore.default.Controller.extend({
      queryParams: ['foo'],
      foo: 'lol'
    });

    bootApplication();

    equal(router.get('location.path'), '');

    _emberMetalCore.default.run(router, 'transitionTo', { queryParams: { foo: 'borf' } });
    equal(router.get('location.path'), '/?foo=borf', 'shorthand supported');
    _emberMetalCore.default.run(router, 'transitionTo', { queryParams: { 'index:foo': 'blaf' } });
    equal(router.get('location.path'), '/?foo=blaf', 'longform supported');
    _emberMetalCore.default.run(router, 'transitionTo', { queryParams: { 'index:foo': false } });
    equal(router.get('location.path'), '/?foo=false', 'longform supported (bool)');
    _emberMetalCore.default.run(router, 'transitionTo', { queryParams: { foo: false } });
    equal(router.get('location.path'), '/?foo=false', 'shorhand supported (bool)');
  });

  QUnit.test('transitionTo supports query params (multiple)', function () {
    App.IndexController = _emberMetalCore.default.Controller.extend({
      queryParams: ['foo', 'bar'],
      foo: 'lol',
      bar: 'wat'
    });

    bootApplication();

    equal(router.get('location.path'), '');

    _emberMetalCore.default.run(router, 'transitionTo', { queryParams: { foo: 'borf' } });
    equal(router.get('location.path'), '/?foo=borf', 'shorthand supported');
    _emberMetalCore.default.run(router, 'transitionTo', { queryParams: { 'index:foo': 'blaf' } });
    equal(router.get('location.path'), '/?foo=blaf', 'longform supported');
    _emberMetalCore.default.run(router, 'transitionTo', { queryParams: { 'index:foo': false } });
    equal(router.get('location.path'), '/?foo=false', 'longform supported (bool)');
    _emberMetalCore.default.run(router, 'transitionTo', { queryParams: { foo: false } });
    equal(router.get('location.path'), '/?foo=false', 'shorhand supported (bool)');
  });

  QUnit.test('setting controller QP to empty string doesn\'t generate null in URL', function () {
    expect(1);
    App.IndexController = _emberMetalCore.default.Controller.extend({
      queryParams: ['foo'],
      foo: '123'
    });

    bootApplication();
    var controller = container.lookup('controller:index');

    expectedPushURL = '/?foo=';
    setAndFlush(controller, 'foo', '');
  });

  QUnit.test('setting QP to empty string doesn\'t generate null in URL', function () {
    expect(1);
    App.IndexRoute = _emberMetalCore.default.Route.extend({
      queryParams: {
        foo: {
          defaultValue: '123'
        }
      }
    });

    bootApplication();
    var controller = container.lookup('controller:index');

    expectedPushURL = '/?foo=';
    setAndFlush(controller, 'foo', '');
  });

  QUnit.test('A default boolean value deserializes QPs as booleans rather than strings', function () {
    App.IndexController = _emberMetalCore.default.Controller.extend({
      queryParams: ['foo'],
      foo: false
    });

    App.IndexRoute = _emberMetalCore.default.Route.extend({
      model: function (params) {
        equal(params.foo, true, 'model hook received foo as boolean true');
      }
    });

    startingURL = '/?foo=true';
    bootApplication();

    var controller = container.lookup('controller:index');
    equal(controller.get('foo'), true);

    handleURL('/?foo=false');
    equal(controller.get('foo'), false);
  });

  QUnit.test('Query param without value are empty string', function () {
    App.IndexController = _emberMetalCore.default.Controller.extend({
      queryParams: ['foo'],
      foo: ''
    });

    startingURL = '/?foo=';
    bootApplication();

    var controller = container.lookup('controller:index');
    equal(controller.get('foo'), '');
  });

  QUnit.test('Array query params can be set', function () {
    Router.map(function () {
      this.route('home', { path: '/' });
    });

    App.HomeController = _emberMetalCore.default.Controller.extend({
      queryParams: ['foo'],
      foo: []
    });

    bootApplication();

    var controller = container.lookup('controller:home');

    setAndFlush(controller, 'foo', [1, 2]);

    equal(router.get('location.path'), '/?foo=%5B1%2C2%5D');

    setAndFlush(controller, 'foo', [3, 4]);
    equal(router.get('location.path'), '/?foo=%5B3%2C4%5D');
  });

  QUnit.test('(de)serialization: arrays', function () {
    App.IndexController = _emberMetalCore.default.Controller.extend({
      queryParams: ['foo'],
      foo: [1]
    });

    bootApplication();

    equal(router.get('location.path'), '');

    _emberMetalCore.default.run(router, 'transitionTo', { queryParams: { foo: [2, 3] } });
    equal(router.get('location.path'), '/?foo=%5B2%2C3%5D', 'shorthand supported');
    _emberMetalCore.default.run(router, 'transitionTo', { queryParams: { 'index:foo': [4, 5] } });
    equal(router.get('location.path'), '/?foo=%5B4%2C5%5D', 'longform supported');
    _emberMetalCore.default.run(router, 'transitionTo', { queryParams: { foo: [] } });
    equal(router.get('location.path'), '/?foo=%5B%5D', 'longform supported');
  });

  QUnit.test('Url with array query param sets controller property to array', function () {
    App.IndexController = _emberMetalCore.default.Controller.extend({
      queryParams: ['foo'],
      foo: ''
    });

    startingURL = '/?foo[]=1&foo[]=2&foo[]=3';
    bootApplication();

    var controller = container.lookup('controller:index');
    deepEqual(controller.get('foo'), ['1', '2', '3']);
  });

  QUnit.test('Array query params can be pushed/popped', function () {
    Router.map(function () {
      this.route('home', { path: '/' });
    });

    App.HomeController = _emberMetalCore.default.Controller.extend({
      queryParams: ['foo'],
      foo: _emberMetalCore.default.A([])
    });

    bootApplication();

    equal(router.get('location.path'), '');

    var controller = container.lookup('controller:home');

    _emberMetalCore.default.run(controller.foo, 'pushObject', 1);
    equal(router.get('location.path'), '/?foo=%5B1%5D');
    deepEqual(controller.foo, [1]);
    _emberMetalCore.default.run(controller.foo, 'popObject');
    equal(router.get('location.path'), '/');
    deepEqual(controller.foo, []);
    _emberMetalCore.default.run(controller.foo, 'pushObject', 1);
    equal(router.get('location.path'), '/?foo=%5B1%5D');
    deepEqual(controller.foo, [1]);
    _emberMetalCore.default.run(controller.foo, 'popObject');
    equal(router.get('location.path'), '/');
    deepEqual(controller.foo, []);
    _emberMetalCore.default.run(controller.foo, 'pushObject', 1);
    equal(router.get('location.path'), '/?foo=%5B1%5D');
    deepEqual(controller.foo, [1]);
    _emberMetalCore.default.run(controller.foo, 'pushObject', 2);
    equal(router.get('location.path'), '/?foo=%5B1%2C2%5D');
    deepEqual(controller.foo, [1, 2]);
    _emberMetalCore.default.run(controller.foo, 'popObject');
    equal(router.get('location.path'), '/?foo=%5B1%5D');
    deepEqual(controller.foo, [1]);
    _emberMetalCore.default.run(controller.foo, 'unshiftObject', 'lol');
    equal(router.get('location.path'), '/?foo=%5B%22lol%22%2C1%5D');
    deepEqual(controller.foo, ['lol', 1]);
  });

  QUnit.test('Overwriting with array with same content shouldn\'t refire update', function () {
    expect(3);
    var modelCount = 0;

    Router.map(function () {
      this.route('home', { path: '/' });
    });

    App.HomeRoute = _emberMetalCore.default.Route.extend({
      model: function () {
        modelCount++;
      }
    });

    App.HomeController = _emberMetalCore.default.Controller.extend({
      queryParams: ['foo'],
      foo: _emberMetalCore.default.A([1])
    });

    bootApplication();

    equal(modelCount, 1);
    var controller = container.lookup('controller:home');
    setAndFlush(controller, 'model', _emberMetalCore.default.A([1]));
    equal(modelCount, 1);
    equal(router.get('location.path'), '');
  });

  QUnit.test('Defaulting to params hash as the model should not result in that params object being watched', function () {
    expect(1);

    Router.map(function () {
      this.route('other');
    });

    // This causes the params hash, which is returned as a route's
    // model if no other model could be resolved given the provided
    // params (and no custom model hook was defined), to be watched,
    // unless we return a copy of the params hash.
    App.ApplicationController = _emberMetalCore.default.Controller.extend({
      queryParams: ['woot'],
      woot: 'wat'
    });

    App.OtherRoute = _emberMetalCore.default.Route.extend({
      model: function (p, trans) {
        var m = _emberMetalCore.default.meta(trans.params.application);
        ok(!m.watching.woot, 'A meta object isn\'t constructed for this params POJO');
      }
    });

    bootApplication();

    _emberMetalCore.default.run(router, 'transitionTo', 'other');
  });

  QUnit.test('A child of a resource route still defaults to parent route\'s model even if the child route has a query param', function () {
    expect(1);

    App.IndexController = _emberMetalCore.default.Controller.extend({
      queryParams: ['woot']
    });

    App.ApplicationRoute = _emberMetalCore.default.Route.extend({
      model: function (p, trans) {
        return { woot: true };
      }
    });

    App.IndexRoute = _emberMetalCore.default.Route.extend({
      setupController: function (controller, model) {
        deepEqual(model, { woot: true }, 'index route inherited model route from parent route');
      }
    });

    bootApplication();
  });

  QUnit.test('opting into replace does not affect transitions between routes', function () {
    expect(5);
    _emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('{{link-to \'Foo\' \'foo\' id=\'foo-link\'}}' + '{{link-to \'Bar\' \'bar\' id=\'bar-no-qp-link\'}}' + '{{link-to \'Bar\' \'bar\' (query-params raytiley=\'isthebest\') id=\'bar-link\'}}' + '{{outlet}}');
    App.Router.map(function () {
      this.route('foo');
      this.route('bar');
    });

    App.BarController = _emberMetalCore.default.Controller.extend({
      queryParams: ['raytiley'],
      raytiley: 'israd'
    });

    App.BarRoute = _emberMetalCore.default.Route.extend({
      queryParams: {
        raytiley: {
          replace: true
        }
      }
    });

    bootApplication();
    var controller = container.lookup('controller:bar');

    expectedPushURL = '/foo';
    _emberMetalCore.default.run(_emberMetalCore.default.$('#foo-link'), 'click');

    expectedPushURL = '/bar';
    _emberMetalCore.default.run(_emberMetalCore.default.$('#bar-no-qp-link'), 'click');

    expectedReplaceURL = '/bar?raytiley=woot';
    setAndFlush(controller, 'raytiley', 'woot');

    expectedPushURL = '/foo';
    _emberMetalCore.default.run(_emberMetalCore.default.$('#foo-link'), 'click');

    expectedPushURL = '/bar?raytiley=isthebest';
    _emberMetalCore.default.run(_emberMetalCore.default.$('#bar-link'), 'click');
  });

  QUnit.test('Undefined isn\'t deserialized into a string', function () {
    expect(3);
    Router.map(function () {
      this.route('example');
    });

    _emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('{{link-to \'Example\' \'example\' id=\'the-link\'}}');

    App.ExampleController = _emberMetalCore.default.Controller.extend({
      queryParams: ['foo']
      // uncommon to not support default value, but should assume undefined.
    });

    App.ExampleRoute = _emberMetalCore.default.Route.extend({
      model: function (params) {
        deepEqual(params, { foo: undefined });
      }
    });

    bootApplication();

    var $link = _emberMetalCore.default.$('#the-link');
    equal($link.attr('href'), '/example');
    _emberMetalCore.default.run($link, 'click');

    var controller = container.lookup('controller:example');
    equal(get(controller, 'foo'), undefined);
  });

  QUnit.test('warn user that routes query params configuration must be an Object, not an Array', function () {
    expect(1);

    App.ApplicationRoute = _emberMetalCore.default.Route.extend({
      queryParams: [{ commitBy: { replace: true } }]
    });

    expectAssertion(function () {
      bootApplication();
    }, 'You passed in `[{"commitBy":{"replace":true}}]` as the value for `queryParams` but `queryParams` cannot be an Array');
  });

  QUnit.test('handle routes names that clash with Object.prototype properties', function () {
    expect(1);

    Router.map(function () {
      this.route('constructor');
    });

    App.ConstructorRoute = _emberMetalCore.default.Route.extend({
      queryParams: {
        foo: {
          defaultValue: '123'
        }
      }
    });

    bootApplication();

    _emberMetalCore.default.run(router, 'transitionTo', 'constructor', { queryParams: { foo: '999' } });

    var controller = container.lookup('controller:constructor');
    equal(get(controller, 'foo'), '999');
  });
});

// uncommon to not support default value, but should assume undefined.

// This causes the params hash, which is returned as a route's
// model if no other model could be resolved given the provided
// params (and no custom model hook was defined), to be watched,
// unless we return a copy of the params hash.

// uncommon to not support default value, but should assume undefined.
enifed('ember/tests/routing/query_params_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember/tests/routing');
  test('ember/tests/routing/query_params_test.js should pass jscs', function () {
    ok(true, 'ember/tests/routing/query_params_test.js should pass jscs.');
  });
});
enifed('ember/tests/routing/query_params_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember/tests/routing');
  QUnit.test('ember/tests/routing/query_params_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember/tests/routing/query_params_test.js should pass jshint.');
  });
});
enifed('ember/tests/routing/query_params_test/model_dependent_state_with_query_params_test', ['exports', 'ember', 'ember-metal/core', 'ember-metal/features', 'ember-template-compiler'], function (exports, _ember, _emberMetalCore, _emberMetalFeatures, _emberTemplateCompiler) {
  'use strict';

  var Router, App, router, registry, container;

  function bootApplication() {
    router = container.lookup('router:main');
    _emberMetalCore.default.run(App, 'advanceReadiness');
  }

  function handleURL(path) {
    return _emberMetalCore.default.run(function () {
      return router.handleURL(path).then(function (value) {
        ok(true, 'url: `' + path + '` was handled');
        return value;
      }, function (reason) {
        ok(false, 'failed to visit:`' + path + '` reason: `' + QUnit.jsDump.parse(reason));
        throw reason;
      });
    });
  }

  var startingURL = '';
  var expectedReplaceURL, expectedPushURL;

  function setAndFlush(obj, prop, value) {
    _emberMetalCore.default.run(obj, 'set', prop, value);
  }

  var TestLocation = _emberMetalCore.default.NoneLocation.extend({
    initState: function () {
      this.set('path', startingURL);
    },

    setURL: function (path) {
      if (expectedReplaceURL) {
        ok(false, 'pushState occurred but a replaceState was expected');
      }
      if (expectedPushURL) {
        equal(path, expectedPushURL, 'an expected pushState occurred');
        expectedPushURL = null;
      }
      this.set('path', path);
    },

    replaceURL: function (path) {
      if (expectedPushURL) {
        ok(false, 'replaceState occurred but a pushState was expected');
      }
      if (expectedReplaceURL) {
        equal(path, expectedReplaceURL, 'an expected replaceState occurred');
        expectedReplaceURL = null;
      }
      this.set('path', path);
    }
  });

  function sharedSetup() {
    _emberMetalCore.default.run(function () {
      App = _emberMetalCore.default.Application.create({
        name: 'App',
        rootElement: '#qunit-fixture'
      });

      App.deferReadiness();

      registry = App.registry;
      container = App.__container__;

      registry.register('location:test', TestLocation);

      startingURL = expectedReplaceURL = expectedPushURL = '';

      App.Router.reopen({
        location: 'test'
      });

      Router = App.Router;

      App.LoadingRoute = _emberMetalCore.default.Route.extend({});

      _emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('{{outlet}}');
      _emberMetalCore.default.TEMPLATES.home = _emberTemplateCompiler.compile('<h3>Hours</h3>');
    });
  }

  function sharedTeardown() {
    _emberMetalCore.default.run(function () {
      App.destroy();
      App = null;

      _emberMetalCore.default.TEMPLATES = {};
    });
  }

  function queryParamsStickyTest1(urlPrefix) {
    return function () {
      this.boot();

      _emberMetalCore.default.run(this.$link1, 'click');
      equal(router.get('location.path'), urlPrefix + '/a-1');

      setAndFlush(this.controller, 'q', 'lol');

      equal(this.$link1.attr('href'), urlPrefix + '/a-1?q=lol');
      equal(this.$link2.attr('href'), urlPrefix + '/a-2');
      equal(this.$link3.attr('href'), urlPrefix + '/a-3');

      _emberMetalCore.default.run(this.$link2, 'click');

      equal(this.controller.get('q'), 'wat');
      equal(this.controller.get('z'), 0);
      deepEqual(this.controller.get('model'), { id: 'a-2' });
      equal(this.$link1.attr('href'), urlPrefix + '/a-1?q=lol');
      equal(this.$link2.attr('href'), urlPrefix + '/a-2');
      equal(this.$link3.attr('href'), urlPrefix + '/a-3');
    };
  }

  function queryParamsStickyTest2(urlPrefix) {
    return function () {
      this.boot();

      this.expectedModelHookParams = { id: 'a-1', q: 'lol', z: 0 };
      handleURL(urlPrefix + '/a-1?q=lol');

      deepEqual(this.controller.get('model'), { id: 'a-1' });
      equal(this.controller.get('q'), 'lol');
      equal(this.controller.get('z'), 0);
      equal(this.$link1.attr('href'), urlPrefix + '/a-1?q=lol');
      equal(this.$link2.attr('href'), urlPrefix + '/a-2');
      equal(this.$link3.attr('href'), urlPrefix + '/a-3');

      this.expectedModelHookParams = { id: 'a-2', q: 'lol', z: 0 };
      handleURL(urlPrefix + '/a-2?q=lol');

      deepEqual(this.controller.get('model'), { id: 'a-2' }, 'controller\'s model changed to a-2');
      equal(this.controller.get('q'), 'lol');
      equal(this.controller.get('z'), 0);
      equal(this.$link1.attr('href'), urlPrefix + '/a-1?q=lol');
      equal(this.$link2.attr('href'), urlPrefix + '/a-2?q=lol'); // fail
      equal(this.$link3.attr('href'), urlPrefix + '/a-3');

      this.expectedModelHookParams = { id: 'a-3', q: 'lol', z: 123 };
      handleURL(urlPrefix + '/a-3?q=lol&z=123');

      equal(this.controller.get('q'), 'lol');
      equal(this.controller.get('z'), 123);
      equal(this.$link1.attr('href'), urlPrefix + '/a-1?q=lol');
      equal(this.$link2.attr('href'), urlPrefix + '/a-2?q=lol');
      equal(this.$link3.attr('href'), urlPrefix + '/a-3?q=lol&z=123');
    };
  }

  function queryParamsStickyTest3(urlPrefix, articleLookup) {
    return function () {
      _emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('{{#each articles as |a|}} {{link-to \'Article\' \'' + articleLookup + '\' a.id id=a.id}} {{/each}}');

      this.boot();

      this.expectedModelHookParams = { id: 'a-1', q: 'wat', z: 0 };
      _emberMetalCore.default.run(router, 'transitionTo', articleLookup, 'a-1');

      deepEqual(this.controller.get('model'), { id: 'a-1' });
      equal(this.controller.get('q'), 'wat');
      equal(this.controller.get('z'), 0);
      equal(this.$link1.attr('href'), urlPrefix + '/a-1');
      equal(this.$link2.attr('href'), urlPrefix + '/a-2');
      equal(this.$link3.attr('href'), urlPrefix + '/a-3');

      this.expectedModelHookParams = { id: 'a-2', q: 'lol', z: 0 };
      _emberMetalCore.default.run(router, 'transitionTo', articleLookup, 'a-2', { queryParams: { q: 'lol' } });

      deepEqual(this.controller.get('model'), { id: 'a-2' });
      equal(this.controller.get('q'), 'lol');
      equal(this.controller.get('z'), 0);
      equal(this.$link1.attr('href'), urlPrefix + '/a-1');
      equal(this.$link2.attr('href'), urlPrefix + '/a-2?q=lol');
      equal(this.$link3.attr('href'), urlPrefix + '/a-3');

      this.expectedModelHookParams = { id: 'a-3', q: 'hay', z: 0 };
      _emberMetalCore.default.run(router, 'transitionTo', articleLookup, 'a-3', { queryParams: { q: 'hay' } });

      deepEqual(this.controller.get('model'), { id: 'a-3' });
      equal(this.controller.get('q'), 'hay');
      equal(this.controller.get('z'), 0);
      equal(this.$link1.attr('href'), urlPrefix + '/a-1');
      equal(this.$link2.attr('href'), urlPrefix + '/a-2?q=lol');
      equal(this.$link3.attr('href'), urlPrefix + '/a-3?q=hay');

      this.expectedModelHookParams = { id: 'a-2', q: 'lol', z: 1 };
      _emberMetalCore.default.run(router, 'transitionTo', articleLookup, 'a-2', { queryParams: { z: 1 } });

      deepEqual(this.controller.get('model'), { id: 'a-2' });
      equal(this.controller.get('q'), 'lol');
      equal(this.controller.get('z'), 1);
      equal(this.$link1.attr('href'), urlPrefix + '/a-1');
      equal(this.$link2.attr('href'), urlPrefix + '/a-2?q=lol&z=1');
      equal(this.$link3.attr('href'), urlPrefix + '/a-3?q=hay');
    };
  }

  function queryParamsStickyTest4(urlPrefix, articleLookup) {
    return function () {
      var articleClass = _emberMetalCore.default.String.classify(articleLookup);

      App[articleClass + 'Controller'].reopen({
        queryParams: { q: { scope: 'controller' } }
      });

      this.boot();

      _emberMetalCore.default.run(this.$link1, 'click');
      equal(router.get('location.path'), urlPrefix + '/a-1');

      setAndFlush(this.controller, 'q', 'lol');

      equal(this.$link1.attr('href'), urlPrefix + '/a-1?q=lol');
      equal(this.$link2.attr('href'), urlPrefix + '/a-2?q=lol');
      equal(this.$link3.attr('href'), urlPrefix + '/a-3?q=lol');

      _emberMetalCore.default.run(this.$link2, 'click');

      equal(this.controller.get('q'), 'lol');
      equal(this.controller.get('z'), 0);
      deepEqual(this.controller.get('model'), { id: 'a-2' });

      equal(this.$link1.attr('href'), urlPrefix + '/a-1?q=lol');
      equal(this.$link2.attr('href'), urlPrefix + '/a-2?q=lol');
      equal(this.$link3.attr('href'), urlPrefix + '/a-3?q=lol');

      this.expectedModelHookParams = { id: 'a-3', q: 'haha', z: 123 };
      handleURL(urlPrefix + '/a-3?q=haha&z=123');

      deepEqual(this.controller.get('model'), { id: 'a-3' });
      equal(this.controller.get('q'), 'haha');
      equal(this.controller.get('z'), 123);

      equal(this.$link1.attr('href'), urlPrefix + '/a-1?q=haha');
      equal(this.$link2.attr('href'), urlPrefix + '/a-2?q=haha');
      equal(this.$link3.attr('href'), urlPrefix + '/a-3?q=haha&z=123');

      setAndFlush(this.controller, 'q', 'woot');

      equal(this.$link1.attr('href'), urlPrefix + '/a-1?q=woot');
      equal(this.$link2.attr('href'), urlPrefix + '/a-2?q=woot');
      equal(this.$link3.attr('href'), urlPrefix + '/a-3?q=woot&z=123');
    };
  }

  function queryParamsStickyTest5(urlPrefix, commentsLookupKey) {
    return function () {
      this.boot();

      _emberMetalCore.default.run(router, 'transitionTo', commentsLookupKey, 'a-1');

      var commentsCtrl = container.lookup('controller:' + commentsLookupKey);
      equal(commentsCtrl.get('page'), 1);
      equal(router.get('location.path'), urlPrefix + '/a-1/comments');

      setAndFlush(commentsCtrl, 'page', 2);
      equal(router.get('location.path'), urlPrefix + '/a-1/comments?page=2');

      setAndFlush(commentsCtrl, 'page', 3);
      equal(router.get('location.path'), urlPrefix + '/a-1/comments?page=3');

      _emberMetalCore.default.run(router, 'transitionTo', commentsLookupKey, 'a-2');
      equal(commentsCtrl.get('page'), 1);
      equal(router.get('location.path'), urlPrefix + '/a-2/comments');

      _emberMetalCore.default.run(router, 'transitionTo', commentsLookupKey, 'a-1');
      equal(commentsCtrl.get('page'), 3);
      equal(router.get('location.path'), urlPrefix + '/a-1/comments?page=3');
    };
  }

  function queryParamsStickyTest6(urlPrefix, articleLookup, commentsLookup) {
    return function () {
      var articleClass = _emberMetalCore.default.String.classify(articleLookup);

      App[articleClass + 'Route'].reopen({
        resetController: function (controller, isExiting) {
          this.controllerFor(commentsLookup).set('page', 1);
          if (isExiting) {
            controller.set('q', 'imdone');
          }
        }
      });

      _emberMetalCore.default.TEMPLATES.about = _emberTemplateCompiler.compile('{{link-to \'A\' \'' + commentsLookup + '\' \'a-1\' id=\'one\'}} {{link-to \'B\' \'' + commentsLookup + '\' \'a-2\' id=\'two\'}}');

      this.boot();

      _emberMetalCore.default.run(router, 'transitionTo', commentsLookup, 'a-1');

      var commentsCtrl = container.lookup('controller:' + commentsLookup);
      equal(commentsCtrl.get('page'), 1);
      equal(router.get('location.path'), urlPrefix + '/a-1/comments');

      setAndFlush(commentsCtrl, 'page', 2);
      equal(router.get('location.path'), urlPrefix + '/a-1/comments?page=2');

      _emberMetalCore.default.run(router, 'transitionTo', commentsLookup, 'a-2');
      equal(commentsCtrl.get('page'), 1);
      equal(this.controller.get('q'), 'wat');

      _emberMetalCore.default.run(router, 'transitionTo', commentsLookup, 'a-1');

      equal(router.get('location.path'), urlPrefix + '/a-1/comments');
      equal(commentsCtrl.get('page'), 1);

      _emberMetalCore.default.run(router, 'transitionTo', 'about');

      equal(_emberMetalCore.default.$('#one').attr('href'), urlPrefix + '/a-1/comments?q=imdone');
      equal(_emberMetalCore.default.$('#two').attr('href'), urlPrefix + '/a-2/comments');
    };
  }

  QUnit.module('Model Dep Query Params', {
    setup: function () {
      sharedSetup();

      App.Router.map(function () {
        this.route('article', { path: '/a/:id' }, function () {
          this.route('comments', { resetNamespace: true });
        });
        this.route('about');
      });

      var articles = this.articles = _emberMetalCore.default.A([{ id: 'a-1' }, { id: 'a-2' }, { id: 'a-3' }]);

      App.ApplicationController = _emberMetalCore.default.Controller.extend({
        articles: this.articles
      });

      var self = this;
      App.ArticleRoute = _emberMetalCore.default.Route.extend({
        model: function (params) {
          if (self.expectedModelHookParams) {
            deepEqual(params, self.expectedModelHookParams, 'the ArticleRoute model hook received the expected merged dynamic segment + query params hash');
            self.expectedModelHookParams = null;
          }
          return articles.findBy('id', params.id);
        }
      });

      App.ArticleController = _emberMetalCore.default.Controller.extend({
        queryParams: ['q', 'z'],
        q: 'wat',
        z: 0
      });

      App.CommentsController = _emberMetalCore.default.Controller.extend({
        queryParams: 'page',
        page: 1
      });

      _emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('{{#each articles as |a|}} {{link-to \'Article\' \'article\' a id=a.id}} {{/each}} {{outlet}}');

      this.boot = function () {
        bootApplication();

        self.$link1 = _emberMetalCore.default.$('#a-1');
        self.$link2 = _emberMetalCore.default.$('#a-2');
        self.$link3 = _emberMetalCore.default.$('#a-3');

        equal(self.$link1.attr('href'), '/a/a-1');
        equal(self.$link2.attr('href'), '/a/a-2');
        equal(self.$link3.attr('href'), '/a/a-3');

        self.controller = container.lookup('controller:article');
      };
    },

    teardown: function () {
      sharedTeardown();
      ok(!this.expectedModelHookParams, 'there should be no pending expectation of expected model hook params');
    }
  });

  QUnit.test('query params have \'model\' stickiness by default', queryParamsStickyTest1('/a'));

  QUnit.test('query params have \'model\' stickiness by default (url changes)', queryParamsStickyTest2('/a'));

  QUnit.test('query params have \'model\' stickiness by default (params-based transitions)', queryParamsStickyTest3('/a', 'article'));

  QUnit.test('\'controller\' stickiness shares QP state between models', queryParamsStickyTest4('/a', 'article'));

  QUnit.test('\'model\' stickiness is scoped to current or first dynamic parent route', queryParamsStickyTest5('/a', 'comments'));

  QUnit.test('can reset query params using the resetController hook', queryParamsStickyTest6('/a', 'article', 'comments'));

  QUnit.module('Model Dep Query Params (nested)', {
    setup: function () {
      sharedSetup();

      App.Router.map(function () {
        this.route('site', function () {
          this.route('article', { path: '/a/:id' }, function () {
            this.route('comments');
          });
        });
        this.route('about');
      });

      var site_articles = this.site_articles = _emberMetalCore.default.A([{ id: 'a-1' }, { id: 'a-2' }, { id: 'a-3' }]);

      App.ApplicationController = _emberMetalCore.default.Controller.extend({
        articles: this.site_articles
      });

      var self = this;
      App.SiteArticleRoute = _emberMetalCore.default.Route.extend({
        model: function (params) {
          if (self.expectedModelHookParams) {
            deepEqual(params, self.expectedModelHookParams, 'the ArticleRoute model hook received the expected merged dynamic segment + query params hash');
            self.expectedModelHookParams = null;
          }
          return site_articles.findBy('id', params.id);
        }
      });

      App.SiteArticleController = _emberMetalCore.default.Controller.extend({
        queryParams: ['q', 'z'],
        q: 'wat',
        z: 0
      });

      App.SiteArticleCommentsController = _emberMetalCore.default.Controller.extend({
        queryParams: 'page',
        page: 1
      });

      _emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('{{#each articles as |a|}} {{link-to \'Article\' \'site.article\' a id=a.id}} {{/each}} {{outlet}}');

      this.boot = function () {
        bootApplication();

        self.$link1 = _emberMetalCore.default.$('#a-1');
        self.$link2 = _emberMetalCore.default.$('#a-2');
        self.$link3 = _emberMetalCore.default.$('#a-3');

        equal(self.$link1.attr('href'), '/site/a/a-1');
        equal(self.$link2.attr('href'), '/site/a/a-2');
        equal(self.$link3.attr('href'), '/site/a/a-3');

        self.controller = container.lookup('controller:site.article');
      };
    },

    teardown: function () {
      sharedTeardown();
      ok(!this.expectedModelHookParams, 'there should be no pending expectation of expected model hook params');
    }
  });

  QUnit.test('query params have \'model\' stickiness by default', queryParamsStickyTest1('/site/a'));

  QUnit.test('query params have \'model\' stickiness by default (url changes)', queryParamsStickyTest2('/site/a'));

  QUnit.test('query params have \'model\' stickiness by default (params-based transitions)', queryParamsStickyTest3('/site/a', 'site.article'));

  QUnit.test('\'controller\' stickiness shares QP state between models', queryParamsStickyTest4('/site/a', 'site.article'));

  QUnit.test('\'model\' stickiness is scoped to current or first dynamic parent route', queryParamsStickyTest5('/site/a', 'site.article.comments'));

  QUnit.test('can reset query params using the resetController hook', queryParamsStickyTest6('/site/a', 'site.article', 'site.article.comments'));

  QUnit.module('Model Dep Query Params (nested & more than 1 dynamic segment)', {
    setup: function () {
      sharedSetup();

      App.Router.map(function () {
        this.route('site', { path: '/site/:site_id' }, function () {
          this.route('article', { path: '/a/:article_id' }, function () {
            this.route('comments');
          });
        });
      });

      var sites = this.sites = _emberMetalCore.default.A([{ id: 's-1' }, { id: 's-2' }, { id: 's-3' }]);
      var site_articles = this.site_articles = _emberMetalCore.default.A([{ id: 'a-1' }, { id: 'a-2' }, { id: 'a-3' }]);

      App.ApplicationController = _emberMetalCore.default.Controller.extend({
        siteArticles: this.site_articles,
        sites: this.sites,
        allSitesAllArticles: _emberMetalCore.default.computed({
          get: function () {
            var ret = [];
            var siteArticles = this.siteArticles;
            var sites = this.sites;
            sites.forEach(function (site) {
              ret = ret.concat(siteArticles.map(function (article) {
                return { id: site.id + '-' + article.id, site_id: site.id, article_id: article.id };
              }));
            });
            return ret;
          }
        })
      });

      var self = this;
      App.SiteRoute = _emberMetalCore.default.Route.extend({
        model: function (params) {
          if (self.expectedSiteModelHookParams) {
            deepEqual(params, self.expectedSiteModelHookParams, 'the SiteRoute model hook received the expected merged dynamic segment + query params hash');
            self.expectedSiteModelHookParams = null;
          }
          return sites.findBy('id', params.site_id);
        }
      });
      App.SiteArticleRoute = _emberMetalCore.default.Route.extend({
        model: function (params) {
          if (self.expectedArticleModelHookParams) {
            deepEqual(params, self.expectedArticleModelHookParams, 'the SiteArticleRoute model hook received the expected merged dynamic segment + query params hash');
            self.expectedArticleModelHookParams = null;
          }
          return site_articles.findBy('id', params.article_id);
        }
      });

      App.SiteController = _emberMetalCore.default.Controller.extend({
        queryParams: ['country'],
        country: 'au'
      });

      App.SiteArticleController = _emberMetalCore.default.Controller.extend({
        queryParams: ['q', 'z'],
        q: 'wat',
        z: 0
      });

      App.SiteArticleCommentsController = _emberMetalCore.default.Controller.extend({
        queryParams: ['page'],
        page: 1
      });

      _emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('{{#each allSitesAllArticles as |a|}} {{#link-to \'site.article\' a.site_id a.article_id id=a.id}}Article [{{a.site_id}}] [{{a.article_id}}]{{/link-to}} {{/each}} {{outlet}}');

      this.boot = function () {
        bootApplication();
        self.links = {};
        self.links['s-1-a-1'] = _emberMetalCore.default.$('#s-1-a-1');
        self.links['s-1-a-2'] = _emberMetalCore.default.$('#s-1-a-2');
        self.links['s-1-a-3'] = _emberMetalCore.default.$('#s-1-a-3');
        self.links['s-2-a-1'] = _emberMetalCore.default.$('#s-2-a-1');
        self.links['s-2-a-2'] = _emberMetalCore.default.$('#s-2-a-2');
        self.links['s-2-a-3'] = _emberMetalCore.default.$('#s-2-a-3');
        self.links['s-3-a-1'] = _emberMetalCore.default.$('#s-3-a-1');
        self.links['s-3-a-2'] = _emberMetalCore.default.$('#s-3-a-2');
        self.links['s-3-a-3'] = _emberMetalCore.default.$('#s-3-a-3');

        equal(self.links['s-1-a-1'].attr('href'), '/site/s-1/a/a-1');
        equal(self.links['s-1-a-2'].attr('href'), '/site/s-1/a/a-2');
        equal(self.links['s-1-a-3'].attr('href'), '/site/s-1/a/a-3');
        equal(self.links['s-2-a-1'].attr('href'), '/site/s-2/a/a-1');
        equal(self.links['s-2-a-2'].attr('href'), '/site/s-2/a/a-2');
        equal(self.links['s-2-a-3'].attr('href'), '/site/s-2/a/a-3');
        equal(self.links['s-3-a-1'].attr('href'), '/site/s-3/a/a-1');
        equal(self.links['s-3-a-2'].attr('href'), '/site/s-3/a/a-2');
        equal(self.links['s-3-a-3'].attr('href'), '/site/s-3/a/a-3');

        self.site_controller = container.lookup('controller:site');
        self.article_controller = container.lookup('controller:site.article');
      };
    },

    teardown: function () {
      sharedTeardown();
      ok(!this.expectedModelHookParams, 'there should be no pending expectation of expected model hook params');
    }
  });

  QUnit.test('query params have \'model\' stickiness by default', function () {
    this.boot();

    _emberMetalCore.default.run(this.links['s-1-a-1'], 'click');
    deepEqual(this.site_controller.get('model'), { id: 's-1' });
    deepEqual(this.article_controller.get('model'), { id: 'a-1' });
    equal(router.get('location.path'), '/site/s-1/a/a-1');

    setAndFlush(this.article_controller, 'q', 'lol');

    equal(this.links['s-1-a-1'].attr('href'), '/site/s-1/a/a-1?q=lol');
    equal(this.links['s-1-a-2'].attr('href'), '/site/s-1/a/a-2');
    equal(this.links['s-1-a-3'].attr('href'), '/site/s-1/a/a-3');
    equal(this.links['s-2-a-1'].attr('href'), '/site/s-2/a/a-1?q=lol');
    equal(this.links['s-2-a-2'].attr('href'), '/site/s-2/a/a-2');
    equal(this.links['s-2-a-3'].attr('href'), '/site/s-2/a/a-3');
    equal(this.links['s-3-a-1'].attr('href'), '/site/s-3/a/a-1?q=lol');
    equal(this.links['s-3-a-2'].attr('href'), '/site/s-3/a/a-2');
    equal(this.links['s-3-a-3'].attr('href'), '/site/s-3/a/a-3');

    setAndFlush(this.site_controller, 'country', 'us');

    equal(this.links['s-1-a-1'].attr('href'), '/site/s-1/a/a-1?country=us&q=lol');
    equal(this.links['s-1-a-2'].attr('href'), '/site/s-1/a/a-2?country=us');
    equal(this.links['s-1-a-3'].attr('href'), '/site/s-1/a/a-3?country=us');
    equal(this.links['s-2-a-1'].attr('href'), '/site/s-2/a/a-1?q=lol');
    equal(this.links['s-2-a-2'].attr('href'), '/site/s-2/a/a-2');
    equal(this.links['s-2-a-3'].attr('href'), '/site/s-2/a/a-3');
    equal(this.links['s-3-a-1'].attr('href'), '/site/s-3/a/a-1?q=lol');
    equal(this.links['s-3-a-2'].attr('href'), '/site/s-3/a/a-2');
    equal(this.links['s-3-a-3'].attr('href'), '/site/s-3/a/a-3');

    _emberMetalCore.default.run(this.links['s-1-a-2'], 'click');

    equal(this.site_controller.get('country'), 'us');
    equal(this.article_controller.get('q'), 'wat');
    equal(this.article_controller.get('z'), 0);
    deepEqual(this.site_controller.get('model'), { id: 's-1' });
    deepEqual(this.article_controller.get('model'), { id: 'a-2' });
    equal(this.links['s-1-a-1'].attr('href'), '/site/s-1/a/a-1?country=us&q=lol');
    equal(this.links['s-1-a-2'].attr('href'), '/site/s-1/a/a-2?country=us');
    equal(this.links['s-1-a-3'].attr('href'), '/site/s-1/a/a-3?country=us');
    equal(this.links['s-2-a-1'].attr('href'), '/site/s-2/a/a-1?q=lol');
    equal(this.links['s-2-a-2'].attr('href'), '/site/s-2/a/a-2');
    equal(this.links['s-2-a-3'].attr('href'), '/site/s-2/a/a-3');
    equal(this.links['s-3-a-1'].attr('href'), '/site/s-3/a/a-1?q=lol');
    equal(this.links['s-3-a-2'].attr('href'), '/site/s-3/a/a-2');
    equal(this.links['s-3-a-3'].attr('href'), '/site/s-3/a/a-3');

    _emberMetalCore.default.run(this.links['s-2-a-2'], 'click');

    equal(this.site_controller.get('country'), 'au');
    equal(this.article_controller.get('q'), 'wat');
    equal(this.article_controller.get('z'), 0);
    deepEqual(this.site_controller.get('model'), { id: 's-2' });
    deepEqual(this.article_controller.get('model'), { id: 'a-2' });
    equal(this.links['s-1-a-1'].attr('href'), '/site/s-1/a/a-1?country=us&q=lol');
    equal(this.links['s-1-a-2'].attr('href'), '/site/s-1/a/a-2?country=us');
    equal(this.links['s-1-a-3'].attr('href'), '/site/s-1/a/a-3?country=us');
    equal(this.links['s-2-a-1'].attr('href'), '/site/s-2/a/a-1?q=lol');
    equal(this.links['s-2-a-2'].attr('href'), '/site/s-2/a/a-2');
    equal(this.links['s-2-a-3'].attr('href'), '/site/s-2/a/a-3');
    equal(this.links['s-3-a-1'].attr('href'), '/site/s-3/a/a-1?q=lol');
    equal(this.links['s-3-a-2'].attr('href'), '/site/s-3/a/a-2');
    equal(this.links['s-3-a-3'].attr('href'), '/site/s-3/a/a-3');
  });

  QUnit.test('query params have \'model\' stickiness by default (url changes)', function () {

    this.boot();

    this.expectedSiteModelHookParams = { site_id: 's-1', country: 'au' };
    this.expectedArticleModelHookParams = { article_id: 'a-1', q: 'lol', z: 0 };
    handleURL('/site/s-1/a/a-1?q=lol');

    deepEqual(this.site_controller.get('model'), { id: 's-1' }, 'site controller\'s model is s-1');
    deepEqual(this.article_controller.get('model'), { id: 'a-1' }, 'article controller\'s model is a-1');
    equal(this.site_controller.get('country'), 'au');
    equal(this.article_controller.get('q'), 'lol');
    equal(this.article_controller.get('z'), 0);
    equal(this.links['s-1-a-1'].attr('href'), '/site/s-1/a/a-1?q=lol');
    equal(this.links['s-1-a-2'].attr('href'), '/site/s-1/a/a-2');
    equal(this.links['s-1-a-3'].attr('href'), '/site/s-1/a/a-3');
    equal(this.links['s-2-a-1'].attr('href'), '/site/s-2/a/a-1?q=lol');
    equal(this.links['s-2-a-2'].attr('href'), '/site/s-2/a/a-2');
    equal(this.links['s-2-a-3'].attr('href'), '/site/s-2/a/a-3');
    equal(this.links['s-3-a-1'].attr('href'), '/site/s-3/a/a-1?q=lol');
    equal(this.links['s-3-a-2'].attr('href'), '/site/s-3/a/a-2');
    equal(this.links['s-3-a-3'].attr('href'), '/site/s-3/a/a-3');

    this.expectedSiteModelHookParams = { site_id: 's-2', country: 'us' };
    this.expectedArticleModelHookParams = { article_id: 'a-1', q: 'lol', z: 0 };
    handleURL('/site/s-2/a/a-1?country=us&q=lol');

    deepEqual(this.site_controller.get('model'), { id: 's-2' }, 'site controller\'s model is s-2');
    deepEqual(this.article_controller.get('model'), { id: 'a-1' }, 'article controller\'s model is a-1');
    equal(this.site_controller.get('country'), 'us');
    equal(this.article_controller.get('q'), 'lol');
    equal(this.article_controller.get('z'), 0);
    equal(this.links['s-1-a-1'].attr('href'), '/site/s-1/a/a-1?q=lol');
    equal(this.links['s-1-a-2'].attr('href'), '/site/s-1/a/a-2');
    equal(this.links['s-1-a-3'].attr('href'), '/site/s-1/a/a-3');
    equal(this.links['s-2-a-1'].attr('href'), '/site/s-2/a/a-1?country=us&q=lol');
    equal(this.links['s-2-a-2'].attr('href'), '/site/s-2/a/a-2?country=us');
    equal(this.links['s-2-a-3'].attr('href'), '/site/s-2/a/a-3?country=us');
    equal(this.links['s-3-a-1'].attr('href'), '/site/s-3/a/a-1?q=lol');
    equal(this.links['s-3-a-2'].attr('href'), '/site/s-3/a/a-2');
    equal(this.links['s-3-a-3'].attr('href'), '/site/s-3/a/a-3');

    this.expectedSiteModelHookParams = { site_id: 's-2', country: 'us' };
    this.expectedArticleModelHookParams = { article_id: 'a-2', q: 'lol', z: 0 };
    handleURL('/site/s-2/a/a-2?country=us&q=lol');

    deepEqual(this.site_controller.get('model'), { id: 's-2' }, 'site controller\'s model is s-2');
    deepEqual(this.article_controller.get('model'), { id: 'a-2' }, 'article controller\'s model is a-2');
    equal(this.site_controller.get('country'), 'us');
    equal(this.article_controller.get('q'), 'lol');
    equal(this.article_controller.get('z'), 0);
    equal(this.links['s-1-a-1'].attr('href'), '/site/s-1/a/a-1?q=lol');
    equal(this.links['s-1-a-2'].attr('href'), '/site/s-1/a/a-2?q=lol');
    equal(this.links['s-1-a-3'].attr('href'), '/site/s-1/a/a-3');
    equal(this.links['s-2-a-1'].attr('href'), '/site/s-2/a/a-1?country=us&q=lol');
    equal(this.links['s-2-a-2'].attr('href'), '/site/s-2/a/a-2?country=us&q=lol');
    equal(this.links['s-2-a-3'].attr('href'), '/site/s-2/a/a-3?country=us');
    equal(this.links['s-3-a-1'].attr('href'), '/site/s-3/a/a-1?q=lol');
    equal(this.links['s-3-a-2'].attr('href'), '/site/s-3/a/a-2?q=lol');
    equal(this.links['s-3-a-3'].attr('href'), '/site/s-3/a/a-3');

    this.expectedSiteModelHookParams = { site_id: 's-2', country: 'us' };
    this.expectedArticleModelHookParams = { article_id: 'a-3', q: 'lol', z: 123 };
    handleURL('/site/s-2/a/a-3?country=us&q=lol&z=123');

    deepEqual(this.site_controller.get('model'), { id: 's-2' }, 'site controller\'s model is s-2');
    deepEqual(this.article_controller.get('model'), { id: 'a-3' }, 'article controller\'s model is a-3');
    equal(this.site_controller.get('country'), 'us');
    equal(this.article_controller.get('q'), 'lol');
    equal(this.article_controller.get('z'), 123);
    equal(this.links['s-1-a-1'].attr('href'), '/site/s-1/a/a-1?q=lol');
    equal(this.links['s-1-a-2'].attr('href'), '/site/s-1/a/a-2?q=lol');
    equal(this.links['s-1-a-3'].attr('href'), '/site/s-1/a/a-3?q=lol&z=123');
    equal(this.links['s-2-a-1'].attr('href'), '/site/s-2/a/a-1?country=us&q=lol');
    equal(this.links['s-2-a-2'].attr('href'), '/site/s-2/a/a-2?country=us&q=lol');
    equal(this.links['s-2-a-3'].attr('href'), '/site/s-2/a/a-3?country=us&q=lol&z=123');
    equal(this.links['s-3-a-1'].attr('href'), '/site/s-3/a/a-1?q=lol');
    equal(this.links['s-3-a-2'].attr('href'), '/site/s-3/a/a-2?q=lol');
    equal(this.links['s-3-a-3'].attr('href'), '/site/s-3/a/a-3?q=lol&z=123');

    this.expectedSiteModelHookParams = { site_id: 's-3', country: 'nz' };
    this.expectedArticleModelHookParams = { article_id: 'a-3', q: 'lol', z: 123 };
    handleURL('/site/s-3/a/a-3?country=nz&q=lol&z=123');

    deepEqual(this.site_controller.get('model'), { id: 's-3' }, 'site controller\'s model is s-3');
    deepEqual(this.article_controller.get('model'), { id: 'a-3' }, 'article controller\'s model is a-3');
    equal(this.site_controller.get('country'), 'nz');
    equal(this.article_controller.get('q'), 'lol');
    equal(this.article_controller.get('z'), 123);
    equal(this.links['s-1-a-1'].attr('href'), '/site/s-1/a/a-1?q=lol');
    equal(this.links['s-1-a-2'].attr('href'), '/site/s-1/a/a-2?q=lol');
    equal(this.links['s-1-a-3'].attr('href'), '/site/s-1/a/a-3?q=lol&z=123');
    equal(this.links['s-2-a-1'].attr('href'), '/site/s-2/a/a-1?country=us&q=lol');
    equal(this.links['s-2-a-2'].attr('href'), '/site/s-2/a/a-2?country=us&q=lol');
    equal(this.links['s-2-a-3'].attr('href'), '/site/s-2/a/a-3?country=us&q=lol&z=123');
    equal(this.links['s-3-a-1'].attr('href'), '/site/s-3/a/a-1?country=nz&q=lol');
    equal(this.links['s-3-a-2'].attr('href'), '/site/s-3/a/a-2?country=nz&q=lol');
    equal(this.links['s-3-a-3'].attr('href'), '/site/s-3/a/a-3?country=nz&q=lol&z=123');
  });

  QUnit.test('query params have \'model\' stickiness by default (params-based transitions)', function () {
    this.boot();

    this.expectedSiteModelHookParams = { site_id: 's-1', country: 'au' };
    this.expectedArticleModelHookParams = { article_id: 'a-1', q: 'wat', z: 0 };
    _emberMetalCore.default.run(router, 'transitionTo', 'site.article', 's-1', 'a-1');

    deepEqual(this.site_controller.get('model'), { id: 's-1' });
    deepEqual(this.article_controller.get('model'), { id: 'a-1' });
    equal(this.site_controller.get('country'), 'au');
    equal(this.article_controller.get('q'), 'wat');
    equal(this.article_controller.get('z'), 0);
    equal(this.links['s-1-a-1'].attr('href'), '/site/s-1/a/a-1');
    equal(this.links['s-1-a-2'].attr('href'), '/site/s-1/a/a-2');
    equal(this.links['s-1-a-3'].attr('href'), '/site/s-1/a/a-3');
    equal(this.links['s-2-a-1'].attr('href'), '/site/s-2/a/a-1');
    equal(this.links['s-2-a-2'].attr('href'), '/site/s-2/a/a-2');
    equal(this.links['s-2-a-3'].attr('href'), '/site/s-2/a/a-3');
    equal(this.links['s-3-a-1'].attr('href'), '/site/s-3/a/a-1');
    equal(this.links['s-3-a-2'].attr('href'), '/site/s-3/a/a-2');
    equal(this.links['s-3-a-3'].attr('href'), '/site/s-3/a/a-3');

    this.expectedSiteModelHookParams = { site_id: 's-1', country: 'au' };
    this.expectedArticleModelHookParams = { article_id: 'a-2', q: 'lol', z: 0 };
    _emberMetalCore.default.run(router, 'transitionTo', 'site.article', 's-1', 'a-2', { queryParams: { q: 'lol' } });

    deepEqual(this.site_controller.get('model'), { id: 's-1' });
    deepEqual(this.article_controller.get('model'), { id: 'a-2' });
    equal(this.site_controller.get('country'), 'au');
    equal(this.article_controller.get('q'), 'lol');
    equal(this.article_controller.get('z'), 0);
    equal(this.links['s-1-a-1'].attr('href'), '/site/s-1/a/a-1');
    equal(this.links['s-1-a-2'].attr('href'), '/site/s-1/a/a-2?q=lol');
    equal(this.links['s-1-a-3'].attr('href'), '/site/s-1/a/a-3');
    equal(this.links['s-2-a-1'].attr('href'), '/site/s-2/a/a-1');
    equal(this.links['s-2-a-2'].attr('href'), '/site/s-2/a/a-2?q=lol');
    equal(this.links['s-2-a-3'].attr('href'), '/site/s-2/a/a-3');
    equal(this.links['s-3-a-1'].attr('href'), '/site/s-3/a/a-1');
    equal(this.links['s-3-a-2'].attr('href'), '/site/s-3/a/a-2?q=lol');
    equal(this.links['s-3-a-3'].attr('href'), '/site/s-3/a/a-3');

    this.expectedSiteModelHookParams = { site_id: 's-1', country: 'au' };
    this.expectedArticleModelHookParams = { article_id: 'a-3', q: 'hay', z: 0 };
    _emberMetalCore.default.run(router, 'transitionTo', 'site.article', 's-1', 'a-3', { queryParams: { q: 'hay' } });

    deepEqual(this.site_controller.get('model'), { id: 's-1' });
    deepEqual(this.article_controller.get('model'), { id: 'a-3' });
    equal(this.site_controller.get('country'), 'au');
    equal(this.article_controller.get('q'), 'hay');
    equal(this.article_controller.get('z'), 0);
    equal(this.links['s-1-a-1'].attr('href'), '/site/s-1/a/a-1');
    equal(this.links['s-1-a-2'].attr('href'), '/site/s-1/a/a-2?q=lol');
    equal(this.links['s-1-a-3'].attr('href'), '/site/s-1/a/a-3?q=hay');
    equal(this.links['s-2-a-1'].attr('href'), '/site/s-2/a/a-1');
    equal(this.links['s-2-a-2'].attr('href'), '/site/s-2/a/a-2?q=lol');
    equal(this.links['s-2-a-3'].attr('href'), '/site/s-2/a/a-3?q=hay');
    equal(this.links['s-3-a-1'].attr('href'), '/site/s-3/a/a-1');
    equal(this.links['s-3-a-2'].attr('href'), '/site/s-3/a/a-2?q=lol');
    equal(this.links['s-3-a-3'].attr('href'), '/site/s-3/a/a-3?q=hay');

    this.expectedSiteModelHookParams = { site_id: 's-1', country: 'au' };
    this.expectedArticleModelHookParams = { article_id: 'a-2', q: 'lol', z: 1 };
    _emberMetalCore.default.run(router, 'transitionTo', 'site.article', 's-1', 'a-2', { queryParams: { z: 1 } });

    deepEqual(this.site_controller.get('model'), { id: 's-1' });
    deepEqual(this.article_controller.get('model'), { id: 'a-2' });
    equal(this.site_controller.get('country'), 'au');
    equal(this.article_controller.get('q'), 'lol');
    equal(this.article_controller.get('z'), 1);
    equal(this.links['s-1-a-1'].attr('href'), '/site/s-1/a/a-1');
    equal(this.links['s-1-a-2'].attr('href'), '/site/s-1/a/a-2?q=lol&z=1');
    equal(this.links['s-1-a-3'].attr('href'), '/site/s-1/a/a-3?q=hay');
    equal(this.links['s-2-a-1'].attr('href'), '/site/s-2/a/a-1');
    equal(this.links['s-2-a-2'].attr('href'), '/site/s-2/a/a-2?q=lol&z=1');
    equal(this.links['s-2-a-3'].attr('href'), '/site/s-2/a/a-3?q=hay');
    equal(this.links['s-3-a-1'].attr('href'), '/site/s-3/a/a-1');
    equal(this.links['s-3-a-2'].attr('href'), '/site/s-3/a/a-2?q=lol&z=1');
    equal(this.links['s-3-a-3'].attr('href'), '/site/s-3/a/a-3?q=hay');

    this.expectedSiteModelHookParams = { site_id: 's-2', country: 'us' };
    this.expectedArticleModelHookParams = { article_id: 'a-2', q: 'lol', z: 1 };
    _emberMetalCore.default.run(router, 'transitionTo', 'site.article', 's-2', 'a-2', { queryParams: { country: 'us' } });

    deepEqual(this.site_controller.get('model'), { id: 's-2' });
    deepEqual(this.article_controller.get('model'), { id: 'a-2' });
    equal(this.site_controller.get('country'), 'us');
    equal(this.article_controller.get('q'), 'lol');
    equal(this.article_controller.get('z'), 1);
    equal(this.links['s-1-a-1'].attr('href'), '/site/s-1/a/a-1');
    equal(this.links['s-1-a-2'].attr('href'), '/site/s-1/a/a-2?q=lol&z=1');
    equal(this.links['s-1-a-3'].attr('href'), '/site/s-1/a/a-3?q=hay');
    equal(this.links['s-2-a-1'].attr('href'), '/site/s-2/a/a-1?country=us');
    equal(this.links['s-2-a-2'].attr('href'), '/site/s-2/a/a-2?country=us&q=lol&z=1');
    equal(this.links['s-2-a-3'].attr('href'), '/site/s-2/a/a-3?country=us&q=hay');
    equal(this.links['s-3-a-1'].attr('href'), '/site/s-3/a/a-1');
    equal(this.links['s-3-a-2'].attr('href'), '/site/s-3/a/a-2?q=lol&z=1');
    equal(this.links['s-3-a-3'].attr('href'), '/site/s-3/a/a-3?q=hay');

    this.expectedSiteModelHookParams = { site_id: 's-2', country: 'us' };
    this.expectedArticleModelHookParams = { article_id: 'a-1', q: 'yeah', z: 0 };
    _emberMetalCore.default.run(router, 'transitionTo', 'site.article', 's-2', 'a-1', { queryParams: { q: 'yeah' } });

    deepEqual(this.site_controller.get('model'), { id: 's-2' });
    deepEqual(this.article_controller.get('model'), { id: 'a-1' });
    equal(this.site_controller.get('country'), 'us');
    equal(this.article_controller.get('q'), 'yeah');
    equal(this.article_controller.get('z'), 0);
    equal(this.links['s-1-a-1'].attr('href'), '/site/s-1/a/a-1?q=yeah');
    equal(this.links['s-1-a-2'].attr('href'), '/site/s-1/a/a-2?q=lol&z=1');
    equal(this.links['s-1-a-3'].attr('href'), '/site/s-1/a/a-3?q=hay');
    equal(this.links['s-2-a-1'].attr('href'), '/site/s-2/a/a-1?country=us&q=yeah');
    equal(this.links['s-2-a-2'].attr('href'), '/site/s-2/a/a-2?country=us&q=lol&z=1');
    equal(this.links['s-2-a-3'].attr('href'), '/site/s-2/a/a-3?country=us&q=hay');
    equal(this.links['s-3-a-1'].attr('href'), '/site/s-3/a/a-1?q=yeah');
    equal(this.links['s-3-a-2'].attr('href'), '/site/s-3/a/a-2?q=lol&z=1');
    equal(this.links['s-3-a-3'].attr('href'), '/site/s-3/a/a-3?q=hay');

    this.expectedSiteModelHookParams = { site_id: 's-3', country: 'nz' };
    this.expectedArticleModelHookParams = { article_id: 'a-3', q: 'hay', z: 3 };
    _emberMetalCore.default.run(router, 'transitionTo', 'site.article', 's-3', 'a-3', { queryParams: { country: 'nz', z: 3 } });

    deepEqual(this.site_controller.get('model'), { id: 's-3' });
    deepEqual(this.article_controller.get('model'), { id: 'a-3' });
    equal(this.site_controller.get('country'), 'nz');
    equal(this.article_controller.get('q'), 'hay');
    equal(this.article_controller.get('z'), 3);
    equal(this.links['s-1-a-1'].attr('href'), '/site/s-1/a/a-1?q=yeah');
    equal(this.links['s-1-a-2'].attr('href'), '/site/s-1/a/a-2?q=lol&z=1');
    equal(this.links['s-1-a-3'].attr('href'), '/site/s-1/a/a-3?q=hay&z=3');
    equal(this.links['s-2-a-1'].attr('href'), '/site/s-2/a/a-1?country=us&q=yeah');
    equal(this.links['s-2-a-2'].attr('href'), '/site/s-2/a/a-2?country=us&q=lol&z=1');
    equal(this.links['s-2-a-3'].attr('href'), '/site/s-2/a/a-3?country=us&q=hay&z=3');
    equal(this.links['s-3-a-1'].attr('href'), '/site/s-3/a/a-1?country=nz&q=yeah');
    equal(this.links['s-3-a-2'].attr('href'), '/site/s-3/a/a-2?country=nz&q=lol&z=1');
    equal(this.links['s-3-a-3'].attr('href'), '/site/s-3/a/a-3?country=nz&q=hay&z=3');
  });
});
enifed('ember/tests/routing/query_params_test/model_dependent_state_with_query_params_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember/tests/routing/query_params_test');
  test('ember/tests/routing/query_params_test/model_dependent_state_with_query_params_test.js should pass jscs', function () {
    ok(true, 'ember/tests/routing/query_params_test/model_dependent_state_with_query_params_test.js should pass jscs.');
  });
});
enifed('ember/tests/routing/query_params_test/model_dependent_state_with_query_params_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember/tests/routing/query_params_test');
  QUnit.test('ember/tests/routing/query_params_test/model_dependent_state_with_query_params_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember/tests/routing/query_params_test/model_dependent_state_with_query_params_test.js should pass jshint.');
  });
});
enifed('ember/tests/routing/query_params_test/overlapping_query_params_test', ['exports', 'ember', 'ember-metal/core', 'ember-metal/features', 'ember-template-compiler'], function (exports, _ember, _emberMetalCore, _emberMetalFeatures, _emberTemplateCompiler) {
  'use strict';

  var Router, App, router, registry, container;

  function bootApplication() {
    router = container.lookup('router:main');
    _emberMetalCore.default.run(App, 'advanceReadiness');
  }

  var startingURL = '';
  var expectedReplaceURL, expectedPushURL;

  function setAndFlush(obj, prop, value) {
    _emberMetalCore.default.run(obj, 'set', prop, value);
  }

  var TestLocation = _emberMetalCore.default.NoneLocation.extend({
    initState: function () {
      this.set('path', startingURL);
    },

    setURL: function (path) {
      if (expectedReplaceURL) {
        ok(false, 'pushState occurred but a replaceState was expected');
      }
      if (expectedPushURL) {
        equal(path, expectedPushURL, 'an expected pushState occurred');
        expectedPushURL = null;
      }
      this.set('path', path);
    },

    replaceURL: function (path) {
      if (expectedPushURL) {
        ok(false, 'replaceState occurred but a pushState was expected');
      }
      if (expectedReplaceURL) {
        equal(path, expectedReplaceURL, 'an expected replaceState occurred');
        expectedReplaceURL = null;
      }
      this.set('path', path);
    }
  });

  function sharedSetup() {
    _emberMetalCore.default.run(function () {
      App = _emberMetalCore.default.Application.create({
        name: 'App',
        rootElement: '#qunit-fixture'
      });

      App.deferReadiness();

      registry = App.registry;
      container = App.__container__;

      registry.register('location:test', TestLocation);

      startingURL = expectedReplaceURL = expectedPushURL = '';

      App.Router.reopen({
        location: 'test'
      });

      Router = App.Router;

      App.LoadingRoute = _emberMetalCore.default.Route.extend({});

      _emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('{{outlet}}');
      _emberMetalCore.default.TEMPLATES.home = _emberTemplateCompiler.compile('<h3>Hours</h3>');
    });
  }

  function sharedTeardown() {
    _emberMetalCore.default.run(function () {
      App.destroy();
      App = null;

      _emberMetalCore.default.TEMPLATES = {};
    });
  }

  QUnit.module('Query Params - overlapping query param property names', {
    setup: function () {
      sharedSetup();

      App.Router.map(function () {
        this.route('parent', function () {
          this.route('child');
        });
      });

      this.boot = function () {
        bootApplication();
        _emberMetalCore.default.run(router, 'transitionTo', 'parent.child');
      };
    },

    teardown: function () {
      sharedTeardown();
    }
  });

  QUnit.test('can remap same-named qp props', function () {
    App.ParentController = _emberMetalCore.default.Controller.extend({
      queryParams: { page: 'parentPage' },
      page: 1
    });

    App.ParentChildController = _emberMetalCore.default.Controller.extend({
      queryParams: { page: 'childPage' },
      page: 1
    });

    this.boot();

    equal(router.get('location.path'), '/parent/child');

    var parentController = container.lookup('controller:parent');
    var parentChildController = container.lookup('controller:parent.child');

    setAndFlush(parentController, 'page', 2);
    equal(router.get('location.path'), '/parent/child?parentPage=2');
    setAndFlush(parentController, 'page', 1);
    equal(router.get('location.path'), '/parent/child');

    setAndFlush(parentChildController, 'page', 2);
    equal(router.get('location.path'), '/parent/child?childPage=2');
    setAndFlush(parentChildController, 'page', 1);
    equal(router.get('location.path'), '/parent/child');

    _emberMetalCore.default.run(function () {
      parentController.set('page', 2);
      parentChildController.set('page', 2);
    });

    equal(router.get('location.path'), '/parent/child?childPage=2&parentPage=2');

    _emberMetalCore.default.run(function () {
      parentController.set('page', 1);
      parentChildController.set('page', 1);
    });

    equal(router.get('location.path'), '/parent/child');
  });

  QUnit.test('query params in the same route hierarchy with the same url key get auto-scoped', function () {
    App.ParentController = _emberMetalCore.default.Controller.extend({
      queryParams: { foo: 'shared' },
      foo: 1
    });

    App.ParentChildController = _emberMetalCore.default.Controller.extend({
      queryParams: { bar: 'shared' },
      bar: 1
    });

    var self = this;
    expectAssertion(function () {
      self.boot();
    }, 'You\'re not allowed to have more than one controller property map to the same query param key, but both `parent:foo` and `parent.child:bar` map to `shared`. You can fix this by mapping one of the controller properties to a different query param key via the `as` config option, e.g. `foo: { as: \'other-foo\' }`');
  });

  QUnit.test('Support shared but overridable mixin pattern', function () {

    var HasPage = _emberMetalCore.default.Mixin.create({
      queryParams: 'page',
      page: 1
    });

    App.ParentController = _emberMetalCore.default.Controller.extend(HasPage, {
      queryParams: { page: 'yespage' }
    });

    App.ParentChildController = _emberMetalCore.default.Controller.extend(HasPage);

    this.boot();

    equal(router.get('location.path'), '/parent/child');

    var parentController = container.lookup('controller:parent');
    var parentChildController = container.lookup('controller:parent.child');

    setAndFlush(parentChildController, 'page', 2);
    equal(router.get('location.path'), '/parent/child?page=2');
    equal(parentController.get('page'), 1);
    equal(parentChildController.get('page'), 2);

    setAndFlush(parentController, 'page', 2);
    equal(router.get('location.path'), '/parent/child?page=2&yespage=2');
    equal(parentController.get('page'), 2);
    equal(parentChildController.get('page'), 2);
  });
});
enifed('ember/tests/routing/query_params_test/overlapping_query_params_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember/tests/routing/query_params_test');
  test('ember/tests/routing/query_params_test/overlapping_query_params_test.js should pass jscs', function () {
    ok(true, 'ember/tests/routing/query_params_test/overlapping_query_params_test.js should pass jscs.');
  });
});
enifed('ember/tests/routing/query_params_test/overlapping_query_params_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember/tests/routing/query_params_test');
  QUnit.test('ember/tests/routing/query_params_test/overlapping_query_params_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember/tests/routing/query_params_test/overlapping_query_params_test.js should pass jshint.');
  });
});
enifed('ember/tests/routing/query_params_test/query_params_paramless_link_to_test', ['exports', 'ember', 'ember-metal/core', 'ember-metal/features', 'ember-runtime/system/string', 'ember-template-compiler'], function (exports, _ember, _emberMetalCore, _emberMetalFeatures, _emberRuntimeSystemString, _emberTemplateCompiler) {
  'use strict';

  var App, Router, container, router, registry;
  var expectedReplaceURL, expectedPushURL;

  var TestLocation = _emberMetalCore.default.NoneLocation.extend({
    initState: function () {
      this.set('path', startingURL);
    },

    setURL: function (path) {
      if (expectedReplaceURL) {
        ok(false, 'pushState occurred but a replaceState was expected');
      }
      if (expectedPushURL) {
        equal(path, expectedPushURL, 'an expected pushState occurred');
        expectedPushURL = null;
      }
      this.set('path', path);
    },

    replaceURL: function (path) {
      if (expectedPushURL) {
        ok(false, 'replaceState occurred but a pushState was expected');
      }
      if (expectedReplaceURL) {
        equal(path, expectedReplaceURL, 'an expected replaceState occurred');
        expectedReplaceURL = null;
      }
      this.set('path', path);
    }
  });

  function bootApplication() {
    router = container.lookup('router:main');
    _emberMetalCore.default.run(App, 'advanceReadiness');
  }

  function sharedSetup() {
    _emberMetalCore.default.run(function () {
      App = _emberMetalCore.default.Application.create({
        name: 'App',
        rootElement: '#qunit-fixture'
      });

      App.deferReadiness();

      registry = App.registry;
      container = App.__container__;

      registry.register('location:test', TestLocation);

      startingURL = expectedReplaceURL = expectedPushURL = '';

      App.Router.reopen({
        location: 'test'
      });

      Router = App.Router;

      App.LoadingRoute = _emberMetalCore.default.Route.extend({});

      _emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('{{outlet}}');
      _emberMetalCore.default.TEMPLATES.home = _emberTemplateCompiler.compile('<h3>Hours</h3>');
    });
  }

  function sharedTeardown() {
    _emberMetalCore.default.run(function () {
      App.destroy();
      App = null;

      _emberMetalCore.default.TEMPLATES = {};
    });
  }

  QUnit.module('Routing with Query Params', {
    setup: function () {
      sharedSetup();
    },

    teardown: function () {
      sharedTeardown();
    }
  });

  var startingURL = '';

  var testParamlessLinks = function (routeName) {
    QUnit.test('param-less links in an app booted with query params in the URL don\'t reset the query params: ' + routeName, function () {
      expect(1);

      _emberMetalCore.default.TEMPLATES[routeName] = _emberTemplateCompiler.compile('{{link-to \'index\' \'index\' id=\'index-link\'}}');

      App[_emberRuntimeSystemString.capitalize(routeName) + 'Controller'] = _emberMetalCore.default.Controller.extend({
        queryParams: ['foo'],
        foo: 'wat'
      });

      startingURL = '/?foo=YEAH';
      bootApplication();

      equal(_emberMetalCore.default.$('#index-link').attr('href'), '/?foo=YEAH');
    });
  };

  var testParamlessLinksWithRouteConfig = function (routeName) {
    QUnit.test('param-less links in an app booted with query params in the URL don\'t reset the query params: ' + routeName, function () {
      expect(1);

      _emberMetalCore.default.TEMPLATES[routeName] = _emberTemplateCompiler.compile('{{link-to \'index\' \'index\' id=\'index-link\'}}');

      App[_emberRuntimeSystemString.capitalize(routeName) + 'Route'] = _emberMetalCore.default.Route.extend({
        queryParams: {
          foo: {
            defaultValue: 'wat'
          }
        }
      });

      startingURL = '/?foo=YEAH';
      bootApplication();

      equal(_emberMetalCore.default.$('#index-link').attr('href'), '/?foo=YEAH');
    });
  };

  testParamlessLinks('application');
  testParamlessLinks('index');
});
enifed('ember/tests/routing/query_params_test/query_params_paramless_link_to_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember/tests/routing/query_params_test');
  test('ember/tests/routing/query_params_test/query_params_paramless_link_to_test.js should pass jscs', function () {
    ok(true, 'ember/tests/routing/query_params_test/query_params_paramless_link_to_test.js should pass jscs.');
  });
});
enifed('ember/tests/routing/query_params_test/query_params_paramless_link_to_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember/tests/routing/query_params_test');
  QUnit.test('ember/tests/routing/query_params_test/query_params_paramless_link_to_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember/tests/routing/query_params_test/query_params_paramless_link_to_test.js should pass jshint.');
  });
});
enifed('ember/tests/routing/router_map_test', ['exports', 'ember', 'ember-metal/core', 'ember-template-compiler/system/compile'], function (exports, _ember, _emberMetalCore, _emberTemplateCompilerSystemCompile) {
  'use strict';

  var Router, router, App, container;

  function bootApplication() {
    router = container.lookup('router:main');
    _emberMetalCore.default.run(App, 'advanceReadiness');
  }

  function handleURL(path) {
    return _emberMetalCore.default.run(function () {
      return router.handleURL(path).then(function (value) {
        ok(true, 'url: `' + path + '` was handled');
        return value;
      }, function (reason) {
        ok(false, 'failed to visit:`' + path + '` reason: `' + QUnit.jsDump.parse(reason));
        throw reason;
      });
    });
  }

  QUnit.module('Router.map', {
    setup: function () {
      _emberMetalCore.default.run(function () {
        App = _emberMetalCore.default.Application.create({
          name: 'App',
          rootElement: '#qunit-fixture'
        });

        App.deferReadiness();

        App.Router.reopen({
          location: 'none'
        });

        Router = App.Router;

        container = App.__container__;
      });
    },

    teardown: function () {
      _emberMetalCore.default.run(function () {
        App.destroy();
        App = null;

        _emberMetalCore.default.TEMPLATES = {};
        //Ember.Logger.error = originalLoggerError;
      });
    }
  });

  QUnit.test('Router.map returns an Ember Router class', function () {
    expect(1);

    var ret = App.Router.map(function () {
      this.route('hello');
    });

    ok(_emberMetalCore.default.Router.detect(ret));
  });

  QUnit.test('Router.map can be called multiple times', function () {
    expect(4);

    _emberMetalCore.default.TEMPLATES.hello = _emberTemplateCompilerSystemCompile.default('Hello!');
    _emberMetalCore.default.TEMPLATES.goodbye = _emberTemplateCompilerSystemCompile.default('Goodbye!');

    App.Router.map(function () {
      this.route('hello');
    });

    App.Router.map(function () {
      this.route('goodbye');
    });

    bootApplication();

    handleURL('/hello');

    equal(_emberMetalCore.default.$('#qunit-fixture').text(), 'Hello!', 'The hello template was rendered');

    handleURL('/goodbye');

    equal(_emberMetalCore.default.$('#qunit-fixture').text(), 'Goodbye!', 'The goodbye template was rendered');
  });
});
enifed('ember/tests/routing/router_map_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember/tests/routing');
  test('ember/tests/routing/router_map_test.js should pass jscs', function () {
    ok(true, 'ember/tests/routing/router_map_test.js should pass jscs.');
  });
});
enifed('ember/tests/routing/router_map_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember/tests/routing');
  QUnit.test('ember/tests/routing/router_map_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember/tests/routing/router_map_test.js should pass jshint.');
  });
});
enifed('ember/tests/routing/substates_test', ['exports', 'ember', 'ember-metal/core', 'ember-metal/features', 'ember-template-compiler', 'ember-views/views/view'], function (exports, _ember, _emberMetalCore, _emberMetalFeatures, _emberTemplateCompiler, _emberViewsViewsView) {
  'use strict';

  var Router, App, templates, router, container, counter;

  function step(expectedValue, description) {
    equal(counter, expectedValue, 'Step ' + expectedValue + ': ' + description);
    counter++;
  }

  function bootApplication(startingURL) {

    for (var name in templates) {
      _emberMetalCore.default.TEMPLATES[name] = _emberTemplateCompiler.compile(templates[name]);
    }

    if (startingURL) {
      _emberMetalCore.default.NoneLocation.reopen({
        path: startingURL
      });
    }

    startingURL = startingURL || '';
    router = container.lookup('router:main');
    _emberMetalCore.default.run(App, 'advanceReadiness');
  }

  QUnit.module('Loading/Error Substates', {
    setup: function () {
      counter = 1;

      _emberMetalCore.default.run(function () {
        App = _emberMetalCore.default.Application.create({
          name: 'App',
          rootElement: '#qunit-fixture',
          // fake a modules resolver
          Resolver: _emberMetalCore.default.DefaultResolver.extend({ moduleBasedResolver: true })
        });

        App.deferReadiness();

        App.Router.reopen({
          location: 'none'
        });

        Router = App.Router;

        container = App.__container__;

        templates = {
          application: '<div id="app">{{outlet}}</div>',
          index: 'INDEX',
          loading: 'LOADING',
          bro: 'BRO',
          sis: 'SIS'
        };
      });
    },

    teardown: function () {
      _emberMetalCore.default.run(function () {
        App.destroy();
        App = null;

        _emberMetalCore.default.TEMPLATES = {};
      });

      _emberMetalCore.default.NoneLocation.reopen({
        path: ''
      });
    }
  });

  QUnit.test('Slow promise from a child route of application enters nested loading state', function () {

    var broModel = {};
    var broDeferred = _emberMetalCore.default.RSVP.defer();

    Router.map(function () {
      this.route('bro');
    });

    App.ApplicationRoute = _emberMetalCore.default.Route.extend({
      setupController: function () {
        step(2, 'ApplicationRoute#setup');
      }
    });

    App.BroRoute = _emberMetalCore.default.Route.extend({
      model: function () {
        step(1, 'BroRoute#model');
        return broDeferred.promise;
      }
    });

    bootApplication('/bro');

    equal(_emberMetalCore.default.$('#app', '#qunit-fixture').text(), 'LOADING', 'The Loading template is nested in application template\'s outlet');

    _emberMetalCore.default.run(broDeferred, 'resolve', broModel);

    equal(_emberMetalCore.default.$('#app', '#qunit-fixture').text(), 'BRO', 'bro template has loaded and replaced loading template');
  });

  QUnit.test('Slow promises waterfall on startup', function () {

    expect(7);

    var grandmaDeferred = _emberMetalCore.default.RSVP.defer();
    var sallyDeferred = _emberMetalCore.default.RSVP.defer();

    Router.map(function () {
      this.route('grandma', function () {
        this.route('mom', { resetNamespace: true }, function () {
          this.route('sally');
        });
      });
    });

    templates.grandma = 'GRANDMA {{outlet}}';
    templates.mom = 'MOM {{outlet}}';
    templates['mom/loading'] = 'MOMLOADING';
    templates['mom/sally'] = 'SALLY';

    App.GrandmaRoute = _emberMetalCore.default.Route.extend({
      model: function () {
        step(1, 'GrandmaRoute#model');
        return grandmaDeferred.promise;
      }
    });

    App.MomRoute = _emberMetalCore.default.Route.extend({
      model: function () {
        step(2, 'Mom#model');
        return {};
      }
    });

    App.MomSallyRoute = _emberMetalCore.default.Route.extend({
      model: function () {
        step(3, 'SallyRoute#model');
        return sallyDeferred.promise;
      },
      setupController: function () {
        step(4, 'SallyRoute#setupController');
      }
    });

    bootApplication('/grandma/mom/sally');

    equal(_emberMetalCore.default.$('#app', '#qunit-fixture').text(), 'LOADING', 'The Loading template is nested in application template\'s outlet');

    _emberMetalCore.default.run(grandmaDeferred, 'resolve', {});
    equal(_emberMetalCore.default.$('#app', '#qunit-fixture').text(), 'GRANDMA MOM MOMLOADING', 'Mom\'s child loading route is displayed due to sally\'s slow promise');

    _emberMetalCore.default.run(sallyDeferred, 'resolve', {});
    equal(_emberMetalCore.default.$('#app', '#qunit-fixture').text(), 'GRANDMA MOM SALLY', 'Sally template displayed');
  });

  QUnit.test('ApplicationRoute#currentPath reflects loading state path', function () {

    expect(4);

    var momDeferred = _emberMetalCore.default.RSVP.defer();

    Router.map(function () {
      this.route('grandma', function () {
        this.route('mom');
      });
    });

    templates.grandma = 'GRANDMA {{outlet}}';
    templates['grandma/loading'] = 'GRANDMALOADING';
    templates['grandma/mom'] = 'MOM';

    App.GrandmaMomRoute = _emberMetalCore.default.Route.extend({
      model: function () {
        return momDeferred.promise;
      }
    });

    bootApplication('/grandma/mom');

    equal(_emberMetalCore.default.$('#app', '#qunit-fixture').text(), 'GRANDMA GRANDMALOADING');

    var appController = container.lookup('controller:application');
    equal(appController.get('currentPath'), 'grandma.loading', 'currentPath reflects loading state');

    _emberMetalCore.default.run(momDeferred, 'resolve', {});
    equal(_emberMetalCore.default.$('#app', '#qunit-fixture').text(), 'GRANDMA MOM');
    equal(appController.get('currentPath'), 'grandma.mom', 'currentPath reflects final state');
  });

  QUnit.test('Slow promises returned from ApplicationRoute#model don\'t enter LoadingRoute', function () {

    expect(2);

    var appDeferred = _emberMetalCore.default.RSVP.defer();

    App.ApplicationRoute = _emberMetalCore.default.Route.extend({
      model: function () {
        return appDeferred.promise;
      }
    });

    App.LoadingRoute = _emberMetalCore.default.Route.extend({
      setupController: function () {
        ok(false, 'shouldn\'t get here');
      }
    });

    bootApplication();

    equal(_emberMetalCore.default.$('#app', '#qunit-fixture').text(), '', 'nothing has been rendered yet');

    _emberMetalCore.default.run(appDeferred, 'resolve', {});
    equal(_emberMetalCore.default.$('#app', '#qunit-fixture').text(), 'INDEX');
  });

  QUnit.test('Don\'t enter loading route unless either route or template defined', function () {

    delete templates.loading;

    expect(2);

    var indexDeferred = _emberMetalCore.default.RSVP.defer();

    App.ApplicationController = _emberMetalCore.default.Controller.extend();

    App.IndexRoute = _emberMetalCore.default.Route.extend({
      model: function () {
        return indexDeferred.promise;
      }
    });

    bootApplication();

    var appController = container.lookup('controller:application');
    ok(appController.get('currentPath') !== 'loading', 'loading state not entered');

    _emberMetalCore.default.run(indexDeferred, 'resolve', {});
    equal(_emberMetalCore.default.$('#app', '#qunit-fixture').text(), 'INDEX');
  });

  QUnit.test('Enter loading route if only LoadingRoute defined', function () {

    delete templates.loading;

    expect(4);

    var indexDeferred = _emberMetalCore.default.RSVP.defer();

    App.IndexRoute = _emberMetalCore.default.Route.extend({
      model: function () {
        step(1, 'IndexRoute#model');
        return indexDeferred.promise;
      }
    });

    App.LoadingRoute = _emberMetalCore.default.Route.extend({
      setupController: function () {
        step(2, 'LoadingRoute#setupController');
      }
    });

    bootApplication();

    var appController = container.lookup('controller:application');
    equal(appController.get('currentPath'), 'loading', 'loading state entered');

    _emberMetalCore.default.run(indexDeferred, 'resolve', {});
    equal(_emberMetalCore.default.$('#app', '#qunit-fixture').text(), 'INDEX');
  });

  QUnit.test('Enter child loading state of pivot route', function () {

    expect(4);

    var deferred = _emberMetalCore.default.RSVP.defer();

    Router.map(function () {
      this.route('grandma', function () {
        this.route('mom', { resetNamespace: true }, function () {
          this.route('sally');
        });
        this.route('smells');
      });
    });

    templates['grandma/loading'] = 'GMONEYLOADING';

    App.ApplicationController = _emberMetalCore.default.Controller.extend();

    App.MomSallyRoute = _emberMetalCore.default.Route.extend({
      setupController: function () {
        step(1, 'SallyRoute#setupController');
      }
    });

    App.GrandmaSmellsRoute = _emberMetalCore.default.Route.extend({
      model: function () {
        return deferred.promise;
      }
    });

    bootApplication('/grandma/mom/sally');

    var appController = container.lookup('controller:application');
    equal(appController.get('currentPath'), 'grandma.mom.sally', 'Initial route fully loaded');

    _emberMetalCore.default.run(router, 'transitionTo', 'grandma.smells');
    equal(appController.get('currentPath'), 'grandma.loading', 'in pivot route\'s child loading state');

    _emberMetalCore.default.run(deferred, 'resolve', {});

    equal(appController.get('currentPath'), 'grandma.smells', 'Finished transition');
  });

  QUnit.test('Loading actions bubble to root, but don\'t enter substates above pivot', function () {

    expect(6);

    delete templates.loading;

    var sallyDeferred = _emberMetalCore.default.RSVP.defer();
    var smellsDeferred = _emberMetalCore.default.RSVP.defer();

    Router.map(function () {
      this.route('grandma', function () {
        this.route('mom', { resetNamespace: true }, function () {
          this.route('sally');
        });
        this.route('smells');
      });
    });

    App.ApplicationController = _emberMetalCore.default.Controller.extend();

    App.ApplicationRoute = _emberMetalCore.default.Route.extend({
      actions: {
        loading: function (transition, route) {
          ok(true, 'loading action received on ApplicationRoute');
        }
      }
    });

    App.MomSallyRoute = _emberMetalCore.default.Route.extend({
      model: function () {
        return sallyDeferred.promise;
      }
    });

    App.GrandmaSmellsRoute = _emberMetalCore.default.Route.extend({
      model: function () {
        return smellsDeferred.promise;
      }
    });

    bootApplication('/grandma/mom/sally');

    var appController = container.lookup('controller:application');
    ok(!appController.get('currentPath'), 'Initial route fully loaded');
    _emberMetalCore.default.run(sallyDeferred, 'resolve', {});

    equal(appController.get('currentPath'), 'grandma.mom.sally', 'transition completed');

    _emberMetalCore.default.run(router, 'transitionTo', 'grandma.smells');
    equal(appController.get('currentPath'), 'grandma.mom.sally', 'still in initial state because the only loading state is above the pivot route');

    _emberMetalCore.default.run(smellsDeferred, 'resolve', {});

    equal(appController.get('currentPath'), 'grandma.smells', 'Finished transition');
  });

  QUnit.test('Default error event moves into nested route', function () {

    expect(5);

    templates['grandma'] = 'GRANDMA {{outlet}}';
    templates['grandma/error'] = 'ERROR: {{model.msg}}';

    Router.map(function () {
      this.route('grandma', function () {
        this.route('mom', { resetNamespace: true }, function () {
          this.route('sally');
        });
      });
    });

    App.ApplicationController = _emberMetalCore.default.Controller.extend();

    App.MomSallyRoute = _emberMetalCore.default.Route.extend({
      model: function () {
        step(1, 'MomSallyRoute#model');

        return _emberMetalCore.default.RSVP.reject({
          msg: 'did it broke?'
        });
      },
      actions: {
        error: function () {
          step(2, 'MomSallyRoute#actions.error');
          return true;
        }
      }
    });

    bootApplication('/grandma/mom/sally');

    step(3, 'App finished booting');

    equal(_emberMetalCore.default.$('#app', '#qunit-fixture').text(), 'GRANDMA ERROR: did it broke?', 'error bubbles');

    var appController = container.lookup('controller:application');
    equal(appController.get('currentPath'), 'grandma.error', 'Initial route fully loaded');
  });

  QUnit.test('Setting a query param during a slow transition should work', function () {
    var deferred = _emberMetalCore.default.RSVP.defer();

    Router.map(function () {
      this.route('grandma', { path: '/grandma/:seg' }, function () {});
    });

    templates['grandma/loading'] = 'GMONEYLOADING';

    App.ApplicationController = _emberMetalCore.default.Controller.extend();

    App.IndexRoute = _emberMetalCore.default.Route.extend({
      beforeModel: function () {
        this.transitionTo('grandma', 1);
      }
    });

    App.GrandmaRoute = _emberMetalCore.default.Route.extend({
      queryParams: {
        test: { defaultValue: 1 }
      }
    });

    App.GrandmaIndexRoute = _emberMetalCore.default.Route.extend({
      model: function () {
        return deferred.promise;
      }
    });

    bootApplication('/');

    var appController = container.lookup('controller:application');
    var grandmaController = container.lookup('controller:grandma');

    equal(appController.get('currentPath'), 'grandma.loading', 'Initial route should be loading');

    _emberMetalCore.default.run(function () {
      grandmaController.set('test', 3);
    });

    equal(appController.get('currentPath'), 'grandma.loading', 'Route should still be loading');
    equal(grandmaController.get('test'), 3, 'Controller query param value should have changed');

    _emberMetalCore.default.run(deferred, 'resolve', {});

    equal(appController.get('currentPath'), 'grandma.index', 'Transition should be complete');
  });

  QUnit.test('Slow promises returned from ApplicationRoute#model enter ApplicationLoadingRoute if present', function () {

    expect(2);

    var appDeferred = _emberMetalCore.default.RSVP.defer();

    App.ApplicationRoute = _emberMetalCore.default.Route.extend({
      model: function () {
        return appDeferred.promise;
      }
    });

    var loadingRouteEntered = false;
    App.ApplicationLoadingRoute = _emberMetalCore.default.Route.extend({
      setupController: function () {
        loadingRouteEntered = true;
      }
    });

    bootApplication();

    ok(loadingRouteEntered, 'ApplicationLoadingRoute was entered');

    _emberMetalCore.default.run(appDeferred, 'resolve', {});
    equal(_emberMetalCore.default.$('#app', '#qunit-fixture').text(), 'INDEX');
  });

  QUnit.test('Slow promises returned from ApplicationRoute#model enter application_loading if template present', function () {

    expect(3);

    templates['application_loading'] = 'TOPLEVEL LOADING';

    var appDeferred = _emberMetalCore.default.RSVP.defer();
    App.ApplicationRoute = _emberMetalCore.default.Route.extend({
      model: function () {
        return appDeferred.promise;
      }
    });

    var loadingRouteEntered = false;
    App.ApplicationLoadingRoute = _emberMetalCore.default.Route.extend({
      setupController: function () {
        loadingRouteEntered = true;
      }
    });

    App.ApplicationLoadingView = _emberViewsViewsView.default.extend({
      elementId: 'toplevel-loading'
    });

    bootApplication();

    equal(_emberMetalCore.default.$('#qunit-fixture > #toplevel-loading').text(), 'TOPLEVEL LOADING');

    _emberMetalCore.default.run(appDeferred, 'resolve', {});

    equal(_emberMetalCore.default.$('#toplevel-loading', '#qunit-fixture').length, 0, 'top-level loading View has been entirely removed from DOM');
    equal(_emberMetalCore.default.$('#app', '#qunit-fixture').text(), 'INDEX');
  });

  QUnit.test('Default error event moves into nested route, prioritizing more specifically named error route', function () {

    expect(5);

    templates['grandma'] = 'GRANDMA {{outlet}}';
    templates['grandma/error'] = 'ERROR: {{model.msg}}';
    templates['grandma/mom_error'] = 'MOM ERROR: {{model.msg}}';

    Router.map(function () {
      this.route('grandma', function () {
        this.route('mom', { resetNamespace: true }, function () {
          this.route('sally');
        });
      });
    });

    App.ApplicationController = _emberMetalCore.default.Controller.extend();

    App.MomSallyRoute = _emberMetalCore.default.Route.extend({
      model: function () {
        step(1, 'MomSallyRoute#model');

        return _emberMetalCore.default.RSVP.reject({
          msg: 'did it broke?'
        });
      },
      actions: {
        error: function () {
          step(2, 'MomSallyRoute#actions.error');
          return true;
        }
      }
    });

    bootApplication('/grandma/mom/sally');

    step(3, 'App finished booting');

    equal(_emberMetalCore.default.$('#app', '#qunit-fixture').text(), 'GRANDMA MOM ERROR: did it broke?', 'the more specifically-named mom error substate was entered over the other error route');

    var appController = container.lookup('controller:application');
    equal(appController.get('currentPath'), 'grandma.mom_error', 'Initial route fully loaded');
  });

  QUnit.test('Prioritized substate entry works with preserved-namespace nested routes', function () {

    expect(2);

    templates['foo/bar_loading'] = 'FOOBAR LOADING';
    templates['foo/bar/index'] = 'YAY';

    Router.map(function () {
      this.route('foo', function () {
        this.route('foo.bar', { path: '/bar', resetNamespace: true }, function () {});
      });
    });

    App.ApplicationController = _emberMetalCore.default.Controller.extend();

    var deferred = _emberMetalCore.default.RSVP.defer();
    App.FooBarRoute = _emberMetalCore.default.Route.extend({
      model: function () {
        return deferred.promise;
      }
    });

    bootApplication('/foo/bar');

    equal(_emberMetalCore.default.$('#app', '#qunit-fixture').text(), 'FOOBAR LOADING', 'foo.bar_loading was entered (as opposed to something like foo/foo/bar_loading)');

    _emberMetalCore.default.run(deferred, 'resolve');

    equal(_emberMetalCore.default.$('#app', '#qunit-fixture').text(), 'YAY');
  });

  QUnit.test('Prioritized loading substate entry works with preserved-namespace nested routes', function () {

    expect(2);

    templates['foo/bar_loading'] = 'FOOBAR LOADING';
    templates['foo/bar'] = 'YAY';

    Router.map(function () {
      this.route('foo', function () {
        this.route('bar');
      });
    });

    App.ApplicationController = _emberMetalCore.default.Controller.extend();

    var deferred = _emberMetalCore.default.RSVP.defer();
    App.FooBarRoute = _emberMetalCore.default.Route.extend({
      model: function () {
        return deferred.promise;
      }
    });

    bootApplication('/foo/bar');

    equal(_emberMetalCore.default.$('#app', '#qunit-fixture').text(), 'FOOBAR LOADING', 'foo.bar_loading was entered (as opposed to something like foo/foo/bar_loading)');

    _emberMetalCore.default.run(deferred, 'resolve');

    equal(_emberMetalCore.default.$('#app', '#qunit-fixture').text(), 'YAY');
  });

  QUnit.test('Prioritized error substate entry works with preserved-namespace nested routes', function () {

    expect(1);

    templates['foo/bar_error'] = 'FOOBAR ERROR: {{model.msg}}';
    templates['foo/bar'] = 'YAY';

    Router.map(function () {
      this.route('foo', function () {
        this.route('bar');
      });
    });

    App.ApplicationController = _emberMetalCore.default.Controller.extend();

    App.FooBarRoute = _emberMetalCore.default.Route.extend({
      model: function () {
        return _emberMetalCore.default.RSVP.reject({
          msg: 'did it broke?'
        });
      }
    });

    bootApplication('/foo/bar');

    equal(_emberMetalCore.default.$('#app', '#qunit-fixture').text(), 'FOOBAR ERROR: did it broke?', 'foo.bar_error was entered (as opposed to something like foo/foo/bar_error)');
  });

  QUnit.test('Prioritized loading substate entry works with auto-generated index routes', function () {

    expect(2);

    templates['foo/index_loading'] = 'FOO LOADING';
    templates['foo/index'] = 'YAY';
    templates['foo'] = '{{outlet}}';

    Router.map(function () {
      this.route('foo', function () {
        this.route('bar');
      });
    });

    App.ApplicationController = _emberMetalCore.default.Controller.extend();

    var deferred = _emberMetalCore.default.RSVP.defer();
    App.FooIndexRoute = _emberMetalCore.default.Route.extend({
      model: function () {
        return deferred.promise;
      }
    });
    App.FooRoute = _emberMetalCore.default.Route.extend({
      model: function () {
        return true;
      }
    });

    bootApplication('/foo');

    equal(_emberMetalCore.default.$('#app', '#qunit-fixture').text(), 'FOO LOADING', 'foo.index_loading was entered');

    _emberMetalCore.default.run(deferred, 'resolve');

    equal(_emberMetalCore.default.$('#app', '#qunit-fixture').text(), 'YAY');
  });

  QUnit.test('Prioritized error substate entry works with auto-generated index routes', function () {

    expect(1);

    templates['foo/index_error'] = 'FOO ERROR: {{model.msg}}';
    templates['foo/index'] = 'YAY';
    templates['foo'] = '{{outlet}}';

    Router.map(function () {
      this.route('foo', function () {
        this.route('bar');
      });
    });

    App.ApplicationController = _emberMetalCore.default.Controller.extend();

    App.FooIndexRoute = _emberMetalCore.default.Route.extend({
      model: function () {
        return _emberMetalCore.default.RSVP.reject({
          msg: 'did it broke?'
        });
      }
    });
    App.FooRoute = _emberMetalCore.default.Route.extend({
      model: function () {
        return true;
      }
    });

    bootApplication('/foo');

    equal(_emberMetalCore.default.$('#app', '#qunit-fixture').text(), 'FOO ERROR: did it broke?', 'foo.index_error was entered');
  });

  QUnit.test('Rejected promises returned from ApplicationRoute transition into top-level application_error', function () {

    expect(2);

    templates['application_error'] = '<p id="toplevel-error">TOPLEVEL ERROR: {{model.msg}}</p>';

    var reject = true;
    App.ApplicationRoute = _emberMetalCore.default.Route.extend({
      model: function () {
        if (reject) {
          return _emberMetalCore.default.RSVP.reject({ msg: 'BAD NEWS BEARS' });
        } else {
          return {};
        }
      }
    });

    bootApplication();

    equal(_emberMetalCore.default.$('#toplevel-error', '#qunit-fixture').text(), 'TOPLEVEL ERROR: BAD NEWS BEARS');

    reject = false;
    _emberMetalCore.default.run(router, 'transitionTo', 'index');

    equal(_emberMetalCore.default.$('#app', '#qunit-fixture').text(), 'INDEX');
  });
});
enifed('ember/tests/routing/substates_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember/tests/routing');
  test('ember/tests/routing/substates_test.js should pass jscs', function () {
    ok(true, 'ember/tests/routing/substates_test.js should pass jscs.');
  });
});
enifed('ember/tests/routing/substates_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember/tests/routing');
  QUnit.test('ember/tests/routing/substates_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember/tests/routing/substates_test.js should pass jshint.');
  });
});
enifed('ember/tests/routing/toplevel_dom_test', ['exports', 'ember', 'ember-metal/core', 'ember-template-compiler', 'ember-views/views/view'], function (exports, _ember, _emberMetalCore, _emberTemplateCompiler, _emberViewsViewsView) {
  'use strict';

  var Router, App, templates, router, container;

  function bootApplication() {
    for (var name in templates) {
      _emberMetalCore.default.TEMPLATES[name] = _emberTemplateCompiler.compile(templates[name]);
    }
    router = container.lookup('router:main');
    _emberMetalCore.default.run(App, 'advanceReadiness');
  }

  QUnit.module('Top Level DOM Structure', {
    setup: function () {
      _emberMetalCore.default.run(function () {
        App = _emberMetalCore.default.Application.create({
          name: 'App',
          rootElement: '#qunit-fixture'
        });

        App.deferReadiness();

        App.Router.reopen({
          location: 'none'
        });

        Router = App.Router;

        container = App.__container__;

        templates = {
          application: 'hello world'
        };
      });
    },

    teardown: function () {
      _emberMetalCore.default.run(function () {
        App.destroy();
        App = null;

        _emberMetalCore.default.TEMPLATES = {};
      });

      _emberMetalCore.default.NoneLocation.reopen({
        path: ''
      });
    }
  });

  QUnit.test('Topmost template always get an element', function () {
    bootApplication();
    equal(_emberMetalCore.default.$('#qunit-fixture > .ember-view').text(), 'hello world');
  });

  QUnit.test('If topmost view has its own element, it doesn\'t get wrapped in a higher element', function () {
    App.registry.register('view:application', _emberViewsViewsView.default.extend({
      classNames: ['im-special']
    }));
    bootApplication();
    equal(_emberMetalCore.default.$('#qunit-fixture > .im-special').text(), 'hello world');
  });
});
enifed('ember/tests/routing/toplevel_dom_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember/tests/routing');
  test('ember/tests/routing/toplevel_dom_test.js should pass jscs', function () {
    ok(true, 'ember/tests/routing/toplevel_dom_test.js should pass jscs.');
  });
});
enifed('ember/tests/routing/toplevel_dom_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember/tests/routing');
  QUnit.test('ember/tests/routing/toplevel_dom_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember/tests/routing/toplevel_dom_test.js should pass jshint.');
  });
});
enifed('ember/tests/view_instrumentation_test', ['exports', 'ember-metal/core', 'ember-metal/run_loop', 'ember-views/system/jquery', 'ember-metal/instrumentation', 'ember-template-compiler'], function (exports, _emberMetalCore, _emberMetalRun_loop, _emberViewsSystemJquery, _emberMetalInstrumentation, _emberTemplateCompiler) {
  'use strict';

  var App, $fixture;

  function setupExample() {
    // setup templates
    _emberMetalCore.default.TEMPLATES.application = _emberTemplateCompiler.compile('{{outlet}}');
    _emberMetalCore.default.TEMPLATES.index = _emberTemplateCompiler.compile('<h1>Node 1</h1>');
    _emberMetalCore.default.TEMPLATES.posts = _emberTemplateCompiler.compile('<h1>Node 1</h1>');

    App.Router.map(function () {
      this.route('posts');
    });
  }

  function handleURL(path) {
    var router = App.__container__.lookup('router:main');
    return _emberMetalRun_loop.default(router, 'handleURL', path);
  }

  QUnit.module('View Instrumentation', {
    setup: function () {
      _emberMetalRun_loop.default(function () {
        App = _emberMetalCore.default.Application.create({
          rootElement: '#qunit-fixture'
        });
        App.deferReadiness();

        App.Router.reopen({
          location: 'none'
        });
      });

      $fixture = _emberViewsSystemJquery.default('#qunit-fixture');
      setupExample();
    },

    teardown: function () {
      _emberMetalRun_loop.default(App, 'destroy');
      App = null;
      _emberMetalCore.default.TEMPLATES = {};
    }
  });

  QUnit.test('Nodes without view instances are instrumented', function (assert) {
    var called = false;
    var subscriber = _emberMetalInstrumentation.subscribe('render', {
      before: function () {
        called = true;
      },
      after: function () {}
    });
    _emberMetalRun_loop.default(App, 'advanceReadiness');
    assert.ok(called, 'Instrumentation called on first render');
    called = false;
    handleURL('/posts');
    assert.ok(called, 'instrumentation called on transition to non-view backed route');
    _emberMetalInstrumentation.unsubscribe(subscriber);
  });
});
enifed('ember/tests/view_instrumentation_test.jscs-test', ['exports'], function (exports) {
  'use strict';

  module('JSCS - ember/tests');
  test('ember/tests/view_instrumentation_test.js should pass jscs', function () {
    ok(true, 'ember/tests/view_instrumentation_test.js should pass jscs.');
  });
});
enifed('ember/tests/view_instrumentation_test.jshint', ['exports'], function (exports) {
  'use strict';

  QUnit.module('JSHint - ember/tests');
  QUnit.test('ember/tests/view_instrumentation_test.js should pass jshint', function (assert) {
    assert.expect(1);
    assert.ok(true, 'ember/tests/view_instrumentation_test.js should pass jshint.');
  });
});
})();