discourse-ember-source 3.5.1.1 → 3.5.1.2

data/dist/es/ember-runtime/tests/inject_test.js

@@ -1,51 +0,0 @@
-import { InjectedProperty } from 'ember-metal';
-import { DEBUG } from '@glimmer/env';
-import EmberObject from '../lib/system/object';
-import { buildOwner } from 'internal-test-helpers';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-moduleFor(
-  'inject',
-  class extends AbstractTestCase {
-    ['@test attempting to inject a nonexistent container key should error']() {
-      let owner = buildOwner();
-      let AnObject = EmberObject.extend({
-        foo: new InjectedProperty('bar', 'baz'),
-      });
-
-      owner.register('foo:main', AnObject);
-
-      expectAssertion(() => {
-        owner.lookup('foo:main');
-      }, /Attempting to inject an unknown injection: 'bar:baz'/);
-    }
-
-    ['@test factories should return a list of lazy injection full names'](assert) {
-      if (DEBUG) {
-        let AnObject = EmberObject.extend({
-          foo: new InjectedProperty('foo', 'bar'),
-          bar: new InjectedProperty('quux'),
-        });
-
-        assert.deepEqual(
-          AnObject._lazyInjections(),
-          {
-            foo: {
-              specifier: 'foo:bar',
-              source: undefined,
-              namespace: undefined,
-            },
-            bar: {
-              specifier: 'quux:bar',
-              source: undefined,
-              namespace: undefined,
-            },
-          },
-          'should return injected container keys'
-        );
-      } else {
-        assert.expect(0);
-      }
-    }
-  }
-);

data/dist/es/ember-runtime/tests/legacy_1x/mixins/observable/chained_test.js

@@ -1,63 +0,0 @@
-import { run } from '@ember/runloop';
-import { get, set, addObserver } from 'ember-metal';
-import EmberObject from '../../../../lib/system/object';
-import { A as emberA } from '../../../../lib/mixins/array';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-/*
-  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()
-*/
-
-moduleFor(
-  'Ember.Observable - Observing with @each',
-  class extends AbstractTestCase {
-    ['@test chained observers on enumerable properties are triggered when the observed property of any item changes'](
-      assert
-    ) {
-      let family = EmberObject.create({ momma: null });
-      let momma = EmberObject.create({ children: [] });
-
-      let child1 = EmberObject.create({ name: 'Bartholomew' });
-      let child2 = EmberObject.create({ name: 'Agnes' });
-      let child3 = EmberObject.create({ name: 'Dan' });
-      let child4 = EmberObject.create({ name: 'Nancy' });
-
-      set(family, 'momma', momma);
-      set(momma, 'children', emberA([child1, child2, child3]));
-
-      let observerFiredCount = 0;
-      addObserver(family, 'momma.children.@each.name', this, function() {
-        observerFiredCount++;
-      });
-
-      observerFiredCount = 0;
-      run(() => get(momma, 'children').setEach('name', 'Juan'));
-      assert.equal(observerFiredCount, 3, 'observer fired after changing child names');
-
-      observerFiredCount = 0;
-      run(() => get(momma, 'children').pushObject(child4));
-      assert.equal(observerFiredCount, 1, 'observer fired after adding a new item');
-
-      observerFiredCount = 0;
-      run(() => set(child4, 'name', 'Herbert'));
-      assert.equal(observerFiredCount, 1, 'observer fired after changing property on new object');
-
-      set(momma, 'children', []);
-
-      observerFiredCount = 0;
-      run(() => set(child1, 'name', 'Hanna'));
-      assert.equal(
-        observerFiredCount,
-        0,
-        'observer did not fire after removing changing property on a removed object'
-      );
-    }
-  }
-);

data/dist/es/ember-runtime/tests/legacy_1x/mixins/observable/observable_test.js

