Use verifyProperty in language/statements tests

test/language/statements/class/definition/fn-name-accessor-get.js

@@ -27,37 +27,49 @@ class A {
 }
 
 getter = Object.getOwnPropertyDescriptor(A.prototype, 'id').get;
-assert.sameValue(getter.name, 'get id');
+verifyProperty(getter, 'name', {
-verifyNotEnumerable(getter, 'name');
+  value: 'get id',
-verifyNotWritable(getter, 'name');
+  writable: false,
-verifyConfigurable(getter, 'name');
+  enumerable: false,
+  configurable: true,
+});
 
 getter = Object.getOwnPropertyDescriptor(A.prototype, anonSym).get;
-assert.sameValue(getter.name, 'get ');
+verifyProperty(getter, 'name', {
-verifyNotEnumerable(getter, 'name');
+  value: 'get ',
-verifyNotWritable(getter, 'name');
+  writable: false,
-verifyConfigurable(getter, 'name');
+  enumerable: false,
+  configurable: true,
+});
 
 getter = Object.getOwnPropertyDescriptor(A.prototype, namedSym).get;
-assert.sameValue(getter.name, 'get [test262]');
+verifyProperty(getter, 'name', {
-verifyNotEnumerable(getter, 'name');
+  value: 'get [test262]',
-verifyNotWritable(getter, 'name');
+  writable: false,
-verifyConfigurable(getter, 'name');
+  enumerable: false,
+  configurable: true,
+});
 
 getter = Object.getOwnPropertyDescriptor(A, 'id').get;
-assert.sameValue(getter.name, 'get id');
+verifyProperty(getter, 'name', {
-verifyNotEnumerable(getter, 'name');
+  value: 'get id',
-verifyNotWritable(getter, 'name');
+  writable: false,
-verifyConfigurable(getter, 'name');
+  enumerable: false,
+  configurable: true,
+});
 
 getter = Object.getOwnPropertyDescriptor(A, anonSym).get;
-assert.sameValue(getter.name, 'get ');
+verifyProperty(getter, 'name', {
-verifyNotEnumerable(getter, 'name');
+  value: 'get ',
-verifyNotWritable(getter, 'name');
+  writable: false,
-verifyConfigurable(getter, 'name');
+  enumerable: false,
+  configurable: true,
+});
 
 getter = Object.getOwnPropertyDescriptor(A, namedSym).get;
-assert.sameValue(getter.name, 'get [test262]');
+verifyProperty(getter, 'name', {
-verifyNotEnumerable(getter, 'name');
+  value: 'get [test262]',
-verifyNotWritable(getter, 'name');
+  writable: false,
-verifyConfigurable(getter, 'name');
+  enumerable: false,
+  configurable: true,
+});

test/language/statements/class/definition/fn-name-accessor-set.js

@@ -28,37 +28,49 @@ class A {
 }
 
 setter = Object.getOwnPropertyDescriptor(A.prototype, 'id').set;
-assert.sameValue(setter.name, 'set id');
+verifyProperty(setter, 'name', {
-verifyNotEnumerable(setter, 'name');
+  value: 'set id',
-verifyNotWritable(setter, 'name');
+  writable: false,
-verifyConfigurable(setter, 'name');
+  enumerable: false,
+  configurable: true,
+});
 
 setter = Object.getOwnPropertyDescriptor(A.prototype, anonSym).set;
-assert.sameValue(setter.name, 'set ');
+verifyProperty(setter, 'name', {
-verifyNotEnumerable(setter, 'name');
+  value: 'set ',
-verifyNotWritable(setter, 'name');
+  writable: false,
-verifyConfigurable(setter, 'name');
+  enumerable: false,
+  configurable: true,
+});
 
 setter = Object.getOwnPropertyDescriptor(A.prototype, namedSym).set;
-assert.sameValue(setter.name, 'set [test262]');
+verifyProperty(setter, 'name', {
-verifyNotEnumerable(setter, 'name');
+  value: 'set [test262]',
-verifyNotWritable(setter, 'name');
+  writable: false,
-verifyConfigurable(setter, 'name');
+  enumerable: false,
+  configurable: true,
+});
 
 setter = Object.getOwnPropertyDescriptor(A, 'id').set;
-assert.sameValue(setter.name, 'set id');
+verifyProperty(setter, 'name', {
-verifyNotEnumerable(setter, 'name');
+  value: 'set id',
-verifyNotWritable(setter, 'name');
+  writable: false,
-verifyConfigurable(setter, 'name');
+  enumerable: false,
+  configurable: true,
+});
 
 setter = Object.getOwnPropertyDescriptor(A, anonSym).set;
-assert.sameValue(setter.name, 'set ');
+verifyProperty(setter, 'name', {
-verifyNotEnumerable(setter, 'name');
+  value: 'set ',
-verifyNotWritable(setter, 'name');
+  writable: false,
-verifyConfigurable(setter, 'name');
+  enumerable: false,
+  configurable: true,
+});
 
 setter = Object.getOwnPropertyDescriptor(A, namedSym).set;
-assert.sameValue(setter.name, 'set [test262]');
+verifyProperty(setter, 'name', {
-verifyNotEnumerable(setter, 'name');
+  value: 'set [test262]',
-verifyNotWritable(setter, 'name');
+  writable: false,
-verifyConfigurable(setter, 'name');
+  enumerable: false,
+  configurable: true,
+});

