super.property store

test/mjsunit/harmony/super.js

 // Copyright 2014 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // Flags: --harmony-classes --allow-natives-syntax
 
 (function TestSuperNamedLoads() {
   function Base() { }
   function fBase() { }
   Base.prototype = {
@@ skipping 577 matching lines @@
   };
 
   function Derived() {}
   Derived.prototype = {
     __proto__: Base.prototype,
     constructor: Derived,
     testSetter() {
       setCalled = 0;
       getCalled = 0;
       assertEquals('object', typeof this);
-      assertTrue(this instanceof Number)
+      assertInstanceof(this, Number)
       assertEquals(42, this.valueOf());
       assertEquals(1, super.x);
       assertEquals(1, getCalled);
       assertEquals(0, setCalled);
 
       assertEquals(5, super.x = 5);
       assertEquals(1, getCalled);
       assertEquals(1, setCalled);
 
       assertEquals(6, super.x += 5);
@@ skipping 19 matching lines @@
       assertEquals(1, setCalled);
 
       assertEquals(6, super.x += 5);
       assertEquals(2, getCalled);
       assertEquals(2, setCalled);
 
       var ex;
       try {
         super.newProperty = 15;
       } catch (e) { ex = e; }
-      assertTrue(ex instanceof TypeError);
+      assertInstanceof(ex, TypeError);
     }
   }
 
   Derived.prototype.testSetter.call(42);
   Derived.prototype.testSetterStrict.call(42);
 
   function DerivedFromString() {}
   DerivedFromString.prototype = {
     __proto__: String.prototype,
     f() {
       'use strict';
       assertTrue(42 === this);
       assertEquals(String.prototype.toString, super.toString);
       var ex;
       try {
         super.toString();
       } catch(e) { ex = e; }
 
-      assertTrue(ex instanceof TypeError);
+      assertInstanceof(ex, TypeError);
     }
   };
 
   DerivedFromString.prototype.f.call(42);
 }());
 
 
 (function TestKeyedAccessorsOnPrimitives() {
   var x = 'x';
   var newProperty = 'newProperty';
@@ skipping 14 matching lines @@
   };
 
   function Derived() {}
   Derived.prototype = {
     __proto__: Base.prototype,
     constructor: Derived,
     testSetter() {
       setCalled = 0;
       getCalled = 0;
       assertEquals('object', typeof this);
-      assertTrue(this instanceof Number)
+      assertInstanceof(this, Number)
       assertEquals(42, this.valueOf());
       assertEquals(1, super[x]);
       assertEquals(1, getCalled);
       assertEquals(0, setCalled);
 
       assertEquals(5, super[x] = 5);
       assertEquals(1, getCalled);
       assertEquals(1, setCalled);
 
       assertEquals(6, super[x] += 5);
@@ skipping 19 matching lines @@
       assertEquals(1, setCalled);
 
       assertEquals(6, super[x] += 5);
       assertEquals(2, getCalled);
       assertEquals(2, setCalled);
 
       var ex;
       try {
         super[newProperty] = 15;
       } catch (e) { ex = e; }
-      assertTrue(ex instanceof TypeError);
+      assertInstanceof(ex,TypeError);
     }
   };
 
   Derived.prototype.testSetter.call(42);
   Derived.prototype.testSetterStrict.call(42);
 
   function DerivedFromString() {}
   DerivedFromString.prototype = {
     __proto__: String.prototype,
     f() {
       'use strict';
       assertTrue(42 === this);
       assertEquals(String.prototype.toString, super[toString]);
       var ex;
       try {
         super[toString]();
       } catch(e) { ex = e; }
 
-      assertTrue(ex instanceof TypeError);
+      assertInstanceof(ex, TypeError);
     }
   };
   DerivedFromString.prototype.f.call(42);
 }());
 
 
 (function TestNumericKeyedAccessorsOnPrimitives() {
   var x = 42;
   var newProperty = 43;
   var getCalled = 0;
@@ skipping 15 matching lines @@
   });
 
   function Derived() {}
   Derived.prototype = {
     __proto__: Base.prototype,
     constructor: Derived,
     testSetter() {
       setCalled = 0;
       getCalled = 0;
       assertEquals('object', typeof this);
-      assertTrue(this instanceof Number)
+      assertInstanceof(this, Number)
       assertEquals(42, this.valueOf());
       assertEquals(1, super[x]);
       assertEquals(1, getCalled);
       assertEquals(0, setCalled);
 
       assertEquals(5, super[x] = 5);
       assertEquals(1, getCalled);
       assertEquals(1, setCalled);
 
       assertEquals(6, super[x] += 5);
@@ skipping 19 matching lines @@
       assertEquals(1, setCalled);
 
       assertEquals(6, super[x] += 5);
       assertEquals(2, getCalled);
       assertEquals(2, setCalled);
 
       var ex;
       try {
         super[newProperty] = 15;
       } catch (e) { ex = e; }
-      assertTrue(ex instanceof TypeError);
+      assertInstanceof(ex, TypeError);
     }
   };
 
   Derived.prototype.testSetter.call(42);
   Derived.prototype.testSetterStrict.call(42);
 }());
 
 
 (function TestKeyedNumericSetterOnExotics() {
   function Base() {}
   function Derived() {}
   Derived.prototype = {
     __proto__: Base.prototype,
     callSetterOnArray() {
       super[42] = 1;
     },
     callStrictSetterOnString() {
       'use strict';
       assertEquals('string', typeof this);
       assertTrue('abcdef' === this);
       var ex = null;
       try {
         super[5] = 'q';
       } catch(e) { ex = e; }
-      assertTrue(ex instanceof TypeError);
+      assertInstanceof(ex, TypeError);
 
       ex = null;
       try {
         super[1024] = 'q';
       } catch(e) { ex = e; }
-      assertTrue(ex instanceof TypeError);
+      assertInstanceof(ex, TypeError);
     }
   };
 
   var x = [];
   assertEquals(0, x.length);
   Derived.prototype.callSetterOnArray.call(x);
   assertEquals(43, x.length);
   assertEquals(1, x[42]);
 
   var s = 'abcdef';
@@ skipping 87 matching lines @@
   };
   var d = new Derived();
   d.mSloppy();
   assertEquals(10, d[x]);
   var d1 = new Derived();
   d1.mStrict();
   assertEquals(10, d[x]);
 }());
 
 