@@ -1,892 +0,0 @@
-import { context } from 'ember-environment';
-import { run } from '@ember/runloop';
-import { get, computed, observer } from 'ember-metal';
-import { w } from '@ember/string';
-import EmberObject from '../../../../lib/system/object';
-import Observable from '../../../../lib/mixins/observable';
-import { A as emberA } from '../../../../lib/mixins/array';
-import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
-
-/*
-  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(...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.
-  * 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 = EmberObject.extend(Observable);
-var originalLookup = context.lookup;
-
-// ..........................................................
-// GET()
-//
-
-moduleFor(
-  'object.get()',
-  class extends AbstractTestCase {
-    beforeEach() {
-      object = ObservableObject.extend(Observable, {
-        computed: computed(function() {
-          return 'value';
-        }).volatile(),
-        method() {
-          return 'value';
-        },
-        unknownProperty(key) {
-          this.lastUnknownProperty = key;
-          return 'unknown';
-        },
-      }).create({
-        normal: 'value',
-        numberVal: 24,
-        toggleVal: true,
-        nullProperty: null,
-      });
-    }
-
-    ['@test should get normal properties'](assert) {
-      assert.equal(object.get('normal'), 'value');
-    }
-
-    ['@test should call computed properties and return their result'](assert) {
-      assert.equal(object.get('computed'), 'value');
-    }
-
-    ['@test should return the function for a non-computed property'](assert) {
-      var value = object.get('method');
-      assert.equal(typeof value, 'function');
-    }
-
-    ['@test should return null when property value is null'](assert) {
-      assert.equal(object.get('nullProperty'), null);
-    }
-
-    ['@test should call unknownProperty when value is undefined'](assert) {
-      assert.equal(object.get('unknown'), 'unknown');
-      assert.equal(object.lastUnknownProperty, 'unknown');
-    }
-  }
-);
-// ..........................................................
-// Ember.GET()
-//
-moduleFor(
-  'Ember.get()',
-  class extends AbstractTestCase {
-    beforeEach() {
-      objectA = ObservableObject.extend({
-        computed: computed(function() {
-          return 'value';
-        }).volatile(),
-        method() {
-          return 'value';
-        },
-        unknownProperty(key) {
-          this.lastUnknownProperty = key;
-          return 'unknown';
-        },
-      }).create({
-        normal: 'value',
-        numberVal: 24,
-        toggleVal: true,
-        nullProperty: null,
-      });
-
-      objectB = {
-        normal: 'value',
-        nullProperty: null,
-      };
-    }
-
-    ['@test should get normal properties on Ember.Observable'](assert) {
-      assert.equal(get(objectA, 'normal'), 'value');
-    }
-
-    ['@test should call computed properties on Ember.Observable and return their result'](assert) {
-      assert.equal(get(objectA, 'computed'), 'value');
-    }
-
-    ['@test should return the function for a non-computed property on Ember.Observable'](assert) {
-      var value = get(objectA, 'method');
-      assert.equal(typeof value, 'function');
-    }
-
-    ['@test should return null when property value is null on Ember.Observable'](assert) {
-      assert.equal(get(objectA, 'nullProperty'), null);
-    }
-
-    ['@test should call unknownProperty when value is undefined on Ember.Observable'](assert) {
-      assert.equal(get(objectA, 'unknown'), 'unknown');
-      assert.equal(objectA.lastUnknownProperty, 'unknown');
-    }
-
-    ['@test should get normal properties on standard objects'](assert) {
-      assert.equal(get(objectB, 'normal'), 'value');
-    }
-
-    ['@test should return null when property is null on standard objects'](assert) {
-      assert.equal(get(objectB, 'nullProperty'), null);
-    }
-
-    ['@test raise if the provided object is undefined']() {
-      expectAssertion(function() {
-        get(undefined, 'key');
-      }, /Cannot call get with 'key' on an undefined object/i);
-    }
-  }
-);
-
-moduleFor(
-  'Ember.get() with paths',
-  class extends AbstractTestCase {
-    ['@test should return a property at a given path relative to the passed object'](assert) {
-      var foo = ObservableObject.create({
-        bar: ObservableObject.extend({
-          baz: computed(function() {
-            return 'blargh';
-          }).volatile(),
-        }).create(),
-      });
-
-      assert.equal(get(foo, 'bar.baz'), 'blargh');
-    }
-
-    ['@test should return a property at a given path relative to the passed object - JavaScript hash'](
-      assert
-    ) {
-      var foo = {
-        bar: {
-          baz: 'blargh',
-        },
-      };
-
-      assert.equal(get(foo, 'bar.baz'), 'blargh');
-    }
-  }
-);
-
-// ..........................................................
-// SET()
-//
-
-moduleFor(
-  'object.set()',
-  class extends AbstractTestCase {
-    beforeEach() {
-      object = ObservableObject.extend({
-        computed: computed({
-          get() {
-            return this._computed;
-          },
-          set(key, value) {
-            this._computed = value;
-            return this._computed;
-          },
-        }).volatile(),
-
-        method(key, value) {
-          if (value !== undefined) {
-            this._method = value;
-          }
-          return this._method;
-        },
-
-        unknownProperty() {
-          return this._unknown;
-        },
-
-        setUnknownProperty(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();
-    }
-
-    ['@test should change normal properties and return the value'](assert) {
-      var ret = object.set('normal', 'changed');
-      assert.equal(object.get('normal'), 'changed');
-      assert.equal(ret, 'changed');
-    }
-
-    ['@test should call computed properties passing value and return the value'](assert) {
-      var ret = object.set('computed', 'changed');
-      assert.equal(object.get('_computed'), 'changed');
-      assert.equal(ret, 'changed');
-    }
-
-    ['@test should change normal properties when passing undefined'](assert) {
-      var ret = object.set('normal', undefined);
-      assert.equal(object.get('normal'), undefined);
-      assert.equal(ret, undefined);
-    }
-
-    ['@test should replace the function for a non-computed property and return the value'](assert) {
-      var ret = object.set('method', 'changed');
-      assert.equal(object.get('_method'), 'method'); // make sure this was NOT run
-      assert.ok(typeof object.get('method') !== 'function');
-      assert.equal(ret, 'changed');
-    }
-
-    ['@test should replace prover when property value is null'](assert) {
-      var ret = object.set('nullProperty', 'changed');
-      assert.equal(object.get('nullProperty'), 'changed');
-      assert.equal(ret, 'changed');
-    }
-
-    ['@test should call unknownProperty with value when property is undefined'](assert) {
-      var ret = object.set('unknown', 'changed');
-      assert.equal(object.get('_unknown'), 'changed');
-      assert.equal(ret, 'changed');
-    }
-  }
-);
-
-// ..........................................................
-// COMPUTED PROPERTIES
-//
-
-moduleFor(
-  'Computed properties',
-  class extends AbstractTestCase {
-    beforeEach() {
-      lookup = context.lookup = {};
-
-      object = ObservableObject.extend({
-        computed: computed({
-          get() {
-            this.computedCalls.push('getter-called');
-            return 'computed';
-          },
-          set(key, value) {
-            this.computedCalls.push(value);
-          },
-        }).volatile(),
-
-        computedCached: computed({
-          get() {
-            this.computedCachedCalls.push('getter-called');
-            return 'computedCached';
-          },
-          set: function(key, value) {
-            this.computedCachedCalls.push(value);
-          },
-        }),
-
-        dependent: computed({
-          get() {
-            this.dependentCalls.push('getter-called');
-            return 'dependent';
-          },
-          set(key, value) {
-            this.dependentCalls.push(value);
-          },
-        })
-          .property('changer')
-          .volatile(),
-        dependentFront: computed('changer', {
-          get() {
-            this.dependentFrontCalls.push('getter-called');
-            return 'dependentFront';
-          },
-          set(key, value) {
-            this.dependentFrontCalls.push(value);
-          },
-        }).volatile(),
-        dependentCached: computed({
-          get() {
-            this.dependentCachedCalls.push('getter-called!');
-            return 'dependentCached';
-          },
-          set(key, value) {
-            this.dependentCachedCalls.push(value);
-          },
-        }).property('changer'),
-
-        inc: computed('changer', function() {
-          return this.incCallCount++;
-        }),
-
-        nestedInc: computed(function() {
-          get(this, 'inc');
-          return this.nestedIncCallCount++;
-        }).property('inc'),
-
-        isOn: computed({
-          get() {
-            return this.get('state') === 'on';
-          },
-          set() {
-            this.set('state', 'on');
-            return this.get('state') === 'on';
-          },
-        })
-          .property('state')
-          .volatile(),
-
-        isOff: computed({
-          get() {
-            return this.get('state') === 'off';
-          },
-          set() {
-            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',
-      });
-    }
-    afterEach() {
-      context.lookup = originalLookup;
-    }
-
-    ['@test getting values should call function return value'](assert) {
-      // get each property twice. Verify return.
-      var keys = w('computed computedCached dependent dependentFront dependentCached');
-
-      keys.forEach(function(key) {
-        assert.equal(object.get(key), key, `Try #1: object.get(${key}) should run function`);
-        assert.equal(object.get(key), key, `Try #2: object.get(${key}) should run function`);
-      });
-
-      // verify each call count.  cached should only be called once
-      w('computedCalls dependentFrontCalls dependentCalls').forEach(key => {
-        assert.equal(object[key].length, 2, `non-cached property ${key} should be called 2x`);
-      });
-
-      w('computedCachedCalls dependentCachedCalls').forEach(key => {
-        assert.equal(object[key].length, 1, `non-cached property ${key} should be called 1x`);
-      });
-    }
-
-    ['@test setting values should call function return value'](assert) {
-      // get each property twice. Verify return.
-      var keys = w('computed dependent dependentFront computedCached dependentCached');
-      var values = w('value1 value2');
-
-      keys.forEach(key => {
-        assert.equal(
-          object.set(key, values[0]),
-          values[0],
-          `Try #1: object.set(${key}, ${values[0]}) should run function`
-        );
-
-        assert.equal(
-          object.set(key, values[1]),
-          values[1],
-          `Try #2: object.set(${key}, ${values[1]}) should run function`
-        );
-
-        assert.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(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;
-        assert.equal(
-          calls.length,
-          expectedLength,
-          `set(${key}) should be called the right amount of times`
-        );
-        for (idx = 0; idx < 2; idx++) {
-          assert.equal(
-            calls[idx],
-            values[idx],
-            `call #${idx + 1} to set(${key}) should have passed value ${values[idx]}`
-          );
-        }
-      });
-    }
-
-    ['@test notify change should clear cache'](assert) {
-      // call get several times to collect call count
-      object.get('computedCached'); // should run func
-      object.get('computedCached'); // should not run func
-
-      object.notifyPropertyChange('computedCached');
-
-      object.get('computedCached'); // should run again
-      assert.equal(object.computedCachedCalls.length, 2, 'should have invoked method 2x');
-    }
-
-    ['@test change dependent should clear cache'](assert) {
-      // call get several times to collect call count
-      var ret1 = object.get('inc'); // should run func
-      assert.equal(object.get('inc'), ret1, 'multiple calls should not run cached prop');
-
-      object.set('changer', 'bar');
-
-      assert.equal(object.get('inc'), ret1 + 1, 'should increment after dependent key changes'); // should run again
-    }
-
-    ['@test just notifying change of dependent should clear cache'](assert) {
-      // call get several times to collect call count
-      var ret1 = object.get('inc'); // should run func
-      assert.equal(object.get('inc'), ret1, 'multiple calls should not run cached prop');
-
-      object.notifyPropertyChange('changer');
-
-      assert.equal(object.get('inc'), ret1 + 1, 'should increment after dependent key changes'); // should run again
-    }
-
-    ['@test changing dependent should clear nested cache'](assert) {
-      // call get several times to collect call count
-      var ret1 = object.get('nestedInc'); // should run func
-      assert.equal(object.get('nestedInc'), ret1, 'multiple calls should not run cached prop');
-
-      object.set('changer', 'bar');
-
-      assert.equal(
-        object.get('nestedInc'),
-        ret1 + 1,
-        'should increment after dependent key changes'
-      ); // should run again
-    }
-
-    ['@test just notifying change of dependent should clear nested cache'](assert) {
-      // call get several times to collect call count
-      var ret1 = object.get('nestedInc'); // should run func
-      assert.equal(object.get('nestedInc'), ret1, 'multiple calls should not run cached prop');
-
-      object.notifyPropertyChange('changer');
-
-      assert.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.
-    ['@test change dependent should clear cache when observers of dependent are called'](assert) {
-      // call get several times to collect call count
-      var ret1 = object.get('inc'); // should run func
-      assert.equal(object.get('inc'), ret1, 'multiple calls should not run cached prop');
-
-      // add observer to verify change...
-      object.addObserver('inc', this, function() {
-        assert.equal(object.get('inc'), ret1 + 1, 'should increment after dependent key changes'); // should run again
-      });
-
-      // now run
-      object.set('changer', 'bar');
-    }
-
-    ['@test setting one of two computed properties that depend on a third property should clear the kvo cache'](
-      assert
-    ) {
-      // 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);
-      assert.equal(object.get('isOff'), true, 'object.isOff should be true');
-      assert.equal(object.get('isOn'), false, 'object.isOn should be false');
-    }
-
-    ['@test dependent keys should be able to be specified as property paths'](assert) {
-      var depObj = ObservableObject.extend({
-        menuPrice: computed(function() {
-          return this.get('menu.price');
-        }).property('menu.price'),
-      }).create({
-        menu: ObservableObject.create({
-          price: 5,
-        }),
-      });
-
-      assert.equal(depObj.get('menuPrice'), 5, 'precond - initial value returns 5');
-
-      depObj.set('menu.price', 6);
-
-      assert.equal(
-        depObj.get('menuPrice'),
-        6,
-        'cache is properly invalidated after nested property changes'
-      );
-    }
-
-    ['@test cacheable nested dependent keys should clear after their dependencies update'](assert) {
-      assert.ok(true);
-
-      var DepObj;
-
-      run(function() {
-        lookup.DepObj = DepObj = ObservableObject.extend({
-          price: computed('restaurant.menu.price', function() {
-            return this.get('restaurant.menu.price');
-          }),
-        }).create({
-          restaurant: ObservableObject.create({
-            menu: ObservableObject.create({
-              price: 5,
-            }),
-          }),
-        });
-      });
-
-      assert.equal(DepObj.get('price'), 5, 'precond - computed property is correct');
-
-      run(function() {
-        DepObj.set('restaurant.menu.price', 10);
-      });
-      assert.equal(
-        DepObj.get('price'),
-        10,
-        'cacheable computed properties are invalidated even if no run loop occurred'
-      );
-
-      run(function() {
-        DepObj.set('restaurant.menu.price', 20);
-      });
-      assert.equal(
-        DepObj.get('price'),
-        20,
-        'cacheable computed properties are invalidated after a second get before a run loop'
-      );
-      assert.equal(
-        DepObj.get('price'),
-        20,
-        'precond - computed properties remain correct after a run loop'
-      );
-
-      run(function() {
-        DepObj.set(
-          'restaurant.menu',
-          ObservableObject.create({
-            price: 15,
-          })
-        );
-      });
-
-      assert.equal(
-        DepObj.get('price'),
-        15,
-        'cacheable computed properties are invalidated after a middle property changes'
-      );
-
-      run(function() {
-        DepObj.set(
-          'restaurant.menu',
-          ObservableObject.create({
-            price: 25,
-          })
-        );
-      });
-
-      assert.equal(
-        DepObj.get('price'),
-        25,
-        'cacheable computed properties are invalidated after a middle property changes again, before a run loop'
-      );
-    }
-  }
-);
-
-// ..........................................................
-// OBSERVABLE OBJECTS
-//
-
-moduleFor(
-  'Observable objects & object properties ',
-  class extends AbstractTestCase {
-    beforeEach() {
-      object = ObservableObject.extend({
-        getEach() {
-          var keys = ['normal', 'abnormal'];
-          var ret = [];
-          for (var idx = 0; idx < keys.length; idx++) {
-            ret[ret.length] = this.get(keys[idx]);
-          }
-          return ret;
-        },
-
-        newObserver() {
-          this.abnormal = 'changedValueObserved';
-        },
-
-        testObserver: observer('normal', function() {
-          this.abnormal = 'removedObserver';
-        }),
-
-        testArrayObserver: observer('normalArray.[]', function() {
-          this.abnormal = 'notifiedObserver';
-        }),
-      }).create({
-        normal: 'value',
-        abnormal: 'zeroValue',
-        numberVal: 24,
-        toggleVal: true,
-        observedProperty: 'beingWatched',
-        testRemove: 'observerToBeRemoved',
-        normalArray: emberA([1, 2, 3, 4, 5]),
-      });
-    }
-
-    ['@test incrementProperty and decrementProperty'](assert) {
-      var newValue = object.incrementProperty('numberVal');
-
-      assert.equal(25, newValue, 'numerical value incremented');
-      object.numberVal = 24;
-      newValue = object.decrementProperty('numberVal');
-      assert.equal(23, newValue, 'numerical value decremented');
-      object.numberVal = 25;
-      newValue = object.incrementProperty('numberVal', 5);
-      assert.equal(30, newValue, 'numerical value incremented by specified increment');
-      object.numberVal = 25;
-      newValue = object.incrementProperty('numberVal', -5);
-      assert.equal(20, newValue, 'minus numerical value incremented by specified increment');
-      object.numberVal = 25;
-      newValue = object.incrementProperty('numberVal', 0);
-      assert.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);
-
-      assert.equal(
-        25,
-        newValue,
-        'Attempting to increment by non-numeric values should not increment value'
-      );
-
-      object.numberVal = 25;
-      newValue = object.decrementProperty('numberVal', 5);
-      assert.equal(20, newValue, 'numerical value decremented by specified increment');
-      object.numberVal = 25;
-      newValue = object.decrementProperty('numberVal', -5);
-      assert.equal(30, newValue, 'minus numerical value decremented by specified increment');
-      object.numberVal = 25;
-      newValue = object.decrementProperty('numberVal', 0);
-      assert.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);
-
-      assert.equal(
-        25,
-        newValue,
-        'Attempting to decrement by non-numeric values should not decrement value'
-      );
-    }
-
-    ['@test toggle function, should be boolean'](assert) {
-      assert.equal(object.toggleProperty('toggleVal', true, false), object.get('toggleVal'));
-      assert.equal(object.toggleProperty('toggleVal', true, false), object.get('toggleVal'));
-      assert.equal(
-        object.toggleProperty('toggleVal', undefined, undefined),
-        object.get('toggleVal')
-      );
-    }
-
-    ['@test should notify array observer when array changes'](assert) {
-      get(object, 'normalArray').replace(0, 0, [6]);
-      assert.equal(object.abnormal, 'notifiedObserver', 'observer should be notified');
-    }
-  }
-);
-
-moduleFor(
-  'object.addObserver()',
-  class extends AbstractTestCase {
-    beforeEach() {
-      ObjectC = ObservableObject.create({
-        objectE: ObservableObject.create({
-          propertyVal: 'chainedProperty',
-        }),
-
-        normal: 'value',
-        normal1: 'zeroValue',
-        normal2: 'dependentValue',
-        incrementor: 10,
-
-        action() {
-          this.normal1 = 'newZeroValue';
-        },
-
-        observeOnceAction() {
-          this.incrementor = this.incrementor + 1;
-        },
-
-        chainedObserver() {
-          this.normal2 = 'chainedPropertyObserved';
-        },
-      });
-    }
-
-    ['@test should register an observer for a property'](assert) {
-      ObjectC.addObserver('normal', ObjectC, 'action');
-      ObjectC.set('normal', 'newValue');
-      assert.equal(ObjectC.normal1, 'newZeroValue');
-    }
-
-    ['@test should register an observer for a property - Special case of chained property'](
-      assert
-    ) {
-      ObjectC.addObserver('objectE.propertyVal', ObjectC, 'chainedObserver');
-      ObjectC.objectE.set('propertyVal', 'chainedPropertyValue');
-      assert.equal('chainedPropertyObserved', ObjectC.normal2);
-      ObjectC.normal2 = 'dependentValue';
-      ObjectC.set('objectE', '');
-      assert.equal('chainedPropertyObserved', ObjectC.normal2);
-    }
-  }
-);
-
-moduleFor(
-  'object.removeObserver()',
-  class extends AbstractTestCase {
-    beforeEach() {
-      ObjectD = ObservableObject.create({
-        objectF: ObservableObject.create({
-          propertyVal: 'chainedProperty',
-        }),
-
-        normal: 'value',
-        normal1: 'zeroValue',
-        normal2: 'dependentValue',
-        ArrayKeys: ['normal', 'normal1'],
-
-        addAction() {
-          this.normal1 = 'newZeroValue';
-        },
-        removeAction() {
-          this.normal2 = 'newDependentValue';
-        },
-        removeChainedObserver() {
-          this.normal2 = 'chainedPropertyObserved';
-        },
-
-        observableValue: 'hello world',
-
-        observer1() {
-          // Just an observer
-        },
-        observer2() {
-          this.removeObserver('observableValue', null, 'observer1');
-          this.removeObserver('observableValue', null, 'observer2');
-          this.hasObserverFor('observableValue'); // Tickle 'getMembers()'
-          this.removeObserver('observableValue', null, 'observer3');
-        },
-        observer3() {
-          // Just an observer
-        },
-      });
-    }
-
-    ['@test should unregister an observer for a property'](assert) {
-      ObjectD.addObserver('normal', ObjectD, 'addAction');
-      ObjectD.set('normal', 'newValue');
-      assert.equal(ObjectD.normal1, 'newZeroValue');
-
-      ObjectD.set('normal1', 'zeroValue');
-
-      ObjectD.removeObserver('normal', ObjectD, 'addAction');
-      ObjectD.set('normal', 'newValue');
-      assert.equal(ObjectD.normal1, 'zeroValue');
-    }
-
-    ["@test should unregister an observer for a property - special case when key has a '.' in it."](
-      assert
-    ) {
-      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');
-      assert.equal('dependentValue', ObjectD.normal2);
-      ObjectD.set('objectF', '');
-      assert.equal('dependentValue', ObjectD.normal2);
-    }
-
-    ['@test removing an observer inside of an observer shouldn’t cause any problems'](assert) {
-      // 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');
-        run(function() {
-          ObjectD.set('observableValue', 'hi world');
-        });
-      } catch (e) {
-        encounteredError = true;
-      }
-      assert.equal(encounteredError, false);
-    }
-  }
-);