test/language/statements/class/definition/fn-name-gen-method.js

@@ -27,32 +27,44 @@ class A {
   static *[namedSym]() {}
 }
 
-assert.sameValue(A.prototype.id.name, 'id', 'via IdentifierName');
+verifyProperty(A.prototype.id, 'name', {
-verifyNotEnumerable(A.prototype.id, 'name');
+  value: 'id',
-verifyNotWritable(A.prototype.id, 'name');
+  writable: false,
-verifyConfigurable(A.prototype.id, 'name');
+  enumerable: false,
+  configurable: true,
+});
 
-assert.sameValue(A.prototype[anonSym].name, '', 'via anonymous Symbol');
+verifyProperty(A.prototype[anonSym], 'name', {
-verifyNotEnumerable(A.prototype[anonSym], 'name');
+  value: '',
-verifyNotWritable(A.prototype[anonSym], 'name');
+  writable: false,
-verifyConfigurable(A.prototype[anonSym], 'name');
+  enumerable: false,
+  configurable: true,
+});
 
-assert.sameValue(A.prototype[namedSym].name, '[test262]', 'via Symbol');
+verifyProperty(A.prototype[namedSym], 'name', {
-verifyNotEnumerable(A.prototype[namedSym], 'name');
+  value: '[test262]',
-verifyNotWritable(A.prototype[namedSym], 'name');
+  writable: false,
-verifyConfigurable(A.prototype[namedSym], 'name');
+  enumerable: false,
+  configurable: true,
+});
 
-assert.sameValue(A.id.name, 'id', 'static via IdentifierName');
+verifyProperty(A.id, 'name', {
-verifyNotEnumerable(A.id, 'name');
+  value: 'id',
-verifyNotWritable(A.id, 'name');
+  writable: false,
-verifyConfigurable(A.id, 'name');
+  enumerable: false,
+  configurable: true,
+});
 
-assert.sameValue(A[anonSym].name, '', 'static via anonymous Symbol');
+verifyProperty(A[anonSym], 'name', {
-verifyNotEnumerable(A[anonSym], 'name');
+  value: '',
-verifyNotWritable(A[anonSym], 'name');
+  writable: false,
-verifyConfigurable(A[anonSym], 'name');
+  enumerable: false,
+  configurable: true,
+});
 
-assert.sameValue(A[namedSym].name, '[test262]', 'static via Symbol');
+verifyProperty(A[namedSym], 'name', {
-verifyNotEnumerable(A[namedSym], 'name');
+  value: '[test262]',
-verifyNotWritable(A[namedSym], 'name');
+  writable: false,
-verifyConfigurable(A[namedSym], 'name');
+  enumerable: false,
+  configurable: true,
+});

test/language/statements/class/definition/fn-name-method.js

@@ -26,32 +26,44 @@ class A {
   static [namedSym]() {}
 }
 
-assert.sameValue(A.prototype.id.name, 'id', 'via IdentifierName');
+verifyProperty(A.prototype.id, 'name', {
-verifyNotEnumerable(A.prototype.id, 'name');
+  value: 'id',
-verifyNotWritable(A.prototype.id, 'name');
+  writable: false,
-verifyConfigurable(A.prototype.id, 'name');
+  enumerable: false,
+  configurable: true,
+});
 
-assert.sameValue(A.prototype[anonSym].name, '', 'via anonymous Symbol');
+verifyProperty(A.prototype[anonSym], 'name', {
-verifyNotEnumerable(A.prototype[anonSym], 'name');
+  value: '',
-verifyNotWritable(A.prototype[anonSym], 'name');
+  writable: false,
-verifyConfigurable(A.prototype[anonSym], 'name');
+  enumerable: false,
+  configurable: true,
+});
 
-assert.sameValue(A.prototype[namedSym].name, '[test262]', 'via Symbol');
+verifyProperty(A.prototype[namedSym], 'name', {
-verifyNotEnumerable(A.prototype[namedSym], 'name');
+  value: '[test262]',
-verifyNotWritable(A.prototype[namedSym], 'name');
+  writable: false,
-verifyConfigurable(A.prototype[namedSym], 'name');
+  enumerable: false,
+  configurable: true,
+});
 
-assert.sameValue(A.id.name, 'id', 'static via IdentifierName');
+verifyProperty(A.id, 'name', {
-verifyNotEnumerable(A.id, 'name');
+  value: 'id',
-verifyNotWritable(A.id, 'name');
+  writable: false,
-verifyConfigurable(A.id, 'name');
+  enumerable: false,
+  configurable: true,
+});
 
-assert.sameValue(A[anonSym].name, '', 'static via anonymous Symbol');
+verifyProperty(A[anonSym], 'name', {
-verifyNotEnumerable(A[anonSym], 'name');
+  value: '',
-verifyNotWritable(A[anonSym], 'name');
+  writable: false,
-verifyConfigurable(A[anonSym], 'name');
+  enumerable: false,
+  configurable: true,
+});
 
-assert.sameValue(A[namedSym].name, '[test262]', 'static via Symbol');
+verifyProperty(A[namedSym], 'name', {
-verifyNotEnumerable(A[namedSym], 'name');
+  value: '[test262]',
-verifyNotWritable(A[namedSym], 'name');
+  writable: false,
-verifyConfigurable(A[namedSym], 'name');
+  enumerable: false,
+  configurable: true,
+});