-(function TestSetterCreatingOwnProperties() {
-  var setterCalled;
+(function TestSetterCreatingOwnPropertiesReconfigurable() {
   function Base() {}
   function Derived() {}
   Derived.prototype = {
     __proto__: Base.prototype,
     mSloppy() {
       assertEquals(42, this.ownReadOnly);
       super.ownReadOnly = 55;
+      assertEquals(55, this.ownReadOnly);
+      var descr = Object.getOwnPropertyDescriptor(this, 'ownReadOnly');
+      assertEquals(55, descr.value);
+      assertTrue(descr.configurable);
+      assertFalse(descr.enumerable);
+      assertFalse(descr.writable);
+      assertFalse(Base.prototype.hasOwnProperty('ownReadOnly'));
+
+      assertEquals(15, this.ownReadonlyAccessor);
+      super.ownReadonlyAccessor = 25;
+      assertEquals(25, this.ownReadonlyAccessor);
+      var descr = Object.getOwnPropertyDescriptor(this, 'ownReadonlyAccessor');
+      assertEquals(25, descr.value);
+      assertTrue(descr.configurable);
+      assertFalse(descr.enumerable);
+      assertTrue(descr.writable);
+      assertFalse(Base.prototype.hasOwnProperty('ownReadonlyAccessor'));
+
+      super.ownSetter = 35;
+      assertEquals(35, this.ownSetter);
+      var descr = Object.getOwnPropertyDescriptor(this, 'ownSetter');
+      assertEquals(35, descr.value);
+      assertTrue(descr.configurable);
+      assertFalse(descr.enumerable);
+      assertTrue(descr.writable);
+      assertFalse(Base.prototype.hasOwnProperty('ownSetter'));
+    },
+    mStrict() {
+      'use strict';
+      assertEquals(42, this.ownReadOnly);
+      super.ownReadOnly = 55;
+      assertEquals(55, this.ownReadOnly);
+      var descr = Object.getOwnPropertyDescriptor(this, 'ownReadOnly');
+      assertEquals(55, descr.value);
+      assertTrue(descr.configurable);
+      assertFalse(descr.enumerable);
+      assertFalse(descr.writable);
+      assertFalse(Base.prototype.hasOwnProperty('ownReadOnly'));
+
+      assertEquals(15, this.ownReadonlyAccessor);
+      super.ownReadonlyAccessor = 25;
+      assertEquals(25, this.ownReadonlyAccessor);
+      var descr = Object.getOwnPropertyDescriptor(this, 'ownReadonlyAccessor');
+      assertEquals(25, descr.value);
+      assertTrue(descr.configurable);
+      assertFalse(descr.enumerable);
+      assertTrue(descr.writable);
+      assertFalse(Base.prototype.hasOwnProperty('ownReadonlyAccessor'));
+
+      super.ownSetter = 35;
+      assertEquals(35, this.ownSetter);
+      var descr = Object.getOwnPropertyDescriptor(this, 'ownSetter');
+      assertEquals(35, descr.value);
+      assertTrue(descr.configurable);
+      assertFalse(descr.enumerable);
+      assertTrue(descr.writable);
+      assertFalse(Base.prototype.hasOwnProperty('ownSetter'));
+    },
+  };
+
+  var d = new Derived();
+  Object.defineProperty(d, 'ownReadOnly', {
+    value: 42,
+    writable: false,
+    configurable: true
+  });
+  Object.defineProperty(d, 'ownSetter', {
+    set: function() { assertUnreachable(); },
+    configurable: true
+  });
+  Object.defineProperty(d, 'ownReadonlyAccessor', {
+    get: function() { return 15; },
+    configurable: true
+  });
+
+  d.mSloppy();
+
+  var d = new Derived();
+  Object.defineProperty(d, 'ownReadOnly', {
+    value: 42,
+    writable: false,
+    configurable: true
+  });
+  Object.defineProperty(d, 'ownSetter', {
+    set: function() { assertUnreachable(); },
+    configurable: true
+  });
+  Object.defineProperty(d, 'ownReadonlyAccessor', {
+    get: function() { return 15; },
+    configurable: true
+  });
+  d.mStrict();
+}());
+
+
+(function TestSetterCreatingOwnPropertiesNonConfigurable() {
+  function Base() {}
+  function Derived() {}
+  Derived.prototype = {
+    __proto__: Base.prototype,
+    mSloppy() {
+      assertEquals(42, this.ownReadOnly);
+      super.ownReadOnly = 55;
       assertEquals(42, this.ownReadOnly);
+      var descr = Object.getOwnPropertyDescriptor(this, 'ownReadOnly');
+      assertEquals(42, descr.value);
+      assertFalse(descr.configurable);
+      assertFalse(descr.enumerable);
+      assertFalse(descr.writable);
+      assertFalse(Base.prototype.hasOwnProperty('ownReadOnly'));
 
       assertEquals(15, this.ownReadonlyAccessor);
-      super.ownReadonlyAccessor = 55;
+      super.ownReadonlyAccessor = 25;
       assertEquals(15, this.ownReadonlyAccessor);
+      var descr = Object.getOwnPropertyDescriptor(this, 'ownReadonlyAccessor');
+      assertFalse(descr.configurable);
+      assertFalse(descr.enumerable);
+      assertFalse(Base.prototype.hasOwnProperty('ownReadonlyAccessor'));
 
-      setterCalled = 0;
-      super.ownSetter = 42;
-      assertEquals(1, setterCalled);
+      super.ownSetter = 35;
+      var descr = Object.getOwnPropertyDescriptor(this, 'ownSetter');
+      assertFalse(descr.configurable);
+      assertFalse(descr.enumerable);
+      assertFalse(Base.prototype.hasOwnProperty('ownSetter'));
     },
     mStrict() {
       'use strict';
+      var ex;
       assertEquals(42, this.ownReadOnly);
-      var ex;
       try {
         super.ownReadOnly = 55;
-      } catch(e) { ex = e; }
-      assertTrue(ex instanceof TypeError);
+      } catch (e) {
+        ex = e;
+      }
+      assertInstanceof(ex, TypeError);
+      assertEquals(
+          "Cannot assign to read only property 'ownReadOnly' of #<Base>",
+          ex.message);
       assertEquals(42, this.ownReadOnly);
 
+      ex = null;
       assertEquals(15, this.ownReadonlyAccessor);
+      try {
+        super.ownReadonlyAccessor = 25;
+      } catch (e) {
+        ex = e;
+      }
+      assertInstanceof(ex, TypeError);
+      assertEquals('Cannot redefine property: ownReadonlyAccessor', ex.message);
+      assertEquals(15, this.ownReadonlyAccessor);
+
       ex = null;
       try {
-        super.ownReadonlyAccessor = 55;
-      } catch(e) { ex = e; }
-      assertTrue(ex instanceof TypeError);
-      assertEquals(15, this.ownReadonlyAccessor);
-
-      setterCalled = 0;
-      super.ownSetter = 42;
-      assertEquals(1, setterCalled);
+        super.ownSetter = 35;
+      } catch (e) {
+        ex = e;
+      }
+      assertInstanceof(ex, TypeError);
+      assertEquals('Cannot redefine property: ownSetter', ex.message);
     }
   };
 
   var d = new Derived();
   Object.defineProperty(d, 'ownReadOnly', { value : 42, writable : false });
   Object.defineProperty(d, 'ownSetter',
-      { set : function() { setterCalled++; } });
+      { set : function() { assertUnreachable(); } });
   Object.defineProperty(d, 'ownReadonlyAccessor',
       { get : function() { return 15; }});
   d.mSloppy();
   d.mStrict();
 }());
 
 
 (function TestSetterInForIn() {
   var setCalled = 0;
   var getCalled = 0;
@@ skipping 46 matching lines @@
   };
 
   new Derived().testIter();
 
   var x = 'x';
 
   new Derived().testIterKeyed();
 }());
 
 
