QUnit.test('reopening a parent with a computed property flushes the child', assert => {
  let MyClass = EmberObject.extend({
    hello: computed(function() {
      return "original hello";
    })
  });

  let SubClass = MyClass.extend({
    hello: computed(function() {
      return this._super();
    })
  });

  let GrandChild = SubClass.extend({
    hello: computed(function() {
      return this._super();
    })
  });

  MyClass.reopen({
    hello: computed(function() {
      return this._super() + " new hello";
    })
  });

  let sub: any = GrandChild.create();

  assert.equal(sub.hello, "original hello new hello");
});

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

QUnit.test('property name is the same as own prototype property', function() {
  let MyClass = EmberObject.extend({
    toString() { return 'MyClass'; }
  });

  equal(MyClass.create().toString(), 'MyClass', 'should inherit property from the arguments of `EmberObject.create`');
});

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

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

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

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

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

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