test/language/statements/class/definition/getters-prop-desc.js

@@ -9,8 +9,10 @@ includes: [propertyHelper.js]
 
 function assertGetterDescriptor(object, name) {
   var desc = Object.getOwnPropertyDescriptor(object, name);
-  verifyNotEnumerable(object, name);
+  verifyProperty(object, name, {
-  verifyConfigurable(object, name);
+    enumerable: false,
+    configurable: true,
+  });
   assert.sameValue(typeof desc.get, 'function', "`typeof desc.get` is `'function'`");
   assert.sameValue('prototype' in desc.get, false, "The result of `'prototype' in desc.get` is `false`");
   assert.sameValue(desc.set, undefined, "The value of `desc.set` is `undefined`");

test/language/statements/class/definition/setters-prop-desc.js

@@ -9,8 +9,10 @@ includes: [propertyHelper.js]
 
 function assertSetterDescriptor(object, name) {
   var descr = Object.getOwnPropertyDescriptor(object, name);
-  verifyNotEnumerable(object, name);
+  verifyProperty(object, name, {
-  verifyConfigurable(object, name);
+    enumerable: false,
+    configurable: true,
+  });
   assert.sameValue(typeof descr.set, 'function', "`typeof descr.set` is `'function'`");
   assert.sameValue('prototype' in descr.set, false, "The result of `'prototype' in descr.set` is `false`");
   assert.sameValue(descr.get, undefined, "The value of `descr.get` is `undefined`");

test/language/statements/class/gen-method-length-dflt.js

@@ -34,34 +34,42 @@ class C1 { *m(x = 42) {} }
 
 var m1 = C1.prototype.m;
 
-assert.sameValue(m1.length, 0, 'formalslist: x = 42');
+verifyProperty(m1, "length", {
-verifyNotEnumerable(m1, 'length');
+  value: 0,
-verifyNotWritable(m1, 'length');
+  writable: false,
-verifyConfigurable(m1, 'length');
+  enumerable: false,
+  configurable: true,
+});
 
 class C2 { *m(x = 42, y) {} }
 
 var m2 = C2.prototype.m;
 
-assert.sameValue(m2.length, 0, 'formalslist: x = 42, y');
+verifyProperty(m2, "length", {
-verifyNotEnumerable(m2, 'length');
+  value: 0,
-verifyNotWritable(m2, 'length');
+  writable: false,
-verifyConfigurable(m2, 'length');
+  enumerable: false,
+  configurable: true,
+});
 
 class C3 { *m(x, y = 42) {} }
 
 var m3 = C3.prototype.m;
 
-assert.sameValue(m3.length, 1, 'formalslist: x, y = 42');
+verifyProperty(m3, "length", {
-verifyNotEnumerable(m3, 'length');
+  value: 1,
-verifyNotWritable(m3, 'length');
+  writable: false,
-verifyConfigurable(m3, 'length');
+  enumerable: false,
+  configurable: true,
+});
 
 class C4 { *m(x, y = 42, z) {} }
 
 var m4 = C4.prototype.m;
 
-assert.sameValue(m4.length, 1, 'formalslist: x, y = 42, z');
+verifyProperty(m4, "length", {
-verifyNotEnumerable(m4, 'length');
+  value: 1,
-verifyNotWritable(m4, 'length');
+  writable: false,
-verifyConfigurable(m4, 'length');
+  enumerable: false,
+  configurable: true,
+});

test/language/statements/class/method-length-dflt.js

@@ -34,34 +34,42 @@ class C1 { m(x = 42) {} }
 
 var m1 = C1.prototype.m;
 
-assert.sameValue(m1.length, 0, 'formalslist: x = 42');
+verifyProperty(m1, "length", {
-verifyNotEnumerable(m1, 'length');
+  value: 0,
-verifyNotWritable(m1, 'length');
+  writable: false,
-verifyConfigurable(m1, 'length');
+  enumerable: false,
+  configurable: true,
+});
 
 class C2 { m(x = 42, y) {} }
 
 var m2 = C2.prototype.m;
 
-assert.sameValue(m2.length, 0, 'formalslist: x = 42, y');
+verifyProperty(m2, "length", {
-verifyNotEnumerable(m2, 'length');
+  value: 0,
-verifyNotWritable(m2, 'length');
+  writable: false,
-verifyConfigurable(m2, 'length');
+  enumerable: false,
+  configurable: true,
+});
 
 class C3 { m(x, y = 42) {} }
 
 var m3 = C3.prototype.m;
 
-assert.sameValue(m3.length, 1, 'formalslist: x, y = 42');
+verifyProperty(m3, "length", {
-verifyNotEnumerable(m3, 'length');
+  value: 1,
-verifyNotWritable(m3, 'length');
+  writable: false,
-verifyConfigurable(m3, 'length');
+  enumerable: false,
+  configurable: true,
+});
 
 class C4 { m(x, y = 42, z) {} }
 
 var m4 = C4.prototype.m;
 
-assert.sameValue(m4.length, 1, 'formalslist: x, y = 42, z');
+verifyProperty(m4, "length", {
-verifyNotEnumerable(m4, 'length');
+  value: 1,
-verifyNotWritable(m4, 'length');
+  writable: false,
-verifyConfigurable(m4, 'length');
+  enumerable: false,
+  configurable: true,
+});

test/language/statements/class/name.js

@@ -15,7 +15,9 @@ includes: [propertyHelper.js]
 
 class Test262 {}
 
-assert.sameValue(Test262.name, 'Test262');
+verifyProperty(Test262, "name", {
-verifyNotEnumerable(Test262, 'name');
+  value: "Test262",
-verifyNotWritable(Test262, 'name');
+  writable: false,
-verifyConfigurable(Test262, 'name');
+  enumerable: false,
+  configurable: true,
+});

test/language/statements/class/setter-length-dflt.js

@@ -33,7 +33,9 @@ includes: [propertyHelper.js]
 class C { set m(x = 42) {} }
 var set = Object.getOwnPropertyDescriptor(C.prototype, 'm').set;
 
-assert.sameValue(set.length, 0, 'FormalsList: x = 42');
+verifyProperty(set, 'length', {
-verifyNotEnumerable(set, 'length');
+  value: 0,
-verifyNotWritable(set, 'length');
+  writable: false,
-verifyConfigurable(set, 'length');
+  enumerable: false,
+  configurable: true,
+});

test/language/statements/class/static-method-length-dflt.js

@@ -34,34 +34,42 @@ class C1 { static m(x = 42) {} }
 
 var m1 = C1.m;
 
-assert.sameValue(m1.length, 0, 'formalslist: x = 42');
+verifyProperty(m1, "length", {
-verifyNotEnumerable(m1, 'length');
+  value: 0,
-verifyNotWritable(m1, 'length');
+  writable: false,
-verifyConfigurable(m1, 'length');
+  enumerable: false,
+  configurable: true,
+});
 
 class C2 { static m(x = 42, y) {} }
 
 var m2 = C2.m;
 
-assert.sameValue(m2.length, 0, 'formalslist: x = 42, y');
+verifyProperty(m2, "length", {
-verifyNotEnumerable(m2, 'length');
+  value: 0,
-verifyNotWritable(m2, 'length');
+  writable: false,
-verifyConfigurable(m2, 'length');
+  enumerable: false,
+  configurable: true,
+});
 
 class C3 { static m(x, y = 42) {} }
 
 var m3 = C3.m;
 
-assert.sameValue(m3.length, 1, 'formalslist: x, y = 42');
+verifyProperty(m3, "length", {
-verifyNotEnumerable(m3, 'length');
+  value: 1,
-verifyNotWritable(m3, 'length');
+  writable: false,
-verifyConfigurable(m3, 'length');
+  enumerable: false,
+  configurable: true,
+});
 
 class C4 { static m(x, y = 42, z) {} }
 
 var m4 = C4.m;
 
-assert.sameValue(m4.length, 1, 'formalslist: x, y = 42, z');
+verifyProperty(m4, "length", {
-verifyNotEnumerable(m4, 'length');
+  value: 1,
-verifyNotWritable(m4, 'length');
+  writable: false,
-verifyConfigurable(m4, 'length');
+  enumerable: false,
+  configurable: true,
+});

test/language/statements/class/subclass/builtin-objects/Error/message-property-assignment.js

@@ -24,12 +24,13 @@ class Err extends Error {}
 Err.prototype.message = 'custom-error';
 
 var err1 = new Err('foo 42');
-assert.sameValue(err1.message, 'foo 42');
-assert(err1.hasOwnProperty('message'));
 
-verifyWritable(err1, 'message');
+verifyProperty(err1, 'message', {
-verifyNotEnumerable(err1, 'message');
+  value: 'foo 42',
-verifyConfigurable(err1, 'message');
+  writable: true,
+  enumerable: false,
+  configurable: true,
+});
 
 var err2 = new Err();
 assert.sameValue(err2.hasOwnProperty('message'), false);

test/language/statements/class/subclass/builtin-objects/Function/instance-length.js

@@ -20,8 +20,9 @@ class Fn extends Function {}
 
 var fn = new Fn('a', 'b', 'return a + b');
 
-assert.sameValue(fn.length, 2);
+verifyProperty(fn, 'length', {
-
+  value: 2,
-verifyNotEnumerable(fn, 'length');
+  writable: false,
-verifyNotWritable(fn, 'length');
+  enumerable: false,
-verifyConfigurable(fn, 'length');
+  configurable: true,
+});

test/language/statements/class/subclass/builtin-objects/Function/instance-name.js

@@ -29,11 +29,9 @@ class Fn extends Function {}
 
 var fn = new Fn('a', 'b', 'return a + b');
 
-assert.sameValue(
+verifyProperty(fn, 'name', {
-  fn.name, 'anonymous',
+  value: 'anonymous',
-  'Dynamic Functions are called anonymous'
+  writable: false,
-);
+  enumerable: false,
-
+  configurable: true,
-verifyNotEnumerable(fn, 'name');
+});
-verifyNotWritable(fn, 'name');
-verifyConfigurable(fn, 'name');

test/language/statements/class/subclass/builtin-objects/GeneratorFunction/instance-length.js

@@ -24,8 +24,9 @@ class GFn extends GeneratorFunction {}
 
 var gfn = new GFn('a', 'b', 'return a + b');
 
-assert.sameValue(gfn.length, 2);
+verifyProperty(gfn, 'length', {
-
+  value: 2,
-verifyNotEnumerable(gfn, 'length');
+  writable: false,
-verifyNotWritable(gfn, 'length');
+  enumerable: false,
-verifyConfigurable(gfn, 'length');
+  configurable: true,
+});

test/language/statements/class/subclass/builtin-objects/GeneratorFunction/instance-name.js

@@ -36,11 +36,9 @@ class GFn extends GeneratorFunction {}
 
 var gfn = new GFn('a', 'b', 'return a + b');
 
-assert.sameValue(
+verifyProperty(gfn, 'name', {
-  gfn.name, 'anonymous',
+  value: 'anonymous',
-  'Dynamic Functions are called anonymous'
+  writable: false,
-);
+  enumerable: false,
-
+  configurable: true,
-verifyNotEnumerable(gfn, 'name');
+});
-verifyNotWritable(gfn, 'name');
-verifyConfigurable(gfn, 'name');

test/language/statements/class/subclass/builtin-objects/GeneratorFunction/instance-prototype.js

@@ -33,6 +33,8 @@ assert.sameValue(
   'prototype has no constructor reference'
 );
 
-verifyNotEnumerable(gfn, 'prototype');
+verifyProperty(gfn, 'prototype', {
-verifyWritable(gfn, 'prototype');
+  writable: true,
-verifyNotConfigurable(gfn, 'prototype');
+  enumerable: false,
+  configurable: false,
+});

test/language/statements/class/subclass/builtin-objects/NativeError/EvalError-message.js

@@ -23,12 +23,13 @@ class Err extends EvalError {}
 Err.prototype.message = 'custom-eval-error';
 
 var err1 = new Err('foo 42');
-assert.sameValue(err1.message, 'foo 42');
-assert(err1.hasOwnProperty('message'));
 
-verifyWritable(err1, 'message');
+verifyProperty(err1, 'message', {
-verifyNotEnumerable(err1, 'message');
+  value: 'foo 42',
-verifyConfigurable(err1, 'message');
+  writable: true,
+  enumerable: false,
+  configurable: true,
+});
 
 var err2 = new Err();
 assert.sameValue(err2.hasOwnProperty('message'), false);

test/language/statements/class/subclass/builtin-objects/NativeError/RangeError-message.js

@@ -23,12 +23,13 @@ class Err extends RangeError {}
 Err.prototype.message = 'custom-range-error';
 
 var err1 = new Err('foo 42');
-assert.sameValue(err1.message, 'foo 42');
-assert(err1.hasOwnProperty('message'));
 
-verifyWritable(err1, 'message');
+verifyProperty(err1, 'message', {
-verifyNotEnumerable(err1, 'message');
+  value: 'foo 42',
-verifyConfigurable(err1, 'message');
+  writable: true,
+  enumerable: false,
+  configurable: true,
+});
 
 var err2 = new Err();
 assert.sameValue(err2.hasOwnProperty('message'), false);

test/language/statements/class/subclass/builtin-objects/NativeError/ReferenceError-message.js

@@ -23,12 +23,13 @@ class Err extends ReferenceError {}
 Err.prototype.message = 'custom-reference-error';
 
 var err1 = new Err('foo 42');
-assert.sameValue(err1.message, 'foo 42');
-assert(err1.hasOwnProperty('message'));
 
-verifyWritable(err1, 'message');
+verifyProperty(err1, 'message', {
-verifyNotEnumerable(err1, 'message');
+  value: 'foo 42',
-verifyConfigurable(err1, 'message');
+  writable: true,
+  enumerable: false,
+  configurable: true,
+});
 
 var err2 = new Err();
 assert.sameValue(err2.hasOwnProperty('message'), false);

test/language/statements/class/subclass/builtin-objects/NativeError/SyntaxError-message.js

@@ -23,12 +23,13 @@ class Err extends SyntaxError {}
 Err.prototype.message = 'custom-syntax-error';
 
 var err1 = new Err('foo 42');
-assert.sameValue(err1.message, 'foo 42');
-assert(err1.hasOwnProperty('message'));
 
-verifyWritable(err1, 'message');
+verifyProperty(err1, 'message', {
-verifyNotEnumerable(err1, 'message');
+  value: 'foo 42',
-verifyConfigurable(err1, 'message');
+  writable: true,
+  enumerable: false,
+  configurable: true,
+});
 
 var err2 = new Err();
 assert.sameValue(err2.hasOwnProperty('message'), false);

test/language/statements/class/subclass/builtin-objects/NativeError/TypeError-message.js

@@ -23,12 +23,13 @@ class Err extends TypeError {}
 Err.prototype.message = 'custom-type-error';
 
 var err1 = new Err('foo 42');
-assert.sameValue(err1.message, 'foo 42');
-assert(err1.hasOwnProperty('message'));
 
-verifyWritable(err1, 'message');
+verifyProperty(err1, 'message', {
-verifyNotEnumerable(err1, 'message');
+  value: 'foo 42',
-verifyConfigurable(err1, 'message');
+  writable: true,
+  enumerable: false,
+  configurable: true,
+});
 
 var err2 = new Err();
 assert.sameValue(err2.hasOwnProperty('message'), false);

test/language/statements/class/subclass/builtin-objects/NativeError/URIError-message.js

@@ -23,12 +23,13 @@ class Err extends URIError {}
 Err.prototype.message = 'custom-uri-error';
 
 var err1 = new Err('foo 42');
-assert.sameValue(err1.message, 'foo 42');
-assert(err1.hasOwnProperty('message'));
 
-verifyWritable(err1, 'message');
+verifyProperty(err1, 'message', {
-verifyNotEnumerable(err1, 'message');
+  value: 'foo 42',
-verifyConfigurable(err1, 'message');
+  writable: true,
+  enumerable: false,
+  configurable: true,
+});
 
 var err2 = new Err();
 assert.sameValue(err2.hasOwnProperty('message'), false);

test/language/statements/class/subclass/builtin-objects/RegExp/lastIndex.js

@@ -19,8 +19,9 @@ var re = new RE('39?');
 
 re.exec('TC39');
 
-assert.sameValue(re.lastIndex, 0);
+verifyProperty(re, 'lastIndex', {
-
+  value: 0,
-verifyWritable(re, 'lastIndex');
+  writable: true,
-verifyNotEnumerable(re, 'lastIndex');
+  enumerable: false,
-verifyNotConfigurable(re, 'lastIndex');
+  configurable: false,
+});

test/language/statements/class/subclass/builtin-objects/String/length.js

@@ -16,15 +16,19 @@ includes: [propertyHelper.js]
 class S extends String {}
 
 var s1 = new S();
-assert.sameValue(s1.length, 0);
 
-verifyNotWritable(s1, 'length');
+verifyProperty(s1, 'length', {
-verifyNotEnumerable(s1, 'length');
+  value: 0,
-verifyNotConfigurable(s1, 'length');
+  writable: false,
+  enumerable: false,
+  configurable: false,
+});
 
 var s2 = new S('test262');
-assert.sameValue(s2.length, 7);
 
-verifyNotWritable(s2, 'length');
+verifyProperty(s2, 'length', {
-verifyNotEnumerable(s2, 'length');
+  value: 7,
-verifyNotConfigurable(s2, 'length');
+  writable: false,
+  enumerable: false,
+  configurable: false,
+});

test/language/statements/const/fn-name-arrow.js

@@ -18,7 +18,9 @@ includes: [propertyHelper.js]
 
 const arrow = () => {};
 
-assert.sameValue(arrow.name, 'arrow');
+verifyProperty(arrow, "name", {
-verifyNotEnumerable(arrow, 'name');
+  value: "arrow",
-verifyNotWritable(arrow, 'name');
+  writable: false,
-verifyConfigurable(arrow, 'name');
+  enumerable: false,
+  configurable: true,
+});

test/language/statements/const/fn-name-class.js

@@ -24,7 +24,9 @@ const xCls2 = class { static name() {} };
 assert.notSameValue(xCls.name, 'xCls');
 assert.notSameValue(xCls2.name, 'xCls2');
 
-assert.sameValue(cls.name, 'cls');
+verifyProperty(cls, 'name', {
-verifyNotEnumerable(cls, 'name');
+  value: 'cls',
-verifyNotWritable(cls, 'name');
+  writable: false,
-verifyConfigurable(cls, 'name');
+  enumerable: false,
+  configurable: true,
+});

test/language/statements/const/fn-name-cover.js

@@ -22,7 +22,9 @@ const cover = (function() {});
 
 assert(xCover.name !== 'xCover');
 
-assert.sameValue(cover.name, 'cover');
+verifyProperty(cover, 'name', {
-verifyNotEnumerable(cover, 'name');
+  value: 'cover',
-verifyNotWritable(cover, 'name');
+  writable: false,
-verifyConfigurable(cover, 'name');
+  enumerable: false,
+  configurable: true,
+});

test/language/statements/const/fn-name-fn.js

@@ -21,7 +21,9 @@ const fn = function() {};
 
 assert(xFn.name !== 'xFn');
 
-assert.sameValue(fn.name, 'fn');
+verifyProperty(fn, 'name', {
-verifyNotEnumerable(fn, 'name');
+  value: 'fn',
-verifyNotWritable(fn, 'name');
+  writable: false,
-verifyConfigurable(fn, 'name');
+  enumerable: false,
+  configurable: true,
+});

test/language/statements/const/fn-name-gen.js

@@ -22,7 +22,9 @@ const gen = function*() {};
 
 assert(xGen.name !== 'xGen');
 
-assert.sameValue(gen.name, 'gen');
+verifyProperty(gen, 'name', {
-verifyNotEnumerable(gen, 'name');
+  value: 'gen',
-verifyNotWritable(gen, 'name');
+  writable: false,
-verifyConfigurable(gen, 'name');
+  enumerable: false,
+  configurable: true,
+});

test/language/statements/function/13.2-15-1.js

@@ -11,9 +11,9 @@ includes: [propertyHelper.js]
 
 var fun = function (x, y) { };
 
-assert(fun.hasOwnProperty("length"));
+verifyProperty(fun, "length", {
-assert.sameValue(fun.length, 2);
+  value: 2,
-
+  writable: false,
-verifyNotEnumerable(fun, "length");
+  enumerable: false,
-verifyNotWritable(fun, "length");
+  configurable: true,
-verifyConfigurable(fun, "length");
+});

test/language/statements/function/13.2-18-1.js

@@ -30,9 +30,11 @@ try {
     assert.notSameValue(fun.prototype, 100);
     assert.sameValue(fun.prototype.toString(), "[object Object]");
 
-    verifyNotEnumerable(fun, "prototype");
+    verifyProperty(fun, "prototype", {
-    verifyWritable(fun, "prototype");
+        writable: true,
-    verifyNotConfigurable(fun, "prototype");
+        enumerable: false,
+        configurable: false,
+    });
 
     assert.sameValue(data, "data");
 } finally {

test/language/statements/function/length-dflt.js

@@ -33,28 +33,36 @@ includes: [propertyHelper.js]
 
 function f1(x = 42) {}
 
-assert.sameValue(f1.length, 0, 'FormalsList: x = 42');
+verifyProperty(f1, "length", {
-verifyNotEnumerable(f1, 'length');
+  value: 0,
-verifyNotWritable(f1, 'length');
+  writable: false,
-verifyConfigurable(f1, 'length');
+  enumerable: false,
+  configurable: true,
+});
 
 function f2(x = 42, y) {}
 
-assert.sameValue(f2.length, 0, 'FormalsList: x = 42, y');
+verifyProperty(f2, "length", {
-verifyNotEnumerable(f2, 'length');
+  value: 0,
-verifyNotWritable(f2, 'length');
+  writable: false,
-verifyConfigurable(f2, 'length');
+  enumerable: false,
+  configurable: true,
+});
 
 function f3(x, y = 42) {}
 
-assert.sameValue(f3.length, 1, 'FormalsList: x, y = 42');
+verifyProperty(f3, "length", {
-verifyNotEnumerable(f3, 'length');
+  value: 1,
-verifyNotWritable(f3, 'length');
+  writable: false,
-verifyConfigurable(f3, 'length');
+  enumerable: false,
+  configurable: true,
+});
 
 function f4(x, y = 42, z) {}
 
-assert.sameValue(f4.length, 1, 'FormalsList: x, y = 42, z');
+verifyProperty(f4, "length", {
-verifyNotEnumerable(f4, 'length');
+  value: 1,
-verifyNotWritable(f4, 'length');
+  writable: false,
-verifyConfigurable(f4, 'length');
+  enumerable: false,
+  configurable: true,
+});

test/language/statements/function/name.js

@@ -18,7 +18,9 @@ includes: [propertyHelper.js]
 
 function func() {}
 
-assert.sameValue(func.name, 'func');
+verifyProperty(func, "name", {
-verifyNotEnumerable(func, 'name');
+  value: "func",
-verifyNotWritable(func, 'name');
+  writable: false,
-verifyConfigurable(func, 'name');
+  enumerable: false,
+  configurable: true,
+});

test/language/statements/generators/length-dflt.js

@@ -33,28 +33,36 @@ includes: [propertyHelper.js]
 
 function* f1(x = 42) {}
 
-assert.sameValue(f1.length, 0, 'FormalsList: x = 42');
+verifyProperty(f1, "length", {
-verifyNotEnumerable(f1, 'length');
+  value: 0,
-verifyNotWritable(f1, 'length');
+  writable: false,
-verifyConfigurable(f1, 'length');
+  enumerable: false,
+  configurable: true,
+});
 
 function* f2(x = 42, y) {}
 
-assert.sameValue(f2.length, 0, 'FormalsList: x = 42, y');
+verifyProperty(f2, "length", {
-verifyNotEnumerable(f2, 'length');
+  value: 0,
-verifyNotWritable(f2, 'length');
+  writable: false,
-verifyConfigurable(f2, 'length');
+  enumerable: false,
+  configurable: true,
+});
 
 function* f3(x, y = 42) {}
 
-assert.sameValue(f3.length, 1, 'FormalsList: x, y = 42');
+verifyProperty(f3, "length", {
-verifyNotEnumerable(f3, 'length');
+  value: 1,
-verifyNotWritable(f3, 'length');
+  writable: false,
-verifyConfigurable(f3, 'length');
+  enumerable: false,
+  configurable: true,
+});
 
 function* f4(x, y = 42, z) {}
 
-assert.sameValue(f4.length, 1, 'FormalsList: x, y = 42, z');
+verifyProperty(f4, "length", {
-verifyNotEnumerable(f4, 'length');
+  value: 1,
-verifyNotWritable(f4, 'length');
+  writable: false,
-verifyConfigurable(f4, 'length');
+  enumerable: false,
+  configurable: true,
+});

test/language/statements/generators/length-property-descriptor.js

@@ -11,7 +11,9 @@ features: [generators]
 
 function* g() {}
 
-assert.sameValue(g.length, 0);
+verifyProperty(g, "length", {
-verifyNotEnumerable(g, 'length');
+  value: 0,
-verifyNotWritable(g, 'length');
+  writable: false,
-verifyConfigurable(g, 'length');
+  enumerable: false,
+  configurable: true,
+});

test/language/statements/generators/name.js

@@ -16,7 +16,9 @@ features: [generators]
 
 function* g() {}
 
-assert.sameValue(g.name, 'g');
+verifyProperty(g, "name", {
-verifyNotEnumerable(g, 'name');
+  value: "g",
-verifyNotWritable(g, 'name');
+  writable: false,
-verifyConfigurable(g, 'name');
+  enumerable: false,
+  configurable: true,
+});

test/language/statements/generators/prototype-property-descriptor.js

@@ -11,6 +11,8 @@ features: [generators]
 
 function* g() {}
 
-verifyNotEnumerable(g, 'prototype');
+verifyProperty(g, "prototype", {
-verifyWritable(g, 'prototype');
+  writable: true,
-verifyNotConfigurable(g, 'prototype');
+  enumerable: false,
+  configurable: false,
+});

test/language/statements/let/fn-name-arrow.js

@@ -18,7 +18,9 @@ includes: [propertyHelper.js]
 
 let arrow = () => {};
 
-assert.sameValue(arrow.name, 'arrow');
+verifyProperty(arrow, 'name', {
-verifyNotEnumerable(arrow, 'name');
+  value: 'arrow',
-verifyNotWritable(arrow, 'name');
+  writable: false,
-verifyConfigurable(arrow, 'name');
+  enumerable: false,
+  configurable: true,
+});

test/language/statements/let/fn-name-class.js

@@ -24,7 +24,9 @@ let xCls2 = class { static name() {} };
 assert.notSameValue(xCls.name, 'xCls');
 assert.notSameValue(xCls2.name, 'xCls2');
 
-assert.sameValue(cls.name, 'cls');
+verifyProperty(cls, 'name', {
-verifyNotEnumerable(cls, 'name');
+  value: 'cls',
-verifyNotWritable(cls, 'name');
+  writable: false,
-verifyConfigurable(cls, 'name');
+  enumerable: false,
+  configurable: true,
+});

test/language/statements/let/fn-name-cover.js

@@ -22,7 +22,9 @@ let cover = (function() {});
 
 assert(xCover.name !== 'xCover');
 
-assert.sameValue(cover.name, 'cover');
+verifyProperty(cover, 'name', {
-verifyNotEnumerable(cover, 'name');
+  value: 'cover',
-verifyNotWritable(cover, 'name');
+  writable: false,
-verifyConfigurable(cover, 'name');
+  enumerable: false,
+  configurable: true,
+});

test/language/statements/let/fn-name-fn.js

@@ -21,7 +21,9 @@ let fn = function() {};
 
 assert(xFn.name !== 'xFn');
 
-assert.sameValue(fn.name, 'fn');
+verifyProperty(fn, 'name', {
-verifyNotEnumerable(fn, 'name');
+  value: 'fn',
-verifyNotWritable(fn, 'name');
+  writable: false,
-verifyConfigurable(fn, 'name');
+  enumerable: false,
+  configurable: true,
+});

test/language/statements/let/fn-name-gen.js

@@ -22,7 +22,9 @@ let gen = function*() {};
 
 assert(xGen.name !== 'xGen');
 
-assert.sameValue(gen.name, 'gen');
+verifyProperty(gen, 'name', {
-verifyNotEnumerable(gen, 'name');
+  value: 'gen',
-verifyNotWritable(gen, 'name');
+  writable: false,
-verifyConfigurable(gen, 'name');
+  enumerable: false,
+  configurable: true,
+});

test/language/statements/variable/fn-name-arrow.js

@@ -18,7 +18,9 @@ includes: [propertyHelper.js]
 
 var arrow = () => {};
 
-assert.sameValue(arrow.name, 'arrow');
+verifyProperty(arrow, 'name', {
-verifyNotEnumerable(arrow, 'name');
+  value: 'arrow',
-verifyNotWritable(arrow, 'name');
+  writable: false,
-verifyConfigurable(arrow, 'name');
+  enumerable: false,
+  configurable: true,
+});

test/language/statements/variable/fn-name-class.js

@@ -24,7 +24,9 @@ var xCls2 = class { static name() {} };
 assert.notSameValue(xCls.name, 'xCls');
 assert.notSameValue(xCls2.name, 'xCls2');
 
-assert.sameValue(cls.name, 'cls');
+verifyProperty(cls, 'name', {
-verifyNotEnumerable(cls, 'name');
+  value: 'cls',
-verifyNotWritable(cls, 'name');
+  writable: false,
-verifyConfigurable(cls, 'name');
+  enumerable: false,
+  configurable: true,
+});

test/language/statements/variable/fn-name-cover.js

@@ -22,7 +22,9 @@ var cover = (function() {});
 
 assert(xCover.name !== 'xCover');
 
-assert.sameValue(cover.name, 'cover');
+verifyProperty(cover, 'name', {
-verifyNotEnumerable(cover, 'name');
+  value: 'cover',
-verifyNotWritable(cover, 'name');
+  writable: false,
-verifyConfigurable(cover, 'name');
+  enumerable: false,
+  configurable: true,
+});

test/language/statements/variable/fn-name-fn.js

@@ -21,7 +21,9 @@ var fn = function() {};
 
 assert(xFn.name !== 'xFn');
 
-assert.sameValue(fn.name, 'fn');
+verifyProperty(fn, 'name', {
-verifyNotEnumerable(fn, 'name');
+  value: 'fn',
-verifyNotWritable(fn, 'name');
+  writable: false,
-verifyConfigurable(fn, 'name');
+  enumerable: false,
+  configurable: true,
+});

test/language/statements/variable/fn-name-gen.js

@@ -22,7 +22,9 @@ var gen = function*() {};
 
 assert(xGen.name !== 'xGen');
 
-assert.sameValue(gen.name, 'gen');
+verifyProperty(gen, 'name', {
-verifyNotEnumerable(gen, 'name');
+  value: 'gen',
-verifyNotWritable(gen, 'name');
+  writable: false,
-verifyConfigurable(gen, 'name');
+  enumerable: false,
+  configurable: true,
+});