-(function TestKeyedSetterCreatingOwnProperties() {
-  var ownReadOnly = 'ownReadOnly';
-  var ownReadonlyAccessor = 'ownReadonlyAccessor';
-  var ownSetter = 'ownSetter';
-  var setterCalled;
+function TestKeyedSetterCreatingOwnPropertiesReconfigurable(ownReadOnly,
+    ownReadonlyAccessor, ownSetter) {
   function Base() {}
   function Derived() {}
   Derived.prototype = {
     __proto__: Base.prototype,
     mSloppy() {
       assertEquals(42, this[ownReadOnly]);
       super[ownReadOnly] = 55;
-      assertEquals(42, this[ownReadOnly]);
+      assertEquals(55, this[ownReadOnly]);
+      var descr = Object.getOwnPropertyDescriptor(this, ownReadOnly);
+      assertEquals(55, descr.value);
+      assertTrue(descr.configurable);
+      assertFalse(descr.enumerable);
+      assertFalse(descr.writable);
+      assertFalse(Base.prototype.hasOwnProperty(ownReadOnly));
 
       assertEquals(15, this[ownReadonlyAccessor]);
-      super[ownReadonlyAccessor] = 55;
-      assertEquals(15, this[ownReadonlyAccessor]);
+      super[ownReadonlyAccessor] = 25;
+      assertEquals(25, this[ownReadonlyAccessor]);
+      var descr = Object.getOwnPropertyDescriptor(this, ownReadonlyAccessor);
+      assertEquals(25, descr.value);
+      assertTrue(descr.configurable);
+      assertFalse(descr.enumerable);
+      assertTrue(descr.writable);
+      assertFalse(Base.prototype.hasOwnProperty(ownReadonlyAccessor));
 
-      setterCalled = 0;
-      super[ownSetter] = 42;
-      assertEquals(1, setterCalled);
+      super[ownSetter] = 35;
+      assertEquals(35, this[ownSetter]);
+      var descr = Object.getOwnPropertyDescriptor(this, ownSetter);
+      assertEquals(35, descr.value);
+      assertTrue(descr.configurable);
+      assertFalse(descr.enumerable);
+      assertTrue(descr.writable);
+      assertFalse(Base.prototype.hasOwnProperty(ownSetter));
     },
     mStrict() {
       'use strict';
       assertEquals(42, this[ownReadOnly]);
-      var ex;
-      try {
-        super[ownReadOnly] = 55;
-      } catch(e) { ex = e; }
-      assertTrue(ex instanceof TypeError);
-      assertEquals(42, this[ownReadOnly]);
+      super[ownReadOnly] = 55;
+      assertEquals(55, this[ownReadOnly]);
+      var descr = Object.getOwnPropertyDescriptor(this, ownReadOnly);
+      assertEquals(55, descr.value);
+      assertTrue(descr.configurable);
+      assertFalse(descr.enumerable);
+      assertFalse(descr.writable);
+      assertFalse(Base.prototype.hasOwnProperty(ownReadOnly));
 
       assertEquals(15, this[ownReadonlyAccessor]);
-      ex = null;
-      try {
-        super[ownReadonlyAccessor] = 55;
-      } catch(e) { ex = e; }
-      assertTrue(ex instanceof TypeError);
-      assertEquals(15, this[ownReadonlyAccessor]);
+      super[ownReadonlyAccessor] = 25;
+      assertEquals(25, this[ownReadonlyAccessor]);
+      var descr = Object.getOwnPropertyDescriptor(this, ownReadonlyAccessor);
+      assertEquals(25, descr.value);
+      assertTrue(descr.configurable);
+      assertFalse(descr.enumerable);
+      assertTrue(descr.writable);
+      assertFalse(Base.prototype.hasOwnProperty(ownReadonlyAccessor));
 
-      setterCalled = 0;
-      super[ownSetter] = 42;
-      assertEquals(1, setterCalled);
-    }
+      super[ownSetter] = 35;
+      assertEquals(35, this[ownSetter]);
+      var descr = Object.getOwnPropertyDescriptor(this, ownSetter);
+      assertEquals(35, descr.value);
+      assertTrue(descr.configurable);
+      assertFalse(descr.enumerable);
+      assertTrue(descr.writable);
+      assertFalse(Base.prototype.hasOwnProperty(ownSetter));
+    },
   };
 
   var d = new Derived();
-  Object.defineProperty(d, 'ownReadOnly', { value : 42, writable : false });
-  Object.defineProperty(d, 'ownSetter',
-      { set : function() { setterCalled++; } });
-  Object.defineProperty(d, 'ownReadonlyAccessor',
-      { get : function() { return 15; }});
+  Object.defineProperty(d, ownReadOnly, {
+    value: 42,
+    writable: false,
+    configurable: true
+  });
+  Object.defineProperty(d, ownSetter, {
+    set: function() { assertUnreachable(); },
+    configurable: true
+  });
+  Object.defineProperty(d, ownReadonlyAccessor, {
+    get: function() { return 15; },
+    configurable: true
+  });
+
   d.mSloppy();
+
+  var d = new Derived();
+  Object.defineProperty(d, ownReadOnly, {
+    value: 42,
+    writable: false,
+    configurable: true
+  });
+  Object.defineProperty(d, ownSetter, {
+    set: function() { assertUnreachable(); },
+    configurable: true
+  });
+  Object.defineProperty(d, ownReadonlyAccessor, {
+    get: function() { return 15; },
+    configurable: true
+  });
   d.mStrict();
-}());
+}
+TestKeyedSetterCreatingOwnPropertiesReconfigurable('ownReadOnly',
+                                                   'ownReadonlyAccessor',
+                                                   'ownSetter');
+TestKeyedSetterCreatingOwnPropertiesReconfigurable(42, 43, 44);
 
 
-(function TestKeyedNumericSetterCreatingOwnProperties() {
-  var ownReadOnly = 42;
-  var ownReadonlyAccessor = 43;
-  var ownSetter = 44;
-  var setterCalled;
+function TestKeyedSetterCreatingOwnPropertiesNonConfigurable(
+    ownReadOnly, ownReadonlyAccessor, ownSetter) {
   function Base() {}
   function Derived() {}
   Derived.prototype = {
     __proto__: Base.prototype,
     mSloppy() {
       assertEquals(42, this[ownReadOnly]);
       super[ownReadOnly] = 55;
       assertEquals(42, this[ownReadOnly]);
+      var descr = Object.getOwnPropertyDescriptor(this, ownReadOnly);
+      assertEquals(42, descr.value);
+      assertFalse(descr.configurable);
+      assertFalse(descr.enumerable);
+      assertFalse(descr.writable);
+      assertFalse(Base.prototype.hasOwnProperty(ownReadOnly));
 
       assertEquals(15, this[ownReadonlyAccessor]);
-      super[ownReadonlyAccessor] = 55;
+      super[ownReadonlyAccessor] = 25;
       assertEquals(15, this[ownReadonlyAccessor]);
+      var descr = Object.getOwnPropertyDescriptor(this, ownReadonlyAccessor);
+      assertFalse(descr.configurable);
+      assertFalse(descr.enumerable);
+      assertFalse(Base.prototype.hasOwnProperty(ownReadonlyAccessor));
 
-      setterCalled = 0;
-      super[ownSetter] = 42;
-      assertEquals(1, setterCalled);
+      super[ownSetter] = 35;
+      var descr = Object.getOwnPropertyDescriptor(this, ownSetter);
+      assertFalse(descr.configurable);
+      assertFalse(descr.enumerable);
+      assertFalse(Base.prototype.hasOwnProperty(ownSetter));
     },
     mStrict() {
       'use strict';
+      var ex;
       assertEquals(42, this[ownReadOnly]);
-      var ex;
       try {
         super[ownReadOnly] = 55;
-      } catch(e) { ex = e; }
-      assertTrue(ex instanceof TypeError);
+      } catch (e) {
+        ex = e;
+      }
+      assertInstanceof(ex, TypeError);
+      assertEquals(
+          "Cannot assign to read only property '" + ownReadOnly +
+              "' of #<Base>",
+          ex.message);
       assertEquals(42, this[ownReadOnly]);
 
+      ex = null;
       assertEquals(15, this[ownReadonlyAccessor]);
+      try {
+        super[ownReadonlyAccessor] = 25;
+      } catch (e) {
+        ex = e;
+      }
+      assertInstanceof(ex, TypeError);
+      assertEquals('Cannot redefine property: ' + ownReadonlyAccessor,
+                   ex.message);
+      assertEquals(15, this[ownReadonlyAccessor]);
+
       ex = null;
       try {
-        super[ownReadonlyAccessor] = 55;
-      } catch(e) { ex = e; }
-      assertTrue(ex instanceof TypeError);
-      assertEquals(15, this[ownReadonlyAccessor]);
-
-      setterCalled = 0;
-      super[ownSetter] = 42;
-      assertEquals(1, setterCalled);
+        super[ownSetter] = 35;
+      } catch (e) {
+        ex = e;
+      }
+      assertInstanceof(ex, TypeError);
+      assertEquals('Cannot redefine property: ' + ownSetter, ex.message);
     }
-  }
+  };
 
   var d = new Derived();
   Object.defineProperty(d, ownReadOnly, { value : 42, writable : false });
   Object.defineProperty(d, ownSetter,
-      { set : function() { setterCalled++; } });
+      { set : function() { assertUnreachable(); } });
   Object.defineProperty(d, ownReadonlyAccessor,
       { get : function() { return 15; }});
   d.mSloppy();
   d.mStrict();
