QUnit.test('using reopen() and calling _super where there is not a super function does not cause infinite recursion', assert => {
  let Taco = EmberObject.extend({
    createBreakfast(this: any) {
      // 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(this: any) {
      return this._super.apply(this, arguments);
    }
  });

  let taco: any = Taco.create();

  let result;
  try {
    result = taco.createBreakfast();
  } catch(e) {
    result = 'Your breakfast was interrupted by an infinite stack error.';
    throw e;
  }

  assert.equal(result, 'Breakfast!');
});

QUnit.test('Sub-subclass', assert => {
  let SomeClass = EmberObject.extend({ foo: 'BAR' });
  let AnotherClass = SomeClass.extend({ bar: 'FOO' });
  let obj: any = new AnotherClass();
  assert.equal(obj.foo, 'BAR');
  assert.equal(obj.bar, 'FOO');
});

QUnit.test('adds new properties to subclass', assert => {
  let Subclass: any = EmberObject.extend();
  Subclass.reopenClass({
    foo() { return 'FOO'; },
    bar: 'BAR'
  });

  assert.equal(Subclass.foo(), 'FOO', 'Adds method');
  assert.equal(get(Subclass, 'bar'), 'BAR', 'Adds property');
});

QUnit.test('adds new properties to subclass instance', assert => {
  let Subclass = EmberObject.extend();
  Subclass.reopen({
    foo() { return 'FOO'; },
    bar: 'BAR'
  });

  assert.equal(new Subclass()['foo'](), 'FOO', 'Adds method');
  assert.equal(get(new Subclass(), 'bar'), 'BAR', 'Adds property');
});

QUnit.test('With concatenatedProperties', assert => {
  let SomeClass = EmberObject.extend({ things: 'foo', concatenatedProperties: ['things'] });
  let AnotherClass = SomeClass.extend({ things: 'bar' });
  let YetAnotherClass = SomeClass.extend({ things: 'baz' });
  let some = new SomeClass();
  let another = new AnotherClass();
  let yetAnother = new YetAnotherClass();
  assert.deepEqual(some.get('things'), ['foo'], 'base class should have just its value');
  assert.deepEqual(another.get('things'), ['foo', 'bar'], 'subclass should have base class\' and its own');
  assert.deepEqual(yetAnother.get('things'), ['foo', 'baz'], 'subclass should have base class\' and its own');
});

QUnit.test('allows reopening already instantiated classes', assert => {
  let Subclass = EmberObject.extend();

  Subclass.create();

  Subclass.reopen({
    trololol: true
  });

  assert.equal(Subclass.create().get('trololol'), true, 'reopen works');
});

QUnit.test('Overriding a method several layers deep', assert => {
  let SomeClass = EmberObject.extend({
    fooCnt: 0,
    foo() { this.fooCnt++; },

    barCnt: 0,
    bar() { this.barCnt++; }
  });

  let AnotherClass = SomeClass.extend({
    barCnt: 0,
    bar(this: any) {
      this.barCnt++;
      this._super.apply(this, arguments);
    }
  });

  let FinalClass = AnotherClass.extend({
    fooCnt: 0,
    foo(this: any) {
      this.fooCnt++;
      this._super.apply(this, arguments);
    }
  });

  let obj: any = new FinalClass();
  obj.foo();
  obj.bar();
  assert.equal(obj.fooCnt, 2, 'should invoke both');
  assert.equal(obj.barCnt, 2, 'should invoke both');

  // Try overriding on create also
  obj = FinalClass.extend({
    foo(this: any) {
      this.fooCnt++;
      this._super.apply(this, arguments);
    }
  }).create();

  obj.foo();
  obj.bar();
  assert.equal(obj.fooCnt, 3, 'should invoke final as well');
  assert.equal(obj.barCnt, 2, 'should invoke both');
});

QUnit.test('mergedProperties should exist even if not explicitly set on create', assert => {
  let AnObj = EmberObject.extend({
    mergedProperties: ['options'],
    options: {
      a: 'a',
      b: {
        c: 'ccc'
      }
    }
  });

  let obj = AnObj.create({
    options: {
      a: 'A'
    }
  });

  assert.equal(get(obj, 'options').a, 'A');
  assert.equal(get(obj, 'options').b.c, 'ccc');
});