diff --git a/packages/@ember/-internals/metal/tests/events_test.js b/packages/@ember/-internals/metal/tests/events_test.js
index 47553698171..624a32d2915 100644
--- a/packages/@ember/-internals/metal/tests/events_test.js
+++ b/packages/@ember/-internals/metal/tests/events_test.js
@@ -26,15 +26,18 @@ moduleFor(
     }
 
     ['@test listeners should be inherited'](assert) {
-      let obj = {};
+      class A {}
+      class B extends A {}
+
       let count = 0;
       let F = function() {
         count++;
       };
 
-      addListener(obj, 'event!', F);
+      addListener(A.prototype, 'event!', F);
 
-      let obj2 = Object.create(obj);
+      let obj = new A();
+      let obj2 = new B();
 
       assert.equal(count, 0, 'nothing yet');
 
diff --git a/packages/@ember/-internals/runtime/tests/system/object/es-compatibility-test.js b/packages/@ember/-internals/runtime/tests/system/object/es-compatibility-test.js
index 9009eaa6b6b..f88e9618da7 100644
--- a/packages/@ember/-internals/runtime/tests/system/object/es-compatibility-test.js
+++ b/packages/@ember/-internals/runtime/tests/system/object/es-compatibility-test.js
@@ -3,8 +3,12 @@ import {
   Mixin,
   defineProperty,
   computed,
+  observer,
+  on,
   addObserver,
+  removeObserver,
   addListener,
+  removeListener,
   sendEvent,
 } from '@ember/-internals/metal';
 import { moduleFor, AbstractTestCase } from 'internal-test-helpers';
@@ -304,6 +308,84 @@ moduleFor(
       SubEmberObject.metaForProperty('foo');
     }
 
+    '@test observes / removeObserver on / removeListener interop'(assert) {
+      let fooDidChangeBase = 0;
+      let fooDidChangeA = 0;
+      let fooDidChangeB = 0;
+      let someEventBase = 0;
+      let someEventA = 0;
+      let someEventB = 0;
+      class A extends EmberObject.extend({
+        fooDidChange: observer('foo', function() {
+          fooDidChangeBase++;
+        }),
+
+        onSomeEvent: on('someEvent', function() {
+          someEventBase++;
+        }),
+      }) {
+        init() {
+          super.init();
+          this.foo = 'bar';
+        }
+
+        fooDidChange() {
+          super.fooDidChange();
+          fooDidChangeA++;
+        }
+
+        onSomeEvent() {
+          super.onSomeEvent();
+          someEventA++;
+        }
+      }
+
+      class B extends A {
+        fooDidChange() {
+          super.fooDidChange();
+          fooDidChangeB++;
+        }
+
+        onSomeEvent() {
+          super.onSomeEvent();
+          someEventB++;
+        }
+      }
+
+      removeObserver(B.prototype, 'foo', null, 'fooDidChange');
+      removeListener(B.prototype, 'someEvent', null, 'onSomeEvent');
+
+      assert.equal(fooDidChangeBase, 0);
+      assert.equal(fooDidChangeA, 0);
+      assert.equal(fooDidChangeB, 0);
+
+      assert.equal(someEventBase, 0);
+      assert.equal(someEventA, 0);
+      assert.equal(someEventB, 0);
+
+      let a = new A();
+      a.set('foo', 'something');
+      assert.equal(fooDidChangeBase, 1);
+      assert.equal(fooDidChangeA, 1);
+      assert.equal(fooDidChangeB, 0);
+
+      sendEvent(a, 'someEvent');
+      assert.equal(someEventBase, 1);
+      assert.equal(someEventA, 1);
+      assert.equal(someEventB, 0);
+
+      let b = new B();
+      b.set('foo', 'something');
+      assert.equal(fooDidChangeBase, 1);
+      assert.equal(fooDidChangeA, 1);
+      assert.equal(fooDidChangeB, 0);
+
+      sendEvent(b, 'someEvent');
+      assert.equal(someEventBase, 1);
+      assert.equal(someEventA, 1);
+      assert.equal(someEventB, 0);
+    }
+
     '@test super and _super interop between old and new methods'(assert) {
       let calls = [];
       let changes = [];