-}());
+}
+TestKeyedSetterCreatingOwnPropertiesNonConfigurable('ownReadOnly',
+    'ownReadonlyAccessor', 'ownSetter');
+TestKeyedSetterCreatingOwnPropertiesNonConfigurable(42, 43, 44);
 
 
 (function TestSetterNoProtoWalk() {
   function Base() {}
   function Derived() {}
   var getCalled;
   var setCalled;
   Derived.prototype = {
     __proto__: Base.prototype,
     get x() { getCalled++; return 42; },
@@ skipping 476 matching lines @@
       super.x = 10;
       assertEquals(27, super.x);
       assertEquals(27, this.x);
     },
     mStrict() {
       'use strict';
       assertEquals(27, super.x);
       assertEquals(27, this.x);
       var ex = null;
       try { super.x = 10; } catch(e) { ex = e; }
-      assertTrue(ex instanceof TypeError);
+      assertInstanceof(ex, TypeError);
       assertEquals(27, super.x);
       assertEquals(27, this.x);
     }
   };
   new Derived().mSloppy();
   new Derived().mStrict();
 }());
 
 
 (function TestSetterKeyedSuperNonWritable() {
@@ skipping 11 matching lines @@
       super[x] = 10;
       assertEquals(27, super[x]);
       assertEquals(27, this[x]);
     },
     mStrict() {
       'use strict';
       assertEquals(27, super[x]);
       assertEquals(27, this[x]);
       var ex = null;
       try { super[x] = 10; } catch(e) { ex = e; }
-      assertTrue(ex instanceof TypeError);
+      assertInstanceof(ex, TypeError);
       assertEquals(27, super[x]);
       assertEquals(27, this[x]);
     }
   };
   new Derived().mSloppy();
   new Derived().mStrict();
 }());
 
 
 (function TestSetterKeyedNumericSuperNonWritable() {
@@ skipping 11 matching lines @@
       super[x] = 10;
       assertEquals(27, super[x]);
       assertEquals(27, this[x]);
     },
     mStrict() {
       'use strict';
       assertEquals(27, super[x]);
       assertEquals(27, this[x]);
       var ex = null;
       try { super[x] = 10; } catch(e) { ex = e; }
-      assertTrue(ex instanceof TypeError);
+      assertInstanceof(ex, TypeError);
       assertEquals(27, super[x]);
       assertEquals(27, this[x]);
     }
   };
   new Derived().mSloppy();
   new Derived().mStrict();
 }());
 
 
 (function TestSuperCall() {
@@ skipping 76 matching lines @@
   assertEquals(1, calls);
 }());
 
 
 (function TestExtendsObject() {
   'use strict';
   class F extends Object { }
   var f = new F(42);
 
   // TODO(dslomov,arv): Fix this. BUG=v8:3886.
-  assertTrue(f instanceof Number);
+  assertInstanceof(f, Number);
 }());
 
 (function TestSuperCallErrorCases() {
   'use strict';
   class T extends Object {
     constructor() {
       super();
     }
   }
 
   T.__proto__ = null;
   assertThrows(function() { new T(); }, TypeError);
 }());