From cc559ac106f773e99de4182fb4045a4e7de50fdd Mon Sep 17 00:00:00 2001
From: Philip Chimento <pchimento@igalia.com>
Date: Thu, 24 Nov 2022 09:24:46 -0800
Subject: [PATCH] Rebuild generated tests

---
 .../array/spread-obj-symbol-property.js       |  2 +-
 ...amed-yield-identifier-spread-non-strict.js |  2 +-
 .../yield-identifier-spread-non-strict.js     |  2 +-
 .../call/spread-obj-symbol-property.js        |  2 +-
 .../after-same-line-gen-computed-names.js     | 50 +++++++++---
 ...ter-same-line-gen-computed-symbol-names.js | 55 ++++++++++---
 ...tename-identifier-semantics-stringvalue.js |  5 +-
 .../after-same-line-gen-literal-names-asi.js  | 25 ++++--
 .../after-same-line-gen-literal-names.js      | 35 ++++++--
 ...after-same-line-gen-private-field-usage.js |  5 +-
 ...me-line-gen-private-method-getter-usage.js |  5 +-
 ...fter-same-line-gen-private-method-usage.js |  5 +-
 .../after-same-line-gen-private-names.js      | 21 ++---
 ...ine-gen-rs-field-identifier-initializer.js |  5 +-
 ...after-same-line-gen-rs-field-identifier.js |  5 +-
 ...ter-same-line-gen-rs-private-getter-alt.js |  5 +-
 .../after-same-line-gen-rs-private-getter.js  |  5 +-
 ...ter-same-line-gen-rs-private-method-alt.js |  5 +-
 .../after-same-line-gen-rs-private-method.js  |  5 +-
 ...ter-same-line-gen-rs-private-setter-alt.js |  5 +-
 .../after-same-line-gen-rs-private-setter.js  |  5 +-
 ...-line-gen-rs-privatename-identifier-alt.js |  5 +-
 ...-privatename-identifier-initializer-alt.js |  5 +-
 ...n-rs-privatename-identifier-initializer.js |  5 +-
 ...same-line-gen-rs-privatename-identifier.js |  5 +-
 ...rator-method-privatename-identifier-alt.js |  5 +-
 ...generator-method-privatename-identifier.js |  5 +-
 ...async-method-privatename-identifier-alt.js |  5 +-
 ...tic-async-method-privatename-identifier.js |  5 +-
 ...rator-method-privatename-identifier-alt.js |  5 +-
 ...generator-method-privatename-identifier.js |  5 +-
 ...tatic-method-privatename-identifier-alt.js |  5 +-
 ...rs-static-method-privatename-identifier.js |  5 +-
 ...privatename-identifier-alt-by-classname.js |  5 +-
 ...en-rs-static-privatename-identifier-alt.js |  5 +-
 ...tic-privatename-identifier-by-classname.js |  5 +-
 ...identifier-initializer-alt-by-classname.js |  5 +-
 ...-privatename-identifier-initializer-alt.js |  5 +-
 ...atic-privatename-identifier-initializer.js |  5 +-
 ...ne-gen-rs-static-privatename-identifier.js |  5 +-
 ...ter-same-line-gen-static-private-fields.js | 21 ++---
 ...-gen-static-private-methods-with-fields.js | 37 +++++----
 ...er-same-line-gen-static-private-methods.js | 21 ++---
 ...fter-same-line-gen-string-literal-names.js | 45 ++++++++---
 .../after-same-line-method-computed-names.js  | 50 +++++++++---
 ...-same-line-method-computed-symbol-names.js | 55 ++++++++++---
 ...tename-identifier-semantics-stringvalue.js |  5 +-
 ...fter-same-line-method-literal-names-asi.js | 25 ++++--
 .../after-same-line-method-literal-names.js   | 35 ++++++--
 ...er-same-line-method-private-field-usage.js |  5 +-
 ...line-method-private-method-getter-usage.js |  5 +-
 ...r-same-line-method-private-method-usage.js |  5 +-
 .../after-same-line-method-private-names.js   | 21 ++---
 ...-method-rs-field-identifier-initializer.js |  5 +-
 ...er-same-line-method-rs-field-identifier.js |  5 +-
 ...-same-line-method-rs-private-getter-alt.js |  5 +-
 ...fter-same-line-method-rs-private-getter.js |  5 +-
 ...-same-line-method-rs-private-method-alt.js |  5 +-
 ...fter-same-line-method-rs-private-method.js |  5 +-
 ...-same-line-method-rs-private-setter-alt.js |  5 +-
 ...fter-same-line-method-rs-private-setter.js |  5 +-
 ...ne-method-rs-privatename-identifier-alt.js |  5 +-
 ...-privatename-identifier-initializer-alt.js |  5 +-
 ...d-rs-privatename-identifier-initializer.js |  5 +-
 ...e-line-method-rs-privatename-identifier.js |  5 +-
 ...rator-method-privatename-identifier-alt.js |  5 +-
 ...generator-method-privatename-identifier.js |  5 +-
 ...async-method-privatename-identifier-alt.js |  5 +-
 ...tic-async-method-privatename-identifier.js |  5 +-
 ...rator-method-privatename-identifier-alt.js |  5 +-
 ...generator-method-privatename-identifier.js |  5 +-
 ...tatic-method-privatename-identifier-alt.js |  5 +-
 ...rs-static-method-privatename-identifier.js |  5 +-
 ...privatename-identifier-alt-by-classname.js |  5 +-
 ...od-rs-static-privatename-identifier-alt.js |  5 +-
 ...tic-privatename-identifier-by-classname.js |  5 +-
 ...identifier-initializer-alt-by-classname.js |  5 +-
 ...-privatename-identifier-initializer-alt.js |  5 +-
 ...atic-privatename-identifier-initializer.js |  5 +-
 ...method-rs-static-privatename-identifier.js |  5 +-
 ...-same-line-method-static-private-fields.js | 21 ++---
 ...thod-static-private-methods-with-fields.js | 37 +++++----
 ...same-line-method-static-private-methods.js | 21 ++---
 ...r-same-line-method-string-literal-names.js | 45 ++++++++---
 ...me-line-static-async-gen-computed-names.js | 55 ++++++++++---
 ...-static-async-gen-computed-symbol-names.js | 60 +++++++++++---
 ...tename-identifier-semantics-stringvalue.js | 10 ++-
 ...line-static-async-gen-literal-names-asi.js | 30 +++++--
 ...ame-line-static-async-gen-literal-names.js | 40 ++++++++--
 ...ne-static-async-gen-private-field-usage.js | 10 ++-
 ...c-async-gen-private-method-getter-usage.js | 10 ++-
 ...e-static-async-gen-private-method-usage.js | 10 ++-
 ...ame-line-static-async-gen-private-names.js | 26 +++---
 ...ync-gen-rs-field-identifier-initializer.js | 10 ++-
 ...ne-static-async-gen-rs-field-identifier.js | 10 ++-
 ...-static-async-gen-rs-private-getter-alt.js | 10 ++-
 ...line-static-async-gen-rs-private-getter.js | 10 ++-
 ...-static-async-gen-rs-private-method-alt.js | 10 ++-
 ...line-static-async-gen-rs-private-method.js | 10 ++-
 ...-static-async-gen-rs-private-setter-alt.js | 10 ++-
 ...line-static-async-gen-rs-private-setter.js | 10 ++-
 ...async-gen-rs-privatename-identifier-alt.js | 10 ++-
 ...-privatename-identifier-initializer-alt.js | 10 ++-
 ...n-rs-privatename-identifier-initializer.js | 10 ++-
 ...tic-async-gen-rs-privatename-identifier.js | 10 ++-
 ...rator-method-privatename-identifier-alt.js | 10 ++-
 ...generator-method-privatename-identifier.js | 10 ++-
 ...async-method-privatename-identifier-alt.js | 10 ++-
 ...tic-async-method-privatename-identifier.js | 10 ++-
 ...rator-method-privatename-identifier-alt.js | 10 ++-
 ...generator-method-privatename-identifier.js | 10 ++-
 ...tatic-method-privatename-identifier-alt.js | 10 ++-
 ...rs-static-method-privatename-identifier.js | 10 ++-
 ...privatename-identifier-alt-by-classname.js | 10 ++-
 ...en-rs-static-privatename-identifier-alt.js | 10 ++-
 ...tic-privatename-identifier-by-classname.js | 10 ++-
 ...identifier-initializer-alt-by-classname.js | 10 ++-
 ...-privatename-identifier-initializer-alt.js | 10 ++-
 ...atic-privatename-identifier-initializer.js | 10 ++-
 ...nc-gen-rs-static-privatename-identifier.js | 10 ++-
 ...-static-async-gen-static-private-fields.js | 26 +++---
 ...-gen-static-private-methods-with-fields.js | 42 +++++-----
 ...static-async-gen-static-private-methods.js | 26 +++---
 ...e-static-async-gen-string-literal-names.js | 50 +++++++++---
 ...line-static-async-method-computed-names.js | 55 ++++++++++---
 ...atic-async-method-computed-symbol-names.js | 60 +++++++++++---
 ...tename-identifier-semantics-stringvalue.js | 10 ++-
 ...e-static-async-method-literal-names-asi.js | 30 +++++--
 ...-line-static-async-method-literal-names.js | 40 ++++++++--
 ...static-async-method-private-field-usage.js | 10 ++-
 ...sync-method-private-method-getter-usage.js | 10 ++-
 ...tatic-async-method-private-method-usage.js | 10 ++-
 ...-line-static-async-method-private-names.js | 26 +++---
 ...-method-rs-field-identifier-initializer.js | 10 ++-
 ...static-async-method-rs-field-identifier.js | 10 ++-
 ...atic-async-method-rs-private-getter-alt.js | 10 ++-
 ...e-static-async-method-rs-private-getter.js | 10 ++-
 ...atic-async-method-rs-private-method-alt.js | 10 ++-
 ...e-static-async-method-rs-private-method.js | 10 ++-
 ...atic-async-method-rs-private-setter-alt.js | 10 ++-
 ...e-static-async-method-rs-private-setter.js | 10 ++-
 ...nc-method-rs-privatename-identifier-alt.js | 10 ++-
 ...-privatename-identifier-initializer-alt.js | 10 ++-
 ...d-rs-privatename-identifier-initializer.js | 10 ++-
 ...-async-method-rs-privatename-identifier.js | 10 ++-
 ...rator-method-privatename-identifier-alt.js | 10 ++-
 ...generator-method-privatename-identifier.js | 10 ++-
 ...async-method-privatename-identifier-alt.js | 10 ++-
 ...tic-async-method-privatename-identifier.js | 10 ++-
 ...rator-method-privatename-identifier-alt.js | 10 ++-
 ...generator-method-privatename-identifier.js | 10 ++-
 ...tatic-method-privatename-identifier-alt.js | 10 ++-
 ...rs-static-method-privatename-identifier.js | 10 ++-
 ...privatename-identifier-alt-by-classname.js | 10 ++-
 ...od-rs-static-privatename-identifier-alt.js | 10 ++-
 ...tic-privatename-identifier-by-classname.js | 10 ++-
 ...identifier-initializer-alt-by-classname.js | 10 ++-
 ...-privatename-identifier-initializer-alt.js | 10 ++-
 ...atic-privatename-identifier-initializer.js | 10 ++-
 ...method-rs-static-privatename-identifier.js | 10 ++-
 ...atic-async-method-static-private-fields.js | 26 +++---
 ...thod-static-private-methods-with-fields.js | 42 +++++-----
 ...tic-async-method-static-private-methods.js | 26 +++---
 ...tatic-async-method-string-literal-names.js | 50 +++++++++---
 ...ter-same-line-static-gen-computed-names.js | 55 ++++++++++---
 ...e-line-static-gen-computed-symbol-names.js | 60 +++++++++++---
 ...tename-identifier-semantics-stringvalue.js | 10 ++-
 ...-same-line-static-gen-literal-names-asi.js | 30 +++++--
 ...fter-same-line-static-gen-literal-names.js | 40 ++++++++--
 ...ame-line-static-gen-private-field-usage.js | 10 ++-
 ...-static-gen-private-method-getter-usage.js | 10 ++-
 ...me-line-static-gen-private-method-usage.js | 10 ++-
 ...fter-same-line-static-gen-private-names.js | 26 +++---
 ...tic-gen-rs-field-identifier-initializer.js | 10 ++-
 ...ame-line-static-gen-rs-field-identifier.js | 10 ++-
 ...e-line-static-gen-rs-private-getter-alt.js | 10 ++-
 ...-same-line-static-gen-rs-private-getter.js | 10 ++-
 ...e-line-static-gen-rs-private-method-alt.js | 10 ++-
 ...-same-line-static-gen-rs-private-method.js | 10 ++-
 ...e-line-static-gen-rs-private-setter-alt.js | 10 ++-
 ...-same-line-static-gen-rs-private-setter.js | 10 ++-
 ...tatic-gen-rs-privatename-identifier-alt.js | 10 ++-
 ...-privatename-identifier-initializer-alt.js | 10 ++-
 ...n-rs-privatename-identifier-initializer.js | 10 ++-
 ...ne-static-gen-rs-privatename-identifier.js | 10 ++-
 ...rator-method-privatename-identifier-alt.js | 10 ++-
 ...generator-method-privatename-identifier.js | 10 ++-
 ...async-method-privatename-identifier-alt.js | 10 ++-
 ...tic-async-method-privatename-identifier.js | 10 ++-
 ...rator-method-privatename-identifier-alt.js | 10 ++-
 ...generator-method-privatename-identifier.js | 10 ++-
 ...tatic-method-privatename-identifier-alt.js | 10 ++-
 ...rs-static-method-privatename-identifier.js | 10 ++-
 ...privatename-identifier-alt-by-classname.js | 10 ++-
 ...en-rs-static-privatename-identifier-alt.js | 10 ++-
 ...tic-privatename-identifier-by-classname.js | 10 ++-
 ...identifier-initializer-alt-by-classname.js | 10 ++-
 ...-privatename-identifier-initializer-alt.js | 10 ++-
 ...atic-privatename-identifier-initializer.js | 10 ++-
 ...ic-gen-rs-static-privatename-identifier.js | 10 ++-
 ...e-line-static-gen-static-private-fields.js | 26 +++---
 ...-gen-static-private-methods-with-fields.js | 42 +++++-----
 ...-line-static-gen-static-private-methods.js | 26 +++---
 ...me-line-static-gen-string-literal-names.js | 50 +++++++++---
 ...-same-line-static-method-computed-names.js | 55 ++++++++++---
 ...ine-static-method-computed-symbol-names.js | 60 +++++++++++---
 ...tename-identifier-semantics-stringvalue.js | 10 ++-
 ...me-line-static-method-literal-names-asi.js | 30 +++++--
 ...r-same-line-static-method-literal-names.js | 40 ++++++++--
 ...-line-static-method-private-field-usage.js | 10 ++-
 ...atic-method-private-method-getter-usage.js | 10 ++-
 ...line-static-method-private-method-usage.js | 10 ++-
 ...r-same-line-static-method-private-names.js | 26 +++---
 ...-method-rs-field-identifier-initializer.js | 10 ++-
 ...-line-static-method-rs-field-identifier.js | 10 ++-
 ...ine-static-method-rs-private-getter-alt.js | 10 ++-
 ...me-line-static-method-rs-private-getter.js | 10 ++-
 ...ine-static-method-rs-private-method-alt.js | 10 ++-
 ...me-line-static-method-rs-private-method.js | 10 ++-
 ...ine-static-method-rs-private-setter-alt.js | 10 ++-
 ...me-line-static-method-rs-private-setter.js | 10 ++-
 ...ic-method-rs-privatename-identifier-alt.js | 10 ++-
 ...-privatename-identifier-initializer-alt.js | 10 ++-
 ...d-rs-privatename-identifier-initializer.js | 10 ++-
 ...static-method-rs-privatename-identifier.js | 10 ++-
 ...rator-method-privatename-identifier-alt.js | 10 ++-
 ...generator-method-privatename-identifier.js | 10 ++-
 ...async-method-privatename-identifier-alt.js | 10 ++-
 ...tic-async-method-privatename-identifier.js | 10 ++-
 ...rator-method-privatename-identifier-alt.js | 10 ++-
 ...generator-method-privatename-identifier.js | 10 ++-
 ...tatic-method-privatename-identifier-alt.js | 10 ++-
 ...rs-static-method-privatename-identifier.js | 10 ++-
 ...privatename-identifier-alt-by-classname.js | 10 ++-
 ...od-rs-static-privatename-identifier-alt.js | 10 ++-
 ...tic-privatename-identifier-by-classname.js | 10 ++-
 ...identifier-initializer-alt-by-classname.js | 10 ++-
 ...-privatename-identifier-initializer-alt.js | 10 ++-
 ...atic-privatename-identifier-initializer.js | 10 ++-
 ...method-rs-static-privatename-identifier.js | 10 ++-
 ...ine-static-method-static-private-fields.js | 26 +++---
 ...thod-static-private-methods-with-fields.js | 42 +++++-----
 ...ne-static-method-static-private-methods.js | 26 +++---
 ...line-static-method-string-literal-names.js | 50 +++++++++---
 .../yield-identifier-spread-strict.js         | 20 ++++-
 .../yield-identifier-strict.js                | 20 ++++-
 .../yield-promise-reject-next-catch.js        | 20 ++++-
 ...reject-next-for-await-of-async-iterator.js | 20 ++++-
 ...-reject-next-for-await-of-sync-iterator.js | 20 ++++-
 ...e-reject-next-yield-star-async-iterator.js | 20 ++++-
 ...se-reject-next-yield-star-sync-iterator.js | 20 ++++-
 .../yield-promise-reject-next.js              | 20 ++++-
 .../yield-spread-arr-multiple.js              | 20 ++++-
 .../yield-spread-arr-single.js                | 20 ++++-
 .../yield-spread-obj.js                       | 20 ++++-
 .../yield-star-async-next.js                  | 20 ++++-
 .../yield-star-async-return.js                | 20 ++++-
 .../yield-star-async-throw.js                 | 20 ++++-
 .../yield-star-expr-abrupt.js                 | 20 ++++-
 .../yield-star-getiter-async-get-abrupt.js    | 20 ++++-
 ...etiter-async-not-callable-boolean-throw.js | 20 ++++-
 ...getiter-async-not-callable-number-throw.js | 20 ++++-
 ...getiter-async-not-callable-object-throw.js | 20 ++++-
 ...getiter-async-not-callable-string-throw.js | 20 ++++-
 ...getiter-async-not-callable-symbol-throw.js | 20 ++++-
 ...star-getiter-async-null-sync-get-abrupt.js | 20 ++++-
 ...yield-star-getiter-async-returns-abrupt.js | 20 ++++-
 ...tar-getiter-async-returns-boolean-throw.js | 20 ++++-
 ...d-star-getiter-async-returns-null-throw.js | 20 ++++-
 ...star-getiter-async-returns-number-throw.js | 20 ++++-
 ...star-getiter-async-returns-string-throw.js | 20 ++++-
 ...star-getiter-async-returns-symbol-throw.js | 20 ++++-
 ...r-getiter-async-returns-undefined-throw.js | 20 ++++-
 ...getiter-async-undefined-sync-get-abrupt.js | 20 ++++-
 .../yield-star-getiter-sync-get-abrupt.js     | 20 ++++-
 ...getiter-sync-not-callable-boolean-throw.js | 20 ++++-
 ...-getiter-sync-not-callable-number-throw.js | 20 ++++-
 ...-getiter-sync-not-callable-object-throw.js | 20 ++++-
 ...-getiter-sync-not-callable-string-throw.js | 20 ++++-
 ...-getiter-sync-not-callable-symbol-throw.js | 20 ++++-
 .../yield-star-getiter-sync-returns-abrupt.js | 20 ++++-
 ...star-getiter-sync-returns-boolean-throw.js | 20 ++++-
 ...ld-star-getiter-sync-returns-null-throw.js | 20 ++++-
 ...-star-getiter-sync-returns-number-throw.js | 20 ++++-
 ...-star-getiter-sync-returns-string-throw.js | 20 ++++-
 ...-star-getiter-sync-returns-symbol-throw.js | 20 ++++-
 ...ar-getiter-sync-returns-undefined-throw.js | 20 ++++-
 .../yield-star-next-call-done-get-abrupt.js   | 20 ++++-
 .../yield-star-next-call-returns-abrupt.js    | 20 ++++-
 .../yield-star-next-call-value-get-abrupt.js  | 20 ++++-
 .../yield-star-next-get-abrupt.js             | 20 ++++-
 ...yield-star-next-non-object-ignores-then.js | 20 ++++-
 ...ld-star-next-not-callable-boolean-throw.js | 20 ++++-
 ...yield-star-next-not-callable-null-throw.js | 20 ++++-
 ...eld-star-next-not-callable-number-throw.js | 20 ++++-
 ...eld-star-next-not-callable-object-throw.js | 20 ++++-
 ...eld-star-next-not-callable-string-throw.js | 20 ++++-
 ...eld-star-next-not-callable-symbol-throw.js | 20 ++++-
 ...-star-next-not-callable-undefined-throw.js | 20 ++++-
 .../yield-star-next-then-get-abrupt.js        | 20 ++++-
 ...hen-non-callable-boolean-fulfillpromise.js | 20 ++++-
 ...t-then-non-callable-null-fulfillpromise.js | 20 ++++-
 ...then-non-callable-number-fulfillpromise.js | 20 ++++-
 ...then-non-callable-object-fulfillpromise.js | 20 ++++-
 ...then-non-callable-string-fulfillpromise.js | 20 ++++-
 ...then-non-callable-symbol-fulfillpromise.js | 20 ++++-
 ...n-non-callable-undefined-fulfillpromise.js | 20 ++++-
 .../yield-star-next-then-returns-abrupt.js    | 20 ++++-
 .../yield-star-sync-next.js                   | 20 ++++-
 .../yield-star-sync-return.js                 | 20 ++++-
 .../yield-star-sync-throw.js                  | 20 ++++-
 .../yield-identifier-spread-strict.js         | 30 +++++--
 .../yield-identifier-strict.js                | 30 +++++--
 .../yield-promise-reject-next-catch.js        | 30 +++++--
 ...reject-next-for-await-of-async-iterator.js | 30 +++++--
 ...-reject-next-for-await-of-sync-iterator.js | 30 +++++--
 ...e-reject-next-yield-star-async-iterator.js | 30 +++++--
 ...se-reject-next-yield-star-sync-iterator.js | 30 +++++--
 .../yield-promise-reject-next.js              | 30 +++++--
 .../yield-spread-arr-multiple.js              | 30 +++++--
 .../yield-spread-arr-single.js                | 30 +++++--
 .../yield-spread-obj.js                       | 30 +++++--
 .../yield-star-async-next.js                  | 30 +++++--
 .../yield-star-async-return.js                | 30 +++++--
 .../yield-star-async-throw.js                 | 30 +++++--
 .../yield-star-expr-abrupt.js                 | 30 +++++--
 .../yield-star-getiter-async-get-abrupt.js    | 30 +++++--
 ...etiter-async-not-callable-boolean-throw.js | 30 +++++--
 ...getiter-async-not-callable-number-throw.js | 30 +++++--
 ...getiter-async-not-callable-object-throw.js | 30 +++++--
 ...getiter-async-not-callable-string-throw.js | 30 +++++--
 ...getiter-async-not-callable-symbol-throw.js | 30 +++++--
 ...star-getiter-async-null-sync-get-abrupt.js | 30 +++++--
 ...yield-star-getiter-async-returns-abrupt.js | 30 +++++--
 ...tar-getiter-async-returns-boolean-throw.js | 30 +++++--
 ...d-star-getiter-async-returns-null-throw.js | 30 +++++--
 ...star-getiter-async-returns-number-throw.js | 30 +++++--
 ...star-getiter-async-returns-string-throw.js | 30 +++++--
 ...star-getiter-async-returns-symbol-throw.js | 30 +++++--
 ...r-getiter-async-returns-undefined-throw.js | 30 +++++--
 ...getiter-async-undefined-sync-get-abrupt.js | 30 +++++--
 .../yield-star-getiter-sync-get-abrupt.js     | 30 +++++--
 ...getiter-sync-not-callable-boolean-throw.js | 30 +++++--
 ...-getiter-sync-not-callable-number-throw.js | 30 +++++--
 ...-getiter-sync-not-callable-object-throw.js | 30 +++++--
 ...-getiter-sync-not-callable-string-throw.js | 30 +++++--
 ...-getiter-sync-not-callable-symbol-throw.js | 30 +++++--
 .../yield-star-getiter-sync-returns-abrupt.js | 30 +++++--
 ...star-getiter-sync-returns-boolean-throw.js | 30 +++++--
 ...ld-star-getiter-sync-returns-null-throw.js | 30 +++++--
 ...-star-getiter-sync-returns-number-throw.js | 30 +++++--
 ...-star-getiter-sync-returns-string-throw.js | 30 +++++--
 ...-star-getiter-sync-returns-symbol-throw.js | 30 +++++--
 ...ar-getiter-sync-returns-undefined-throw.js | 30 +++++--
 .../yield-star-next-call-done-get-abrupt.js   | 30 +++++--
 .../yield-star-next-call-returns-abrupt.js    | 30 +++++--
 .../yield-star-next-call-value-get-abrupt.js  | 30 +++++--
 .../yield-star-next-get-abrupt.js             | 30 +++++--
 ...yield-star-next-non-object-ignores-then.js | 30 +++++--
 ...ld-star-next-not-callable-boolean-throw.js | 30 +++++--
 ...yield-star-next-not-callable-null-throw.js | 30 +++++--
 ...eld-star-next-not-callable-number-throw.js | 30 +++++--
 ...eld-star-next-not-callable-object-throw.js | 30 +++++--
 ...eld-star-next-not-callable-string-throw.js | 30 +++++--
 ...eld-star-next-not-callable-symbol-throw.js | 30 +++++--
 ...-star-next-not-callable-undefined-throw.js | 30 +++++--
 .../yield-star-next-then-get-abrupt.js        | 30 +++++--
 ...hen-non-callable-boolean-fulfillpromise.js | 30 +++++--
 ...t-then-non-callable-null-fulfillpromise.js | 30 +++++--
 ...then-non-callable-number-fulfillpromise.js | 30 +++++--
 ...then-non-callable-object-fulfillpromise.js | 30 +++++--
 ...then-non-callable-string-fulfillpromise.js | 30 +++++--
 ...then-non-callable-symbol-fulfillpromise.js | 30 +++++--
 ...n-non-callable-undefined-fulfillpromise.js | 30 +++++--
 .../yield-star-next-then-returns-abrupt.js    | 30 +++++--
 .../yield-star-sync-next.js                   | 30 +++++--
 .../yield-star-sync-return.js                 | 30 +++++--
 .../yield-star-sync-throw.js                  | 30 +++++--
 .../computed-name-toprimitive-symbol.js       | 30 +++++--
 .../elements/computed-name-toprimitive.js     | 30 +++++--
 .../class/elements/field-declaration.js       | 20 ++++-
 ...-definition-accessor-no-line-terminator.js | 30 +++++--
 .../yield-identifier-spread-strict.js         | 20 ++++-
 .../yield-identifier-strict.js                | 20 ++++-
 .../yield-spread-arr-multiple.js              | 20 ++++-
 .../yield-spread-arr-single.js                | 20 ++++-
 .../yield-spread-obj.js                       | 20 ++++-
 .../yield-identifier-spread-strict.js         | 30 +++++--
 .../yield-identifier-strict.js                | 30 +++++--
 .../yield-spread-arr-multiple.js              | 30 +++++--
 .../yield-spread-arr-single.js                | 30 +++++--
 .../gen-private-method/yield-spread-obj.js    | 30 +++++--
 .../multiple-definitions-computed-names.js    | 75 +++++++++++++----
 ...tiple-definitions-computed-symbol-names.js | 80 +++++++++++++++----
 ...tename-identifier-semantics-stringvalue.js | 30 +++++--
 .../multiple-definitions-literal-names-asi.js | 50 +++++++++---
 .../multiple-definitions-literal-names.js     | 60 +++++++++++---
 ...ultiple-definitions-private-field-usage.js | 30 +++++--
 ...definitions-private-method-getter-usage.js | 30 +++++--
 ...ltiple-definitions-private-method-usage.js | 30 +++++--
 .../multiple-definitions-private-names.js     | 46 +++++++----
 ...nitions-rs-field-identifier-initializer.js | 30 +++++--
 ...ultiple-definitions-rs-field-identifier.js | 30 +++++--
 ...tiple-definitions-rs-private-getter-alt.js | 30 +++++--
 .../multiple-definitions-rs-private-getter.js | 30 +++++--
 ...tiple-definitions-rs-private-method-alt.js | 30 +++++--
 .../multiple-definitions-rs-private-method.js | 30 +++++--
 ...tiple-definitions-rs-private-setter-alt.js | 30 +++++--
 .../multiple-definitions-rs-private-setter.js | 30 +++++--
 ...finitions-rs-privatename-identifier-alt.js | 30 +++++--
 ...-privatename-identifier-initializer-alt.js | 30 +++++--
 ...s-rs-privatename-identifier-initializer.js | 30 +++++--
 ...e-definitions-rs-privatename-identifier.js | 30 +++++--
 ...rator-method-privatename-identifier-alt.js | 30 +++++--
 ...generator-method-privatename-identifier.js | 30 +++++--
 ...async-method-privatename-identifier-alt.js | 30 +++++--
 ...tic-async-method-privatename-identifier.js | 30 +++++--
 ...rator-method-privatename-identifier-alt.js | 30 +++++--
 ...generator-method-privatename-identifier.js | 30 +++++--
 ...tatic-method-privatename-identifier-alt.js | 30 +++++--
 ...rs-static-method-privatename-identifier.js | 30 +++++--
 ...privatename-identifier-alt-by-classname.js | 30 +++++--
 ...ns-rs-static-privatename-identifier-alt.js | 30 +++++--
 ...tic-privatename-identifier-by-classname.js | 30 +++++--
 ...identifier-initializer-alt-by-classname.js | 30 +++++--
 ...-privatename-identifier-initializer-alt.js | 30 +++++--
 ...atic-privatename-identifier-initializer.js | 30 +++++--
 ...itions-rs-static-privatename-identifier.js | 30 +++++--
 ...tiple-definitions-static-private-fields.js | 46 +++++++----
 ...ions-static-private-methods-with-fields.js | 62 +++++++++-----
 ...iple-definitions-static-private-methods.js | 46 +++++++----
 ...ltiple-definitions-string-literal-names.js | 70 ++++++++++++----
 ...iple-stacked-definitions-computed-names.js | 65 ++++++++++++---
 ...acked-definitions-computed-symbol-names.js | 70 ++++++++++++----
 ...tename-identifier-semantics-stringvalue.js | 20 ++++-
 ...e-stacked-definitions-literal-names-asi.js | 40 ++++++++--
 ...tiple-stacked-definitions-literal-names.js | 50 +++++++++---
 ...stacked-definitions-private-field-usage.js | 20 ++++-
 ...definitions-private-method-getter-usage.js | 20 ++++-
 ...tacked-definitions-private-method-usage.js | 20 ++++-
 ...tiple-stacked-definitions-private-names.js | 36 ++++++---
 ...nitions-rs-field-identifier-initializer.js | 20 ++++-
 ...stacked-definitions-rs-field-identifier.js | 20 ++++-
 ...acked-definitions-rs-private-getter-alt.js | 20 ++++-
 ...e-stacked-definitions-rs-private-getter.js | 20 ++++-
 ...acked-definitions-rs-private-method-alt.js | 20 ++++-
 ...e-stacked-definitions-rs-private-method.js | 20 ++++-
 ...acked-definitions-rs-private-setter-alt.js | 20 ++++-
 ...e-stacked-definitions-rs-private-setter.js | 20 ++++-
 ...finitions-rs-privatename-identifier-alt.js | 20 ++++-
 ...-privatename-identifier-initializer-alt.js | 20 ++++-
 ...s-rs-privatename-identifier-initializer.js | 20 ++++-
 ...d-definitions-rs-privatename-identifier.js | 20 ++++-
 ...rator-method-privatename-identifier-alt.js | 20 ++++-
 ...generator-method-privatename-identifier.js | 20 ++++-
 ...async-method-privatename-identifier-alt.js | 20 ++++-
 ...tic-async-method-privatename-identifier.js | 20 ++++-
 ...rator-method-privatename-identifier-alt.js | 20 ++++-
 ...generator-method-privatename-identifier.js | 20 ++++-
 ...tatic-method-privatename-identifier-alt.js | 20 ++++-
 ...rs-static-method-privatename-identifier.js | 20 ++++-
 ...privatename-identifier-alt-by-classname.js | 20 ++++-
 ...ns-rs-static-privatename-identifier-alt.js | 20 ++++-
 ...tic-privatename-identifier-by-classname.js | 20 ++++-
 ...identifier-initializer-alt-by-classname.js | 20 ++++-
 ...-privatename-identifier-initializer-alt.js | 20 ++++-
 ...atic-privatename-identifier-initializer.js | 20 ++++-
 ...itions-rs-static-privatename-identifier.js | 20 ++++-
 ...acked-definitions-static-private-fields.js | 36 ++++++---
 ...ions-static-private-methods-with-fields.js | 52 +++++++-----
 ...cked-definitions-static-private-methods.js | 36 ++++++---
 ...tacked-definitions-string-literal-names.js | 60 +++++++++++---
 .../new-no-sc-line-method-computed-names.js   | 50 +++++++++---
 ...no-sc-line-method-computed-symbol-names.js | 55 ++++++++++---
 ...tename-identifier-semantics-stringvalue.js |  5 +-
 ...new-no-sc-line-method-literal-names-asi.js | 25 ++++--
 .../new-no-sc-line-method-literal-names.js    | 35 ++++++--
 ...w-no-sc-line-method-private-field-usage.js |  5 +-
 ...line-method-private-method-getter-usage.js |  5 +-
 ...-no-sc-line-method-private-method-usage.js |  5 +-
 .../new-no-sc-line-method-private-names.js    | 21 ++---
 ...-method-rs-field-identifier-initializer.js |  5 +-
 ...w-no-sc-line-method-rs-field-identifier.js |  5 +-
 ...no-sc-line-method-rs-private-getter-alt.js |  5 +-
 ...new-no-sc-line-method-rs-private-getter.js |  5 +-
 ...no-sc-line-method-rs-private-method-alt.js |  5 +-
 ...new-no-sc-line-method-rs-private-method.js |  5 +-
 ...no-sc-line-method-rs-private-setter-alt.js |  5 +-
 ...new-no-sc-line-method-rs-private-setter.js |  5 +-
 ...ne-method-rs-privatename-identifier-alt.js |  5 +-
 ...-privatename-identifier-initializer-alt.js |  5 +-
 ...d-rs-privatename-identifier-initializer.js |  5 +-
 ...c-line-method-rs-privatename-identifier.js |  5 +-
 ...rator-method-privatename-identifier-alt.js |  5 +-
 ...generator-method-privatename-identifier.js |  5 +-
 ...async-method-privatename-identifier-alt.js |  5 +-
 ...tic-async-method-privatename-identifier.js |  5 +-
 ...rator-method-privatename-identifier-alt.js |  5 +-
 ...generator-method-privatename-identifier.js |  5 +-
 ...tatic-method-privatename-identifier-alt.js |  5 +-
 ...rs-static-method-privatename-identifier.js |  5 +-
 ...privatename-identifier-alt-by-classname.js |  5 +-
 ...od-rs-static-privatename-identifier-alt.js |  5 +-
 ...tic-privatename-identifier-by-classname.js |  5 +-
 ...identifier-initializer-alt-by-classname.js |  5 +-
 ...-privatename-identifier-initializer-alt.js |  5 +-
 ...atic-privatename-identifier-initializer.js |  5 +-
 ...method-rs-static-privatename-identifier.js |  5 +-
 ...no-sc-line-method-static-private-fields.js | 21 ++---
 ...thod-static-private-methods-with-fields.js | 37 +++++----
 ...o-sc-line-method-static-private-methods.js | 21 ++---
 ...-no-sc-line-method-string-literal-names.js | 45 ++++++++---
 .../new-sc-line-gen-computed-names.js         | 50 +++++++++---
 .../new-sc-line-gen-computed-symbol-names.js  | 55 ++++++++++---
 ...tename-identifier-semantics-stringvalue.js |  5 +-
 .../new-sc-line-gen-literal-names-asi.js      | 25 ++++--
 .../elements/new-sc-line-gen-literal-names.js | 35 ++++++--
 .../new-sc-line-gen-private-field-usage.js    |  5 +-
 ...sc-line-gen-private-method-getter-usage.js |  5 +-
 .../new-sc-line-gen-private-method-usage.js   |  5 +-
 .../elements/new-sc-line-gen-private-names.js | 21 ++---
 ...ine-gen-rs-field-identifier-initializer.js |  5 +-
 .../new-sc-line-gen-rs-field-identifier.js    |  5 +-
 .../new-sc-line-gen-rs-private-getter-alt.js  |  5 +-
 .../new-sc-line-gen-rs-private-getter.js      |  5 +-
 .../new-sc-line-gen-rs-private-method-alt.js  |  5 +-
 .../new-sc-line-gen-rs-private-method.js      |  5 +-
 .../new-sc-line-gen-rs-private-setter-alt.js  |  5 +-
 .../new-sc-line-gen-rs-private-setter.js      |  5 +-
 ...-line-gen-rs-privatename-identifier-alt.js |  5 +-
 ...-privatename-identifier-initializer-alt.js |  5 +-
 ...n-rs-privatename-identifier-initializer.js |  5 +-
 ...w-sc-line-gen-rs-privatename-identifier.js |  5 +-
 ...rator-method-privatename-identifier-alt.js |  5 +-
 ...generator-method-privatename-identifier.js |  5 +-
 ...async-method-privatename-identifier-alt.js |  5 +-
 ...tic-async-method-privatename-identifier.js |  5 +-
 ...rator-method-privatename-identifier-alt.js |  5 +-
 ...generator-method-privatename-identifier.js |  5 +-
 ...tatic-method-privatename-identifier-alt.js |  5 +-
 ...rs-static-method-privatename-identifier.js |  5 +-
 ...privatename-identifier-alt-by-classname.js |  5 +-
 ...en-rs-static-privatename-identifier-alt.js |  5 +-
 ...tic-privatename-identifier-by-classname.js |  5 +-
 ...identifier-initializer-alt-by-classname.js |  5 +-
 ...-privatename-identifier-initializer-alt.js |  5 +-
 ...atic-privatename-identifier-initializer.js |  5 +-
 ...ne-gen-rs-static-privatename-identifier.js |  5 +-
 .../new-sc-line-gen-static-private-fields.js  | 21 ++---
 ...-gen-static-private-methods-with-fields.js | 37 +++++----
 .../new-sc-line-gen-static-private-methods.js | 21 ++---
 .../new-sc-line-gen-string-literal-names.js   | 45 ++++++++---
 .../new-sc-line-method-computed-names.js      | 50 +++++++++---
 ...ew-sc-line-method-computed-symbol-names.js | 55 ++++++++++---
 ...tename-identifier-semantics-stringvalue.js |  5 +-
 .../new-sc-line-method-literal-names-asi.js   | 25 ++++--
 .../new-sc-line-method-literal-names.js       | 35 ++++++--
 .../new-sc-line-method-private-field-usage.js |  5 +-
 ...line-method-private-method-getter-usage.js |  5 +-
 ...new-sc-line-method-private-method-usage.js |  5 +-
 .../new-sc-line-method-private-names.js       | 21 ++---
 ...-method-rs-field-identifier-initializer.js |  5 +-
 .../new-sc-line-method-rs-field-identifier.js |  5 +-
 ...ew-sc-line-method-rs-private-getter-alt.js |  5 +-
 .../new-sc-line-method-rs-private-getter.js   |  5 +-
 ...ew-sc-line-method-rs-private-method-alt.js |  5 +-
 .../new-sc-line-method-rs-private-method.js   |  5 +-
 ...ew-sc-line-method-rs-private-setter-alt.js |  5 +-
 .../new-sc-line-method-rs-private-setter.js   |  5 +-
 ...ne-method-rs-privatename-identifier-alt.js |  5 +-
 ...-privatename-identifier-initializer-alt.js |  5 +-
 ...d-rs-privatename-identifier-initializer.js |  5 +-
 ...c-line-method-rs-privatename-identifier.js |  5 +-
 ...rator-method-privatename-identifier-alt.js |  5 +-
 ...generator-method-privatename-identifier.js |  5 +-
 ...async-method-privatename-identifier-alt.js |  5 +-
 ...tic-async-method-privatename-identifier.js |  5 +-
 ...rator-method-privatename-identifier-alt.js |  5 +-
 ...generator-method-privatename-identifier.js |  5 +-
 ...tatic-method-privatename-identifier-alt.js |  5 +-
 ...rs-static-method-privatename-identifier.js |  5 +-
 ...privatename-identifier-alt-by-classname.js |  5 +-
 ...od-rs-static-privatename-identifier-alt.js |  5 +-
 ...tic-privatename-identifier-by-classname.js |  5 +-
 ...identifier-initializer-alt-by-classname.js |  5 +-
 ...-privatename-identifier-initializer-alt.js |  5 +-
 ...atic-privatename-identifier-initializer.js |  5 +-
 ...method-rs-static-privatename-identifier.js |  5 +-
 ...ew-sc-line-method-static-private-fields.js | 21 ++---
 ...thod-static-private-methods-with-fields.js | 37 +++++----
 ...w-sc-line-method-static-private-methods.js | 21 ++---
 ...new-sc-line-method-string-literal-names.js | 45 ++++++++---
 .../class/elements/redeclaration-symbol.js    | 10 ++-
 .../class/elements/redeclaration.js           | 10 ++-
 .../regular-definitions-computed-names.js     | 45 ++++++++---
 ...gular-definitions-computed-symbol-names.js | 50 +++++++++---
 .../regular-definitions-literal-names-asi.js  | 20 ++++-
 .../regular-definitions-literal-names.js      | 30 +++++--
 .../regular-definitions-private-names.js      | 16 ++--
 ...gular-definitions-static-private-fields.js | 16 ++--
 ...ions-static-private-methods-with-fields.js | 32 ++++----
 ...ular-definitions-static-private-methods.js | 16 ++--
 ...egular-definitions-string-literal-names.js | 40 ++++++++--
 .../same-line-async-gen-computed-names.js     | 50 +++++++++---
 ...me-line-async-gen-computed-symbol-names.js | 55 ++++++++++---
 ...tename-identifier-semantics-stringvalue.js |  5 +-
 .../same-line-async-gen-literal-names-asi.js  | 25 ++++--
 .../same-line-async-gen-literal-names.js      | 35 ++++++--
 ...same-line-async-gen-private-field-usage.js |  5 +-
 ...e-async-gen-private-method-getter-usage.js |  5 +-
 ...ame-line-async-gen-private-method-usage.js |  5 +-
 .../same-line-async-gen-private-names.js      | 21 ++---
 ...ync-gen-rs-field-identifier-initializer.js |  5 +-
 ...same-line-async-gen-rs-field-identifier.js |  5 +-
 ...me-line-async-gen-rs-private-getter-alt.js |  5 +-
 .../same-line-async-gen-rs-private-getter.js  |  5 +-
 ...me-line-async-gen-rs-private-method-alt.js |  5 +-
 .../same-line-async-gen-rs-private-method.js  |  5 +-
 ...me-line-async-gen-rs-private-setter-alt.js |  5 +-
 .../same-line-async-gen-rs-private-setter.js  |  5 +-
 ...async-gen-rs-privatename-identifier-alt.js |  5 +-
 ...-privatename-identifier-initializer-alt.js |  5 +-
 ...n-rs-privatename-identifier-initializer.js |  5 +-
 ...ine-async-gen-rs-privatename-identifier.js |  5 +-
 ...rator-method-privatename-identifier-alt.js |  5 +-
 ...generator-method-privatename-identifier.js |  5 +-
 ...async-method-privatename-identifier-alt.js |  5 +-
 ...tic-async-method-privatename-identifier.js |  5 +-
 ...rator-method-privatename-identifier-alt.js |  5 +-
 ...generator-method-privatename-identifier.js |  5 +-
 ...tatic-method-privatename-identifier-alt.js |  5 +-
 ...rs-static-method-privatename-identifier.js |  5 +-
 ...privatename-identifier-alt-by-classname.js |  5 +-
 ...en-rs-static-privatename-identifier-alt.js |  5 +-
 ...tic-privatename-identifier-by-classname.js |  5 +-
 ...identifier-initializer-alt-by-classname.js |  5 +-
 ...-privatename-identifier-initializer-alt.js |  5 +-
 ...atic-privatename-identifier-initializer.js |  5 +-
 ...nc-gen-rs-static-privatename-identifier.js |  5 +-
 ...me-line-async-gen-static-private-fields.js | 21 ++---
 ...-gen-static-private-methods-with-fields.js | 37 +++++----
 ...e-line-async-gen-static-private-methods.js | 21 ++---
 ...ame-line-async-gen-string-literal-names.js | 45 ++++++++---
 .../same-line-async-method-computed-names.js  | 50 +++++++++---
 ...line-async-method-computed-symbol-names.js | 55 ++++++++++---
 ...tename-identifier-semantics-stringvalue.js |  5 +-
 ...ame-line-async-method-literal-names-asi.js | 25 ++++--
 .../same-line-async-method-literal-names.js   | 35 ++++++--
 ...e-line-async-method-private-field-usage.js |  5 +-
 ...sync-method-private-method-getter-usage.js |  5 +-
 ...-line-async-method-private-method-usage.js |  5 +-
 .../same-line-async-method-private-names.js   | 21 ++---
 ...-method-rs-field-identifier-initializer.js |  5 +-
 ...e-line-async-method-rs-field-identifier.js |  5 +-
 ...line-async-method-rs-private-getter-alt.js |  5 +-
 ...ame-line-async-method-rs-private-getter.js |  5 +-
 ...line-async-method-rs-private-method-alt.js |  5 +-
 ...ame-line-async-method-rs-private-method.js |  5 +-
 ...line-async-method-rs-private-setter-alt.js |  5 +-
 ...ame-line-async-method-rs-private-setter.js |  5 +-
 ...nc-method-rs-privatename-identifier-alt.js |  5 +-
 ...-privatename-identifier-initializer-alt.js |  5 +-
 ...d-rs-privatename-identifier-initializer.js |  5 +-
 ...-async-method-rs-privatename-identifier.js |  5 +-
 ...rator-method-privatename-identifier-alt.js |  5 +-
 ...generator-method-privatename-identifier.js |  5 +-
 ...async-method-privatename-identifier-alt.js |  5 +-
 ...tic-async-method-privatename-identifier.js |  5 +-
 ...rator-method-privatename-identifier-alt.js |  5 +-
 ...generator-method-privatename-identifier.js |  5 +-
 ...tatic-method-privatename-identifier-alt.js |  5 +-
 ...rs-static-method-privatename-identifier.js |  5 +-
 ...privatename-identifier-alt-by-classname.js |  5 +-
 ...od-rs-static-privatename-identifier-alt.js |  5 +-
 ...tic-privatename-identifier-by-classname.js |  5 +-
 ...identifier-initializer-alt-by-classname.js |  5 +-
 ...-privatename-identifier-initializer-alt.js |  5 +-
 ...atic-privatename-identifier-initializer.js |  5 +-
 ...method-rs-static-privatename-identifier.js |  5 +-
 ...line-async-method-static-private-fields.js | 21 ++---
 ...thod-static-private-methods-with-fields.js | 37 +++++----
 ...ine-async-method-static-private-methods.js | 21 ++---
 ...-line-async-method-string-literal-names.js | 45 ++++++++---
 .../elements/same-line-gen-computed-names.js  | 50 +++++++++---
 .../same-line-gen-computed-symbol-names.js    | 55 ++++++++++---
 ...tename-identifier-semantics-stringvalue.js |  5 +-
 .../same-line-gen-literal-names-asi.js        | 25 ++++--
 .../elements/same-line-gen-literal-names.js   | 35 ++++++--
 .../same-line-gen-private-field-usage.js      |  5 +-
 ...me-line-gen-private-method-getter-usage.js |  5 +-
 .../same-line-gen-private-method-usage.js     |  5 +-
 .../elements/same-line-gen-private-names.js   | 21 ++---
 ...ine-gen-rs-field-identifier-initializer.js |  5 +-
 .../same-line-gen-rs-field-identifier.js      |  5 +-
 .../same-line-gen-rs-private-getter-alt.js    |  5 +-
 .../same-line-gen-rs-private-getter.js        |  5 +-
 .../same-line-gen-rs-private-method-alt.js    |  5 +-
 .../same-line-gen-rs-private-method.js        |  5 +-
 .../same-line-gen-rs-private-setter-alt.js    |  5 +-
 .../same-line-gen-rs-private-setter.js        |  5 +-
 ...-line-gen-rs-privatename-identifier-alt.js |  5 +-
 ...-privatename-identifier-initializer-alt.js |  5 +-
 ...n-rs-privatename-identifier-initializer.js |  5 +-
 ...same-line-gen-rs-privatename-identifier.js |  5 +-
 ...rator-method-privatename-identifier-alt.js |  5 +-
 ...generator-method-privatename-identifier.js |  5 +-
 ...async-method-privatename-identifier-alt.js |  5 +-
 ...tic-async-method-privatename-identifier.js |  5 +-
 ...rator-method-privatename-identifier-alt.js |  5 +-
 ...generator-method-privatename-identifier.js |  5 +-
 ...tatic-method-privatename-identifier-alt.js |  5 +-
 ...rs-static-method-privatename-identifier.js |  5 +-
 ...privatename-identifier-alt-by-classname.js |  5 +-
 ...en-rs-static-privatename-identifier-alt.js |  5 +-
 ...tic-privatename-identifier-by-classname.js |  5 +-
 ...identifier-initializer-alt-by-classname.js |  5 +-
 ...-privatename-identifier-initializer-alt.js |  5 +-
 ...atic-privatename-identifier-initializer.js |  5 +-
 ...ne-gen-rs-static-privatename-identifier.js |  5 +-
 .../same-line-gen-static-private-fields.js    | 21 ++---
 ...-gen-static-private-methods-with-fields.js | 37 +++++----
 .../same-line-gen-static-private-methods.js   | 21 ++---
 .../same-line-gen-string-literal-names.js     | 45 ++++++++---
 .../same-line-method-computed-names.js        | 50 +++++++++---
 .../same-line-method-computed-symbol-names.js | 55 ++++++++++---
 ...tename-identifier-semantics-stringvalue.js |  5 +-
 .../same-line-method-literal-names-asi.js     | 25 ++++--
 .../same-line-method-literal-names.js         | 35 ++++++--
 .../same-line-method-private-field-usage.js   |  5 +-
 ...line-method-private-method-getter-usage.js |  5 +-
 .../same-line-method-private-method-usage.js  |  5 +-
 .../same-line-method-private-names.js         | 21 ++---
 ...-method-rs-field-identifier-initializer.js |  5 +-
 .../same-line-method-rs-field-identifier.js   |  5 +-
 .../same-line-method-rs-private-getter-alt.js |  5 +-
 .../same-line-method-rs-private-getter.js     |  5 +-
 .../same-line-method-rs-private-method-alt.js |  5 +-
 .../same-line-method-rs-private-method.js     |  5 +-
 .../same-line-method-rs-private-setter-alt.js |  5 +-
 .../same-line-method-rs-private-setter.js     |  5 +-
 ...ne-method-rs-privatename-identifier-alt.js |  5 +-
 ...-privatename-identifier-initializer-alt.js |  5 +-
 ...d-rs-privatename-identifier-initializer.js |  5 +-
 ...e-line-method-rs-privatename-identifier.js |  5 +-
 ...rator-method-privatename-identifier-alt.js |  5 +-
 ...generator-method-privatename-identifier.js |  5 +-
 ...async-method-privatename-identifier-alt.js |  5 +-
 ...tic-async-method-privatename-identifier.js |  5 +-
 ...rator-method-privatename-identifier-alt.js |  5 +-
 ...generator-method-privatename-identifier.js |  5 +-
 ...tatic-method-privatename-identifier-alt.js |  5 +-
 ...rs-static-method-privatename-identifier.js |  5 +-
 ...privatename-identifier-alt-by-classname.js |  5 +-
 ...od-rs-static-privatename-identifier-alt.js |  5 +-
 ...tic-privatename-identifier-by-classname.js |  5 +-
 ...identifier-initializer-alt-by-classname.js |  5 +-
 ...-privatename-identifier-initializer-alt.js |  5 +-
 ...atic-privatename-identifier-initializer.js |  5 +-
 ...method-rs-static-privatename-identifier.js |  5 +-
 .../same-line-method-static-private-fields.js | 21 ++---
 ...thod-static-private-methods-with-fields.js | 37 +++++----
 ...same-line-method-static-private-methods.js | 21 ++---
 .../same-line-method-string-literal-names.js  | 45 ++++++++---
 .../elements/static-field-declaration.js      | 20 ++++-
 .../elements/wrapped-in-sc-computed-names.js  | 45 ++++++++---
 .../wrapped-in-sc-computed-symbol-names.js    | 50 +++++++++---
 .../wrapped-in-sc-literal-names-asi.js        | 20 ++++-
 .../elements/wrapped-in-sc-literal-names.js   | 30 +++++--
 .../elements/wrapped-in-sc-private-names.js   | 16 ++--
 .../wrapped-in-sc-static-private-fields.js    | 16 ++--
 ...n-sc-static-private-methods-with-fields.js | 32 ++++----
 .../wrapped-in-sc-static-private-methods.js   | 16 ++--
 .../wrapped-in-sc-string-literal-names.js     | 40 ++++++++--
 ...amed-yield-identifier-spread-non-strict.js |  2 +-
 .../yield-identifier-spread-non-strict.js     |  2 +-
 .../new/spread-obj-symbol-property.js         |  2 +-
 ...-gen-yield-identifier-spread-non-strict.js |  2 +-
 .../gen-yield-identifier-spread-non-strict.js |  2 +-
 .../super/call-spread-obj-symbol-property.js  |  2 +-
 .../yield-identifier-spread-non-strict.js     |  2 +-
 ...or-call-expr-identifier-reference-yield.js | 19 +++--
 ...ecorator-call-expr-identifier-reference.js | 49 +++++++++---
 ...rator-member-expr-decorator-member-expr.js | 54 ++++++++++---
 ...-member-expr-identifier-reference-yield.js | 19 +++--
 ...orator-member-expr-identifier-reference.js | 49 +++++++++---
 ...hesized-expr-identifier-reference-yield.js | 19 +++--
 ...parenthesized-expr-identifier-reference.js | 49 +++++++++---
 .../after-same-line-gen-computed-names.js     | 50 +++++++++---
 ...ter-same-line-gen-computed-symbol-names.js | 55 ++++++++++---
 ...tename-identifier-semantics-stringvalue.js |  5 +-
 .../after-same-line-gen-literal-names-asi.js  | 25 ++++--
 .../after-same-line-gen-literal-names.js      | 35 ++++++--
 ...after-same-line-gen-private-field-usage.js |  5 +-
 ...me-line-gen-private-method-getter-usage.js |  5 +-
 ...fter-same-line-gen-private-method-usage.js |  5 +-
 .../after-same-line-gen-private-names.js      | 21 ++---
 ...ine-gen-rs-field-identifier-initializer.js |  5 +-
 ...after-same-line-gen-rs-field-identifier.js |  5 +-
 ...ter-same-line-gen-rs-private-getter-alt.js |  5 +-
 .../after-same-line-gen-rs-private-getter.js  |  5 +-
 ...ter-same-line-gen-rs-private-method-alt.js |  5 +-
 .../after-same-line-gen-rs-private-method.js  |  5 +-
 ...ter-same-line-gen-rs-private-setter-alt.js |  5 +-
 .../after-same-line-gen-rs-private-setter.js  |  5 +-
 ...-line-gen-rs-privatename-identifier-alt.js |  5 +-
 ...-privatename-identifier-initializer-alt.js |  5 +-
 ...n-rs-privatename-identifier-initializer.js |  5 +-
 ...same-line-gen-rs-privatename-identifier.js |  5 +-
 ...rator-method-privatename-identifier-alt.js |  5 +-
 ...generator-method-privatename-identifier.js |  5 +-
 ...async-method-privatename-identifier-alt.js |  5 +-
 ...tic-async-method-privatename-identifier.js |  5 +-
 ...rator-method-privatename-identifier-alt.js |  5 +-
 ...generator-method-privatename-identifier.js |  5 +-
 ...tatic-method-privatename-identifier-alt.js |  5 +-
 ...rs-static-method-privatename-identifier.js |  5 +-
 ...privatename-identifier-alt-by-classname.js |  5 +-
 ...en-rs-static-privatename-identifier-alt.js |  5 +-
 ...tic-privatename-identifier-by-classname.js |  5 +-
 ...identifier-initializer-alt-by-classname.js |  5 +-
 ...-privatename-identifier-initializer-alt.js |  5 +-
 ...atic-privatename-identifier-initializer.js |  5 +-
 ...ne-gen-rs-static-privatename-identifier.js |  5 +-
 ...ter-same-line-gen-static-private-fields.js | 21 ++---
 ...-gen-static-private-methods-with-fields.js | 37 +++++----
 ...er-same-line-gen-static-private-methods.js | 21 ++---
 ...fter-same-line-gen-string-literal-names.js | 45 ++++++++---
 .../after-same-line-method-computed-names.js  | 50 +++++++++---
 ...-same-line-method-computed-symbol-names.js | 55 ++++++++++---
 ...tename-identifier-semantics-stringvalue.js |  5 +-
 ...fter-same-line-method-literal-names-asi.js | 25 ++++--
 .../after-same-line-method-literal-names.js   | 35 ++++++--
 ...er-same-line-method-private-field-usage.js |  5 +-
 ...line-method-private-method-getter-usage.js |  5 +-
 ...r-same-line-method-private-method-usage.js |  5 +-
 .../after-same-line-method-private-names.js   | 21 ++---
 ...-method-rs-field-identifier-initializer.js |  5 +-
 ...er-same-line-method-rs-field-identifier.js |  5 +-
 ...-same-line-method-rs-private-getter-alt.js |  5 +-
 ...fter-same-line-method-rs-private-getter.js |  5 +-
 ...-same-line-method-rs-private-method-alt.js |  5 +-
 ...fter-same-line-method-rs-private-method.js |  5 +-
 ...-same-line-method-rs-private-setter-alt.js |  5 +-
 ...fter-same-line-method-rs-private-setter.js |  5 +-
 ...ne-method-rs-privatename-identifier-alt.js |  5 +-
 ...-privatename-identifier-initializer-alt.js |  5 +-
 ...d-rs-privatename-identifier-initializer.js |  5 +-
 ...e-line-method-rs-privatename-identifier.js |  5 +-
 ...rator-method-privatename-identifier-alt.js |  5 +-
 ...generator-method-privatename-identifier.js |  5 +-
 ...async-method-privatename-identifier-alt.js |  5 +-
 ...tic-async-method-privatename-identifier.js |  5 +-
 ...rator-method-privatename-identifier-alt.js |  5 +-
 ...generator-method-privatename-identifier.js |  5 +-
 ...tatic-method-privatename-identifier-alt.js |  5 +-
 ...rs-static-method-privatename-identifier.js |  5 +-
 ...privatename-identifier-alt-by-classname.js |  5 +-
 ...od-rs-static-privatename-identifier-alt.js |  5 +-
 ...tic-privatename-identifier-by-classname.js |  5 +-
 ...identifier-initializer-alt-by-classname.js |  5 +-
 ...-privatename-identifier-initializer-alt.js |  5 +-
 ...atic-privatename-identifier-initializer.js |  5 +-
 ...method-rs-static-privatename-identifier.js |  5 +-
 ...-same-line-method-static-private-fields.js | 21 ++---
 ...thod-static-private-methods-with-fields.js | 37 +++++----
 ...same-line-method-static-private-methods.js | 21 ++---
 ...r-same-line-method-string-literal-names.js | 45 ++++++++---
 ...me-line-static-async-gen-computed-names.js | 55 ++++++++++---
 ...-static-async-gen-computed-symbol-names.js | 60 +++++++++++---
 ...tename-identifier-semantics-stringvalue.js | 10 ++-
 ...line-static-async-gen-literal-names-asi.js | 30 +++++--
 ...ame-line-static-async-gen-literal-names.js | 40 ++++++++--
 ...ne-static-async-gen-private-field-usage.js | 10 ++-
 ...c-async-gen-private-method-getter-usage.js | 10 ++-
 ...e-static-async-gen-private-method-usage.js | 10 ++-
 ...ame-line-static-async-gen-private-names.js | 26 +++---
 ...ync-gen-rs-field-identifier-initializer.js | 10 ++-
 ...ne-static-async-gen-rs-field-identifier.js | 10 ++-
 ...-static-async-gen-rs-private-getter-alt.js | 10 ++-
 ...line-static-async-gen-rs-private-getter.js | 10 ++-
 ...-static-async-gen-rs-private-method-alt.js | 10 ++-
 ...line-static-async-gen-rs-private-method.js | 10 ++-
 ...-static-async-gen-rs-private-setter-alt.js | 10 ++-
 ...line-static-async-gen-rs-private-setter.js | 10 ++-
 ...async-gen-rs-privatename-identifier-alt.js | 10 ++-
 ...-privatename-identifier-initializer-alt.js | 10 ++-
 ...n-rs-privatename-identifier-initializer.js | 10 ++-
 ...tic-async-gen-rs-privatename-identifier.js | 10 ++-
 ...rator-method-privatename-identifier-alt.js | 10 ++-
 ...generator-method-privatename-identifier.js | 10 ++-
 ...async-method-privatename-identifier-alt.js | 10 ++-
 ...tic-async-method-privatename-identifier.js | 10 ++-
 ...rator-method-privatename-identifier-alt.js | 10 ++-
 ...generator-method-privatename-identifier.js | 10 ++-
 ...tatic-method-privatename-identifier-alt.js | 10 ++-
 ...rs-static-method-privatename-identifier.js | 10 ++-
 ...privatename-identifier-alt-by-classname.js | 10 ++-
 ...en-rs-static-privatename-identifier-alt.js | 10 ++-
 ...tic-privatename-identifier-by-classname.js | 10 ++-
 ...identifier-initializer-alt-by-classname.js | 10 ++-
 ...-privatename-identifier-initializer-alt.js | 10 ++-
 ...atic-privatename-identifier-initializer.js | 10 ++-
 ...nc-gen-rs-static-privatename-identifier.js | 10 ++-
 ...-static-async-gen-static-private-fields.js | 26 +++---
 ...-gen-static-private-methods-with-fields.js | 42 +++++-----
 ...static-async-gen-static-private-methods.js | 26 +++---
 ...e-static-async-gen-string-literal-names.js | 50 +++++++++---
 ...line-static-async-method-computed-names.js | 55 ++++++++++---
 ...atic-async-method-computed-symbol-names.js | 60 +++++++++++---
 ...tename-identifier-semantics-stringvalue.js | 10 ++-
 ...e-static-async-method-literal-names-asi.js | 30 +++++--
 ...-line-static-async-method-literal-names.js | 40 ++++++++--
 ...static-async-method-private-field-usage.js | 10 ++-
 ...sync-method-private-method-getter-usage.js | 10 ++-
 ...tatic-async-method-private-method-usage.js | 10 ++-
 ...-line-static-async-method-private-names.js | 26 +++---
 ...-method-rs-field-identifier-initializer.js | 10 ++-
 ...static-async-method-rs-field-identifier.js | 10 ++-
 ...atic-async-method-rs-private-getter-alt.js | 10 ++-
 ...e-static-async-method-rs-private-getter.js | 10 ++-
 ...atic-async-method-rs-private-method-alt.js | 10 ++-
 ...e-static-async-method-rs-private-method.js | 10 ++-
 ...atic-async-method-rs-private-setter-alt.js | 10 ++-
 ...e-static-async-method-rs-private-setter.js | 10 ++-
 ...nc-method-rs-privatename-identifier-alt.js | 10 ++-
 ...-privatename-identifier-initializer-alt.js | 10 ++-
 ...d-rs-privatename-identifier-initializer.js | 10 ++-
 ...-async-method-rs-privatename-identifier.js | 10 ++-
 ...rator-method-privatename-identifier-alt.js | 10 ++-
 ...generator-method-privatename-identifier.js | 10 ++-
 ...async-method-privatename-identifier-alt.js | 10 ++-
 ...tic-async-method-privatename-identifier.js | 10 ++-
 ...rator-method-privatename-identifier-alt.js | 10 ++-
 ...generator-method-privatename-identifier.js | 10 ++-
 ...tatic-method-privatename-identifier-alt.js | 10 ++-
 ...rs-static-method-privatename-identifier.js | 10 ++-
 ...privatename-identifier-alt-by-classname.js | 10 ++-
 ...od-rs-static-privatename-identifier-alt.js | 10 ++-
 ...tic-privatename-identifier-by-classname.js | 10 ++-
 ...identifier-initializer-alt-by-classname.js | 10 ++-
 ...-privatename-identifier-initializer-alt.js | 10 ++-
 ...atic-privatename-identifier-initializer.js | 10 ++-
 ...method-rs-static-privatename-identifier.js | 10 ++-
 ...atic-async-method-static-private-fields.js | 26 +++---
 ...thod-static-private-methods-with-fields.js | 42 +++++-----
 ...tic-async-method-static-private-methods.js | 26 +++---
 ...tatic-async-method-string-literal-names.js | 50 +++++++++---
 ...ter-same-line-static-gen-computed-names.js | 55 ++++++++++---
 ...e-line-static-gen-computed-symbol-names.js | 60 +++++++++++---
 ...tename-identifier-semantics-stringvalue.js | 10 ++-
 ...-same-line-static-gen-literal-names-asi.js | 30 +++++--
 ...fter-same-line-static-gen-literal-names.js | 40 ++++++++--
 ...ame-line-static-gen-private-field-usage.js | 10 ++-
 ...-static-gen-private-method-getter-usage.js | 10 ++-
 ...me-line-static-gen-private-method-usage.js | 10 ++-
 ...fter-same-line-static-gen-private-names.js | 26 +++---
 ...tic-gen-rs-field-identifier-initializer.js | 10 ++-
 ...ame-line-static-gen-rs-field-identifier.js | 10 ++-
 ...e-line-static-gen-rs-private-getter-alt.js | 10 ++-
 ...-same-line-static-gen-rs-private-getter.js | 10 ++-
 ...e-line-static-gen-rs-private-method-alt.js | 10 ++-
 ...-same-line-static-gen-rs-private-method.js | 10 ++-
 ...e-line-static-gen-rs-private-setter-alt.js | 10 ++-
 ...-same-line-static-gen-rs-private-setter.js | 10 ++-
 ...tatic-gen-rs-privatename-identifier-alt.js | 10 ++-
 ...-privatename-identifier-initializer-alt.js | 10 ++-
 ...n-rs-privatename-identifier-initializer.js | 10 ++-
 ...ne-static-gen-rs-privatename-identifier.js | 10 ++-
 ...rator-method-privatename-identifier-alt.js | 10 ++-
 ...generator-method-privatename-identifier.js | 10 ++-
 ...async-method-privatename-identifier-alt.js | 10 ++-
 ...tic-async-method-privatename-identifier.js | 10 ++-
 ...rator-method-privatename-identifier-alt.js | 10 ++-
 ...generator-method-privatename-identifier.js | 10 ++-
 ...tatic-method-privatename-identifier-alt.js | 10 ++-
 ...rs-static-method-privatename-identifier.js | 10 ++-
 ...privatename-identifier-alt-by-classname.js | 10 ++-
 ...en-rs-static-privatename-identifier-alt.js | 10 ++-
 ...tic-privatename-identifier-by-classname.js | 10 ++-
 ...identifier-initializer-alt-by-classname.js | 10 ++-
 ...-privatename-identifier-initializer-alt.js | 10 ++-
 ...atic-privatename-identifier-initializer.js | 10 ++-
 ...ic-gen-rs-static-privatename-identifier.js | 10 ++-
 ...e-line-static-gen-static-private-fields.js | 26 +++---
 ...-gen-static-private-methods-with-fields.js | 42 +++++-----
 ...-line-static-gen-static-private-methods.js | 26 +++---
 ...me-line-static-gen-string-literal-names.js | 50 +++++++++---
 ...-same-line-static-method-computed-names.js | 55 ++++++++++---
 ...ine-static-method-computed-symbol-names.js | 60 +++++++++++---
 ...tename-identifier-semantics-stringvalue.js | 10 ++-
 ...me-line-static-method-literal-names-asi.js | 30 +++++--
 ...r-same-line-static-method-literal-names.js | 40 ++++++++--
 ...-line-static-method-private-field-usage.js | 10 ++-
 ...atic-method-private-method-getter-usage.js | 10 ++-
 ...line-static-method-private-method-usage.js | 10 ++-
 ...r-same-line-static-method-private-names.js | 26 +++---
 ...-method-rs-field-identifier-initializer.js | 10 ++-
 ...-line-static-method-rs-field-identifier.js | 10 ++-
 ...ine-static-method-rs-private-getter-alt.js | 10 ++-
 ...me-line-static-method-rs-private-getter.js | 10 ++-
 ...ine-static-method-rs-private-method-alt.js | 10 ++-
 ...me-line-static-method-rs-private-method.js | 10 ++-
 ...ine-static-method-rs-private-setter-alt.js | 10 ++-
 ...me-line-static-method-rs-private-setter.js | 10 ++-
 ...ic-method-rs-privatename-identifier-alt.js | 10 ++-
 ...-privatename-identifier-initializer-alt.js | 10 ++-
 ...d-rs-privatename-identifier-initializer.js | 10 ++-
 ...static-method-rs-privatename-identifier.js | 10 ++-
 ...rator-method-privatename-identifier-alt.js | 10 ++-
 ...generator-method-privatename-identifier.js | 10 ++-
 ...async-method-privatename-identifier-alt.js | 10 ++-
 ...tic-async-method-privatename-identifier.js | 10 ++-
 ...rator-method-privatename-identifier-alt.js | 10 ++-
 ...generator-method-privatename-identifier.js | 10 ++-
 ...tatic-method-privatename-identifier-alt.js | 10 ++-
 ...rs-static-method-privatename-identifier.js | 10 ++-
 ...privatename-identifier-alt-by-classname.js | 10 ++-
 ...od-rs-static-privatename-identifier-alt.js | 10 ++-
 ...tic-privatename-identifier-by-classname.js | 10 ++-
 ...identifier-initializer-alt-by-classname.js | 10 ++-
 ...-privatename-identifier-initializer-alt.js | 10 ++-
 ...atic-privatename-identifier-initializer.js | 10 ++-
 ...method-rs-static-privatename-identifier.js | 10 ++-
 ...ine-static-method-static-private-fields.js | 26 +++---
 ...thod-static-private-methods-with-fields.js | 42 +++++-----
 ...ne-static-method-static-private-methods.js | 26 +++---
 ...line-static-method-string-literal-names.js | 50 +++++++++---
 .../yield-identifier-spread-strict.js         | 20 ++++-
 .../yield-identifier-strict.js                | 20 ++++-
 .../yield-promise-reject-next-catch.js        | 20 ++++-
 ...reject-next-for-await-of-async-iterator.js | 20 ++++-
 ...-reject-next-for-await-of-sync-iterator.js | 20 ++++-
 ...e-reject-next-yield-star-async-iterator.js | 20 ++++-
 ...se-reject-next-yield-star-sync-iterator.js | 20 ++++-
 .../yield-promise-reject-next.js              | 20 ++++-
 .../yield-spread-arr-multiple.js              | 20 ++++-
 .../yield-spread-arr-single.js                | 20 ++++-
 .../yield-spread-obj.js                       | 20 ++++-
 .../yield-star-async-next.js                  | 20 ++++-
 .../yield-star-async-return.js                | 20 ++++-
 .../yield-star-async-throw.js                 | 20 ++++-
 .../yield-star-expr-abrupt.js                 | 20 ++++-
 .../yield-star-getiter-async-get-abrupt.js    | 20 ++++-
 ...etiter-async-not-callable-boolean-throw.js | 20 ++++-
 ...getiter-async-not-callable-number-throw.js | 20 ++++-
 ...getiter-async-not-callable-object-throw.js | 20 ++++-
 ...getiter-async-not-callable-string-throw.js | 20 ++++-
 ...getiter-async-not-callable-symbol-throw.js | 20 ++++-
 ...star-getiter-async-null-sync-get-abrupt.js | 20 ++++-
 ...yield-star-getiter-async-returns-abrupt.js | 20 ++++-
 ...tar-getiter-async-returns-boolean-throw.js | 20 ++++-
 ...d-star-getiter-async-returns-null-throw.js | 20 ++++-
 ...star-getiter-async-returns-number-throw.js | 20 ++++-
 ...star-getiter-async-returns-string-throw.js | 20 ++++-
 ...star-getiter-async-returns-symbol-throw.js | 20 ++++-
 ...r-getiter-async-returns-undefined-throw.js | 20 ++++-
 ...getiter-async-undefined-sync-get-abrupt.js | 20 ++++-
 .../yield-star-getiter-sync-get-abrupt.js     | 20 ++++-
 ...getiter-sync-not-callable-boolean-throw.js | 20 ++++-
 ...-getiter-sync-not-callable-number-throw.js | 20 ++++-
 ...-getiter-sync-not-callable-object-throw.js | 20 ++++-
 ...-getiter-sync-not-callable-string-throw.js | 20 ++++-
 ...-getiter-sync-not-callable-symbol-throw.js | 20 ++++-
 .../yield-star-getiter-sync-returns-abrupt.js | 20 ++++-
 ...star-getiter-sync-returns-boolean-throw.js | 20 ++++-
 ...ld-star-getiter-sync-returns-null-throw.js | 20 ++++-
 ...-star-getiter-sync-returns-number-throw.js | 20 ++++-
 ...-star-getiter-sync-returns-string-throw.js | 20 ++++-
 ...-star-getiter-sync-returns-symbol-throw.js | 20 ++++-
 ...ar-getiter-sync-returns-undefined-throw.js | 20 ++++-
 .../yield-star-next-call-done-get-abrupt.js   | 20 ++++-
 .../yield-star-next-call-returns-abrupt.js    | 20 ++++-
 .../yield-star-next-call-value-get-abrupt.js  | 20 ++++-
 .../yield-star-next-get-abrupt.js             | 20 ++++-
 ...yield-star-next-non-object-ignores-then.js | 20 ++++-
 ...ld-star-next-not-callable-boolean-throw.js | 20 ++++-
 ...yield-star-next-not-callable-null-throw.js | 20 ++++-
 ...eld-star-next-not-callable-number-throw.js | 20 ++++-
 ...eld-star-next-not-callable-object-throw.js | 20 ++++-
 ...eld-star-next-not-callable-string-throw.js | 20 ++++-
 ...eld-star-next-not-callable-symbol-throw.js | 20 ++++-
 ...-star-next-not-callable-undefined-throw.js | 20 ++++-
 .../yield-star-next-then-get-abrupt.js        | 20 ++++-
 ...hen-non-callable-boolean-fulfillpromise.js | 20 ++++-
 ...t-then-non-callable-null-fulfillpromise.js | 20 ++++-
 ...then-non-callable-number-fulfillpromise.js | 20 ++++-
 ...then-non-callable-object-fulfillpromise.js | 20 ++++-
 ...then-non-callable-string-fulfillpromise.js | 20 ++++-
 ...then-non-callable-symbol-fulfillpromise.js | 20 ++++-
 ...n-non-callable-undefined-fulfillpromise.js | 20 ++++-
 .../yield-star-next-then-returns-abrupt.js    | 20 ++++-
 .../yield-star-sync-next.js                   | 20 ++++-
 .../yield-star-sync-return.js                 | 20 ++++-
 .../yield-star-sync-throw.js                  | 20 ++++-
 .../yield-identifier-spread-strict.js         | 30 +++++--
 .../yield-identifier-strict.js                | 30 +++++--
 .../yield-promise-reject-next-catch.js        | 30 +++++--
 ...reject-next-for-await-of-async-iterator.js | 30 +++++--
 ...-reject-next-for-await-of-sync-iterator.js | 30 +++++--
 ...e-reject-next-yield-star-async-iterator.js | 30 +++++--
 ...se-reject-next-yield-star-sync-iterator.js | 30 +++++--
 .../yield-promise-reject-next.js              | 30 +++++--
 .../yield-spread-arr-multiple.js              | 30 +++++--
 .../yield-spread-arr-single.js                | 30 +++++--
 .../yield-spread-obj.js                       | 30 +++++--
 .../yield-star-async-next.js                  | 30 +++++--
 .../yield-star-async-return.js                | 30 +++++--
 .../yield-star-async-throw.js                 | 30 +++++--
 .../yield-star-expr-abrupt.js                 | 30 +++++--
 .../yield-star-getiter-async-get-abrupt.js    | 30 +++++--
 ...etiter-async-not-callable-boolean-throw.js | 30 +++++--
 ...getiter-async-not-callable-number-throw.js | 30 +++++--
 ...getiter-async-not-callable-object-throw.js | 30 +++++--
 ...getiter-async-not-callable-string-throw.js | 30 +++++--
 ...getiter-async-not-callable-symbol-throw.js | 30 +++++--
 ...star-getiter-async-null-sync-get-abrupt.js | 30 +++++--
 ...yield-star-getiter-async-returns-abrupt.js | 30 +++++--
 ...tar-getiter-async-returns-boolean-throw.js | 30 +++++--
 ...d-star-getiter-async-returns-null-throw.js | 30 +++++--
 ...star-getiter-async-returns-number-throw.js | 30 +++++--
 ...star-getiter-async-returns-string-throw.js | 30 +++++--
 ...star-getiter-async-returns-symbol-throw.js | 30 +++++--
 ...r-getiter-async-returns-undefined-throw.js | 30 +++++--
 ...getiter-async-undefined-sync-get-abrupt.js | 30 +++++--
 .../yield-star-getiter-sync-get-abrupt.js     | 30 +++++--
 ...getiter-sync-not-callable-boolean-throw.js | 30 +++++--
 ...-getiter-sync-not-callable-number-throw.js | 30 +++++--
 ...-getiter-sync-not-callable-object-throw.js | 30 +++++--
 ...-getiter-sync-not-callable-string-throw.js | 30 +++++--
 ...-getiter-sync-not-callable-symbol-throw.js | 30 +++++--
 .../yield-star-getiter-sync-returns-abrupt.js | 30 +++++--
 ...star-getiter-sync-returns-boolean-throw.js | 30 +++++--
 ...ld-star-getiter-sync-returns-null-throw.js | 30 +++++--
 ...-star-getiter-sync-returns-number-throw.js | 30 +++++--
 ...-star-getiter-sync-returns-string-throw.js | 30 +++++--
 ...-star-getiter-sync-returns-symbol-throw.js | 30 +++++--
 ...ar-getiter-sync-returns-undefined-throw.js | 30 +++++--
 .../yield-star-next-call-done-get-abrupt.js   | 30 +++++--
 .../yield-star-next-call-returns-abrupt.js    | 30 +++++--
 .../yield-star-next-call-value-get-abrupt.js  | 30 +++++--
 .../yield-star-next-get-abrupt.js             | 30 +++++--
 ...yield-star-next-non-object-ignores-then.js | 30 +++++--
 ...ld-star-next-not-callable-boolean-throw.js | 30 +++++--
 ...yield-star-next-not-callable-null-throw.js | 30 +++++--
 ...eld-star-next-not-callable-number-throw.js | 30 +++++--
 ...eld-star-next-not-callable-object-throw.js | 30 +++++--
 ...eld-star-next-not-callable-string-throw.js | 30 +++++--
 ...eld-star-next-not-callable-symbol-throw.js | 30 +++++--
 ...-star-next-not-callable-undefined-throw.js | 30 +++++--
 .../yield-star-next-then-get-abrupt.js        | 30 +++++--
 ...hen-non-callable-boolean-fulfillpromise.js | 30 +++++--
 ...t-then-non-callable-null-fulfillpromise.js | 30 +++++--
 ...then-non-callable-number-fulfillpromise.js | 30 +++++--
 ...then-non-callable-object-fulfillpromise.js | 30 +++++--
 ...then-non-callable-string-fulfillpromise.js | 30 +++++--
 ...then-non-callable-symbol-fulfillpromise.js | 30 +++++--
 ...n-non-callable-undefined-fulfillpromise.js | 30 +++++--
 .../yield-star-next-then-returns-abrupt.js    | 30 +++++--
 .../yield-star-sync-next.js                   | 30 +++++--
 .../yield-star-sync-return.js                 | 30 +++++--
 .../yield-star-sync-throw.js                  | 30 +++++--
 .../computed-name-toprimitive-symbol.js       | 30 +++++--
 .../elements/computed-name-toprimitive.js     | 30 +++++--
 .../class/elements/field-declaration.js       | 20 ++++-
 ...-definition-accessor-no-line-terminator.js | 30 +++++--
 .../yield-identifier-spread-strict.js         | 20 ++++-
 .../yield-identifier-strict.js                | 20 ++++-
 .../yield-spread-arr-multiple.js              | 20 ++++-
 .../yield-spread-arr-single.js                | 20 ++++-
 .../yield-spread-obj.js                       | 20 ++++-
 .../yield-identifier-spread-strict.js         | 30 +++++--
 .../yield-identifier-strict.js                | 30 +++++--
 .../yield-spread-arr-multiple.js              | 30 +++++--
 .../yield-spread-arr-single.js                | 30 +++++--
 .../gen-private-method/yield-spread-obj.js    | 30 +++++--
 .../multiple-definitions-computed-names.js    | 75 +++++++++++++----
 ...tiple-definitions-computed-symbol-names.js | 80 +++++++++++++++----
 ...tename-identifier-semantics-stringvalue.js | 30 +++++--
 .../multiple-definitions-literal-names-asi.js | 50 +++++++++---
 .../multiple-definitions-literal-names.js     | 60 +++++++++++---
 ...ultiple-definitions-private-field-usage.js | 30 +++++--
 ...definitions-private-method-getter-usage.js | 30 +++++--
 ...ltiple-definitions-private-method-usage.js | 30 +++++--
 .../multiple-definitions-private-names.js     | 46 +++++++----
 ...nitions-rs-field-identifier-initializer.js | 30 +++++--
 ...ultiple-definitions-rs-field-identifier.js | 30 +++++--
 ...tiple-definitions-rs-private-getter-alt.js | 30 +++++--
 .../multiple-definitions-rs-private-getter.js | 30 +++++--
 ...tiple-definitions-rs-private-method-alt.js | 30 +++++--
 .../multiple-definitions-rs-private-method.js | 30 +++++--
 ...tiple-definitions-rs-private-setter-alt.js | 30 +++++--
 .../multiple-definitions-rs-private-setter.js | 30 +++++--
 ...finitions-rs-privatename-identifier-alt.js | 30 +++++--
 ...-privatename-identifier-initializer-alt.js | 30 +++++--
 ...s-rs-privatename-identifier-initializer.js | 30 +++++--
 ...e-definitions-rs-privatename-identifier.js | 30 +++++--
 ...rator-method-privatename-identifier-alt.js | 30 +++++--
 ...generator-method-privatename-identifier.js | 30 +++++--
 ...async-method-privatename-identifier-alt.js | 30 +++++--
 ...tic-async-method-privatename-identifier.js | 30 +++++--
 ...rator-method-privatename-identifier-alt.js | 30 +++++--
 ...generator-method-privatename-identifier.js | 30 +++++--
 ...tatic-method-privatename-identifier-alt.js | 30 +++++--
 ...rs-static-method-privatename-identifier.js | 30 +++++--
 ...privatename-identifier-alt-by-classname.js | 30 +++++--
 ...ns-rs-static-privatename-identifier-alt.js | 30 +++++--
 ...tic-privatename-identifier-by-classname.js | 30 +++++--
 ...identifier-initializer-alt-by-classname.js | 30 +++++--
 ...-privatename-identifier-initializer-alt.js | 30 +++++--
 ...atic-privatename-identifier-initializer.js | 30 +++++--
 ...itions-rs-static-privatename-identifier.js | 30 +++++--
 ...tiple-definitions-static-private-fields.js | 46 +++++++----
 ...ions-static-private-methods-with-fields.js | 62 +++++++++-----
 ...iple-definitions-static-private-methods.js | 46 +++++++----
 ...ltiple-definitions-string-literal-names.js | 70 ++++++++++++----
 ...iple-stacked-definitions-computed-names.js | 65 ++++++++++++---
 ...acked-definitions-computed-symbol-names.js | 70 ++++++++++++----
 ...tename-identifier-semantics-stringvalue.js | 20 ++++-
 ...e-stacked-definitions-literal-names-asi.js | 40 ++++++++--
 ...tiple-stacked-definitions-literal-names.js | 50 +++++++++---
 ...stacked-definitions-private-field-usage.js | 20 ++++-
 ...definitions-private-method-getter-usage.js | 20 ++++-
 ...tacked-definitions-private-method-usage.js | 20 ++++-
 ...tiple-stacked-definitions-private-names.js | 36 ++++++---
 ...nitions-rs-field-identifier-initializer.js | 20 ++++-
 ...stacked-definitions-rs-field-identifier.js | 20 ++++-
 ...acked-definitions-rs-private-getter-alt.js | 20 ++++-
 ...e-stacked-definitions-rs-private-getter.js | 20 ++++-
 ...acked-definitions-rs-private-method-alt.js | 20 ++++-
 ...e-stacked-definitions-rs-private-method.js | 20 ++++-
 ...acked-definitions-rs-private-setter-alt.js | 20 ++++-
 ...e-stacked-definitions-rs-private-setter.js | 20 ++++-
 ...finitions-rs-privatename-identifier-alt.js | 20 ++++-
 ...-privatename-identifier-initializer-alt.js | 20 ++++-
 ...s-rs-privatename-identifier-initializer.js | 20 ++++-
 ...d-definitions-rs-privatename-identifier.js | 20 ++++-
 ...rator-method-privatename-identifier-alt.js | 20 ++++-
 ...generator-method-privatename-identifier.js | 20 ++++-
 ...async-method-privatename-identifier-alt.js | 20 ++++-
 ...tic-async-method-privatename-identifier.js | 20 ++++-
 ...rator-method-privatename-identifier-alt.js | 20 ++++-
 ...generator-method-privatename-identifier.js | 20 ++++-
 ...tatic-method-privatename-identifier-alt.js | 20 ++++-
 ...rs-static-method-privatename-identifier.js | 20 ++++-
 ...privatename-identifier-alt-by-classname.js | 20 ++++-
 ...ns-rs-static-privatename-identifier-alt.js | 20 ++++-
 ...tic-privatename-identifier-by-classname.js | 20 ++++-
 ...identifier-initializer-alt-by-classname.js | 20 ++++-
 ...-privatename-identifier-initializer-alt.js | 20 ++++-
 ...atic-privatename-identifier-initializer.js | 20 ++++-
 ...itions-rs-static-privatename-identifier.js | 20 ++++-
 ...acked-definitions-static-private-fields.js | 36 ++++++---
 ...ions-static-private-methods-with-fields.js | 52 +++++++-----
 ...cked-definitions-static-private-methods.js | 36 ++++++---
 ...tacked-definitions-string-literal-names.js | 60 +++++++++++---
 .../new-no-sc-line-method-computed-names.js   | 50 +++++++++---
 ...no-sc-line-method-computed-symbol-names.js | 55 ++++++++++---
 ...tename-identifier-semantics-stringvalue.js |  5 +-
 ...new-no-sc-line-method-literal-names-asi.js | 25 ++++--
 .../new-no-sc-line-method-literal-names.js    | 35 ++++++--
 ...w-no-sc-line-method-private-field-usage.js |  5 +-
 ...line-method-private-method-getter-usage.js |  5 +-
 ...-no-sc-line-method-private-method-usage.js |  5 +-
 .../new-no-sc-line-method-private-names.js    | 21 ++---
 ...-method-rs-field-identifier-initializer.js |  5 +-
 ...w-no-sc-line-method-rs-field-identifier.js |  5 +-
 ...no-sc-line-method-rs-private-getter-alt.js |  5 +-
 ...new-no-sc-line-method-rs-private-getter.js |  5 +-
 ...no-sc-line-method-rs-private-method-alt.js |  5 +-
 ...new-no-sc-line-method-rs-private-method.js |  5 +-
 ...no-sc-line-method-rs-private-setter-alt.js |  5 +-
 ...new-no-sc-line-method-rs-private-setter.js |  5 +-
 ...ne-method-rs-privatename-identifier-alt.js |  5 +-
 ...-privatename-identifier-initializer-alt.js |  5 +-
 ...d-rs-privatename-identifier-initializer.js |  5 +-
 ...c-line-method-rs-privatename-identifier.js |  5 +-
 ...rator-method-privatename-identifier-alt.js |  5 +-
 ...generator-method-privatename-identifier.js |  5 +-
 ...async-method-privatename-identifier-alt.js |  5 +-
 ...tic-async-method-privatename-identifier.js |  5 +-
 ...rator-method-privatename-identifier-alt.js |  5 +-
 ...generator-method-privatename-identifier.js |  5 +-
 ...tatic-method-privatename-identifier-alt.js |  5 +-
 ...rs-static-method-privatename-identifier.js |  5 +-
 ...privatename-identifier-alt-by-classname.js |  5 +-
 ...od-rs-static-privatename-identifier-alt.js |  5 +-
 ...tic-privatename-identifier-by-classname.js |  5 +-
 ...identifier-initializer-alt-by-classname.js |  5 +-
 ...-privatename-identifier-initializer-alt.js |  5 +-
 ...atic-privatename-identifier-initializer.js |  5 +-
 ...method-rs-static-privatename-identifier.js |  5 +-
 ...no-sc-line-method-static-private-fields.js | 21 ++---
 ...thod-static-private-methods-with-fields.js | 37 +++++----
 ...o-sc-line-method-static-private-methods.js | 21 ++---
 ...-no-sc-line-method-string-literal-names.js | 45 ++++++++---
 .../new-sc-line-gen-computed-names.js         | 50 +++++++++---
 .../new-sc-line-gen-computed-symbol-names.js  | 55 ++++++++++---
 ...tename-identifier-semantics-stringvalue.js |  5 +-
 .../new-sc-line-gen-literal-names-asi.js      | 25 ++++--
 .../elements/new-sc-line-gen-literal-names.js | 35 ++++++--
 .../new-sc-line-gen-private-field-usage.js    |  5 +-
 ...sc-line-gen-private-method-getter-usage.js |  5 +-
 .../new-sc-line-gen-private-method-usage.js   |  5 +-
 .../elements/new-sc-line-gen-private-names.js | 21 ++---
 ...ine-gen-rs-field-identifier-initializer.js |  5 +-
 .../new-sc-line-gen-rs-field-identifier.js    |  5 +-
 .../new-sc-line-gen-rs-private-getter-alt.js  |  5 +-
 .../new-sc-line-gen-rs-private-getter.js      |  5 +-
 .../new-sc-line-gen-rs-private-method-alt.js  |  5 +-
 .../new-sc-line-gen-rs-private-method.js      |  5 +-
 .../new-sc-line-gen-rs-private-setter-alt.js  |  5 +-
 .../new-sc-line-gen-rs-private-setter.js      |  5 +-
 ...-line-gen-rs-privatename-identifier-alt.js |  5 +-
 ...-privatename-identifier-initializer-alt.js |  5 +-
 ...n-rs-privatename-identifier-initializer.js |  5 +-
 ...w-sc-line-gen-rs-privatename-identifier.js |  5 +-
 ...rator-method-privatename-identifier-alt.js |  5 +-
 ...generator-method-privatename-identifier.js |  5 +-
 ...async-method-privatename-identifier-alt.js |  5 +-
 ...tic-async-method-privatename-identifier.js |  5 +-
 ...rator-method-privatename-identifier-alt.js |  5 +-
 ...generator-method-privatename-identifier.js |  5 +-
 ...tatic-method-privatename-identifier-alt.js |  5 +-
 ...rs-static-method-privatename-identifier.js |  5 +-
 ...privatename-identifier-alt-by-classname.js |  5 +-
 ...en-rs-static-privatename-identifier-alt.js |  5 +-
 ...tic-privatename-identifier-by-classname.js |  5 +-
 ...identifier-initializer-alt-by-classname.js |  5 +-
 ...-privatename-identifier-initializer-alt.js |  5 +-
 ...atic-privatename-identifier-initializer.js |  5 +-
 ...ne-gen-rs-static-privatename-identifier.js |  5 +-
 .../new-sc-line-gen-static-private-fields.js  | 21 ++---
 ...-gen-static-private-methods-with-fields.js | 37 +++++----
 .../new-sc-line-gen-static-private-methods.js | 21 ++---
 .../new-sc-line-gen-string-literal-names.js   | 45 ++++++++---
 .../new-sc-line-method-computed-names.js      | 50 +++++++++---
 ...ew-sc-line-method-computed-symbol-names.js | 55 ++++++++++---
 ...tename-identifier-semantics-stringvalue.js |  5 +-
 .../new-sc-line-method-literal-names-asi.js   | 25 ++++--
 .../new-sc-line-method-literal-names.js       | 35 ++++++--
 .../new-sc-line-method-private-field-usage.js |  5 +-
 ...line-method-private-method-getter-usage.js |  5 +-
 ...new-sc-line-method-private-method-usage.js |  5 +-
 .../new-sc-line-method-private-names.js       | 21 ++---
 ...-method-rs-field-identifier-initializer.js |  5 +-
 .../new-sc-line-method-rs-field-identifier.js |  5 +-
 ...ew-sc-line-method-rs-private-getter-alt.js |  5 +-
 .../new-sc-line-method-rs-private-getter.js   |  5 +-
 ...ew-sc-line-method-rs-private-method-alt.js |  5 +-
 .../new-sc-line-method-rs-private-method.js   |  5 +-
 ...ew-sc-line-method-rs-private-setter-alt.js |  5 +-
 .../new-sc-line-method-rs-private-setter.js   |  5 +-
 ...ne-method-rs-privatename-identifier-alt.js |  5 +-
 ...-privatename-identifier-initializer-alt.js |  5 +-
 ...d-rs-privatename-identifier-initializer.js |  5 +-
 ...c-line-method-rs-privatename-identifier.js |  5 +-
 ...rator-method-privatename-identifier-alt.js |  5 +-
 ...generator-method-privatename-identifier.js |  5 +-
 ...async-method-privatename-identifier-alt.js |  5 +-
 ...tic-async-method-privatename-identifier.js |  5 +-
 ...rator-method-privatename-identifier-alt.js |  5 +-
 ...generator-method-privatename-identifier.js |  5 +-
 ...tatic-method-privatename-identifier-alt.js |  5 +-
 ...rs-static-method-privatename-identifier.js |  5 +-
 ...privatename-identifier-alt-by-classname.js |  5 +-
 ...od-rs-static-privatename-identifier-alt.js |  5 +-
 ...tic-privatename-identifier-by-classname.js |  5 +-
 ...identifier-initializer-alt-by-classname.js |  5 +-
 ...-privatename-identifier-initializer-alt.js |  5 +-
 ...atic-privatename-identifier-initializer.js |  5 +-
 ...method-rs-static-privatename-identifier.js |  5 +-
 ...ew-sc-line-method-static-private-fields.js | 21 ++---
 ...thod-static-private-methods-with-fields.js | 37 +++++----
 ...w-sc-line-method-static-private-methods.js | 21 ++---
 ...new-sc-line-method-string-literal-names.js | 45 ++++++++---
 .../class/elements/redeclaration-symbol.js    | 10 ++-
 .../class/elements/redeclaration.js           | 10 ++-
 .../regular-definitions-computed-names.js     | 45 ++++++++---
 ...gular-definitions-computed-symbol-names.js | 50 +++++++++---
 .../regular-definitions-literal-names-asi.js  | 20 ++++-
 .../regular-definitions-literal-names.js      | 30 +++++--
 .../regular-definitions-private-names.js      | 16 ++--
 ...gular-definitions-static-private-fields.js | 16 ++--
 ...ions-static-private-methods-with-fields.js | 32 ++++----
 ...ular-definitions-static-private-methods.js | 16 ++--
 ...egular-definitions-string-literal-names.js | 40 ++++++++--
 .../same-line-async-gen-computed-names.js     | 50 +++++++++---
 ...me-line-async-gen-computed-symbol-names.js | 55 ++++++++++---
 ...tename-identifier-semantics-stringvalue.js |  5 +-
 .../same-line-async-gen-literal-names-asi.js  | 25 ++++--
 .../same-line-async-gen-literal-names.js      | 35 ++++++--
 ...same-line-async-gen-private-field-usage.js |  5 +-
 ...e-async-gen-private-method-getter-usage.js |  5 +-
 ...ame-line-async-gen-private-method-usage.js |  5 +-
 .../same-line-async-gen-private-names.js      | 21 ++---
 ...ync-gen-rs-field-identifier-initializer.js |  5 +-
 ...same-line-async-gen-rs-field-identifier.js |  5 +-
 ...me-line-async-gen-rs-private-getter-alt.js |  5 +-
 .../same-line-async-gen-rs-private-getter.js  |  5 +-
 ...me-line-async-gen-rs-private-method-alt.js |  5 +-
 .../same-line-async-gen-rs-private-method.js  |  5 +-
 ...me-line-async-gen-rs-private-setter-alt.js |  5 +-
 .../same-line-async-gen-rs-private-setter.js  |  5 +-
 ...async-gen-rs-privatename-identifier-alt.js |  5 +-
 ...-privatename-identifier-initializer-alt.js |  5 +-
 ...n-rs-privatename-identifier-initializer.js |  5 +-
 ...ine-async-gen-rs-privatename-identifier.js |  5 +-
 ...rator-method-privatename-identifier-alt.js |  5 +-
 ...generator-method-privatename-identifier.js |  5 +-
 ...async-method-privatename-identifier-alt.js |  5 +-
 ...tic-async-method-privatename-identifier.js |  5 +-
 ...rator-method-privatename-identifier-alt.js |  5 +-
 ...generator-method-privatename-identifier.js |  5 +-
 ...tatic-method-privatename-identifier-alt.js |  5 +-
 ...rs-static-method-privatename-identifier.js |  5 +-
 ...privatename-identifier-alt-by-classname.js |  5 +-
 ...en-rs-static-privatename-identifier-alt.js |  5 +-
 ...tic-privatename-identifier-by-classname.js |  5 +-
 ...identifier-initializer-alt-by-classname.js |  5 +-
 ...-privatename-identifier-initializer-alt.js |  5 +-
 ...atic-privatename-identifier-initializer.js |  5 +-
 ...nc-gen-rs-static-privatename-identifier.js |  5 +-
 ...me-line-async-gen-static-private-fields.js | 21 ++---
 ...-gen-static-private-methods-with-fields.js | 37 +++++----
 ...e-line-async-gen-static-private-methods.js | 21 ++---
 ...ame-line-async-gen-string-literal-names.js | 45 ++++++++---
 .../same-line-async-method-computed-names.js  | 50 +++++++++---
 ...line-async-method-computed-symbol-names.js | 55 ++++++++++---
 ...tename-identifier-semantics-stringvalue.js |  5 +-
 ...ame-line-async-method-literal-names-asi.js | 25 ++++--
 .../same-line-async-method-literal-names.js   | 35 ++++++--
 ...e-line-async-method-private-field-usage.js |  5 +-
 ...sync-method-private-method-getter-usage.js |  5 +-
 ...-line-async-method-private-method-usage.js |  5 +-
 .../same-line-async-method-private-names.js   | 21 ++---
 ...-method-rs-field-identifier-initializer.js |  5 +-
 ...e-line-async-method-rs-field-identifier.js |  5 +-
 ...line-async-method-rs-private-getter-alt.js |  5 +-
 ...ame-line-async-method-rs-private-getter.js |  5 +-
 ...line-async-method-rs-private-method-alt.js |  5 +-
 ...ame-line-async-method-rs-private-method.js |  5 +-
 ...line-async-method-rs-private-setter-alt.js |  5 +-
 ...ame-line-async-method-rs-private-setter.js |  5 +-
 ...nc-method-rs-privatename-identifier-alt.js |  5 +-
 ...-privatename-identifier-initializer-alt.js |  5 +-
 ...d-rs-privatename-identifier-initializer.js |  5 +-
 ...-async-method-rs-privatename-identifier.js |  5 +-
 ...rator-method-privatename-identifier-alt.js |  5 +-
 ...generator-method-privatename-identifier.js |  5 +-
 ...async-method-privatename-identifier-alt.js |  5 +-
 ...tic-async-method-privatename-identifier.js |  5 +-
 ...rator-method-privatename-identifier-alt.js |  5 +-
 ...generator-method-privatename-identifier.js |  5 +-
 ...tatic-method-privatename-identifier-alt.js |  5 +-
 ...rs-static-method-privatename-identifier.js |  5 +-
 ...privatename-identifier-alt-by-classname.js |  5 +-
 ...od-rs-static-privatename-identifier-alt.js |  5 +-
 ...tic-privatename-identifier-by-classname.js |  5 +-
 ...identifier-initializer-alt-by-classname.js |  5 +-
 ...-privatename-identifier-initializer-alt.js |  5 +-
 ...atic-privatename-identifier-initializer.js |  5 +-
 ...method-rs-static-privatename-identifier.js |  5 +-
 ...line-async-method-static-private-fields.js | 21 ++---
 ...thod-static-private-methods-with-fields.js | 37 +++++----
 ...ine-async-method-static-private-methods.js | 21 ++---
 ...-line-async-method-string-literal-names.js | 45 ++++++++---
 .../elements/same-line-gen-computed-names.js  | 50 +++++++++---
 .../same-line-gen-computed-symbol-names.js    | 55 ++++++++++---
 ...tename-identifier-semantics-stringvalue.js |  5 +-
 .../same-line-gen-literal-names-asi.js        | 25 ++++--
 .../elements/same-line-gen-literal-names.js   | 35 ++++++--
 .../same-line-gen-private-field-usage.js      |  5 +-
 ...me-line-gen-private-method-getter-usage.js |  5 +-
 .../same-line-gen-private-method-usage.js     |  5 +-
 .../elements/same-line-gen-private-names.js   | 21 ++---
 ...ine-gen-rs-field-identifier-initializer.js |  5 +-
 .../same-line-gen-rs-field-identifier.js      |  5 +-
 .../same-line-gen-rs-private-getter-alt.js    |  5 +-
 .../same-line-gen-rs-private-getter.js        |  5 +-
 .../same-line-gen-rs-private-method-alt.js    |  5 +-
 .../same-line-gen-rs-private-method.js        |  5 +-
 .../same-line-gen-rs-private-setter-alt.js    |  5 +-
 .../same-line-gen-rs-private-setter.js        |  5 +-
 ...-line-gen-rs-privatename-identifier-alt.js |  5 +-
 ...-privatename-identifier-initializer-alt.js |  5 +-
 ...n-rs-privatename-identifier-initializer.js |  5 +-
 ...same-line-gen-rs-privatename-identifier.js |  5 +-
 ...rator-method-privatename-identifier-alt.js |  5 +-
 ...generator-method-privatename-identifier.js |  5 +-
 ...async-method-privatename-identifier-alt.js |  5 +-
 ...tic-async-method-privatename-identifier.js |  5 +-
 ...rator-method-privatename-identifier-alt.js |  5 +-
 ...generator-method-privatename-identifier.js |  5 +-
 ...tatic-method-privatename-identifier-alt.js |  5 +-
 ...rs-static-method-privatename-identifier.js |  5 +-
 ...privatename-identifier-alt-by-classname.js |  5 +-
 ...en-rs-static-privatename-identifier-alt.js |  5 +-
 ...tic-privatename-identifier-by-classname.js |  5 +-
 ...identifier-initializer-alt-by-classname.js |  5 +-
 ...-privatename-identifier-initializer-alt.js |  5 +-
 ...atic-privatename-identifier-initializer.js |  5 +-
 ...ne-gen-rs-static-privatename-identifier.js |  5 +-
 .../same-line-gen-static-private-fields.js    | 21 ++---
 ...-gen-static-private-methods-with-fields.js | 37 +++++----
 .../same-line-gen-static-private-methods.js   | 21 ++---
 .../same-line-gen-string-literal-names.js     | 45 ++++++++---
 .../same-line-method-computed-names.js        | 50 +++++++++---
 .../same-line-method-computed-symbol-names.js | 55 ++++++++++---
 ...tename-identifier-semantics-stringvalue.js |  5 +-
 .../same-line-method-literal-names-asi.js     | 25 ++++--
 .../same-line-method-literal-names.js         | 35 ++++++--
 .../same-line-method-private-field-usage.js   |  5 +-
 ...line-method-private-method-getter-usage.js |  5 +-
 .../same-line-method-private-method-usage.js  |  5 +-
 .../same-line-method-private-names.js         | 21 ++---
 ...-method-rs-field-identifier-initializer.js |  5 +-
 .../same-line-method-rs-field-identifier.js   |  5 +-
 .../same-line-method-rs-private-getter-alt.js |  5 +-
 .../same-line-method-rs-private-getter.js     |  5 +-
 .../same-line-method-rs-private-method-alt.js |  5 +-
 .../same-line-method-rs-private-method.js     |  5 +-
 .../same-line-method-rs-private-setter-alt.js |  5 +-
 .../same-line-method-rs-private-setter.js     |  5 +-
 ...ne-method-rs-privatename-identifier-alt.js |  5 +-
 ...-privatename-identifier-initializer-alt.js |  5 +-
 ...d-rs-privatename-identifier-initializer.js |  5 +-
 ...e-line-method-rs-privatename-identifier.js |  5 +-
 ...rator-method-privatename-identifier-alt.js |  5 +-
 ...generator-method-privatename-identifier.js |  5 +-
 ...async-method-privatename-identifier-alt.js |  5 +-
 ...tic-async-method-privatename-identifier.js |  5 +-
 ...rator-method-privatename-identifier-alt.js |  5 +-
 ...generator-method-privatename-identifier.js |  5 +-
 ...tatic-method-privatename-identifier-alt.js |  5 +-
 ...rs-static-method-privatename-identifier.js |  5 +-
 ...privatename-identifier-alt-by-classname.js |  5 +-
 ...od-rs-static-privatename-identifier-alt.js |  5 +-
 ...tic-privatename-identifier-by-classname.js |  5 +-
 ...identifier-initializer-alt-by-classname.js |  5 +-
 ...-privatename-identifier-initializer-alt.js |  5 +-
 ...atic-privatename-identifier-initializer.js |  5 +-
 ...method-rs-static-privatename-identifier.js |  5 +-
 .../same-line-method-static-private-fields.js | 21 ++---
 ...thod-static-private-methods-with-fields.js | 37 +++++----
 ...same-line-method-static-private-methods.js | 21 ++---
 .../same-line-method-string-literal-names.js  | 45 ++++++++---
 .../elements/static-field-declaration.js      | 20 ++++-
 .../elements/wrapped-in-sc-computed-names.js  | 45 ++++++++---
 .../wrapped-in-sc-computed-symbol-names.js    | 50 +++++++++---
 .../wrapped-in-sc-literal-names-asi.js        | 20 ++++-
 .../elements/wrapped-in-sc-literal-names.js   | 30 +++++--
 .../elements/wrapped-in-sc-private-names.js   | 16 ++--
 .../wrapped-in-sc-static-private-fields.js    | 16 ++--
 ...n-sc-static-private-methods-with-fields.js | 32 ++++----
 .../wrapped-in-sc-static-private-methods.js   | 16 ++--
 .../wrapped-in-sc-string-literal-names.js     | 40 ++++++++--
 .../yield-identifier-spread-non-strict.js     |  2 +-
 1557 files changed, 21242 insertions(+), 6350 deletions(-)

diff --git a/test/language/expressions/array/spread-obj-symbol-property.js b/test/language/expressions/array/spread-obj-symbol-property.js
index 826974a401..5e0744bee9 100644
--- a/test/language/expressions/array/spread-obj-symbol-property.js
+++ b/test/language/expressions/array/spread-obj-symbol-property.js
@@ -41,7 +41,7 @@ var callCount = 0;
 
 (function(obj) {
   assert.sameValue(obj[symbol], 1);
-  assert(Object.hasOwnProperty.call(obj, symbol));
+  assert(Object.prototype.hasOwnProperty.call(obj, symbol), "symbol is an own property");
   assert.sameValue(obj.c, 4);
   assert.sameValue(obj.d, 5);
   assert.sameValue(Object.keys(obj).length, 2);
diff --git a/test/language/expressions/async-generator/named-yield-identifier-spread-non-strict.js b/test/language/expressions/async-generator/named-yield-identifier-spread-non-strict.js
index 47b18daea7..08efe107bf 100644
--- a/test/language/expressions/async-generator/named-yield-identifier-spread-non-strict.js
+++ b/test/language/expressions/async-generator/named-yield-identifier-spread-non-strict.js
@@ -57,7 +57,7 @@ item.then(({ done, value }) => {
   assert.sameValue(value.b, 2);
   assert.sameValue(value[s], 42);
   assert.sameValue(Object.keys(value).length, 5);
-  assert(Object.hasOwnProperty.call(value, s));
+  assert(Object.prototype.hasOwnProperty.call(value, s), "s is an own property");
 }).then($DONE, $DONE);
 
 assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/async-generator/yield-identifier-spread-non-strict.js b/test/language/expressions/async-generator/yield-identifier-spread-non-strict.js
index d9f489f2b1..160d80ea7c 100644
--- a/test/language/expressions/async-generator/yield-identifier-spread-non-strict.js
+++ b/test/language/expressions/async-generator/yield-identifier-spread-non-strict.js
@@ -57,7 +57,7 @@ item.then(({ done, value }) => {
   assert.sameValue(value.b, 2);
   assert.sameValue(value[s], 42);
   assert.sameValue(Object.keys(value).length, 5);
-  assert(Object.hasOwnProperty.call(value, s));
+  assert(Object.prototype.hasOwnProperty.call(value, s), "s is an own property");
 }).then($DONE, $DONE);
 
 assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/call/spread-obj-symbol-property.js b/test/language/expressions/call/spread-obj-symbol-property.js
index dca4bbca5f..1dd15ff6a9 100644
--- a/test/language/expressions/call/spread-obj-symbol-property.js
+++ b/test/language/expressions/call/spread-obj-symbol-property.js
@@ -39,7 +39,7 @@ var callCount = 0;
 
 (function(obj) {
   assert.sameValue(obj[symbol], 1);
-  assert(Object.hasOwnProperty.call(obj, symbol));
+  assert(Object.prototype.hasOwnProperty.call(obj, symbol), "symbol is an own property");
   assert.sameValue(obj.c, 4);
   assert.sameValue(obj.d, 5);
   assert.sameValue(Object.keys(obj).length, 2);
diff --git a/test/language/expressions/class/elements/after-same-line-gen-computed-names.js b/test/language/expressions/class/elements/after-same-line-gen-computed-names.js
index 1329d9f17f..d332a35ed1 100644
--- a/test/language/expressions/class/elements/after-same-line-gen-computed-names.js
+++ b/test/language/expressions/class/elements/after-same-line-gen-computed-names.js
@@ -31,7 +31,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -40,8 +43,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -50,12 +59,27 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "10"),
+  "10 doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "10"),
+  "10 doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "10", {
   value: "meep",
@@ -64,8 +88,14 @@ verifyProperty(c, "10", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "not initialized", {
   value: undefined,
diff --git a/test/language/expressions/class/elements/after-same-line-gen-computed-symbol-names.js b/test/language/expressions/class/elements/after-same-line-gen-computed-symbol-names.js
index ca5853ba46..e33e71e25a 100644
--- a/test/language/expressions/class/elements/after-same-line-gen-computed-symbol-names.js
+++ b/test/language/expressions/class/elements/after-same-line-gen-computed-symbol-names.js
@@ -32,7 +32,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -41,8 +44,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, x), false);
-assert.sameValue(Object.hasOwnProperty.call(C, x), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, x),
+  "Symbol x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, x),
+  "Symbol x doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, x, {
   value: undefined,
@@ -51,8 +60,14 @@ verifyProperty(c, x, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
-assert.sameValue(Object.hasOwnProperty.call(C, y), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, y),
+  "Symbol y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, y),
+  "Symbol y doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, y, {
   value: 42,
@@ -61,10 +76,28 @@ verifyProperty(c, y, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "y"),
+  "y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "y"),
+  "y doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "y"),
+  "y doesn't appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/after-same-line-gen-grammar-privatename-identifier-semantics-stringvalue.js b/test/language/expressions/class/elements/after-same-line-gen-grammar-privatename-identifier-semantics-stringvalue.js
index 6caacf2218..d39e9641c9 100644
--- a/test/language/expressions/class/elements/after-same-line-gen-grammar-privatename-identifier-semantics-stringvalue.js
+++ b/test/language/expressions/class/elements/after-same-line-gen-grammar-privatename-identifier-semantics-stringvalue.js
@@ -89,7 +89,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-gen-literal-names-asi.js b/test/language/expressions/class/elements/after-same-line-gen-literal-names-asi.js
index 60b0080a9c..52ae039b5d 100644
--- a/test/language/expressions/class/elements/after-same-line-gen-literal-names-asi.js
+++ b/test/language/expressions/class/elements/after-same-line-gen-literal-names-asi.js
@@ -30,7 +30,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -39,8 +42,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -49,8 +58,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
diff --git a/test/language/expressions/class/elements/after-same-line-gen-literal-names.js b/test/language/expressions/class/elements/after-same-line-gen-literal-names.js
index 48018a0700..fd0fcb7503 100644
--- a/test/language/expressions/class/elements/after-same-line-gen-literal-names.js
+++ b/test/language/expressions/class/elements/after-same-line-gen-literal-names.js
@@ -32,7 +32,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -41,8 +44,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -51,8 +60,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -61,8 +76,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: fn,
diff --git a/test/language/expressions/class/elements/after-same-line-gen-private-field-usage.js b/test/language/expressions/class/elements/after-same-line-gen-private-field-usage.js
index ee1194793b..1c14a995a6 100644
--- a/test/language/expressions/class/elements/after-same-line-gen-private-field-usage.js
+++ b/test/language/expressions/class/elements/after-same-line-gen-private-field-usage.js
@@ -32,7 +32,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-gen-private-method-getter-usage.js b/test/language/expressions/class/elements/after-same-line-gen-private-method-getter-usage.js
index 2ead1b9cc3..7c3ea3ebb5 100644
--- a/test/language/expressions/class/elements/after-same-line-gen-private-method-getter-usage.js
+++ b/test/language/expressions/class/elements/after-same-line-gen-private-method-getter-usage.js
@@ -32,7 +32,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-gen-private-method-usage.js b/test/language/expressions/class/elements/after-same-line-gen-private-method-usage.js
index ad5d834630..ba388482df 100644
--- a/test/language/expressions/class/elements/after-same-line-gen-private-method-usage.js
+++ b/test/language/expressions/class/elements/after-same-line-gen-private-method-usage.js
@@ -32,7 +32,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-gen-private-names.js b/test/language/expressions/class/elements/after-same-line-gen-private-names.js
index bdb5a41e4d..d174ba26c9 100644
--- a/test/language/expressions/class/elements/after-same-line-gen-private-names.js
+++ b/test/language/expressions/class/elements/after-same-line-gen-private-names.js
@@ -39,7 +39,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -49,18 +52,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(c.x(), 42, "test 7");
 assert.sameValue(c.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 10");
diff --git a/test/language/expressions/class/elements/after-same-line-gen-rs-field-identifier-initializer.js b/test/language/expressions/class/elements/after-same-line-gen-rs-field-identifier-initializer.js
index 3414bc5c47..01363b8e1f 100644
--- a/test/language/expressions/class/elements/after-same-line-gen-rs-field-identifier-initializer.js
+++ b/test/language/expressions/class/elements/after-same-line-gen-rs-field-identifier-initializer.js
@@ -65,7 +65,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-gen-rs-field-identifier.js b/test/language/expressions/class/elements/after-same-line-gen-rs-field-identifier.js
index 52cfd8aa92..1d147fbbad 100644
--- a/test/language/expressions/class/elements/after-same-line-gen-rs-field-identifier.js
+++ b/test/language/expressions/class/elements/after-same-line-gen-rs-field-identifier.js
@@ -65,7 +65,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-gen-rs-private-getter-alt.js b/test/language/expressions/class/elements/after-same-line-gen-rs-private-getter-alt.js
index a06921b079..5903e7a6c4 100644
--- a/test/language/expressions/class/elements/after-same-line-gen-rs-private-getter-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-gen-rs-private-getter-alt.js
@@ -106,7 +106,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-gen-rs-private-getter.js b/test/language/expressions/class/elements/after-same-line-gen-rs-private-getter.js
index 10cff62449..57f9972804 100644
--- a/test/language/expressions/class/elements/after-same-line-gen-rs-private-getter.js
+++ b/test/language/expressions/class/elements/after-same-line-gen-rs-private-getter.js
@@ -106,7 +106,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-gen-rs-private-method-alt.js b/test/language/expressions/class/elements/after-same-line-gen-rs-private-method-alt.js
index 04503002e0..9b3b751319 100644
--- a/test/language/expressions/class/elements/after-same-line-gen-rs-private-method-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-gen-rs-private-method-alt.js
@@ -105,7 +105,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-gen-rs-private-method.js b/test/language/expressions/class/elements/after-same-line-gen-rs-private-method.js
index ffaf0f6b97..219062cff5 100644
--- a/test/language/expressions/class/elements/after-same-line-gen-rs-private-method.js
+++ b/test/language/expressions/class/elements/after-same-line-gen-rs-private-method.js
@@ -105,7 +105,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-gen-rs-private-setter-alt.js b/test/language/expressions/class/elements/after-same-line-gen-rs-private-setter-alt.js
index 92fa02721b..2737cfb1a7 100644
--- a/test/language/expressions/class/elements/after-same-line-gen-rs-private-setter-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-gen-rs-private-setter-alt.js
@@ -105,7 +105,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-gen-rs-private-setter.js b/test/language/expressions/class/elements/after-same-line-gen-rs-private-setter.js
index dc61369497..57ecec4ab0 100644
--- a/test/language/expressions/class/elements/after-same-line-gen-rs-private-setter.js
+++ b/test/language/expressions/class/elements/after-same-line-gen-rs-private-setter.js
@@ -105,7 +105,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-gen-rs-privatename-identifier-alt.js b/test/language/expressions/class/elements/after-same-line-gen-rs-privatename-identifier-alt.js
index da6a0ff6dc..b5947e74b6 100644
--- a/test/language/expressions/class/elements/after-same-line-gen-rs-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-gen-rs-privatename-identifier-alt.js
@@ -86,7 +86,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-gen-rs-privatename-identifier-initializer-alt.js b/test/language/expressions/class/elements/after-same-line-gen-rs-privatename-identifier-initializer-alt.js
index 15425291f7..3689219274 100644
--- a/test/language/expressions/class/elements/after-same-line-gen-rs-privatename-identifier-initializer-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-gen-rs-privatename-identifier-initializer-alt.js
@@ -80,7 +80,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-gen-rs-privatename-identifier-initializer.js b/test/language/expressions/class/elements/after-same-line-gen-rs-privatename-identifier-initializer.js
index 5432dcce89..c06d0b7dd6 100644
--- a/test/language/expressions/class/elements/after-same-line-gen-rs-privatename-identifier-initializer.js
+++ b/test/language/expressions/class/elements/after-same-line-gen-rs-privatename-identifier-initializer.js
@@ -80,7 +80,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-gen-rs-privatename-identifier.js b/test/language/expressions/class/elements/after-same-line-gen-rs-privatename-identifier.js
index daa6065b8a..1249b1387d 100644
--- a/test/language/expressions/class/elements/after-same-line-gen-rs-privatename-identifier.js
+++ b/test/language/expressions/class/elements/after-same-line-gen-rs-privatename-identifier.js
@@ -86,7 +86,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/after-same-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js
index 46fcd2276b..cb0fb7d96a 100644
--- a/test/language/expressions/class/elements/after-same-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -102,7 +102,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-gen-rs-static-async-generator-method-privatename-identifier.js b/test/language/expressions/class/elements/after-same-line-gen-rs-static-async-generator-method-privatename-identifier.js
index b284d855f1..974a1ee406 100644
--- a/test/language/expressions/class/elements/after-same-line-gen-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/after-same-line-gen-rs-static-async-generator-method-privatename-identifier.js
@@ -102,7 +102,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-gen-rs-static-async-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/after-same-line-gen-rs-static-async-method-privatename-identifier-alt.js
index 7f0b8ed5d7..2f5e16a64a 100644
--- a/test/language/expressions/class/elements/after-same-line-gen-rs-static-async-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-gen-rs-static-async-method-privatename-identifier-alt.js
@@ -102,7 +102,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-gen-rs-static-async-method-privatename-identifier.js b/test/language/expressions/class/elements/after-same-line-gen-rs-static-async-method-privatename-identifier.js
index 946ada17c9..0f5320151a 100644
--- a/test/language/expressions/class/elements/after-same-line-gen-rs-static-async-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/after-same-line-gen-rs-static-async-method-privatename-identifier.js
@@ -102,7 +102,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-gen-rs-static-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/after-same-line-gen-rs-static-generator-method-privatename-identifier-alt.js
index d03fe76ac1..eeee763ebc 100644
--- a/test/language/expressions/class/elements/after-same-line-gen-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-gen-rs-static-generator-method-privatename-identifier-alt.js
@@ -102,7 +102,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-gen-rs-static-generator-method-privatename-identifier.js b/test/language/expressions/class/elements/after-same-line-gen-rs-static-generator-method-privatename-identifier.js
index f87f8e87a7..0ae619462a 100644
--- a/test/language/expressions/class/elements/after-same-line-gen-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/after-same-line-gen-rs-static-generator-method-privatename-identifier.js
@@ -102,7 +102,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-gen-rs-static-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/after-same-line-gen-rs-static-method-privatename-identifier-alt.js
index 87f8142aec..bb27c2d2ff 100644
--- a/test/language/expressions/class/elements/after-same-line-gen-rs-static-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-gen-rs-static-method-privatename-identifier-alt.js
@@ -99,7 +99,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-gen-rs-static-method-privatename-identifier.js b/test/language/expressions/class/elements/after-same-line-gen-rs-static-method-privatename-identifier.js
index aec7bef2c1..112ac3790f 100644
--- a/test/language/expressions/class/elements/after-same-line-gen-rs-static-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/after-same-line-gen-rs-static-method-privatename-identifier.js
@@ -99,7 +99,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-gen-rs-static-privatename-identifier-alt-by-classname.js b/test/language/expressions/class/elements/after-same-line-gen-rs-static-privatename-identifier-alt-by-classname.js
index 2e3aa82f32..c6f00a2c50 100644
--- a/test/language/expressions/class/elements/after-same-line-gen-rs-static-privatename-identifier-alt-by-classname.js
+++ b/test/language/expressions/class/elements/after-same-line-gen-rs-static-privatename-identifier-alt-by-classname.js
@@ -87,7 +87,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-gen-rs-static-privatename-identifier-alt.js b/test/language/expressions/class/elements/after-same-line-gen-rs-static-privatename-identifier-alt.js
index 07160f0074..bddd093ca2 100644
--- a/test/language/expressions/class/elements/after-same-line-gen-rs-static-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-gen-rs-static-privatename-identifier-alt.js
@@ -87,7 +87,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-gen-rs-static-privatename-identifier-by-classname.js b/test/language/expressions/class/elements/after-same-line-gen-rs-static-privatename-identifier-by-classname.js
index 3508023ff0..3a8f7bef08 100644
--- a/test/language/expressions/class/elements/after-same-line-gen-rs-static-privatename-identifier-by-classname.js
+++ b/test/language/expressions/class/elements/after-same-line-gen-rs-static-privatename-identifier-by-classname.js
@@ -87,7 +87,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js b/test/language/expressions/class/elements/after-same-line-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
index feed6f9bd8..97b77f8c8b 100644
--- a/test/language/expressions/class/elements/after-same-line-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
+++ b/test/language/expressions/class/elements/after-same-line-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
@@ -81,7 +81,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-gen-rs-static-privatename-identifier-initializer-alt.js b/test/language/expressions/class/elements/after-same-line-gen-rs-static-privatename-identifier-initializer-alt.js
index 5ee30d0e4c..7014753eec 100644
--- a/test/language/expressions/class/elements/after-same-line-gen-rs-static-privatename-identifier-initializer-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-gen-rs-static-privatename-identifier-initializer-alt.js
@@ -81,7 +81,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-gen-rs-static-privatename-identifier-initializer.js b/test/language/expressions/class/elements/after-same-line-gen-rs-static-privatename-identifier-initializer.js
index 8996648865..fdfc5f9e1f 100644
--- a/test/language/expressions/class/elements/after-same-line-gen-rs-static-privatename-identifier-initializer.js
+++ b/test/language/expressions/class/elements/after-same-line-gen-rs-static-privatename-identifier-initializer.js
@@ -81,7 +81,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-gen-rs-static-privatename-identifier.js b/test/language/expressions/class/elements/after-same-line-gen-rs-static-privatename-identifier.js
index 771808cfd9..06c4578b3e 100644
--- a/test/language/expressions/class/elements/after-same-line-gen-rs-static-privatename-identifier.js
+++ b/test/language/expressions/class/elements/after-same-line-gen-rs-static-privatename-identifier.js
@@ -87,7 +87,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-gen-static-private-fields.js b/test/language/expressions/class/elements/after-same-line-gen-static-private-fields.js
index 026f0f3966..1d352c03bc 100644
--- a/test/language/expressions/class/elements/after-same-line-gen-static-private-fields.js
+++ b/test/language/expressions/class/elements/after-same-line-gen-static-private-fields.js
@@ -39,7 +39,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -49,18 +52,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/expressions/class/elements/after-same-line-gen-static-private-methods-with-fields.js b/test/language/expressions/class/elements/after-same-line-gen-static-private-methods-with-fields.js
index 9ee92740a2..adb1ecd869 100644
--- a/test/language/expressions/class/elements/after-same-line-gen-static-private-methods-with-fields.js
+++ b/test/language/expressions/class/elements/after-same-line-gen-static-private-methods-with-fields.js
@@ -45,7 +45,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -55,29 +58,29 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#xVal"), "test 7");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 8");
+assert(!Object.prototype.hasOwnProperty.call(c, "#xVal"), "test 9");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#yVal"), "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 11");
+assert(!Object.prototype.hasOwnProperty.call(c, "#yVal"), "test 12");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 13");
 assert.sameValue(C.y(), 43, "test 14");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 15");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 16");
 
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 17");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 18");
diff --git a/test/language/expressions/class/elements/after-same-line-gen-static-private-methods.js b/test/language/expressions/class/elements/after-same-line-gen-static-private-methods.js
index 1b89a72d94..51393f6b18 100644
--- a/test/language/expressions/class/elements/after-same-line-gen-static-private-methods.js
+++ b/test/language/expressions/class/elements/after-same-line-gen-static-private-methods.js
@@ -43,7 +43,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -53,18 +56,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/expressions/class/elements/after-same-line-gen-string-literal-names.js b/test/language/expressions/class/elements/after-same-line-gen-string-literal-names.js
index 489ba41f9b..db369b8ea5 100644
--- a/test/language/expressions/class/elements/after-same-line-gen-string-literal-names.js
+++ b/test/language/expressions/class/elements/after-same-line-gen-string-literal-names.js
@@ -30,7 +30,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -39,8 +42,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -49,8 +58,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: undefined,
@@ -59,8 +74,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: 39,
@@ -69,8 +90,14 @@ verifyProperty(c, "c", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "d"),
+  "d does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "d"),
+  "d does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "d", {
   value: 42,
diff --git a/test/language/expressions/class/elements/after-same-line-method-computed-names.js b/test/language/expressions/class/elements/after-same-line-method-computed-names.js
index b262e54bf7..8bb76363af 100644
--- a/test/language/expressions/class/elements/after-same-line-method-computed-names.js
+++ b/test/language/expressions/class/elements/after-same-line-method-computed-names.js
@@ -31,7 +31,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -40,8 +43,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -50,12 +59,27 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "10"),
+  "10 doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "10"),
+  "10 doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "10", {
   value: "meep",
@@ -64,8 +88,14 @@ verifyProperty(c, "10", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "not initialized", {
   value: undefined,
diff --git a/test/language/expressions/class/elements/after-same-line-method-computed-symbol-names.js b/test/language/expressions/class/elements/after-same-line-method-computed-symbol-names.js
index 5a0111b065..75aa157b1f 100644
--- a/test/language/expressions/class/elements/after-same-line-method-computed-symbol-names.js
+++ b/test/language/expressions/class/elements/after-same-line-method-computed-symbol-names.js
@@ -32,7 +32,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -41,8 +44,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, x), false);
-assert.sameValue(Object.hasOwnProperty.call(C, x), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, x),
+  "Symbol x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, x),
+  "Symbol x doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, x, {
   value: undefined,
@@ -51,8 +60,14 @@ verifyProperty(c, x, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
-assert.sameValue(Object.hasOwnProperty.call(C, y), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, y),
+  "Symbol y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, y),
+  "Symbol y doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, y, {
   value: 42,
@@ -61,10 +76,28 @@ verifyProperty(c, y, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "y"),
+  "y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "y"),
+  "y doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "y"),
+  "y doesn't appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/after-same-line-method-grammar-privatename-identifier-semantics-stringvalue.js b/test/language/expressions/class/elements/after-same-line-method-grammar-privatename-identifier-semantics-stringvalue.js
index 0823c308bc..4f0924a58d 100644
--- a/test/language/expressions/class/elements/after-same-line-method-grammar-privatename-identifier-semantics-stringvalue.js
+++ b/test/language/expressions/class/elements/after-same-line-method-grammar-privatename-identifier-semantics-stringvalue.js
@@ -89,7 +89,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-method-literal-names-asi.js b/test/language/expressions/class/elements/after-same-line-method-literal-names-asi.js
index 5d6937ee59..e2f0ecc8fc 100644
--- a/test/language/expressions/class/elements/after-same-line-method-literal-names-asi.js
+++ b/test/language/expressions/class/elements/after-same-line-method-literal-names-asi.js
@@ -30,7 +30,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -39,8 +42,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -49,8 +58,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
diff --git a/test/language/expressions/class/elements/after-same-line-method-literal-names.js b/test/language/expressions/class/elements/after-same-line-method-literal-names.js
index 61e1fd3488..f3a452e130 100644
--- a/test/language/expressions/class/elements/after-same-line-method-literal-names.js
+++ b/test/language/expressions/class/elements/after-same-line-method-literal-names.js
@@ -32,7 +32,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -41,8 +44,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -51,8 +60,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -61,8 +76,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: fn,
diff --git a/test/language/expressions/class/elements/after-same-line-method-private-field-usage.js b/test/language/expressions/class/elements/after-same-line-method-private-field-usage.js
index a2d76b57e2..3ce86ca311 100644
--- a/test/language/expressions/class/elements/after-same-line-method-private-field-usage.js
+++ b/test/language/expressions/class/elements/after-same-line-method-private-field-usage.js
@@ -32,7 +32,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-method-private-method-getter-usage.js b/test/language/expressions/class/elements/after-same-line-method-private-method-getter-usage.js
index a4e00ac7a2..596e17392a 100644
--- a/test/language/expressions/class/elements/after-same-line-method-private-method-getter-usage.js
+++ b/test/language/expressions/class/elements/after-same-line-method-private-method-getter-usage.js
@@ -32,7 +32,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-method-private-method-usage.js b/test/language/expressions/class/elements/after-same-line-method-private-method-usage.js
index e60547415e..3532d649e4 100644
--- a/test/language/expressions/class/elements/after-same-line-method-private-method-usage.js
+++ b/test/language/expressions/class/elements/after-same-line-method-private-method-usage.js
@@ -32,7 +32,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-method-private-names.js b/test/language/expressions/class/elements/after-same-line-method-private-names.js
index f349458837..fab5def29a 100644
--- a/test/language/expressions/class/elements/after-same-line-method-private-names.js
+++ b/test/language/expressions/class/elements/after-same-line-method-private-names.js
@@ -39,7 +39,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -49,18 +52,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(c.x(), 42, "test 7");
 assert.sameValue(c.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 10");
diff --git a/test/language/expressions/class/elements/after-same-line-method-rs-field-identifier-initializer.js b/test/language/expressions/class/elements/after-same-line-method-rs-field-identifier-initializer.js
index e3b7c2c6f6..e27013b9ba 100644
--- a/test/language/expressions/class/elements/after-same-line-method-rs-field-identifier-initializer.js
+++ b/test/language/expressions/class/elements/after-same-line-method-rs-field-identifier-initializer.js
@@ -65,7 +65,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-method-rs-field-identifier.js b/test/language/expressions/class/elements/after-same-line-method-rs-field-identifier.js
index 1d9f6198c9..195c5d9529 100644
--- a/test/language/expressions/class/elements/after-same-line-method-rs-field-identifier.js
+++ b/test/language/expressions/class/elements/after-same-line-method-rs-field-identifier.js
@@ -65,7 +65,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-method-rs-private-getter-alt.js b/test/language/expressions/class/elements/after-same-line-method-rs-private-getter-alt.js
index d943930322..ceb66085b9 100644
--- a/test/language/expressions/class/elements/after-same-line-method-rs-private-getter-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-method-rs-private-getter-alt.js
@@ -106,7 +106,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-method-rs-private-getter.js b/test/language/expressions/class/elements/after-same-line-method-rs-private-getter.js
index 1de275be65..452e8eef19 100644
--- a/test/language/expressions/class/elements/after-same-line-method-rs-private-getter.js
+++ b/test/language/expressions/class/elements/after-same-line-method-rs-private-getter.js
@@ -106,7 +106,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-method-rs-private-method-alt.js b/test/language/expressions/class/elements/after-same-line-method-rs-private-method-alt.js
index 65e8070014..bbfe0c88a5 100644
--- a/test/language/expressions/class/elements/after-same-line-method-rs-private-method-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-method-rs-private-method-alt.js
@@ -105,7 +105,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-method-rs-private-method.js b/test/language/expressions/class/elements/after-same-line-method-rs-private-method.js
index a0808ce4a7..79c3e6e24f 100644
--- a/test/language/expressions/class/elements/after-same-line-method-rs-private-method.js
+++ b/test/language/expressions/class/elements/after-same-line-method-rs-private-method.js
@@ -105,7 +105,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-method-rs-private-setter-alt.js b/test/language/expressions/class/elements/after-same-line-method-rs-private-setter-alt.js
index 30b6e08304..6da2c1e998 100644
--- a/test/language/expressions/class/elements/after-same-line-method-rs-private-setter-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-method-rs-private-setter-alt.js
@@ -105,7 +105,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-method-rs-private-setter.js b/test/language/expressions/class/elements/after-same-line-method-rs-private-setter.js
index 1d06fe4aca..885d5095ad 100644
--- a/test/language/expressions/class/elements/after-same-line-method-rs-private-setter.js
+++ b/test/language/expressions/class/elements/after-same-line-method-rs-private-setter.js
@@ -105,7 +105,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-method-rs-privatename-identifier-alt.js b/test/language/expressions/class/elements/after-same-line-method-rs-privatename-identifier-alt.js
index 2b906f9cd1..92ede81a05 100644
--- a/test/language/expressions/class/elements/after-same-line-method-rs-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-method-rs-privatename-identifier-alt.js
@@ -86,7 +86,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-method-rs-privatename-identifier-initializer-alt.js b/test/language/expressions/class/elements/after-same-line-method-rs-privatename-identifier-initializer-alt.js
index 48e30984d6..86d03adad6 100644
--- a/test/language/expressions/class/elements/after-same-line-method-rs-privatename-identifier-initializer-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-method-rs-privatename-identifier-initializer-alt.js
@@ -80,7 +80,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-method-rs-privatename-identifier-initializer.js b/test/language/expressions/class/elements/after-same-line-method-rs-privatename-identifier-initializer.js
index 62e4ee540d..1c8755ae60 100644
--- a/test/language/expressions/class/elements/after-same-line-method-rs-privatename-identifier-initializer.js
+++ b/test/language/expressions/class/elements/after-same-line-method-rs-privatename-identifier-initializer.js
@@ -80,7 +80,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-method-rs-privatename-identifier.js b/test/language/expressions/class/elements/after-same-line-method-rs-privatename-identifier.js
index c51269e0af..8066922a3a 100644
--- a/test/language/expressions/class/elements/after-same-line-method-rs-privatename-identifier.js
+++ b/test/language/expressions/class/elements/after-same-line-method-rs-privatename-identifier.js
@@ -86,7 +86,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-method-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/after-same-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
index 9499a63d9b..ed09ed8828 100644
--- a/test/language/expressions/class/elements/after-same-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -102,7 +102,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-method-rs-static-async-generator-method-privatename-identifier.js b/test/language/expressions/class/elements/after-same-line-method-rs-static-async-generator-method-privatename-identifier.js
index 248612716f..77a8b2d129 100644
--- a/test/language/expressions/class/elements/after-same-line-method-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/after-same-line-method-rs-static-async-generator-method-privatename-identifier.js
@@ -102,7 +102,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-method-rs-static-async-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/after-same-line-method-rs-static-async-method-privatename-identifier-alt.js
index 0e790f9fa7..a5f127dbc7 100644
--- a/test/language/expressions/class/elements/after-same-line-method-rs-static-async-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-method-rs-static-async-method-privatename-identifier-alt.js
@@ -102,7 +102,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-method-rs-static-async-method-privatename-identifier.js b/test/language/expressions/class/elements/after-same-line-method-rs-static-async-method-privatename-identifier.js
index 2f93483a40..127ccb091a 100644
--- a/test/language/expressions/class/elements/after-same-line-method-rs-static-async-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/after-same-line-method-rs-static-async-method-privatename-identifier.js
@@ -102,7 +102,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-method-rs-static-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/after-same-line-method-rs-static-generator-method-privatename-identifier-alt.js
index 1b27001c6f..7335f87ef3 100644
--- a/test/language/expressions/class/elements/after-same-line-method-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-method-rs-static-generator-method-privatename-identifier-alt.js
@@ -102,7 +102,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-method-rs-static-generator-method-privatename-identifier.js b/test/language/expressions/class/elements/after-same-line-method-rs-static-generator-method-privatename-identifier.js
index e30fea2c4e..8530ac8b50 100644
--- a/test/language/expressions/class/elements/after-same-line-method-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/after-same-line-method-rs-static-generator-method-privatename-identifier.js
@@ -102,7 +102,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-method-rs-static-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/after-same-line-method-rs-static-method-privatename-identifier-alt.js
index 8fb27397df..d55bfec1f1 100644
--- a/test/language/expressions/class/elements/after-same-line-method-rs-static-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-method-rs-static-method-privatename-identifier-alt.js
@@ -99,7 +99,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-method-rs-static-method-privatename-identifier.js b/test/language/expressions/class/elements/after-same-line-method-rs-static-method-privatename-identifier.js
index e2c74fcdad..bd5dc5dbe8 100644
--- a/test/language/expressions/class/elements/after-same-line-method-rs-static-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/after-same-line-method-rs-static-method-privatename-identifier.js
@@ -99,7 +99,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-method-rs-static-privatename-identifier-alt-by-classname.js b/test/language/expressions/class/elements/after-same-line-method-rs-static-privatename-identifier-alt-by-classname.js
index 3c1607a612..8486d3e3c0 100644
--- a/test/language/expressions/class/elements/after-same-line-method-rs-static-privatename-identifier-alt-by-classname.js
+++ b/test/language/expressions/class/elements/after-same-line-method-rs-static-privatename-identifier-alt-by-classname.js
@@ -87,7 +87,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-method-rs-static-privatename-identifier-alt.js b/test/language/expressions/class/elements/after-same-line-method-rs-static-privatename-identifier-alt.js
index e2e521c1cf..c435392077 100644
--- a/test/language/expressions/class/elements/after-same-line-method-rs-static-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-method-rs-static-privatename-identifier-alt.js
@@ -87,7 +87,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-method-rs-static-privatename-identifier-by-classname.js b/test/language/expressions/class/elements/after-same-line-method-rs-static-privatename-identifier-by-classname.js
index 367eb6a276..21ae285f27 100644
--- a/test/language/expressions/class/elements/after-same-line-method-rs-static-privatename-identifier-by-classname.js
+++ b/test/language/expressions/class/elements/after-same-line-method-rs-static-privatename-identifier-by-classname.js
@@ -87,7 +87,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-method-rs-static-privatename-identifier-initializer-alt-by-classname.js b/test/language/expressions/class/elements/after-same-line-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
index 83d310f41c..7e2e1436a8 100644
--- a/test/language/expressions/class/elements/after-same-line-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
+++ b/test/language/expressions/class/elements/after-same-line-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
@@ -81,7 +81,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-method-rs-static-privatename-identifier-initializer-alt.js b/test/language/expressions/class/elements/after-same-line-method-rs-static-privatename-identifier-initializer-alt.js
index 38447abc8c..1c8dbf90c5 100644
--- a/test/language/expressions/class/elements/after-same-line-method-rs-static-privatename-identifier-initializer-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-method-rs-static-privatename-identifier-initializer-alt.js
@@ -81,7 +81,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-method-rs-static-privatename-identifier-initializer.js b/test/language/expressions/class/elements/after-same-line-method-rs-static-privatename-identifier-initializer.js
index 5380bc6795..5678189e16 100644
--- a/test/language/expressions/class/elements/after-same-line-method-rs-static-privatename-identifier-initializer.js
+++ b/test/language/expressions/class/elements/after-same-line-method-rs-static-privatename-identifier-initializer.js
@@ -81,7 +81,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-method-rs-static-privatename-identifier.js b/test/language/expressions/class/elements/after-same-line-method-rs-static-privatename-identifier.js
index 15b710aa49..9c2c441841 100644
--- a/test/language/expressions/class/elements/after-same-line-method-rs-static-privatename-identifier.js
+++ b/test/language/expressions/class/elements/after-same-line-method-rs-static-privatename-identifier.js
@@ -87,7 +87,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/after-same-line-method-static-private-fields.js b/test/language/expressions/class/elements/after-same-line-method-static-private-fields.js
index cce2282ebc..c0b9eddc73 100644
--- a/test/language/expressions/class/elements/after-same-line-method-static-private-fields.js
+++ b/test/language/expressions/class/elements/after-same-line-method-static-private-fields.js
@@ -39,7 +39,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -49,18 +52,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/expressions/class/elements/after-same-line-method-static-private-methods-with-fields.js b/test/language/expressions/class/elements/after-same-line-method-static-private-methods-with-fields.js
index decd3da66d..eb72b150d7 100644
--- a/test/language/expressions/class/elements/after-same-line-method-static-private-methods-with-fields.js
+++ b/test/language/expressions/class/elements/after-same-line-method-static-private-methods-with-fields.js
@@ -45,7 +45,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -55,29 +58,29 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#xVal"), "test 7");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 8");
+assert(!Object.prototype.hasOwnProperty.call(c, "#xVal"), "test 9");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#yVal"), "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 11");
+assert(!Object.prototype.hasOwnProperty.call(c, "#yVal"), "test 12");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 13");
 assert.sameValue(C.y(), 43, "test 14");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 15");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 16");
 
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 17");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 18");
diff --git a/test/language/expressions/class/elements/after-same-line-method-static-private-methods.js b/test/language/expressions/class/elements/after-same-line-method-static-private-methods.js
index ecdf8a869f..b7fc65fa2a 100644
--- a/test/language/expressions/class/elements/after-same-line-method-static-private-methods.js
+++ b/test/language/expressions/class/elements/after-same-line-method-static-private-methods.js
@@ -43,7 +43,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -53,18 +56,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/expressions/class/elements/after-same-line-method-string-literal-names.js b/test/language/expressions/class/elements/after-same-line-method-string-literal-names.js
index e967a21dc5..6067c12f94 100644
--- a/test/language/expressions/class/elements/after-same-line-method-string-literal-names.js
+++ b/test/language/expressions/class/elements/after-same-line-method-string-literal-names.js
@@ -30,7 +30,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -39,8 +42,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -49,8 +58,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: undefined,
@@ -59,8 +74,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: 39,
@@ -69,8 +90,14 @@ verifyProperty(c, "c", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "d"),
+  "d does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "d"),
+  "d does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "d", {
   value: 42,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-gen-computed-names.js b/test/language/expressions/class/elements/after-same-line-static-async-gen-computed-names.js
index 471c6835b8..b61af3ad81 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-gen-computed-names.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-gen-computed-names.js
@@ -30,8 +30,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -50,8 +56,14 @@ C.m().next().then(function(v) {
         throw new Test262Error('Test262:AsyncTestFailure')
       }
     }
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+      "b doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "b"),
+      "b doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "b", {
       value: 42,
@@ -60,12 +72,27 @@ C.m().next().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-    assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+      "x doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "x"),
+      "x doesn't appear as an own property on C constructor"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(c, "x"),
+      "x doesn't appear as an own property on C instance"
+    );
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "10"),
+      "10 doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "10"),
+      "10 doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "10", {
       value: "meep",
@@ -74,8 +101,14 @@ C.m().next().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "not initialized"),
+      "'not initialized' doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "not initialized"),
+      "'not initialized' doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "not initialized", {
       value: undefined,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-gen-computed-symbol-names.js b/test/language/expressions/class/elements/after-same-line-static-async-gen-computed-symbol-names.js
index 29b3730a9e..ac3bdf0fd8 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-gen-computed-symbol-names.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-gen-computed-symbol-names.js
@@ -31,8 +31,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -51,8 +57,14 @@ C.m().next().then(function(v) {
         throw new Test262Error('Test262:AsyncTestFailure')
       }
     }
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, x), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, x), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, x),
+      "Symbol x doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, x),
+      "Symbol x doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, x, {
       value: undefined,
@@ -61,8 +73,14 @@ C.m().next().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, y), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, y),
+      "Symbol y doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, y),
+      "Symbol y doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, y, {
       value: 42,
@@ -71,13 +89,31 @@ C.m().next().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-    assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+      "x doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "x"),
+      "x doesn't appear as an own property on C constructor"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(c, "x"),
+      "x doesn't appear as an own property on C instance"
+    );
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
-    assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "y"),
+      "y doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "y"),
+      "y doesn't appear as an own property on C constructor"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(c, "y"),
+      "y doesn't appear as an own property on C instance"
+    );
   }
 
   return Promise.resolve(assertions());
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-gen-grammar-privatename-identifier-semantics-stringvalue.js b/test/language/expressions/class/elements/after-same-line-static-async-gen-grammar-privatename-identifier-semantics-stringvalue.js
index 5c62f272e0..8f7dd958c7 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-gen-grammar-privatename-identifier-semantics-stringvalue.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-gen-grammar-privatename-identifier-semantics-stringvalue.js
@@ -88,8 +88,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-gen-literal-names-asi.js b/test/language/expressions/class/elements/after-same-line-static-async-gen-literal-names-asi.js
index 251ec98887..0be83c9ade 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-gen-literal-names-asi.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-gen-literal-names-asi.js
@@ -29,8 +29,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -49,8 +55,14 @@ C.m().next().then(function(v) {
         throw new Test262Error('Test262:AsyncTestFailure')
       }
     }
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+      "a doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "a"),
+      "a doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "a", {
       value: undefined,
@@ -59,8 +71,14 @@ C.m().next().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+      "b doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "b"),
+      "b doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "b", {
       value: 42,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-gen-literal-names.js b/test/language/expressions/class/elements/after-same-line-static-async-gen-literal-names.js
index b42f269554..052f19a405 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-gen-literal-names.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-gen-literal-names.js
@@ -31,8 +31,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -51,8 +57,14 @@ C.m().next().then(function(v) {
         throw new Test262Error('Test262:AsyncTestFailure')
       }
     }
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+      "a doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "a"),
+      "a doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "a", {
       value: undefined,
@@ -61,8 +73,14 @@ C.m().next().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+      "b doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "b"),
+      "b doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "b", {
       value: 42,
@@ -71,8 +89,14 @@ C.m().next().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+      "c doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "c"),
+      "c doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "c", {
       value: fn,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-gen-private-field-usage.js b/test/language/expressions/class/elements/after-same-line-static-async-gen-private-field-usage.js
index cf975984c4..cd188a66c9 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-gen-private-field-usage.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-gen-private-field-usage.js
@@ -31,8 +31,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-gen-private-method-getter-usage.js b/test/language/expressions/class/elements/after-same-line-static-async-gen-private-method-getter-usage.js
index 2af857a307..cf41e843fa 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-gen-private-method-getter-usage.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-gen-private-method-getter-usage.js
@@ -31,8 +31,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-gen-private-method-usage.js b/test/language/expressions/class/elements/after-same-line-static-async-gen-private-method-usage.js
index 875a4d9390..6150e3e6a0 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-gen-private-method-usage.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-gen-private-method-usage.js
@@ -31,8 +31,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-gen-private-names.js b/test/language/expressions/class/elements/after-same-line-static-async-gen-private-names.js
index 55ab85a600..8d7d09ddd1 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-gen-private-names.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-gen-private-names.js
@@ -38,8 +38,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -59,21 +65,21 @@ C.m().next().then(function(v) {
       }
     }
     // Test the private fields do not appear as properties before set to value
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
     // Test if private fields can be sucessfully accessed and set to value
     assert.sameValue(c.x(), 42, "test 7");
     assert.sameValue(c.y(), 43, "test 8");
 
     // Test the private fields do not appear as properties before after set to value
-    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 9");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 10");
   }
 
   return Promise.resolve(assertions());
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-field-identifier-initializer.js b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-field-identifier-initializer.js
index 007b5d53f2..fcd0b91afe 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-field-identifier-initializer.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-field-identifier-initializer.js
@@ -64,8 +64,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-field-identifier.js b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-field-identifier.js
index 791b6c11bb..033c4d792d 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-field-identifier.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-field-identifier.js
@@ -64,8 +64,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-private-getter-alt.js b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-private-getter-alt.js
index cdad08a6bc..1019c643f9 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-private-getter-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-private-getter-alt.js
@@ -105,8 +105,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-private-getter.js b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-private-getter.js
index 014078b56a..668c37198a 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-private-getter.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-private-getter.js
@@ -105,8 +105,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-private-method-alt.js b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-private-method-alt.js
index 92fff639eb..603a541f87 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-private-method-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-private-method-alt.js
@@ -104,8 +104,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-private-method.js b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-private-method.js
index 226165f692..94f8018055 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-private-method.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-private-method.js
@@ -104,8 +104,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-private-setter-alt.js b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-private-setter-alt.js
index f54caf05a6..e6c75fe526 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-private-setter-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-private-setter-alt.js
@@ -104,8 +104,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-private-setter.js b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-private-setter.js
index ac15e2565c..b86d53f59d 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-private-setter.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-private-setter.js
@@ -104,8 +104,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-privatename-identifier-alt.js b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-privatename-identifier-alt.js
index 6cef6a9f0c..8646d290d7 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-privatename-identifier-alt.js
@@ -85,8 +85,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-privatename-identifier-initializer-alt.js b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-privatename-identifier-initializer-alt.js
index a7fe02c910..23e383796a 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-privatename-identifier-initializer-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-privatename-identifier-initializer-alt.js
@@ -79,8 +79,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-privatename-identifier-initializer.js b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-privatename-identifier-initializer.js
index 985c532513..c2929e97c1 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-privatename-identifier-initializer.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-privatename-identifier-initializer.js
@@ -79,8 +79,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-privatename-identifier.js b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-privatename-identifier.js
index c4053ff2ed..2e3b5696b3 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-privatename-identifier.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-privatename-identifier.js
@@ -85,8 +85,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-async-generator-method-privatename-identifier-alt.js
index e5ace9fd54..cbb5e0046d 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -101,8 +101,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-async-generator-method-privatename-identifier.js b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-async-generator-method-privatename-identifier.js
index f330348271..7540cefb12 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-async-generator-method-privatename-identifier.js
@@ -101,8 +101,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-async-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-async-method-privatename-identifier-alt.js
index d0e175a391..056b7d6325 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-async-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-async-method-privatename-identifier-alt.js
@@ -101,8 +101,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-async-method-privatename-identifier.js b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-async-method-privatename-identifier.js
index 4a538cdf15..b3c808a0c0 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-async-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-async-method-privatename-identifier.js
@@ -101,8 +101,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-generator-method-privatename-identifier-alt.js
index 5161aded6d..9e4cc92793 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-generator-method-privatename-identifier-alt.js
@@ -101,8 +101,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-generator-method-privatename-identifier.js b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-generator-method-privatename-identifier.js
index b9caa6db39..299ee8d0ba 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-generator-method-privatename-identifier.js
@@ -101,8 +101,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-method-privatename-identifier-alt.js
index 8cb531081a..92f3eb96b9 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-method-privatename-identifier-alt.js
@@ -98,8 +98,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-method-privatename-identifier.js b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-method-privatename-identifier.js
index 50f2ec9d6d..d0a0c49875 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-method-privatename-identifier.js
@@ -98,8 +98,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-alt-by-classname.js b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-alt-by-classname.js
index 17f15f4fd7..d8d2ef3591 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-alt-by-classname.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-alt-by-classname.js
@@ -86,8 +86,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-alt.js b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-alt.js
index 7325b1597d..ee30da7f5e 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-alt.js
@@ -86,8 +86,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-by-classname.js b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-by-classname.js
index 3acb4a6cd5..1453faa17e 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-by-classname.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-by-classname.js
@@ -86,8 +86,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
index f8c3a7b827..7b439ba86c 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
@@ -80,8 +80,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-initializer-alt.js b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-initializer-alt.js
index d76b1933f5..a6c641fbc8 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-initializer-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-initializer-alt.js
@@ -80,8 +80,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-initializer.js b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-initializer.js
index a7bba8bf71..11560e00ed 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-initializer.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-initializer.js
@@ -80,8 +80,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier.js b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier.js
index 8a8c30fa79..5d784075c3 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier.js
@@ -86,8 +86,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-gen-static-private-fields.js b/test/language/expressions/class/elements/after-same-line-static-async-gen-static-private-fields.js
index 3c8bf8ba83..722ee32a6d 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-gen-static-private-fields.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-gen-static-private-fields.js
@@ -38,8 +38,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -59,21 +65,21 @@ C.m().next().then(function(v) {
       }
     }
     // Test the private fields do not appear as properties before set to value
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
     // Test if private fields can be sucessfully accessed and set to value
     assert.sameValue(C.x(), 42, "test 7");
     assert.sameValue(C.y(), 43, "test 8");
 
     // Test the private fields do not appear as properties before after set to value
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
   }
 
   return Promise.resolve(assertions());
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-gen-static-private-methods-with-fields.js b/test/language/expressions/class/elements/after-same-line-static-async-gen-static-private-methods-with-fields.js
index c1fd029870..6fed9f29c4 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-gen-static-private-methods-with-fields.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-gen-static-private-methods-with-fields.js
@@ -44,8 +44,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -65,32 +71,32 @@ C.m().next().then(function(v) {
       }
     }
     // Test the private methods do not appear as properties before set to value
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#xVal"), "test 7");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 8");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#xVal"), "test 9");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#yVal"), "test 10");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 11");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#yVal"), "test 12");
 
     // Test if private fields can be sucessfully accessed and set to value
     assert.sameValue(C.x(), 42, "test 13");
     assert.sameValue(C.y(), 43, "test 14");
 
     // Test the private fields do not appear as properties before after set to value
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 15");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 16");
 
-    assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 17");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 18");
   }
 
   return Promise.resolve(assertions());
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-gen-static-private-methods.js b/test/language/expressions/class/elements/after-same-line-static-async-gen-static-private-methods.js
index a9498b7202..04cac1cfe2 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-gen-static-private-methods.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-gen-static-private-methods.js
@@ -42,8 +42,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -63,21 +69,21 @@ C.m().next().then(function(v) {
       }
     }
     // Test the private methods do not appear as properties before set to value
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
     // Test if private fields can be sucessfully accessed and set to value
     assert.sameValue(C.x(), 42, "test 7");
     assert.sameValue(C.y(), 86, "test 8");
 
     // Test the private fields do not appear as properties before after set to value
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
   }
 
   return Promise.resolve(assertions());
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-gen-string-literal-names.js b/test/language/expressions/class/elements/after-same-line-static-async-gen-string-literal-names.js
index 4b2df445c1..385d624d98 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-gen-string-literal-names.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-gen-string-literal-names.js
@@ -29,8 +29,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -49,8 +55,14 @@ C.m().next().then(function(v) {
         throw new Test262Error('Test262:AsyncTestFailure')
       }
     }
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+      "a does not appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "a"),
+      "a does not appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "a", {
       value: undefined,
@@ -59,8 +71,14 @@ C.m().next().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+      "b does not appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "b"),
+      "b does not appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "b", {
       value: undefined,
@@ -69,8 +87,14 @@ C.m().next().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+      "c does not appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "c"),
+      "c does not appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "c", {
       value: 39,
@@ -79,8 +103,14 @@ C.m().next().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "d"),
+      "d does not appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "d"),
+      "d does not appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "d", {
       value: 42,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-method-computed-names.js b/test/language/expressions/class/elements/after-same-line-static-async-method-computed-names.js
index 8c271e4d3e..0b6381d43e 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-method-computed-names.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-method-computed-names.js
@@ -30,8 +30,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -49,8 +55,14 @@ C.m().then(function(v) {
         throw new Test262Error('Test262:AsyncTestFailure')
       }
     }
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+      "b doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "b"),
+      "b doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "b", {
       value: 42,
@@ -59,12 +71,27 @@ C.m().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-    assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+      "x doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "x"),
+      "x doesn't appear as an own property on C constructor"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(c, "x"),
+      "x doesn't appear as an own property on C instance"
+    );
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "10"),
+      "10 doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "10"),
+      "10 doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "10", {
       value: "meep",
@@ -73,8 +100,14 @@ C.m().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "not initialized"),
+      "'not initialized' doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "not initialized"),
+      "'not initialized' doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "not initialized", {
       value: undefined,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-method-computed-symbol-names.js b/test/language/expressions/class/elements/after-same-line-static-async-method-computed-symbol-names.js
index 0ed4886086..8c98041bbe 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-method-computed-symbol-names.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-method-computed-symbol-names.js
@@ -31,8 +31,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -50,8 +56,14 @@ C.m().then(function(v) {
         throw new Test262Error('Test262:AsyncTestFailure')
       }
     }
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, x), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, x), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, x),
+      "Symbol x doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, x),
+      "Symbol x doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, x, {
       value: undefined,
@@ -60,8 +72,14 @@ C.m().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, y), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, y),
+      "Symbol y doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, y),
+      "Symbol y doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, y, {
       value: 42,
@@ -70,13 +88,31 @@ C.m().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-    assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+      "x doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "x"),
+      "x doesn't appear as an own property on C constructor"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(c, "x"),
+      "x doesn't appear as an own property on C instance"
+    );
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
-    assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "y"),
+      "y doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "y"),
+      "y doesn't appear as an own property on C constructor"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(c, "y"),
+      "y doesn't appear as an own property on C instance"
+    );
   }
 
   return Promise.resolve(assertions());
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-method-grammar-privatename-identifier-semantics-stringvalue.js b/test/language/expressions/class/elements/after-same-line-static-async-method-grammar-privatename-identifier-semantics-stringvalue.js
index fe9e93a22b..126e4cf518 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-method-grammar-privatename-identifier-semantics-stringvalue.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-method-grammar-privatename-identifier-semantics-stringvalue.js
@@ -88,8 +88,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-method-literal-names-asi.js b/test/language/expressions/class/elements/after-same-line-static-async-method-literal-names-asi.js
index 3c79aa5b22..1917531dce 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-method-literal-names-asi.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-method-literal-names-asi.js
@@ -29,8 +29,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -48,8 +54,14 @@ C.m().then(function(v) {
         throw new Test262Error('Test262:AsyncTestFailure')
       }
     }
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+      "a doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "a"),
+      "a doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "a", {
       value: undefined,
@@ -58,8 +70,14 @@ C.m().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+      "b doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "b"),
+      "b doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "b", {
       value: 42,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-method-literal-names.js b/test/language/expressions/class/elements/after-same-line-static-async-method-literal-names.js
index 6d08152c36..a4d650bd35 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-method-literal-names.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-method-literal-names.js
@@ -31,8 +31,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -50,8 +56,14 @@ C.m().then(function(v) {
         throw new Test262Error('Test262:AsyncTestFailure')
       }
     }
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+      "a doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "a"),
+      "a doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "a", {
       value: undefined,
@@ -60,8 +72,14 @@ C.m().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+      "b doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "b"),
+      "b doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "b", {
       value: 42,
@@ -70,8 +88,14 @@ C.m().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+      "c doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "c"),
+      "c doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "c", {
       value: fn,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-method-private-field-usage.js b/test/language/expressions/class/elements/after-same-line-static-async-method-private-field-usage.js
index c5c2e23dcf..5154d05ba0 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-method-private-field-usage.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-method-private-field-usage.js
@@ -31,8 +31,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-method-private-method-getter-usage.js b/test/language/expressions/class/elements/after-same-line-static-async-method-private-method-getter-usage.js
index 1411776d63..23a780f251 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-method-private-method-getter-usage.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-method-private-method-getter-usage.js
@@ -31,8 +31,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-method-private-method-usage.js b/test/language/expressions/class/elements/after-same-line-static-async-method-private-method-usage.js
index 7f2c8cd683..d40fa9dcf2 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-method-private-method-usage.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-method-private-method-usage.js
@@ -31,8 +31,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-method-private-names.js b/test/language/expressions/class/elements/after-same-line-static-async-method-private-names.js
index efc019f139..13245fb559 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-method-private-names.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-method-private-names.js
@@ -38,8 +38,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -58,21 +64,21 @@ C.m().then(function(v) {
       }
     }
     // Test the private fields do not appear as properties before set to value
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
     // Test if private fields can be sucessfully accessed and set to value
     assert.sameValue(c.x(), 42, "test 7");
     assert.sameValue(c.y(), 43, "test 8");
 
     // Test the private fields do not appear as properties before after set to value
-    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 9");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 10");
   }
 
   return Promise.resolve(assertions());
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-field-identifier-initializer.js b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-field-identifier-initializer.js
index 354e9accea..c81e193f30 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-field-identifier-initializer.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-field-identifier-initializer.js
@@ -64,8 +64,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-field-identifier.js b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-field-identifier.js
index ca05495660..5dad578bd2 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-field-identifier.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-field-identifier.js
@@ -64,8 +64,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-private-getter-alt.js b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-private-getter-alt.js
index 05fc165b5f..f78f939d14 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-private-getter-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-private-getter-alt.js
@@ -105,8 +105,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-private-getter.js b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-private-getter.js
index f202229df1..860be86561 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-private-getter.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-private-getter.js
@@ -105,8 +105,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-private-method-alt.js b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-private-method-alt.js
index 385f86f1cd..ac34e0ad57 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-private-method-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-private-method-alt.js
@@ -104,8 +104,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-private-method.js b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-private-method.js
index f27374e8ee..7a1cf65fc7 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-private-method.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-private-method.js
@@ -104,8 +104,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-private-setter-alt.js b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-private-setter-alt.js
index 48b86289c0..f5a5015dea 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-private-setter-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-private-setter-alt.js
@@ -104,8 +104,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-private-setter.js b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-private-setter.js
index e6952f5a78..f5e66d99ff 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-private-setter.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-private-setter.js
@@ -104,8 +104,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-privatename-identifier-alt.js b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-privatename-identifier-alt.js
index 7dac782ad2..35a5357edc 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-privatename-identifier-alt.js
@@ -85,8 +85,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-privatename-identifier-initializer-alt.js b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-privatename-identifier-initializer-alt.js
index 75b3fad4cc..db3c6b52f2 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-privatename-identifier-initializer-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-privatename-identifier-initializer-alt.js
@@ -79,8 +79,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-privatename-identifier-initializer.js b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-privatename-identifier-initializer.js
index 905da743b8..0a6fb5ed04 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-privatename-identifier-initializer.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-privatename-identifier-initializer.js
@@ -79,8 +79,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-privatename-identifier.js b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-privatename-identifier.js
index 61f43971c7..ed9175da2f 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-privatename-identifier.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-privatename-identifier.js
@@ -85,8 +85,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-async-generator-method-privatename-identifier-alt.js
index 3af6641540..702176cf9a 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -101,8 +101,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-async-generator-method-privatename-identifier.js b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-async-generator-method-privatename-identifier.js
index ec688b74ba..b76a4fd350 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-async-generator-method-privatename-identifier.js
@@ -101,8 +101,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-async-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-async-method-privatename-identifier-alt.js
index 368ae25aae..cd9340df2b 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-async-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-async-method-privatename-identifier-alt.js
@@ -101,8 +101,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-async-method-privatename-identifier.js b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-async-method-privatename-identifier.js
index a88245db6c..8aa8ef474d 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-async-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-async-method-privatename-identifier.js
@@ -101,8 +101,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-generator-method-privatename-identifier-alt.js
index 4663b171b8..bf105197a0 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-generator-method-privatename-identifier-alt.js
@@ -101,8 +101,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-generator-method-privatename-identifier.js b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-generator-method-privatename-identifier.js
index 561a29b6b9..67163768ec 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-generator-method-privatename-identifier.js
@@ -101,8 +101,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-method-privatename-identifier-alt.js
index 592a849986..acffded0a4 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-method-privatename-identifier-alt.js
@@ -98,8 +98,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-method-privatename-identifier.js b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-method-privatename-identifier.js
index d90c72b740..e3c56b666e 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-method-privatename-identifier.js
@@ -98,8 +98,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-alt-by-classname.js b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-alt-by-classname.js
index 1b756dc843..be7d570544 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-alt-by-classname.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-alt-by-classname.js
@@ -86,8 +86,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-alt.js b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-alt.js
index 8108517fa1..51c2def06c 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-alt.js
@@ -86,8 +86,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-by-classname.js b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-by-classname.js
index 9129c6c320..4bb737f798 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-by-classname.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-by-classname.js
@@ -86,8 +86,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-initializer-alt-by-classname.js b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
index a137bc1380..2293846e98 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
@@ -80,8 +80,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-initializer-alt.js b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-initializer-alt.js
index 325fe4c07e..b40d8ebbd5 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-initializer-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-initializer-alt.js
@@ -80,8 +80,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-initializer.js b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-initializer.js
index c02b6905ce..e38920f79b 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-initializer.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-initializer.js
@@ -80,8 +80,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier.js b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier.js
index 2829853591..3ea62c97f3 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier.js
@@ -86,8 +86,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-method-static-private-fields.js b/test/language/expressions/class/elements/after-same-line-static-async-method-static-private-fields.js
index ccfc4bdcd4..a9c0e177ef 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-method-static-private-fields.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-method-static-private-fields.js
@@ -38,8 +38,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -58,21 +64,21 @@ C.m().then(function(v) {
       }
     }
     // Test the private fields do not appear as properties before set to value
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
     // Test if private fields can be sucessfully accessed and set to value
     assert.sameValue(C.x(), 42, "test 7");
     assert.sameValue(C.y(), 43, "test 8");
 
     // Test the private fields do not appear as properties before after set to value
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
   }
 
   return Promise.resolve(assertions());
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-method-static-private-methods-with-fields.js b/test/language/expressions/class/elements/after-same-line-static-async-method-static-private-methods-with-fields.js
index 2d692275eb..04e0e46cef 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-method-static-private-methods-with-fields.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-method-static-private-methods-with-fields.js
@@ -44,8 +44,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -64,32 +70,32 @@ C.m().then(function(v) {
       }
     }
     // Test the private methods do not appear as properties before set to value
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#xVal"), "test 7");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 8");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#xVal"), "test 9");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#yVal"), "test 10");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 11");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#yVal"), "test 12");
 
     // Test if private fields can be sucessfully accessed and set to value
     assert.sameValue(C.x(), 42, "test 13");
     assert.sameValue(C.y(), 43, "test 14");
 
     // Test the private fields do not appear as properties before after set to value
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 15");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 16");
 
-    assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 17");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 18");
   }
 
   return Promise.resolve(assertions());
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-method-static-private-methods.js b/test/language/expressions/class/elements/after-same-line-static-async-method-static-private-methods.js
index 0eac2a7c1c..5966bb3feb 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-method-static-private-methods.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-method-static-private-methods.js
@@ -42,8 +42,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -62,21 +68,21 @@ C.m().then(function(v) {
       }
     }
     // Test the private methods do not appear as properties before set to value
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
     // Test if private fields can be sucessfully accessed and set to value
     assert.sameValue(C.x(), 42, "test 7");
     assert.sameValue(C.y(), 86, "test 8");
 
     // Test the private fields do not appear as properties before after set to value
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
   }
 
   return Promise.resolve(assertions());
diff --git a/test/language/expressions/class/elements/after-same-line-static-async-method-string-literal-names.js b/test/language/expressions/class/elements/after-same-line-static-async-method-string-literal-names.js
index f8f4311e02..a79c0b1d6c 100644
--- a/test/language/expressions/class/elements/after-same-line-static-async-method-string-literal-names.js
+++ b/test/language/expressions/class/elements/after-same-line-static-async-method-string-literal-names.js
@@ -29,8 +29,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -48,8 +54,14 @@ C.m().then(function(v) {
         throw new Test262Error('Test262:AsyncTestFailure')
       }
     }
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+      "a does not appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "a"),
+      "a does not appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "a", {
       value: undefined,
@@ -58,8 +70,14 @@ C.m().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+      "b does not appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "b"),
+      "b does not appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "b", {
       value: undefined,
@@ -68,8 +86,14 @@ C.m().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+      "c does not appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "c"),
+      "c does not appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "c", {
       value: 39,
@@ -78,8 +102,14 @@ C.m().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "d"),
+      "d does not appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "d"),
+      "d does not appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "d", {
       value: 42,
diff --git a/test/language/expressions/class/elements/after-same-line-static-gen-computed-names.js b/test/language/expressions/class/elements/after-same-line-static-gen-computed-names.js
index e178389b00..67e1ad7a38 100644
--- a/test/language/expressions/class/elements/after-same-line-static-gen-computed-names.js
+++ b/test/language/expressions/class/elements/after-same-line-static-gen-computed-names.js
@@ -31,8 +31,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -40,8 +46,14 @@ verifyProperty(C, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -50,12 +62,27 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "10"),
+  "10 doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "10"),
+  "10 doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "10", {
   value: "meep",
@@ -64,8 +91,14 @@ verifyProperty(c, "10", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "not initialized", {
   value: undefined,
diff --git a/test/language/expressions/class/elements/after-same-line-static-gen-computed-symbol-names.js b/test/language/expressions/class/elements/after-same-line-static-gen-computed-symbol-names.js
index eb4921af13..b155f7ab47 100644
--- a/test/language/expressions/class/elements/after-same-line-static-gen-computed-symbol-names.js
+++ b/test/language/expressions/class/elements/after-same-line-static-gen-computed-symbol-names.js
@@ -32,8 +32,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -41,8 +47,14 @@ verifyProperty(C, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, x), false);
-assert.sameValue(Object.hasOwnProperty.call(C, x), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, x),
+  "Symbol x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, x),
+  "Symbol x doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, x, {
   value: undefined,
@@ -51,8 +63,14 @@ verifyProperty(c, x, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
-assert.sameValue(Object.hasOwnProperty.call(C, y), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, y),
+  "Symbol y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, y),
+  "Symbol y doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, y, {
   value: 42,
@@ -61,10 +79,28 @@ verifyProperty(c, y, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "y"),
+  "y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "y"),
+  "y doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "y"),
+  "y doesn't appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/after-same-line-static-gen-grammar-privatename-identifier-semantics-stringvalue.js b/test/language/expressions/class/elements/after-same-line-static-gen-grammar-privatename-identifier-semantics-stringvalue.js
index b1519e1759..aebc383d12 100644
--- a/test/language/expressions/class/elements/after-same-line-static-gen-grammar-privatename-identifier-semantics-stringvalue.js
+++ b/test/language/expressions/class/elements/after-same-line-static-gen-grammar-privatename-identifier-semantics-stringvalue.js
@@ -89,8 +89,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-gen-literal-names-asi.js b/test/language/expressions/class/elements/after-same-line-static-gen-literal-names-asi.js
index fcd7876560..f09b0c4959 100644
--- a/test/language/expressions/class/elements/after-same-line-static-gen-literal-names-asi.js
+++ b/test/language/expressions/class/elements/after-same-line-static-gen-literal-names-asi.js
@@ -30,8 +30,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -39,8 +45,14 @@ verifyProperty(C, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -49,8 +61,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
diff --git a/test/language/expressions/class/elements/after-same-line-static-gen-literal-names.js b/test/language/expressions/class/elements/after-same-line-static-gen-literal-names.js
index cb64e1b5d2..133bf2aac8 100644
--- a/test/language/expressions/class/elements/after-same-line-static-gen-literal-names.js
+++ b/test/language/expressions/class/elements/after-same-line-static-gen-literal-names.js
@@ -32,8 +32,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -41,8 +47,14 @@ verifyProperty(C, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -51,8 +63,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -61,8 +79,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: fn,
diff --git a/test/language/expressions/class/elements/after-same-line-static-gen-private-field-usage.js b/test/language/expressions/class/elements/after-same-line-static-gen-private-field-usage.js
index 0b21d6168a..e716c47be2 100644
--- a/test/language/expressions/class/elements/after-same-line-static-gen-private-field-usage.js
+++ b/test/language/expressions/class/elements/after-same-line-static-gen-private-field-usage.js
@@ -32,8 +32,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-gen-private-method-getter-usage.js b/test/language/expressions/class/elements/after-same-line-static-gen-private-method-getter-usage.js
index 14b6edc253..0152034ab1 100644
--- a/test/language/expressions/class/elements/after-same-line-static-gen-private-method-getter-usage.js
+++ b/test/language/expressions/class/elements/after-same-line-static-gen-private-method-getter-usage.js
@@ -32,8 +32,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-gen-private-method-usage.js b/test/language/expressions/class/elements/after-same-line-static-gen-private-method-usage.js
index c463f976b8..685d698f61 100644
--- a/test/language/expressions/class/elements/after-same-line-static-gen-private-method-usage.js
+++ b/test/language/expressions/class/elements/after-same-line-static-gen-private-method-usage.js
@@ -32,8 +32,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-gen-private-names.js b/test/language/expressions/class/elements/after-same-line-static-gen-private-names.js
index 6fc45c5b20..34e8b431ec 100644
--- a/test/language/expressions/class/elements/after-same-line-static-gen-private-names.js
+++ b/test/language/expressions/class/elements/after-same-line-static-gen-private-names.js
@@ -39,8 +39,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -49,18 +55,18 @@ verifyProperty(C, "m", {
 });
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(c.x(), 42, "test 7");
 assert.sameValue(c.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 10");
diff --git a/test/language/expressions/class/elements/after-same-line-static-gen-rs-field-identifier-initializer.js b/test/language/expressions/class/elements/after-same-line-static-gen-rs-field-identifier-initializer.js
index 3b34f4ecca..3f512c0240 100644
--- a/test/language/expressions/class/elements/after-same-line-static-gen-rs-field-identifier-initializer.js
+++ b/test/language/expressions/class/elements/after-same-line-static-gen-rs-field-identifier-initializer.js
@@ -65,8 +65,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-gen-rs-field-identifier.js b/test/language/expressions/class/elements/after-same-line-static-gen-rs-field-identifier.js
index 1b4a7f57c7..5a35769218 100644
--- a/test/language/expressions/class/elements/after-same-line-static-gen-rs-field-identifier.js
+++ b/test/language/expressions/class/elements/after-same-line-static-gen-rs-field-identifier.js
@@ -65,8 +65,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-gen-rs-private-getter-alt.js b/test/language/expressions/class/elements/after-same-line-static-gen-rs-private-getter-alt.js
index b592bbb8eb..22c2844373 100644
--- a/test/language/expressions/class/elements/after-same-line-static-gen-rs-private-getter-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-static-gen-rs-private-getter-alt.js
@@ -106,8 +106,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-gen-rs-private-getter.js b/test/language/expressions/class/elements/after-same-line-static-gen-rs-private-getter.js
index 91628960ff..1fbd3114ed 100644
--- a/test/language/expressions/class/elements/after-same-line-static-gen-rs-private-getter.js
+++ b/test/language/expressions/class/elements/after-same-line-static-gen-rs-private-getter.js
@@ -106,8 +106,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-gen-rs-private-method-alt.js b/test/language/expressions/class/elements/after-same-line-static-gen-rs-private-method-alt.js
index 4c5bf152b8..98a547caac 100644
--- a/test/language/expressions/class/elements/after-same-line-static-gen-rs-private-method-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-static-gen-rs-private-method-alt.js
@@ -105,8 +105,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-gen-rs-private-method.js b/test/language/expressions/class/elements/after-same-line-static-gen-rs-private-method.js
index 40724f7b0d..3a5c1a575b 100644
--- a/test/language/expressions/class/elements/after-same-line-static-gen-rs-private-method.js
+++ b/test/language/expressions/class/elements/after-same-line-static-gen-rs-private-method.js
@@ -105,8 +105,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-gen-rs-private-setter-alt.js b/test/language/expressions/class/elements/after-same-line-static-gen-rs-private-setter-alt.js
index d6a23b9c7a..4d5452a113 100644
--- a/test/language/expressions/class/elements/after-same-line-static-gen-rs-private-setter-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-static-gen-rs-private-setter-alt.js
@@ -105,8 +105,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-gen-rs-private-setter.js b/test/language/expressions/class/elements/after-same-line-static-gen-rs-private-setter.js
index b5265b7823..30b0eafbdc 100644
--- a/test/language/expressions/class/elements/after-same-line-static-gen-rs-private-setter.js
+++ b/test/language/expressions/class/elements/after-same-line-static-gen-rs-private-setter.js
@@ -105,8 +105,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-gen-rs-privatename-identifier-alt.js b/test/language/expressions/class/elements/after-same-line-static-gen-rs-privatename-identifier-alt.js
index ff7b4066a2..6d2600cce7 100644
--- a/test/language/expressions/class/elements/after-same-line-static-gen-rs-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-static-gen-rs-privatename-identifier-alt.js
@@ -86,8 +86,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-gen-rs-privatename-identifier-initializer-alt.js b/test/language/expressions/class/elements/after-same-line-static-gen-rs-privatename-identifier-initializer-alt.js
index 8e6e1275e6..7d17c471be 100644
--- a/test/language/expressions/class/elements/after-same-line-static-gen-rs-privatename-identifier-initializer-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-static-gen-rs-privatename-identifier-initializer-alt.js
@@ -80,8 +80,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-gen-rs-privatename-identifier-initializer.js b/test/language/expressions/class/elements/after-same-line-static-gen-rs-privatename-identifier-initializer.js
index 3fe74b3e3c..ffd0c00b67 100644
--- a/test/language/expressions/class/elements/after-same-line-static-gen-rs-privatename-identifier-initializer.js
+++ b/test/language/expressions/class/elements/after-same-line-static-gen-rs-privatename-identifier-initializer.js
@@ -80,8 +80,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-gen-rs-privatename-identifier.js b/test/language/expressions/class/elements/after-same-line-static-gen-rs-privatename-identifier.js
index 32760ab46f..a2c80911ab 100644
--- a/test/language/expressions/class/elements/after-same-line-static-gen-rs-privatename-identifier.js
+++ b/test/language/expressions/class/elements/after-same-line-static-gen-rs-privatename-identifier.js
@@ -86,8 +86,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-async-generator-method-privatename-identifier-alt.js
index c7fcb0e803..b676360854 100644
--- a/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -102,8 +102,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-async-generator-method-privatename-identifier.js b/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-async-generator-method-privatename-identifier.js
index 58a5172bb4..213ae5dec4 100644
--- a/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-async-generator-method-privatename-identifier.js
@@ -102,8 +102,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-async-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-async-method-privatename-identifier-alt.js
index f4c1e3f3f5..2e139488a1 100644
--- a/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-async-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-async-method-privatename-identifier-alt.js
@@ -102,8 +102,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-async-method-privatename-identifier.js b/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-async-method-privatename-identifier.js
index 541a07cbf6..3a83f96e7f 100644
--- a/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-async-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-async-method-privatename-identifier.js
@@ -102,8 +102,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-generator-method-privatename-identifier-alt.js
index 2466c36764..f1ad050095 100644
--- a/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-generator-method-privatename-identifier-alt.js
@@ -102,8 +102,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-generator-method-privatename-identifier.js b/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-generator-method-privatename-identifier.js
index 949fcb2e0a..d7185ce85b 100644
--- a/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-generator-method-privatename-identifier.js
@@ -102,8 +102,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-method-privatename-identifier-alt.js
index 50f366d1fb..9a15ac2418 100644
--- a/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-method-privatename-identifier-alt.js
@@ -99,8 +99,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-method-privatename-identifier.js b/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-method-privatename-identifier.js
index 82d4fe62df..4bad479d2d 100644
--- a/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-method-privatename-identifier.js
@@ -99,8 +99,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-alt-by-classname.js b/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-alt-by-classname.js
index ffe8cf6865..238204e2e5 100644
--- a/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-alt-by-classname.js
+++ b/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-alt-by-classname.js
@@ -87,8 +87,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-alt.js b/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-alt.js
index 42ef467fd5..6fe975dad1 100644
--- a/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-alt.js
@@ -87,8 +87,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-by-classname.js b/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-by-classname.js
index 2270539e39..f18bae7ceb 100644
--- a/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-by-classname.js
+++ b/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-by-classname.js
@@ -87,8 +87,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js b/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
index 62000a93ea..0193f738c8 100644
--- a/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
+++ b/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
@@ -81,8 +81,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-initializer-alt.js b/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-initializer-alt.js
index 1d6cbbd88b..ed5824b1ff 100644
--- a/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-initializer-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-initializer-alt.js
@@ -81,8 +81,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-initializer.js b/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-initializer.js
index 2fce1b10f3..dc56f83de6 100644
--- a/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-initializer.js
+++ b/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-initializer.js
@@ -81,8 +81,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-privatename-identifier.js b/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-privatename-identifier.js
index 6c9f123d46..b1d770002f 100644
--- a/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-privatename-identifier.js
+++ b/test/language/expressions/class/elements/after-same-line-static-gen-rs-static-privatename-identifier.js
@@ -87,8 +87,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-gen-static-private-fields.js b/test/language/expressions/class/elements/after-same-line-static-gen-static-private-fields.js
index b8b570fb08..fc16812cd3 100644
--- a/test/language/expressions/class/elements/after-same-line-static-gen-static-private-fields.js
+++ b/test/language/expressions/class/elements/after-same-line-static-gen-static-private-fields.js
@@ -39,8 +39,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -49,18 +55,18 @@ verifyProperty(C, "m", {
 });
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/expressions/class/elements/after-same-line-static-gen-static-private-methods-with-fields.js b/test/language/expressions/class/elements/after-same-line-static-gen-static-private-methods-with-fields.js
index a056009d4a..2603911328 100644
--- a/test/language/expressions/class/elements/after-same-line-static-gen-static-private-methods-with-fields.js
+++ b/test/language/expressions/class/elements/after-same-line-static-gen-static-private-methods-with-fields.js
@@ -45,8 +45,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -55,29 +61,29 @@ verifyProperty(C, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#xVal"), "test 7");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 8");
+assert(!Object.prototype.hasOwnProperty.call(c, "#xVal"), "test 9");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#yVal"), "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 11");
+assert(!Object.prototype.hasOwnProperty.call(c, "#yVal"), "test 12");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 13");
 assert.sameValue(C.y(), 43, "test 14");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 15");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 16");
 
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 17");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 18");
diff --git a/test/language/expressions/class/elements/after-same-line-static-gen-static-private-methods.js b/test/language/expressions/class/elements/after-same-line-static-gen-static-private-methods.js
index f42f630925..634fc72734 100644
--- a/test/language/expressions/class/elements/after-same-line-static-gen-static-private-methods.js
+++ b/test/language/expressions/class/elements/after-same-line-static-gen-static-private-methods.js
@@ -43,8 +43,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -53,18 +59,18 @@ verifyProperty(C, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/expressions/class/elements/after-same-line-static-gen-string-literal-names.js b/test/language/expressions/class/elements/after-same-line-static-gen-string-literal-names.js
index b85dd3ff34..9c78731458 100644
--- a/test/language/expressions/class/elements/after-same-line-static-gen-string-literal-names.js
+++ b/test/language/expressions/class/elements/after-same-line-static-gen-string-literal-names.js
@@ -30,8 +30,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -39,8 +45,14 @@ verifyProperty(C, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -49,8 +61,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: undefined,
@@ -59,8 +77,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: 39,
@@ -69,8 +93,14 @@ verifyProperty(c, "c", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "d"),
+  "d does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "d"),
+  "d does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "d", {
   value: 42,
diff --git a/test/language/expressions/class/elements/after-same-line-static-method-computed-names.js b/test/language/expressions/class/elements/after-same-line-static-method-computed-names.js
index 6d4e53ca6e..0354ed4284 100644
--- a/test/language/expressions/class/elements/after-same-line-static-method-computed-names.js
+++ b/test/language/expressions/class/elements/after-same-line-static-method-computed-names.js
@@ -31,8 +31,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -40,8 +46,14 @@ verifyProperty(C, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -50,12 +62,27 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "10"),
+  "10 doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "10"),
+  "10 doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "10", {
   value: "meep",
@@ -64,8 +91,14 @@ verifyProperty(c, "10", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "not initialized", {
   value: undefined,
diff --git a/test/language/expressions/class/elements/after-same-line-static-method-computed-symbol-names.js b/test/language/expressions/class/elements/after-same-line-static-method-computed-symbol-names.js
index 98b62ad9db..703594b212 100644
--- a/test/language/expressions/class/elements/after-same-line-static-method-computed-symbol-names.js
+++ b/test/language/expressions/class/elements/after-same-line-static-method-computed-symbol-names.js
@@ -32,8 +32,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -41,8 +47,14 @@ verifyProperty(C, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, x), false);
-assert.sameValue(Object.hasOwnProperty.call(C, x), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, x),
+  "Symbol x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, x),
+  "Symbol x doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, x, {
   value: undefined,
@@ -51,8 +63,14 @@ verifyProperty(c, x, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
-assert.sameValue(Object.hasOwnProperty.call(C, y), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, y),
+  "Symbol y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, y),
+  "Symbol y doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, y, {
   value: 42,
@@ -61,10 +79,28 @@ verifyProperty(c, y, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "y"),
+  "y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "y"),
+  "y doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "y"),
+  "y doesn't appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/after-same-line-static-method-grammar-privatename-identifier-semantics-stringvalue.js b/test/language/expressions/class/elements/after-same-line-static-method-grammar-privatename-identifier-semantics-stringvalue.js
index e726aefb0b..171f207837 100644
--- a/test/language/expressions/class/elements/after-same-line-static-method-grammar-privatename-identifier-semantics-stringvalue.js
+++ b/test/language/expressions/class/elements/after-same-line-static-method-grammar-privatename-identifier-semantics-stringvalue.js
@@ -89,8 +89,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-method-literal-names-asi.js b/test/language/expressions/class/elements/after-same-line-static-method-literal-names-asi.js
index 966a20ad85..7d433fc6dc 100644
--- a/test/language/expressions/class/elements/after-same-line-static-method-literal-names-asi.js
+++ b/test/language/expressions/class/elements/after-same-line-static-method-literal-names-asi.js
@@ -30,8 +30,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -39,8 +45,14 @@ verifyProperty(C, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -49,8 +61,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
diff --git a/test/language/expressions/class/elements/after-same-line-static-method-literal-names.js b/test/language/expressions/class/elements/after-same-line-static-method-literal-names.js
index 6cd6c14b76..03903711fd 100644
--- a/test/language/expressions/class/elements/after-same-line-static-method-literal-names.js
+++ b/test/language/expressions/class/elements/after-same-line-static-method-literal-names.js
@@ -32,8 +32,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -41,8 +47,14 @@ verifyProperty(C, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -51,8 +63,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -61,8 +79,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: fn,
diff --git a/test/language/expressions/class/elements/after-same-line-static-method-private-field-usage.js b/test/language/expressions/class/elements/after-same-line-static-method-private-field-usage.js
index a2d0b8a6b7..d7fb77ede5 100644
--- a/test/language/expressions/class/elements/after-same-line-static-method-private-field-usage.js
+++ b/test/language/expressions/class/elements/after-same-line-static-method-private-field-usage.js
@@ -32,8 +32,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-method-private-method-getter-usage.js b/test/language/expressions/class/elements/after-same-line-static-method-private-method-getter-usage.js
index 4138350713..02b5499abe 100644
--- a/test/language/expressions/class/elements/after-same-line-static-method-private-method-getter-usage.js
+++ b/test/language/expressions/class/elements/after-same-line-static-method-private-method-getter-usage.js
@@ -32,8 +32,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-method-private-method-usage.js b/test/language/expressions/class/elements/after-same-line-static-method-private-method-usage.js
index 034d7a6952..2b243df267 100644
--- a/test/language/expressions/class/elements/after-same-line-static-method-private-method-usage.js
+++ b/test/language/expressions/class/elements/after-same-line-static-method-private-method-usage.js
@@ -32,8 +32,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-method-private-names.js b/test/language/expressions/class/elements/after-same-line-static-method-private-names.js
index cd07ec5711..ab5fe3b2e5 100644
--- a/test/language/expressions/class/elements/after-same-line-static-method-private-names.js
+++ b/test/language/expressions/class/elements/after-same-line-static-method-private-names.js
@@ -39,8 +39,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -49,18 +55,18 @@ verifyProperty(C, "m", {
 });
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(c.x(), 42, "test 7");
 assert.sameValue(c.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 10");
diff --git a/test/language/expressions/class/elements/after-same-line-static-method-rs-field-identifier-initializer.js b/test/language/expressions/class/elements/after-same-line-static-method-rs-field-identifier-initializer.js
index c86cebeb80..859c9f4938 100644
--- a/test/language/expressions/class/elements/after-same-line-static-method-rs-field-identifier-initializer.js
+++ b/test/language/expressions/class/elements/after-same-line-static-method-rs-field-identifier-initializer.js
@@ -65,8 +65,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-method-rs-field-identifier.js b/test/language/expressions/class/elements/after-same-line-static-method-rs-field-identifier.js
index 6350d3f8cb..ca8d59aecb 100644
--- a/test/language/expressions/class/elements/after-same-line-static-method-rs-field-identifier.js
+++ b/test/language/expressions/class/elements/after-same-line-static-method-rs-field-identifier.js
@@ -65,8 +65,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-method-rs-private-getter-alt.js b/test/language/expressions/class/elements/after-same-line-static-method-rs-private-getter-alt.js
index ec06d51110..fa5669075f 100644
--- a/test/language/expressions/class/elements/after-same-line-static-method-rs-private-getter-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-static-method-rs-private-getter-alt.js
@@ -106,8 +106,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-method-rs-private-getter.js b/test/language/expressions/class/elements/after-same-line-static-method-rs-private-getter.js
index 71be209577..ad66a7a740 100644
--- a/test/language/expressions/class/elements/after-same-line-static-method-rs-private-getter.js
+++ b/test/language/expressions/class/elements/after-same-line-static-method-rs-private-getter.js
@@ -106,8 +106,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-method-rs-private-method-alt.js b/test/language/expressions/class/elements/after-same-line-static-method-rs-private-method-alt.js
index a651a441c0..115f9a7ed5 100644
--- a/test/language/expressions/class/elements/after-same-line-static-method-rs-private-method-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-static-method-rs-private-method-alt.js
@@ -105,8 +105,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-method-rs-private-method.js b/test/language/expressions/class/elements/after-same-line-static-method-rs-private-method.js
index fe81214ddc..a1fb851e2d 100644
--- a/test/language/expressions/class/elements/after-same-line-static-method-rs-private-method.js
+++ b/test/language/expressions/class/elements/after-same-line-static-method-rs-private-method.js
@@ -105,8 +105,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-method-rs-private-setter-alt.js b/test/language/expressions/class/elements/after-same-line-static-method-rs-private-setter-alt.js
index e1651a051c..25692cc642 100644
--- a/test/language/expressions/class/elements/after-same-line-static-method-rs-private-setter-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-static-method-rs-private-setter-alt.js
@@ -105,8 +105,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-method-rs-private-setter.js b/test/language/expressions/class/elements/after-same-line-static-method-rs-private-setter.js
index c4a99b0d4d..db9d579a4c 100644
--- a/test/language/expressions/class/elements/after-same-line-static-method-rs-private-setter.js
+++ b/test/language/expressions/class/elements/after-same-line-static-method-rs-private-setter.js
@@ -105,8 +105,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-method-rs-privatename-identifier-alt.js b/test/language/expressions/class/elements/after-same-line-static-method-rs-privatename-identifier-alt.js
index 7a9de4b32d..0afaae9db7 100644
--- a/test/language/expressions/class/elements/after-same-line-static-method-rs-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-static-method-rs-privatename-identifier-alt.js
@@ -86,8 +86,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-method-rs-privatename-identifier-initializer-alt.js b/test/language/expressions/class/elements/after-same-line-static-method-rs-privatename-identifier-initializer-alt.js
index 2787a29c4b..4472899ce7 100644
--- a/test/language/expressions/class/elements/after-same-line-static-method-rs-privatename-identifier-initializer-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-static-method-rs-privatename-identifier-initializer-alt.js
@@ -80,8 +80,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-method-rs-privatename-identifier-initializer.js b/test/language/expressions/class/elements/after-same-line-static-method-rs-privatename-identifier-initializer.js
index e1ab6f2e86..e96b6d87cd 100644
--- a/test/language/expressions/class/elements/after-same-line-static-method-rs-privatename-identifier-initializer.js
+++ b/test/language/expressions/class/elements/after-same-line-static-method-rs-privatename-identifier-initializer.js
@@ -80,8 +80,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-method-rs-privatename-identifier.js b/test/language/expressions/class/elements/after-same-line-static-method-rs-privatename-identifier.js
index 3924d3aaab..3df9b79d3e 100644
--- a/test/language/expressions/class/elements/after-same-line-static-method-rs-privatename-identifier.js
+++ b/test/language/expressions/class/elements/after-same-line-static-method-rs-privatename-identifier.js
@@ -86,8 +86,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-method-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/after-same-line-static-method-rs-static-async-generator-method-privatename-identifier-alt.js
index 160af8798b..db13910b3e 100644
--- a/test/language/expressions/class/elements/after-same-line-static-method-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-static-method-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -102,8 +102,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-method-rs-static-async-generator-method-privatename-identifier.js b/test/language/expressions/class/elements/after-same-line-static-method-rs-static-async-generator-method-privatename-identifier.js
index 4aafcef233..1696e225fa 100644
--- a/test/language/expressions/class/elements/after-same-line-static-method-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/after-same-line-static-method-rs-static-async-generator-method-privatename-identifier.js
@@ -102,8 +102,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-method-rs-static-async-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/after-same-line-static-method-rs-static-async-method-privatename-identifier-alt.js
index 351fcf1d79..2965192f6d 100644
--- a/test/language/expressions/class/elements/after-same-line-static-method-rs-static-async-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-static-method-rs-static-async-method-privatename-identifier-alt.js
@@ -102,8 +102,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-method-rs-static-async-method-privatename-identifier.js b/test/language/expressions/class/elements/after-same-line-static-method-rs-static-async-method-privatename-identifier.js
index 4154b6212b..d73ad012b2 100644
--- a/test/language/expressions/class/elements/after-same-line-static-method-rs-static-async-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/after-same-line-static-method-rs-static-async-method-privatename-identifier.js
@@ -102,8 +102,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-method-rs-static-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/after-same-line-static-method-rs-static-generator-method-privatename-identifier-alt.js
index d2171bf728..1205b73052 100644
--- a/test/language/expressions/class/elements/after-same-line-static-method-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-static-method-rs-static-generator-method-privatename-identifier-alt.js
@@ -102,8 +102,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-method-rs-static-generator-method-privatename-identifier.js b/test/language/expressions/class/elements/after-same-line-static-method-rs-static-generator-method-privatename-identifier.js
index 21195ed4f3..2d75240b8f 100644
--- a/test/language/expressions/class/elements/after-same-line-static-method-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/after-same-line-static-method-rs-static-generator-method-privatename-identifier.js
@@ -102,8 +102,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-method-rs-static-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/after-same-line-static-method-rs-static-method-privatename-identifier-alt.js
index 3cbecc9369..8a7d7d3da8 100644
--- a/test/language/expressions/class/elements/after-same-line-static-method-rs-static-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-static-method-rs-static-method-privatename-identifier-alt.js
@@ -99,8 +99,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-method-rs-static-method-privatename-identifier.js b/test/language/expressions/class/elements/after-same-line-static-method-rs-static-method-privatename-identifier.js
index 46f8337c2b..55a0e343d9 100644
--- a/test/language/expressions/class/elements/after-same-line-static-method-rs-static-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/after-same-line-static-method-rs-static-method-privatename-identifier.js
@@ -99,8 +99,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-method-rs-static-privatename-identifier-alt-by-classname.js b/test/language/expressions/class/elements/after-same-line-static-method-rs-static-privatename-identifier-alt-by-classname.js
index 129a555fd7..945030b727 100644
--- a/test/language/expressions/class/elements/after-same-line-static-method-rs-static-privatename-identifier-alt-by-classname.js
+++ b/test/language/expressions/class/elements/after-same-line-static-method-rs-static-privatename-identifier-alt-by-classname.js
@@ -87,8 +87,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-method-rs-static-privatename-identifier-alt.js b/test/language/expressions/class/elements/after-same-line-static-method-rs-static-privatename-identifier-alt.js
index 8dc15ac387..bd7793f204 100644
--- a/test/language/expressions/class/elements/after-same-line-static-method-rs-static-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-static-method-rs-static-privatename-identifier-alt.js
@@ -87,8 +87,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-method-rs-static-privatename-identifier-by-classname.js b/test/language/expressions/class/elements/after-same-line-static-method-rs-static-privatename-identifier-by-classname.js
index a2a13ff4c5..be8322c69c 100644
--- a/test/language/expressions/class/elements/after-same-line-static-method-rs-static-privatename-identifier-by-classname.js
+++ b/test/language/expressions/class/elements/after-same-line-static-method-rs-static-privatename-identifier-by-classname.js
@@ -87,8 +87,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-method-rs-static-privatename-identifier-initializer-alt-by-classname.js b/test/language/expressions/class/elements/after-same-line-static-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
index 7e50f43b98..ad72c12797 100644
--- a/test/language/expressions/class/elements/after-same-line-static-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
+++ b/test/language/expressions/class/elements/after-same-line-static-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
@@ -81,8 +81,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-method-rs-static-privatename-identifier-initializer-alt.js b/test/language/expressions/class/elements/after-same-line-static-method-rs-static-privatename-identifier-initializer-alt.js
index fefcfbb508..839ebd183a 100644
--- a/test/language/expressions/class/elements/after-same-line-static-method-rs-static-privatename-identifier-initializer-alt.js
+++ b/test/language/expressions/class/elements/after-same-line-static-method-rs-static-privatename-identifier-initializer-alt.js
@@ -81,8 +81,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-method-rs-static-privatename-identifier-initializer.js b/test/language/expressions/class/elements/after-same-line-static-method-rs-static-privatename-identifier-initializer.js
index 1463a069ef..efb1cfb06e 100644
--- a/test/language/expressions/class/elements/after-same-line-static-method-rs-static-privatename-identifier-initializer.js
+++ b/test/language/expressions/class/elements/after-same-line-static-method-rs-static-privatename-identifier-initializer.js
@@ -81,8 +81,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-method-rs-static-privatename-identifier.js b/test/language/expressions/class/elements/after-same-line-static-method-rs-static-privatename-identifier.js
index 13c7c389cc..1263db8d25 100644
--- a/test/language/expressions/class/elements/after-same-line-static-method-rs-static-privatename-identifier.js
+++ b/test/language/expressions/class/elements/after-same-line-static-method-rs-static-privatename-identifier.js
@@ -87,8 +87,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/after-same-line-static-method-static-private-fields.js b/test/language/expressions/class/elements/after-same-line-static-method-static-private-fields.js
index 2586f97158..7976d7ae33 100644
--- a/test/language/expressions/class/elements/after-same-line-static-method-static-private-fields.js
+++ b/test/language/expressions/class/elements/after-same-line-static-method-static-private-fields.js
@@ -39,8 +39,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -49,18 +55,18 @@ verifyProperty(C, "m", {
 });
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/expressions/class/elements/after-same-line-static-method-static-private-methods-with-fields.js b/test/language/expressions/class/elements/after-same-line-static-method-static-private-methods-with-fields.js
index 98247050ae..bc8922380c 100644
--- a/test/language/expressions/class/elements/after-same-line-static-method-static-private-methods-with-fields.js
+++ b/test/language/expressions/class/elements/after-same-line-static-method-static-private-methods-with-fields.js
@@ -45,8 +45,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -55,29 +61,29 @@ verifyProperty(C, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#xVal"), "test 7");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 8");
+assert(!Object.prototype.hasOwnProperty.call(c, "#xVal"), "test 9");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#yVal"), "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 11");
+assert(!Object.prototype.hasOwnProperty.call(c, "#yVal"), "test 12");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 13");
 assert.sameValue(C.y(), 43, "test 14");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 15");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 16");
 
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 17");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 18");
diff --git a/test/language/expressions/class/elements/after-same-line-static-method-static-private-methods.js b/test/language/expressions/class/elements/after-same-line-static-method-static-private-methods.js
index 5d4994368e..78fe4f482d 100644
--- a/test/language/expressions/class/elements/after-same-line-static-method-static-private-methods.js
+++ b/test/language/expressions/class/elements/after-same-line-static-method-static-private-methods.js
@@ -43,8 +43,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -53,18 +59,18 @@ verifyProperty(C, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/expressions/class/elements/after-same-line-static-method-string-literal-names.js b/test/language/expressions/class/elements/after-same-line-static-method-string-literal-names.js
index a81c7f7bec..30c5bba3b5 100644
--- a/test/language/expressions/class/elements/after-same-line-static-method-string-literal-names.js
+++ b/test/language/expressions/class/elements/after-same-line-static-method-string-literal-names.js
@@ -30,8 +30,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -39,8 +45,14 @@ verifyProperty(C, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -49,8 +61,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: undefined,
@@ -59,8 +77,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: 39,
@@ -69,8 +93,14 @@ verifyProperty(c, "c", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "d"),
+  "d does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "d"),
+  "d does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "d", {
   value: 42,
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-identifier-spread-strict.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-identifier-spread-strict.js
index dc8fae5a57..6aab422ccd 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-identifier-spread-strict.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-identifier-spread-strict.js
@@ -48,8 +48,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -58,5 +64,11 @@ var iter = C.gen();
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-identifier-strict.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-identifier-strict.js
index 8ce058c1c6..7fad8ec2d6 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-identifier-strict.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-identifier-strict.js
@@ -39,8 +39,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -49,5 +55,11 @@ var iter = C.gen();
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-promise-reject-next-catch.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-promise-reject-next-catch.js
index 7cf9caa824..9394831995 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-promise-reject-next-catch.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-promise-reject-next-catch.js
@@ -34,8 +34,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -55,5 +61,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-promise-reject-next-for-await-of-async-iterator.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-promise-reject-next-for-await-of-async-iterator.js
index 3a5078c0f9..2e0a6eee50 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-promise-reject-next-for-await-of-async-iterator.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-promise-reject-next-for-await-of-async-iterator.js
@@ -39,8 +39,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -61,5 +67,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-promise-reject-next-for-await-of-sync-iterator.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-promise-reject-next-for-await-of-sync-iterator.js
index d14246a5ca..183609e851 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-promise-reject-next-for-await-of-sync-iterator.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-promise-reject-next-for-await-of-sync-iterator.js
@@ -39,8 +39,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -60,5 +66,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-promise-reject-next-yield-star-async-iterator.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-promise-reject-next-yield-star-async-iterator.js
index e3caca2ca2..54bffdf800 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-promise-reject-next-yield-star-async-iterator.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-promise-reject-next-yield-star-async-iterator.js
@@ -38,8 +38,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -59,5 +65,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-promise-reject-next-yield-star-sync-iterator.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-promise-reject-next-yield-star-sync-iterator.js
index 8dd4ae7d77..dcabb50490 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-promise-reject-next-yield-star-sync-iterator.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-promise-reject-next-yield-star-sync-iterator.js
@@ -37,8 +37,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -58,5 +64,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-promise-reject-next.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-promise-reject-next.js
index 03be053f31..1c334889c3 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-promise-reject-next.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-promise-reject-next.js
@@ -34,8 +34,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -55,5 +61,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-spread-arr-multiple.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-spread-arr-multiple.js
index 10701c2996..d63826f601 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-spread-arr-multiple.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-spread-arr-multiple.js
@@ -41,8 +41,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -61,5 +67,11 @@ item.then(({ done, value }) => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-spread-arr-single.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-spread-arr-single.js
index 051a73404c..d9da4db0e7 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-spread-arr-single.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-spread-arr-single.js
@@ -39,8 +39,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -60,5 +66,11 @@ item.then(({ done, value }) => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-spread-obj.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-spread-obj.js
index de3e240e4b..4418c47eae 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-spread-obj.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-spread-obj.js
@@ -43,8 +43,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -63,5 +69,11 @@ item.then(({ done, value }) => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-async-next.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-async-next.js
index 9ae13afa52..26ff00721d 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-async-next.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-async-next.js
@@ -151,8 +151,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -230,5 +236,11 @@ iter.next("next-arg-1").then(v => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-async-return.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-async-return.js
index ffe62ff333..98ac8d68ce 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-async-return.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-async-return.js
@@ -165,8 +165,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -246,5 +252,11 @@ iter.next().then(v => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-async-throw.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-async-throw.js
index 87d0eda7cf..ab9da994da 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-async-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-async-throw.js
@@ -170,8 +170,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -254,5 +260,11 @@ iter.next().then(v => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-expr-abrupt.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-expr-abrupt.js
index eac46893df..08014c07d5 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-expr-abrupt.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-expr-abrupt.js
@@ -46,8 +46,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -65,5 +71,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-get-abrupt.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-get-abrupt.js
index 7029c56050..19800af020 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-get-abrupt.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-get-abrupt.js
@@ -66,8 +66,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -85,5 +91,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-boolean-throw.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-boolean-throw.js
index 89ec007d61..ddb7549282 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-boolean-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-boolean-throw.js
@@ -65,8 +65,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -84,5 +90,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-number-throw.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-number-throw.js
index 4a99bac22d..842c432622 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-number-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-number-throw.js
@@ -65,8 +65,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -84,5 +90,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-object-throw.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-object-throw.js
index 70e7baeed5..68c7fae463 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-object-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-object-throw.js
@@ -65,8 +65,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -84,5 +90,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-string-throw.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-string-throw.js
index c3464ff404..4b420bcf40 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-string-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-string-throw.js
@@ -65,8 +65,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -84,5 +90,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-symbol-throw.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-symbol-throw.js
index 4ae2d74a15..58c5b7ffda 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-symbol-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-symbol-throw.js
@@ -65,8 +65,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -84,5 +90,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-null-sync-get-abrupt.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-null-sync-get-abrupt.js
index 2ecd88a808..0773225fdc 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-null-sync-get-abrupt.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-null-sync-get-abrupt.js
@@ -70,8 +70,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -90,5 +96,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-abrupt.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-abrupt.js
index 4feb8ca988..e5f5eb3a0e 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-abrupt.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-abrupt.js
@@ -62,8 +62,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -81,5 +87,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-boolean-throw.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-boolean-throw.js
index 6bbced4d77..a651cb3b1b 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-boolean-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-boolean-throw.js
@@ -62,8 +62,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -81,5 +87,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-null-throw.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-null-throw.js
index 124044db6e..86deaa41f9 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-null-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-null-throw.js
@@ -62,8 +62,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -81,5 +87,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-number-throw.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-number-throw.js
index 32c32490bf..98c0def373 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-number-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-number-throw.js
@@ -62,8 +62,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -81,5 +87,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-string-throw.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-string-throw.js
index 82d2e5f043..2c7c91f2a6 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-string-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-string-throw.js
@@ -62,8 +62,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -81,5 +87,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-symbol-throw.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-symbol-throw.js
index 0bfd04a600..516d8389f4 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-symbol-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-symbol-throw.js
@@ -62,8 +62,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -81,5 +87,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-undefined-throw.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-undefined-throw.js
index e781f0bf90..64e8ab0233 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-undefined-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-undefined-throw.js
@@ -62,8 +62,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -81,5 +87,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-undefined-sync-get-abrupt.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-undefined-sync-get-abrupt.js
index 638baadc17..14c1294af8 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-undefined-sync-get-abrupt.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-async-undefined-sync-get-abrupt.js
@@ -70,8 +70,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -90,5 +96,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-get-abrupt.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-get-abrupt.js
index 291ec8a6ff..b00f2b5baa 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-get-abrupt.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-get-abrupt.js
@@ -65,8 +65,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -84,5 +90,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-boolean-throw.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-boolean-throw.js
index 7865731e76..7a5472cee0 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-boolean-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-boolean-throw.js
@@ -64,8 +64,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -83,5 +89,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-number-throw.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-number-throw.js
index 0bd1c16d38..6f08caa79e 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-number-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-number-throw.js
@@ -64,8 +64,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -83,5 +89,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-object-throw.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-object-throw.js
index e776365d41..185de8a292 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-object-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-object-throw.js
@@ -64,8 +64,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -83,5 +89,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-string-throw.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-string-throw.js
index dca9889476..ee39a2f81d 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-string-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-string-throw.js
@@ -64,8 +64,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -83,5 +89,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-symbol-throw.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-symbol-throw.js
index 512a1ebd14..e5621ca4c2 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-symbol-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-symbol-throw.js
@@ -64,8 +64,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -83,5 +89,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-abrupt.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-abrupt.js
index 0eceee73ff..09466a899e 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-abrupt.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-abrupt.js
@@ -59,8 +59,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -78,5 +84,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-boolean-throw.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-boolean-throw.js
index f4469eb59b..19bf6d1922 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-boolean-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-boolean-throw.js
@@ -64,8 +64,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -83,5 +89,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-null-throw.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-null-throw.js
index e42fe2ae32..ba77d4c1d6 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-null-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-null-throw.js
@@ -64,8 +64,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -83,5 +89,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-number-throw.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-number-throw.js
index 3732426b8a..0f9eba5dc8 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-number-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-number-throw.js
@@ -64,8 +64,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -83,5 +89,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-string-throw.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-string-throw.js
index b0960e20e9..2e6faaa702 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-string-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-string-throw.js
@@ -64,8 +64,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -83,5 +89,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-symbol-throw.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-symbol-throw.js
index e8d3189c2b..adbbe7315d 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-symbol-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-symbol-throw.js
@@ -64,8 +64,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -83,5 +89,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-undefined-throw.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-undefined-throw.js
index 1fae26f520..f2175af6b6 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-undefined-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-undefined-throw.js
@@ -64,8 +64,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -83,5 +89,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-call-done-get-abrupt.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-call-done-get-abrupt.js
index ce4b4966bd..8f5882e565 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-call-done-get-abrupt.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-call-done-get-abrupt.js
@@ -65,8 +65,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -84,5 +90,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-call-returns-abrupt.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-call-returns-abrupt.js
index 2f8f02e28e..16ecf383fb 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-call-returns-abrupt.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-call-returns-abrupt.js
@@ -57,8 +57,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -76,5 +82,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-call-value-get-abrupt.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-call-value-get-abrupt.js
index 1cce9f4b5c..43098a9b3d 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-call-value-get-abrupt.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-call-value-get-abrupt.js
@@ -67,8 +67,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -86,5 +92,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-get-abrupt.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-get-abrupt.js
index d3082648e4..1f1ef3d763 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-get-abrupt.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-get-abrupt.js
@@ -57,8 +57,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -76,5 +82,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-non-object-ignores-then.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-non-object-ignores-then.js
index 0dd5915ff7..3afb1d8ad1 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-non-object-ignores-then.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-non-object-ignores-then.js
@@ -77,8 +77,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -96,5 +102,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-not-callable-boolean-throw.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-not-callable-boolean-throw.js
index bb85ca50e7..0845807701 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-not-callable-boolean-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-not-callable-boolean-throw.js
@@ -54,8 +54,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -73,5 +79,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-not-callable-null-throw.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-not-callable-null-throw.js
index fbe9e4d974..cb48451ae0 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-not-callable-null-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-not-callable-null-throw.js
@@ -54,8 +54,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -73,5 +79,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-not-callable-number-throw.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-not-callable-number-throw.js
index 6a7b05c8a0..10c9823039 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-not-callable-number-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-not-callable-number-throw.js
@@ -54,8 +54,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -73,5 +79,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-not-callable-object-throw.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-not-callable-object-throw.js
index b88dd570a4..704c2a00cb 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-not-callable-object-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-not-callable-object-throw.js
@@ -54,8 +54,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -73,5 +79,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-not-callable-string-throw.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-not-callable-string-throw.js
index c5597af4a4..dc3c079b87 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-not-callable-string-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-not-callable-string-throw.js
@@ -54,8 +54,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -73,5 +79,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-not-callable-symbol-throw.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-not-callable-symbol-throw.js
index 72c31f73f8..bbd634f697 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-not-callable-symbol-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-not-callable-symbol-throw.js
@@ -54,8 +54,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -73,5 +79,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-not-callable-undefined-throw.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-not-callable-undefined-throw.js
index 8f2e964501..436429ab5a 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-not-callable-undefined-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-not-callable-undefined-throw.js
@@ -54,8 +54,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -73,5 +79,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-then-get-abrupt.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-then-get-abrupt.js
index 480d8c64a8..7b280b54d8 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-then-get-abrupt.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-then-get-abrupt.js
@@ -81,8 +81,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -100,5 +106,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-boolean-fulfillpromise.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-boolean-fulfillpromise.js
index 5d68064b91..744c24f906 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-boolean-fulfillpromise.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-boolean-fulfillpromise.js
@@ -81,8 +81,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -94,5 +100,11 @@ iter.next().then(({ value, done }) => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-null-fulfillpromise.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-null-fulfillpromise.js
index 6082230b17..6da0ed1016 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-null-fulfillpromise.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-null-fulfillpromise.js
@@ -81,8 +81,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -94,5 +100,11 @@ iter.next().then(({ value, done }) => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-number-fulfillpromise.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-number-fulfillpromise.js
index e336c7a19b..6b07ad5339 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-number-fulfillpromise.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-number-fulfillpromise.js
@@ -81,8 +81,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -94,5 +100,11 @@ iter.next().then(({ value, done }) => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-object-fulfillpromise.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-object-fulfillpromise.js
index 6bbc9001a5..532bd3ec17 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-object-fulfillpromise.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-object-fulfillpromise.js
@@ -81,8 +81,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -94,5 +100,11 @@ iter.next().then(({ value, done }) => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-string-fulfillpromise.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-string-fulfillpromise.js
index 110db43d7f..6ed92feb9c 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-string-fulfillpromise.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-string-fulfillpromise.js
@@ -81,8 +81,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -94,5 +100,11 @@ iter.next().then(({ value, done }) => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-symbol-fulfillpromise.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-symbol-fulfillpromise.js
index 3be5426208..4291b6cbba 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-symbol-fulfillpromise.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-symbol-fulfillpromise.js
@@ -81,8 +81,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -94,5 +100,11 @@ iter.next().then(({ value, done }) => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-undefined-fulfillpromise.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-undefined-fulfillpromise.js
index 6f329bf7aa..0b386ecfef 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-undefined-fulfillpromise.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-undefined-fulfillpromise.js
@@ -81,8 +81,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -94,5 +100,11 @@ iter.next().then(({ value, done }) => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-then-returns-abrupt.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-then-returns-abrupt.js
index 4be44dfb0a..7c85ecc9f4 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-then-returns-abrupt.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-next-then-returns-abrupt.js
@@ -81,8 +81,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -100,5 +106,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-sync-next.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-sync-next.js
index ec12b1168e..7ef1b7033a 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-sync-next.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-sync-next.js
@@ -170,8 +170,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -233,5 +239,11 @@ iter.next("next-arg-1").then(v => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-sync-return.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-sync-return.js
index 17f6b18a3c..0c8885d246 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-sync-return.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-sync-return.js
@@ -145,8 +145,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -208,5 +214,11 @@ iter.next().then(v => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-sync-throw.js b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-sync-throw.js
index df527f8585..ba3ce66a32 100644
--- a/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-sync-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method-static/yield-star-sync-throw.js
@@ -148,8 +148,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -214,5 +220,11 @@ iter.next().then(v => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-identifier-spread-strict.js b/test/language/expressions/class/elements/async-gen-private-method/yield-identifier-spread-strict.js
index 47f6e850cf..2ecc393224 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-identifier-spread-strict.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-identifier-spread-strict.js
@@ -50,9 +50,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -61,6 +70,15 @@ var iter = c.gen();
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-identifier-strict.js b/test/language/expressions/class/elements/async-gen-private-method/yield-identifier-strict.js
index 0776625453..8471e24865 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-identifier-strict.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-identifier-strict.js
@@ -41,9 +41,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -52,6 +61,15 @@ var iter = c.gen();
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-promise-reject-next-catch.js b/test/language/expressions/class/elements/async-gen-private-method/yield-promise-reject-next-catch.js
index 25a9f68c2b..b5b1091b25 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-promise-reject-next-catch.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-promise-reject-next-catch.js
@@ -36,9 +36,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -58,6 +67,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-promise-reject-next-for-await-of-async-iterator.js b/test/language/expressions/class/elements/async-gen-private-method/yield-promise-reject-next-for-await-of-async-iterator.js
index a2fd7c9a80..38d89484f4 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-promise-reject-next-for-await-of-async-iterator.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-promise-reject-next-for-await-of-async-iterator.js
@@ -41,9 +41,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -64,6 +73,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-promise-reject-next-for-await-of-sync-iterator.js b/test/language/expressions/class/elements/async-gen-private-method/yield-promise-reject-next-for-await-of-sync-iterator.js
index c878da09a2..fef21f8360 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-promise-reject-next-for-await-of-sync-iterator.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-promise-reject-next-for-await-of-sync-iterator.js
@@ -41,9 +41,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -63,6 +72,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-promise-reject-next-yield-star-async-iterator.js b/test/language/expressions/class/elements/async-gen-private-method/yield-promise-reject-next-yield-star-async-iterator.js
index 44a57ad619..6e9de26825 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-promise-reject-next-yield-star-async-iterator.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-promise-reject-next-yield-star-async-iterator.js
@@ -40,9 +40,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -62,6 +71,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-promise-reject-next-yield-star-sync-iterator.js b/test/language/expressions/class/elements/async-gen-private-method/yield-promise-reject-next-yield-star-sync-iterator.js
index 64a4355042..a29a88db87 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-promise-reject-next-yield-star-sync-iterator.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-promise-reject-next-yield-star-sync-iterator.js
@@ -39,9 +39,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -61,6 +70,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-promise-reject-next.js b/test/language/expressions/class/elements/async-gen-private-method/yield-promise-reject-next.js
index 7ee5e440a8..56fcc1db07 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-promise-reject-next.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-promise-reject-next.js
@@ -36,9 +36,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -58,6 +67,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-spread-arr-multiple.js b/test/language/expressions/class/elements/async-gen-private-method/yield-spread-arr-multiple.js
index 4b4797839d..872f19a50c 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-spread-arr-multiple.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-spread-arr-multiple.js
@@ -43,9 +43,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -64,6 +73,15 @@ item.then(({ done, value }) => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-spread-arr-single.js b/test/language/expressions/class/elements/async-gen-private-method/yield-spread-arr-single.js
index 736e51d097..96dabb64da 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-spread-arr-single.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-spread-arr-single.js
@@ -41,9 +41,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -63,6 +72,15 @@ item.then(({ done, value }) => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-spread-obj.js b/test/language/expressions/class/elements/async-gen-private-method/yield-spread-obj.js
index 5f980b98d9..786bf3e812 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-spread-obj.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-spread-obj.js
@@ -45,9 +45,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -66,6 +75,15 @@ item.then(({ done, value }) => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-async-next.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-async-next.js
index f90d553efc..735e24525c 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-async-next.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-async-next.js
@@ -153,9 +153,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -233,6 +242,15 @@ iter.next("next-arg-1").then(v => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-async-return.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-async-return.js
index a63eaff087..bf41b59b51 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-async-return.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-async-return.js
@@ -167,9 +167,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -249,6 +258,15 @@ iter.next().then(v => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-async-throw.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-async-throw.js
index cd249d34bc..8db85244ff 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-async-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-async-throw.js
@@ -172,9 +172,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -257,6 +266,15 @@ iter.next().then(v => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-expr-abrupt.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-expr-abrupt.js
index 2e09d5b8e2..2d120b943c 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-expr-abrupt.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-expr-abrupt.js
@@ -48,9 +48,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -68,6 +77,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-get-abrupt.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-get-abrupt.js
index 2041684a0b..be1737de55 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-get-abrupt.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-get-abrupt.js
@@ -68,9 +68,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -88,6 +97,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-boolean-throw.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-boolean-throw.js
index c475f24927..1b1d9d5e57 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-boolean-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-boolean-throw.js
@@ -67,9 +67,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -87,6 +96,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-number-throw.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-number-throw.js
index 33386e1962..8656ba77d4 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-number-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-number-throw.js
@@ -67,9 +67,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -87,6 +96,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-object-throw.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-object-throw.js
index 37a6cf24cb..c13b5d95df 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-object-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-object-throw.js
@@ -67,9 +67,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -87,6 +96,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-string-throw.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-string-throw.js
index 9574d3604d..5ae8c530ad 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-string-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-string-throw.js
@@ -67,9 +67,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -87,6 +96,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-symbol-throw.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-symbol-throw.js
index e5494abf82..6035b4fa23 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-symbol-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-symbol-throw.js
@@ -67,9 +67,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -87,6 +96,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-null-sync-get-abrupt.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-null-sync-get-abrupt.js
index 8532430046..1acf263997 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-null-sync-get-abrupt.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-null-sync-get-abrupt.js
@@ -72,9 +72,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -93,6 +102,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-returns-abrupt.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-returns-abrupt.js
index d67e5df3d6..b9613f35f9 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-returns-abrupt.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-returns-abrupt.js
@@ -64,9 +64,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -84,6 +93,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-returns-boolean-throw.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-returns-boolean-throw.js
index 650a937861..9b5c0c9dd3 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-returns-boolean-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-returns-boolean-throw.js
@@ -64,9 +64,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -84,6 +93,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-returns-null-throw.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-returns-null-throw.js
index a39991d608..802a88841b 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-returns-null-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-returns-null-throw.js
@@ -64,9 +64,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -84,6 +93,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-returns-number-throw.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-returns-number-throw.js
index ec3fb996b2..e6c285c781 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-returns-number-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-returns-number-throw.js
@@ -64,9 +64,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -84,6 +93,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-returns-string-throw.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-returns-string-throw.js
index 2e37d8ca2b..49ebabc329 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-returns-string-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-returns-string-throw.js
@@ -64,9 +64,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -84,6 +93,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-returns-symbol-throw.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-returns-symbol-throw.js
index 503c9c214f..8a2de24f7f 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-returns-symbol-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-returns-symbol-throw.js
@@ -64,9 +64,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -84,6 +93,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-returns-undefined-throw.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-returns-undefined-throw.js
index 4ffe9bc26c..88f5128013 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-returns-undefined-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-returns-undefined-throw.js
@@ -64,9 +64,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -84,6 +93,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-undefined-sync-get-abrupt.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-undefined-sync-get-abrupt.js
index d4763eed73..fd64305c3f 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-undefined-sync-get-abrupt.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-async-undefined-sync-get-abrupt.js
@@ -72,9 +72,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -93,6 +102,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-get-abrupt.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-get-abrupt.js
index ee8c597a2a..e1f4866e6c 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-get-abrupt.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-get-abrupt.js
@@ -67,9 +67,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -87,6 +96,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-boolean-throw.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-boolean-throw.js
index 82d8f8c9e0..26c0ce4f99 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-boolean-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-boolean-throw.js
@@ -66,9 +66,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -86,6 +95,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-number-throw.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-number-throw.js
index b51a6ef89c..2d0bc1bb9d 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-number-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-number-throw.js
@@ -66,9 +66,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -86,6 +95,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-object-throw.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-object-throw.js
index 78984ad3a0..4ead3afc65 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-object-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-object-throw.js
@@ -66,9 +66,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -86,6 +95,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-string-throw.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-string-throw.js
index 3f1f866d78..5cb3a4b904 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-string-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-string-throw.js
@@ -66,9 +66,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -86,6 +95,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-symbol-throw.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-symbol-throw.js
index c93ca91a3a..76da251fb1 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-symbol-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-symbol-throw.js
@@ -66,9 +66,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -86,6 +95,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-abrupt.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-abrupt.js
index cf1f69c6c3..639b5dcc21 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-abrupt.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-abrupt.js
@@ -61,9 +61,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -81,6 +90,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-boolean-throw.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-boolean-throw.js
index 3c70d1f3d7..31e1eaa9e1 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-boolean-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-boolean-throw.js
@@ -66,9 +66,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -86,6 +95,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-null-throw.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-null-throw.js
index 097f04f7f7..229cab6e14 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-null-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-null-throw.js
@@ -66,9 +66,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -86,6 +95,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-number-throw.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-number-throw.js
index ee8525224e..8f43b84fd4 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-number-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-number-throw.js
@@ -66,9 +66,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -86,6 +95,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-string-throw.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-string-throw.js
index 81ad0a7ce5..ff7390bc63 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-string-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-string-throw.js
@@ -66,9 +66,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -86,6 +95,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-symbol-throw.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-symbol-throw.js
index d43176aa68..bed86dfca0 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-symbol-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-symbol-throw.js
@@ -66,9 +66,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -86,6 +95,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-undefined-throw.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-undefined-throw.js
index 24bc2f4826..9e7c245031 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-undefined-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-undefined-throw.js
@@ -66,9 +66,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -86,6 +95,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-call-done-get-abrupt.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-call-done-get-abrupt.js
index 3a66417594..7866d07f5f 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-call-done-get-abrupt.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-call-done-get-abrupt.js
@@ -67,9 +67,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -87,6 +96,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-call-returns-abrupt.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-call-returns-abrupt.js
index 798b468c98..747e2ef9e0 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-call-returns-abrupt.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-call-returns-abrupt.js
@@ -59,9 +59,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -79,6 +88,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-call-value-get-abrupt.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-call-value-get-abrupt.js
index 2d2e276e28..54a2fd1c10 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-call-value-get-abrupt.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-call-value-get-abrupt.js
@@ -69,9 +69,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -89,6 +98,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-get-abrupt.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-get-abrupt.js
index 12a529f874..050dd90040 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-get-abrupt.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-get-abrupt.js
@@ -59,9 +59,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -79,6 +88,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-non-object-ignores-then.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-non-object-ignores-then.js
index cbfb1f6c66..52bb614fc5 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-non-object-ignores-then.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-non-object-ignores-then.js
@@ -79,9 +79,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -99,6 +108,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-not-callable-boolean-throw.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-not-callable-boolean-throw.js
index b49225aad3..75d0171b86 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-not-callable-boolean-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-not-callable-boolean-throw.js
@@ -56,9 +56,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -76,6 +85,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-not-callable-null-throw.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-not-callable-null-throw.js
index f57460836f..47d95e27d0 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-not-callable-null-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-not-callable-null-throw.js
@@ -56,9 +56,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -76,6 +85,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-not-callable-number-throw.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-not-callable-number-throw.js
index 72f7cd34cd..7fa1ed7773 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-not-callable-number-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-not-callable-number-throw.js
@@ -56,9 +56,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -76,6 +85,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-not-callable-object-throw.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-not-callable-object-throw.js
index 978b3ffd13..4e39cb77bc 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-not-callable-object-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-not-callable-object-throw.js
@@ -56,9 +56,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -76,6 +85,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-not-callable-string-throw.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-not-callable-string-throw.js
index 3cdf91862b..d06ea04812 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-not-callable-string-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-not-callable-string-throw.js
@@ -56,9 +56,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -76,6 +85,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-not-callable-symbol-throw.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-not-callable-symbol-throw.js
index 5952a8e879..697fc2679f 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-not-callable-symbol-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-not-callable-symbol-throw.js
@@ -56,9 +56,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -76,6 +85,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-not-callable-undefined-throw.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-not-callable-undefined-throw.js
index a5eca3bc83..4b52de0d3e 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-not-callable-undefined-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-not-callable-undefined-throw.js
@@ -56,9 +56,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -76,6 +85,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-then-get-abrupt.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-then-get-abrupt.js
index 428784d0ae..91d94d9007 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-then-get-abrupt.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-then-get-abrupt.js
@@ -83,9 +83,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -103,6 +112,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-then-non-callable-boolean-fulfillpromise.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-then-non-callable-boolean-fulfillpromise.js
index dc98b06a5c..e60b777f8f 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-then-non-callable-boolean-fulfillpromise.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-then-non-callable-boolean-fulfillpromise.js
@@ -83,9 +83,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -97,6 +106,15 @@ iter.next().then(({ value, done }) => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-then-non-callable-null-fulfillpromise.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-then-non-callable-null-fulfillpromise.js
index 2bb6b3bbc9..6788cf2dc2 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-then-non-callable-null-fulfillpromise.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-then-non-callable-null-fulfillpromise.js
@@ -83,9 +83,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -97,6 +106,15 @@ iter.next().then(({ value, done }) => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-then-non-callable-number-fulfillpromise.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-then-non-callable-number-fulfillpromise.js
index 35a48cafd0..2f242c5ce8 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-then-non-callable-number-fulfillpromise.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-then-non-callable-number-fulfillpromise.js
@@ -83,9 +83,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -97,6 +106,15 @@ iter.next().then(({ value, done }) => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-then-non-callable-object-fulfillpromise.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-then-non-callable-object-fulfillpromise.js
index 1c00e4adba..6761060751 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-then-non-callable-object-fulfillpromise.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-then-non-callable-object-fulfillpromise.js
@@ -83,9 +83,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -97,6 +106,15 @@ iter.next().then(({ value, done }) => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-then-non-callable-string-fulfillpromise.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-then-non-callable-string-fulfillpromise.js
index bc7a17cecf..eb079dbfc5 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-then-non-callable-string-fulfillpromise.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-then-non-callable-string-fulfillpromise.js
@@ -83,9 +83,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -97,6 +106,15 @@ iter.next().then(({ value, done }) => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-then-non-callable-symbol-fulfillpromise.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-then-non-callable-symbol-fulfillpromise.js
index 83b602362d..898b7ac137 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-then-non-callable-symbol-fulfillpromise.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-then-non-callable-symbol-fulfillpromise.js
@@ -83,9 +83,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -97,6 +106,15 @@ iter.next().then(({ value, done }) => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-then-non-callable-undefined-fulfillpromise.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-then-non-callable-undefined-fulfillpromise.js
index a9610c7896..c456e72668 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-then-non-callable-undefined-fulfillpromise.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-then-non-callable-undefined-fulfillpromise.js
@@ -83,9 +83,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -97,6 +106,15 @@ iter.next().then(({ value, done }) => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-then-returns-abrupt.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-then-returns-abrupt.js
index cead3eba41..e2c7c8d511 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-then-returns-abrupt.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-next-then-returns-abrupt.js
@@ -83,9 +83,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -103,6 +112,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-sync-next.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-sync-next.js
index ddb8522715..fecccbd727 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-sync-next.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-sync-next.js
@@ -172,9 +172,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -236,6 +245,15 @@ iter.next("next-arg-1").then(v => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-sync-return.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-sync-return.js
index 97da519fbe..42594c2897 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-sync-return.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-sync-return.js
@@ -147,9 +147,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -211,6 +220,15 @@ iter.next().then(v => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/async-gen-private-method/yield-star-sync-throw.js b/test/language/expressions/class/elements/async-gen-private-method/yield-star-sync-throw.js
index bbb620d09a..2d9dcd36da 100644
--- a/test/language/expressions/class/elements/async-gen-private-method/yield-star-sync-throw.js
+++ b/test/language/expressions/class/elements/async-gen-private-method/yield-star-sync-throw.js
@@ -150,9 +150,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -217,6 +226,15 @@ iter.next().then(v => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/computed-name-toprimitive-symbol.js b/test/language/expressions/class/elements/computed-name-toprimitive-symbol.js
index 7102797353..d7f5891d7a 100644
--- a/test/language/expressions/class/elements/computed-name-toprimitive-symbol.js
+++ b/test/language/expressions/class/elements/computed-name-toprimitive-symbol.js
@@ -72,8 +72,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, s1), false);
-assert.sameValue(Object.hasOwnProperty.call(C, s1), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, s1),
+  "s1 doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, s1),
+  "s1 doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, s1, {
   value: 42,
@@ -82,8 +88,14 @@ verifyProperty(c, s1, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, s2), false);
-assert.sameValue(Object.hasOwnProperty.call(C, s2), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, s2),
+  "s2 doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, s2),
+  "s2 doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, s2, {
   value: 43,
@@ -92,8 +104,14 @@ verifyProperty(c, s2, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, s3), false);
-assert.sameValue(Object.hasOwnProperty.call(C, s3), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, s3),
+  "s3 doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, s3),
+  "s3 doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, s3, {
   value: 44,
diff --git a/test/language/expressions/class/elements/computed-name-toprimitive.js b/test/language/expressions/class/elements/computed-name-toprimitive.js
index 1086905ac0..f969bc1c37 100644
--- a/test/language/expressions/class/elements/computed-name-toprimitive.js
+++ b/test/language/expressions/class/elements/computed-name-toprimitive.js
@@ -69,8 +69,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "d"),
+  "d doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "d"),
+  "d doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "d", {
   value: 42,
@@ -79,8 +85,14 @@ verifyProperty(c, "d", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "e"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "e"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "e"),
+  "e doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "e"),
+  "e doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "e", {
   value: 43,
@@ -89,8 +101,14 @@ verifyProperty(c, "e", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "f"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "f"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "f"),
+  "f doesn't appear as an own property on C prototype"
+);
+assert(!
+  Object.prototype.hasOwnProperty.call(C, "f"),
+  "f doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "f", {
   value: 44,
diff --git a/test/language/expressions/class/elements/field-declaration.js b/test/language/expressions/class/elements/field-declaration.js
index 38ca345da0..c2a123c1f1 100644
--- a/test/language/expressions/class/elements/field-declaration.js
+++ b/test/language/expressions/class/elements/field-declaration.js
@@ -63,10 +63,22 @@ assert.sameValue(C.g, undefined);
 assert.sameValue(C.h, undefined);
 assert.sameValue(C[0], undefined);
 
-assert.sameValue(Object.hasOwnProperty.call(C, 'f'), false);
-assert.sameValue(Object.hasOwnProperty.call(C, 'g'), false);
-assert.sameValue(Object.hasOwnProperty.call(C, 'h'), false);
-assert.sameValue(Object.hasOwnProperty.call(C, 0), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, 'f'),
+  "f does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, 'g'),
+  "g does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, 'h'),
+  "h does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, 0),
+  "0 does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, 'f', {
   value: 'test262',
diff --git a/test/language/expressions/class/elements/field-definition-accessor-no-line-terminator.js b/test/language/expressions/class/elements/field-definition-accessor-no-line-terminator.js
index 45b1d4a27d..96ab5aaabc 100644
--- a/test/language/expressions/class/elements/field-definition-accessor-no-line-terminator.js
+++ b/test/language/expressions/class/elements/field-definition-accessor-no-line-terminator.js
@@ -23,9 +23,27 @@ var C = class {
 
 let c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, 'accessor'), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, '$'), false);
-assert.sameValue(Object.hasOwnProperty.call(C, 'accessor'), true);
-assert.sameValue(Object.hasOwnProperty.call(C, '$'), false);
-assert.sameValue(Object.hasOwnProperty.call(c, 'accessor'), true);
-assert.sameValue(Object.hasOwnProperty.call(c, '$'), true);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, 'accessor'),
+  "accessor doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, '$'),
+  "$ doesn't appear as an own property on C prototype"
+);
+assert(
+  Object.prototype.hasOwnProperty.call(C, 'accessor'),
+  "C constructor has an own property accessor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, '$'),
+  "$ doesn't appear as an own property on C constructor"
+);
+assert(
+  Object.prototype.hasOwnProperty.call(c, 'accessor'),
+  "C instance has an own property accessor"
+);
+assert(
+  Object.prototype.hasOwnProperty.call(c, '$'),
+  "C instance has an own property $"
+);
diff --git a/test/language/expressions/class/elements/gen-private-method-static/yield-identifier-spread-strict.js b/test/language/expressions/class/elements/gen-private-method-static/yield-identifier-spread-strict.js
index bd987c15bb..13ea2450ae 100644
--- a/test/language/expressions/class/elements/gen-private-method-static/yield-identifier-spread-strict.js
+++ b/test/language/expressions/class/elements/gen-private-method-static/yield-identifier-spread-strict.js
@@ -47,8 +47,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "Private field '#gen' does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "Private field '#gen' does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -57,5 +63,11 @@ var iter = C.gen();
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "Private field '#gen' does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "Private field '#gen' does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/gen-private-method-static/yield-identifier-strict.js b/test/language/expressions/class/elements/gen-private-method-static/yield-identifier-strict.js
index 0d5bfaca73..ff874f7b85 100644
--- a/test/language/expressions/class/elements/gen-private-method-static/yield-identifier-strict.js
+++ b/test/language/expressions/class/elements/gen-private-method-static/yield-identifier-strict.js
@@ -38,8 +38,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "Private field '#gen' does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "Private field '#gen' does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -48,5 +54,11 @@ var iter = C.gen();
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "Private field '#gen' does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "Private field '#gen' does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/gen-private-method-static/yield-spread-arr-multiple.js b/test/language/expressions/class/elements/gen-private-method-static/yield-spread-arr-multiple.js
index 91dd516f50..162675ae58 100644
--- a/test/language/expressions/class/elements/gen-private-method-static/yield-spread-arr-multiple.js
+++ b/test/language/expressions/class/elements/gen-private-method-static/yield-spread-arr-multiple.js
@@ -40,8 +40,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "Private field '#gen' does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "Private field '#gen' does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -55,5 +61,11 @@ assert.sameValue(item.done, false);
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "Private field '#gen' does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "Private field '#gen' does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/gen-private-method-static/yield-spread-arr-single.js b/test/language/expressions/class/elements/gen-private-method-static/yield-spread-arr-single.js
index 53a7de8572..345242d815 100644
--- a/test/language/expressions/class/elements/gen-private-method-static/yield-spread-arr-single.js
+++ b/test/language/expressions/class/elements/gen-private-method-static/yield-spread-arr-single.js
@@ -37,8 +37,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "Private field '#gen' does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "Private field '#gen' does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -57,5 +63,11 @@ assert.sameValue(item.done, false);
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "Private field '#gen' does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "Private field '#gen' does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/gen-private-method-static/yield-spread-obj.js b/test/language/expressions/class/elements/gen-private-method-static/yield-spread-obj.js
index b12831bcd1..2d3843849c 100644
--- a/test/language/expressions/class/elements/gen-private-method-static/yield-spread-obj.js
+++ b/test/language/expressions/class/elements/gen-private-method-static/yield-spread-obj.js
@@ -42,8 +42,14 @@ var C = class {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "Private field '#gen' does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "Private field '#gen' does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -60,5 +66,11 @@ assert.sameValue(item.done, false);
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "Private field '#gen' does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "Private field '#gen' does not appear as an own property on C constructor"
+);
diff --git a/test/language/expressions/class/elements/gen-private-method/yield-identifier-spread-strict.js b/test/language/expressions/class/elements/gen-private-method/yield-identifier-spread-strict.js
index 38fdc84969..55208f5109 100644
--- a/test/language/expressions/class/elements/gen-private-method/yield-identifier-spread-strict.js
+++ b/test/language/expressions/class/elements/gen-private-method/yield-identifier-spread-strict.js
@@ -49,9 +49,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "Private field '#gen' does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "Private field '#gen' does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "Private field '#gen' does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -60,6 +69,15 @@ var iter = c.gen();
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "Private field '#gen' does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "Private field '#gen' does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "Private field '#gen' does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/gen-private-method/yield-identifier-strict.js b/test/language/expressions/class/elements/gen-private-method/yield-identifier-strict.js
index 251857af53..a41c87971c 100644
--- a/test/language/expressions/class/elements/gen-private-method/yield-identifier-strict.js
+++ b/test/language/expressions/class/elements/gen-private-method/yield-identifier-strict.js
@@ -40,9 +40,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "Private field '#gen' does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "Private field '#gen' does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "Private field '#gen' does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -51,6 +60,15 @@ var iter = c.gen();
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "Private field '#gen' does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "Private field '#gen' does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "Private field '#gen' does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/gen-private-method/yield-spread-arr-multiple.js b/test/language/expressions/class/elements/gen-private-method/yield-spread-arr-multiple.js
index 40f919db04..721c587764 100644
--- a/test/language/expressions/class/elements/gen-private-method/yield-spread-arr-multiple.js
+++ b/test/language/expressions/class/elements/gen-private-method/yield-spread-arr-multiple.js
@@ -42,9 +42,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "Private field '#gen' does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "Private field '#gen' does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "Private field '#gen' does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -58,6 +67,15 @@ assert.sameValue(item.done, false);
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "Private field '#gen' does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "Private field '#gen' does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "Private field '#gen' does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/gen-private-method/yield-spread-arr-single.js b/test/language/expressions/class/elements/gen-private-method/yield-spread-arr-single.js
index 8319516135..ad359f9062 100644
--- a/test/language/expressions/class/elements/gen-private-method/yield-spread-arr-single.js
+++ b/test/language/expressions/class/elements/gen-private-method/yield-spread-arr-single.js
@@ -39,9 +39,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "Private field '#gen' does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "Private field '#gen' does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "Private field '#gen' does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -60,6 +69,15 @@ assert.sameValue(item.done, false);
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "Private field '#gen' does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "Private field '#gen' does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "Private field '#gen' does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/gen-private-method/yield-spread-obj.js b/test/language/expressions/class/elements/gen-private-method/yield-spread-obj.js
index 5d72f5b238..e47d35c6a5 100644
--- a/test/language/expressions/class/elements/gen-private-method/yield-spread-obj.js
+++ b/test/language/expressions/class/elements/gen-private-method/yield-spread-obj.js
@@ -44,9 +44,18 @@ var C = class {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "Private field '#gen' does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "Private field '#gen' does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "Private field '#gen' does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -63,6 +72,15 @@ assert.sameValue(item.done, false);
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "Private field '#gen' does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "Private field '#gen' does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "Private field '#gen' does not appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/multiple-definitions-computed-names.js b/test/language/expressions/class/elements/multiple-definitions-computed-names.js
index 6279f576a5..7a1b86393c 100644
--- a/test/language/expressions/class/elements/multiple-definitions-computed-names.js
+++ b/test/language/expressions/class/elements/multiple-definitions-computed-names.js
@@ -35,7 +35,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -45,7 +48,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -55,8 +61,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -66,8 +78,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
@@ -76,8 +94,14 @@ verifyProperty(c, "bar", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -86,12 +110,27 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "10"),
+  "10 doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "10"),
+  "10 doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "10", {
   value: "meep",
@@ -100,8 +139,14 @@ verifyProperty(c, "10", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "not initialized", {
   value: undefined,
diff --git a/test/language/expressions/class/elements/multiple-definitions-computed-symbol-names.js b/test/language/expressions/class/elements/multiple-definitions-computed-symbol-names.js
index f2192a0b0f..cf96201679 100644
--- a/test/language/expressions/class/elements/multiple-definitions-computed-symbol-names.js
+++ b/test/language/expressions/class/elements/multiple-definitions-computed-symbol-names.js
@@ -36,7 +36,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -46,7 +49,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -56,8 +62,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -67,8 +79,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
@@ -77,8 +95,14 @@ verifyProperty(c, "bar", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, x), false);
-assert.sameValue(Object.hasOwnProperty.call(C, x), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, x),
+  "Symbol x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, x),
+  "Symbol x doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, x, {
   value: undefined,
@@ -87,8 +111,14 @@ verifyProperty(c, x, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
-assert.sameValue(Object.hasOwnProperty.call(C, y), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, y),
+  "Symbol y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, y),
+  "Symbol y doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, y, {
   value: 42,
@@ -97,10 +127,28 @@ verifyProperty(c, y, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "y"),
+  "y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "y"),
+  "y doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "y"),
+  "y doesn't appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/multiple-definitions-grammar-privatename-identifier-semantics-stringvalue.js b/test/language/expressions/class/elements/multiple-definitions-grammar-privatename-identifier-semantics-stringvalue.js
index 78cc468121..72670a62ae 100644
--- a/test/language/expressions/class/elements/multiple-definitions-grammar-privatename-identifier-semantics-stringvalue.js
+++ b/test/language/expressions/class/elements/multiple-definitions-grammar-privatename-identifier-semantics-stringvalue.js
@@ -93,7 +93,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -103,7 +106,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -113,8 +119,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -124,8 +136,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-definitions-literal-names-asi.js b/test/language/expressions/class/elements/multiple-definitions-literal-names-asi.js
index a5b3414138..643a4c7077 100644
--- a/test/language/expressions/class/elements/multiple-definitions-literal-names-asi.js
+++ b/test/language/expressions/class/elements/multiple-definitions-literal-names-asi.js
@@ -34,7 +34,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -44,7 +47,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -54,8 +60,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -65,8 +77,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
@@ -75,8 +93,14 @@ verifyProperty(c, "bar", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -85,8 +109,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
diff --git a/test/language/expressions/class/elements/multiple-definitions-literal-names.js b/test/language/expressions/class/elements/multiple-definitions-literal-names.js
index 2fce8f32e0..cc183721a9 100644
--- a/test/language/expressions/class/elements/multiple-definitions-literal-names.js
+++ b/test/language/expressions/class/elements/multiple-definitions-literal-names.js
@@ -36,7 +36,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -46,7 +49,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -56,8 +62,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -67,8 +79,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
@@ -77,8 +95,14 @@ verifyProperty(c, "bar", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -87,8 +111,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -97,8 +127,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: fn,
diff --git a/test/language/expressions/class/elements/multiple-definitions-private-field-usage.js b/test/language/expressions/class/elements/multiple-definitions-private-field-usage.js
index f9a79f6432..8cf7bc5731 100644
--- a/test/language/expressions/class/elements/multiple-definitions-private-field-usage.js
+++ b/test/language/expressions/class/elements/multiple-definitions-private-field-usage.js
@@ -36,7 +36,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -46,7 +49,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -56,8 +62,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -67,8 +79,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-definitions-private-method-getter-usage.js b/test/language/expressions/class/elements/multiple-definitions-private-method-getter-usage.js
index ac03635126..58ced382a8 100644
--- a/test/language/expressions/class/elements/multiple-definitions-private-method-getter-usage.js
+++ b/test/language/expressions/class/elements/multiple-definitions-private-method-getter-usage.js
@@ -36,7 +36,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -46,7 +49,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -56,8 +62,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -67,8 +79,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-definitions-private-method-usage.js b/test/language/expressions/class/elements/multiple-definitions-private-method-usage.js
index 7361c04493..6cda155da2 100644
--- a/test/language/expressions/class/elements/multiple-definitions-private-method-usage.js
+++ b/test/language/expressions/class/elements/multiple-definitions-private-method-usage.js
@@ -36,7 +36,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -46,7 +49,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -56,8 +62,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -67,8 +79,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-definitions-private-names.js b/test/language/expressions/class/elements/multiple-definitions-private-names.js
index d54a92abbb..bdc59a7f02 100644
--- a/test/language/expressions/class/elements/multiple-definitions-private-names.js
+++ b/test/language/expressions/class/elements/multiple-definitions-private-names.js
@@ -43,7 +43,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -53,7 +56,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -63,8 +69,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -74,8 +86,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
@@ -85,18 +103,18 @@ verifyProperty(c, "bar", {
 });
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(c.x(), 42, "test 7");
 assert.sameValue(c.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 10");
diff --git a/test/language/expressions/class/elements/multiple-definitions-rs-field-identifier-initializer.js b/test/language/expressions/class/elements/multiple-definitions-rs-field-identifier-initializer.js
index c8d1e53466..70f168c54b 100644
--- a/test/language/expressions/class/elements/multiple-definitions-rs-field-identifier-initializer.js
+++ b/test/language/expressions/class/elements/multiple-definitions-rs-field-identifier-initializer.js
@@ -69,7 +69,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -79,7 +82,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -89,8 +95,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -100,8 +112,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-definitions-rs-field-identifier.js b/test/language/expressions/class/elements/multiple-definitions-rs-field-identifier.js
index 30073ca0ce..740dfc0755 100644
--- a/test/language/expressions/class/elements/multiple-definitions-rs-field-identifier.js
+++ b/test/language/expressions/class/elements/multiple-definitions-rs-field-identifier.js
@@ -69,7 +69,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -79,7 +82,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -89,8 +95,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -100,8 +112,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-definitions-rs-private-getter-alt.js b/test/language/expressions/class/elements/multiple-definitions-rs-private-getter-alt.js
index 69ce62ca5a..50886c4cb7 100644
--- a/test/language/expressions/class/elements/multiple-definitions-rs-private-getter-alt.js
+++ b/test/language/expressions/class/elements/multiple-definitions-rs-private-getter-alt.js
@@ -110,7 +110,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -120,7 +123,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -130,8 +136,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -141,8 +153,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-definitions-rs-private-getter.js b/test/language/expressions/class/elements/multiple-definitions-rs-private-getter.js
index 4de3fc4a6e..85ff55f0ec 100644
--- a/test/language/expressions/class/elements/multiple-definitions-rs-private-getter.js
+++ b/test/language/expressions/class/elements/multiple-definitions-rs-private-getter.js
@@ -110,7 +110,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -120,7 +123,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -130,8 +136,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -141,8 +153,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-definitions-rs-private-method-alt.js b/test/language/expressions/class/elements/multiple-definitions-rs-private-method-alt.js
index 5a414dba2f..79791cdc65 100644
--- a/test/language/expressions/class/elements/multiple-definitions-rs-private-method-alt.js
+++ b/test/language/expressions/class/elements/multiple-definitions-rs-private-method-alt.js
@@ -109,7 +109,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -119,7 +122,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -129,8 +135,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -140,8 +152,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-definitions-rs-private-method.js b/test/language/expressions/class/elements/multiple-definitions-rs-private-method.js
index d9c15b7d4e..78859e3b30 100644
--- a/test/language/expressions/class/elements/multiple-definitions-rs-private-method.js
+++ b/test/language/expressions/class/elements/multiple-definitions-rs-private-method.js
@@ -109,7 +109,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -119,7 +122,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -129,8 +135,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -140,8 +152,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-definitions-rs-private-setter-alt.js b/test/language/expressions/class/elements/multiple-definitions-rs-private-setter-alt.js
index 86ccb4ca0f..f303772367 100644
--- a/test/language/expressions/class/elements/multiple-definitions-rs-private-setter-alt.js
+++ b/test/language/expressions/class/elements/multiple-definitions-rs-private-setter-alt.js
@@ -109,7 +109,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -119,7 +122,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -129,8 +135,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -140,8 +152,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-definitions-rs-private-setter.js b/test/language/expressions/class/elements/multiple-definitions-rs-private-setter.js
index cc6acf2246..e60807e31e 100644
--- a/test/language/expressions/class/elements/multiple-definitions-rs-private-setter.js
+++ b/test/language/expressions/class/elements/multiple-definitions-rs-private-setter.js
@@ -109,7 +109,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -119,7 +122,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -129,8 +135,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -140,8 +152,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-definitions-rs-privatename-identifier-alt.js b/test/language/expressions/class/elements/multiple-definitions-rs-privatename-identifier-alt.js
index 3d01b07968..437c0c3ed6 100644
--- a/test/language/expressions/class/elements/multiple-definitions-rs-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/multiple-definitions-rs-privatename-identifier-alt.js
@@ -90,7 +90,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -100,7 +103,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -110,8 +116,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -121,8 +133,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-definitions-rs-privatename-identifier-initializer-alt.js b/test/language/expressions/class/elements/multiple-definitions-rs-privatename-identifier-initializer-alt.js
index 777721e0c6..e3a7d0165c 100644
--- a/test/language/expressions/class/elements/multiple-definitions-rs-privatename-identifier-initializer-alt.js
+++ b/test/language/expressions/class/elements/multiple-definitions-rs-privatename-identifier-initializer-alt.js
@@ -84,7 +84,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -94,7 +97,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -104,8 +110,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -115,8 +127,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-definitions-rs-privatename-identifier-initializer.js b/test/language/expressions/class/elements/multiple-definitions-rs-privatename-identifier-initializer.js
index 189c7d017b..f401180ac7 100644
--- a/test/language/expressions/class/elements/multiple-definitions-rs-privatename-identifier-initializer.js
+++ b/test/language/expressions/class/elements/multiple-definitions-rs-privatename-identifier-initializer.js
@@ -84,7 +84,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -94,7 +97,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -104,8 +110,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -115,8 +127,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-definitions-rs-privatename-identifier.js b/test/language/expressions/class/elements/multiple-definitions-rs-privatename-identifier.js
index f1dc2171b2..758241ea82 100644
--- a/test/language/expressions/class/elements/multiple-definitions-rs-privatename-identifier.js
+++ b/test/language/expressions/class/elements/multiple-definitions-rs-privatename-identifier.js
@@ -90,7 +90,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -100,7 +103,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -110,8 +116,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -121,8 +133,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-definitions-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/multiple-definitions-rs-static-async-generator-method-privatename-identifier-alt.js
index b7e012e018..3da8b949af 100644
--- a/test/language/expressions/class/elements/multiple-definitions-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/multiple-definitions-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -106,7 +106,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -116,7 +119,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -126,8 +132,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -137,8 +149,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-definitions-rs-static-async-generator-method-privatename-identifier.js b/test/language/expressions/class/elements/multiple-definitions-rs-static-async-generator-method-privatename-identifier.js
index 45d7e2acdc..cba6537910 100644
--- a/test/language/expressions/class/elements/multiple-definitions-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/multiple-definitions-rs-static-async-generator-method-privatename-identifier.js
@@ -106,7 +106,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -116,7 +119,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -126,8 +132,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -137,8 +149,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-definitions-rs-static-async-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/multiple-definitions-rs-static-async-method-privatename-identifier-alt.js
index a3f6769b0e..52dae257dc 100644
--- a/test/language/expressions/class/elements/multiple-definitions-rs-static-async-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/multiple-definitions-rs-static-async-method-privatename-identifier-alt.js
@@ -106,7 +106,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -116,7 +119,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -126,8 +132,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -137,8 +149,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-definitions-rs-static-async-method-privatename-identifier.js b/test/language/expressions/class/elements/multiple-definitions-rs-static-async-method-privatename-identifier.js
index 57d32e1eec..32e1d4fc44 100644
--- a/test/language/expressions/class/elements/multiple-definitions-rs-static-async-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/multiple-definitions-rs-static-async-method-privatename-identifier.js
@@ -106,7 +106,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -116,7 +119,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -126,8 +132,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -137,8 +149,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-definitions-rs-static-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/multiple-definitions-rs-static-generator-method-privatename-identifier-alt.js
index 3254575df0..d05d952a16 100644
--- a/test/language/expressions/class/elements/multiple-definitions-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/multiple-definitions-rs-static-generator-method-privatename-identifier-alt.js
@@ -106,7 +106,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -116,7 +119,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -126,8 +132,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -137,8 +149,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-definitions-rs-static-generator-method-privatename-identifier.js b/test/language/expressions/class/elements/multiple-definitions-rs-static-generator-method-privatename-identifier.js
index 9117b9bf99..3b76746f0b 100644
--- a/test/language/expressions/class/elements/multiple-definitions-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/multiple-definitions-rs-static-generator-method-privatename-identifier.js
@@ -106,7 +106,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -116,7 +119,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -126,8 +132,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -137,8 +149,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-definitions-rs-static-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/multiple-definitions-rs-static-method-privatename-identifier-alt.js
index 795e39d7f7..d502c68fde 100644
--- a/test/language/expressions/class/elements/multiple-definitions-rs-static-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/multiple-definitions-rs-static-method-privatename-identifier-alt.js
@@ -103,7 +103,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -113,7 +116,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -123,8 +129,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -134,8 +146,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-definitions-rs-static-method-privatename-identifier.js b/test/language/expressions/class/elements/multiple-definitions-rs-static-method-privatename-identifier.js
index 4f8b79d38b..ef6d5d33c3 100644
--- a/test/language/expressions/class/elements/multiple-definitions-rs-static-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/multiple-definitions-rs-static-method-privatename-identifier.js
@@ -103,7 +103,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -113,7 +116,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -123,8 +129,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -134,8 +146,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-definitions-rs-static-privatename-identifier-alt-by-classname.js b/test/language/expressions/class/elements/multiple-definitions-rs-static-privatename-identifier-alt-by-classname.js
index fc1a6fcc11..a3fcab79fd 100644
--- a/test/language/expressions/class/elements/multiple-definitions-rs-static-privatename-identifier-alt-by-classname.js
+++ b/test/language/expressions/class/elements/multiple-definitions-rs-static-privatename-identifier-alt-by-classname.js
@@ -91,7 +91,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -101,7 +104,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -111,8 +117,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -122,8 +134,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-definitions-rs-static-privatename-identifier-alt.js b/test/language/expressions/class/elements/multiple-definitions-rs-static-privatename-identifier-alt.js
index 4cf4cdb3e8..36f07790aa 100644
--- a/test/language/expressions/class/elements/multiple-definitions-rs-static-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/multiple-definitions-rs-static-privatename-identifier-alt.js
@@ -91,7 +91,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -101,7 +104,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -111,8 +117,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -122,8 +134,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-definitions-rs-static-privatename-identifier-by-classname.js b/test/language/expressions/class/elements/multiple-definitions-rs-static-privatename-identifier-by-classname.js
index f8af659b1e..88dfb0e441 100644
--- a/test/language/expressions/class/elements/multiple-definitions-rs-static-privatename-identifier-by-classname.js
+++ b/test/language/expressions/class/elements/multiple-definitions-rs-static-privatename-identifier-by-classname.js
@@ -91,7 +91,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -101,7 +104,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -111,8 +117,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -122,8 +134,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-definitions-rs-static-privatename-identifier-initializer-alt-by-classname.js b/test/language/expressions/class/elements/multiple-definitions-rs-static-privatename-identifier-initializer-alt-by-classname.js
index f526156711..7102b1f6b3 100644
--- a/test/language/expressions/class/elements/multiple-definitions-rs-static-privatename-identifier-initializer-alt-by-classname.js
+++ b/test/language/expressions/class/elements/multiple-definitions-rs-static-privatename-identifier-initializer-alt-by-classname.js
@@ -85,7 +85,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -95,7 +98,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -105,8 +111,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -116,8 +128,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-definitions-rs-static-privatename-identifier-initializer-alt.js b/test/language/expressions/class/elements/multiple-definitions-rs-static-privatename-identifier-initializer-alt.js
index bedb67d740..885fb96a67 100644
--- a/test/language/expressions/class/elements/multiple-definitions-rs-static-privatename-identifier-initializer-alt.js
+++ b/test/language/expressions/class/elements/multiple-definitions-rs-static-privatename-identifier-initializer-alt.js
@@ -85,7 +85,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -95,7 +98,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -105,8 +111,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -116,8 +128,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-definitions-rs-static-privatename-identifier-initializer.js b/test/language/expressions/class/elements/multiple-definitions-rs-static-privatename-identifier-initializer.js
index dfb2e0e0cb..afb5041f62 100644
--- a/test/language/expressions/class/elements/multiple-definitions-rs-static-privatename-identifier-initializer.js
+++ b/test/language/expressions/class/elements/multiple-definitions-rs-static-privatename-identifier-initializer.js
@@ -85,7 +85,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -95,7 +98,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -105,8 +111,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -116,8 +128,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-definitions-rs-static-privatename-identifier.js b/test/language/expressions/class/elements/multiple-definitions-rs-static-privatename-identifier.js
index 8742ec7d2a..4f63450655 100644
--- a/test/language/expressions/class/elements/multiple-definitions-rs-static-privatename-identifier.js
+++ b/test/language/expressions/class/elements/multiple-definitions-rs-static-privatename-identifier.js
@@ -91,7 +91,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -101,7 +104,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -111,8 +117,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -122,8 +134,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-definitions-static-private-fields.js b/test/language/expressions/class/elements/multiple-definitions-static-private-fields.js
index 8fba715f60..1ddff9cfc1 100644
--- a/test/language/expressions/class/elements/multiple-definitions-static-private-fields.js
+++ b/test/language/expressions/class/elements/multiple-definitions-static-private-fields.js
@@ -43,7 +43,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -53,7 +56,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -63,8 +69,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -74,8 +86,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
@@ -85,18 +103,18 @@ verifyProperty(c, "bar", {
 });
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/expressions/class/elements/multiple-definitions-static-private-methods-with-fields.js b/test/language/expressions/class/elements/multiple-definitions-static-private-methods-with-fields.js
index 0f7471bead..2180b23277 100644
--- a/test/language/expressions/class/elements/multiple-definitions-static-private-methods-with-fields.js
+++ b/test/language/expressions/class/elements/multiple-definitions-static-private-methods-with-fields.js
@@ -49,7 +49,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -59,7 +62,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -69,8 +75,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -80,8 +92,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
@@ -91,29 +109,29 @@ verifyProperty(c, "bar", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#xVal"), "test 7");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 8");
+assert(!Object.prototype.hasOwnProperty.call(c, "#xVal"), "test 9");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#yVal"), "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 11");
+assert(!Object.prototype.hasOwnProperty.call(c, "#yVal"), "test 12");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 13");
 assert.sameValue(C.y(), 43, "test 14");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 15");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 16");
 
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 17");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 18");
diff --git a/test/language/expressions/class/elements/multiple-definitions-static-private-methods.js b/test/language/expressions/class/elements/multiple-definitions-static-private-methods.js
index 45872ed75e..9fc27689d9 100644
--- a/test/language/expressions/class/elements/multiple-definitions-static-private-methods.js
+++ b/test/language/expressions/class/elements/multiple-definitions-static-private-methods.js
@@ -47,7 +47,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -57,7 +60,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -67,8 +73,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -78,8 +90,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
@@ -89,18 +107,18 @@ verifyProperty(c, "bar", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/expressions/class/elements/multiple-definitions-string-literal-names.js b/test/language/expressions/class/elements/multiple-definitions-string-literal-names.js
index 38fb8f4d92..239010c328 100644
--- a/test/language/expressions/class/elements/multiple-definitions-string-literal-names.js
+++ b/test/language/expressions/class/elements/multiple-definitions-string-literal-names.js
@@ -34,7 +34,10 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -44,7 +47,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -54,8 +60,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -65,8 +77,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
@@ -75,8 +93,14 @@ verifyProperty(c, "bar", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -85,8 +109,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: undefined,
@@ -95,8 +125,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: 39,
@@ -105,8 +141,14 @@ verifyProperty(c, "c", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "d"),
+  "d does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "d"),
+  "d does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "d", {
   value: 42,
diff --git a/test/language/expressions/class/elements/multiple-stacked-definitions-computed-names.js b/test/language/expressions/class/elements/multiple-stacked-definitions-computed-names.js
index 135f29b11d..0c33251df6 100644
--- a/test/language/expressions/class/elements/multiple-stacked-definitions-computed-names.js
+++ b/test/language/expressions/class/elements/multiple-stacked-definitions-computed-names.js
@@ -33,8 +33,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -44,8 +50,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
@@ -54,8 +66,14 @@ verifyProperty(c, "bar", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -64,12 +82,27 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "10"),
+  "10 doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "10"),
+  "10 doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "10", {
   value: "meep",
@@ -78,8 +111,14 @@ verifyProperty(c, "10", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "not initialized", {
   value: undefined,
diff --git a/test/language/expressions/class/elements/multiple-stacked-definitions-computed-symbol-names.js b/test/language/expressions/class/elements/multiple-stacked-definitions-computed-symbol-names.js
index 9ec75391d4..88c9671f82 100644
--- a/test/language/expressions/class/elements/multiple-stacked-definitions-computed-symbol-names.js
+++ b/test/language/expressions/class/elements/multiple-stacked-definitions-computed-symbol-names.js
@@ -34,8 +34,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -45,8 +51,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
@@ -55,8 +67,14 @@ verifyProperty(c, "bar", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, x), false);
-assert.sameValue(Object.hasOwnProperty.call(C, x), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, x),
+  "Symbol x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, x),
+  "Symbol x doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, x, {
   value: undefined,
@@ -65,8 +83,14 @@ verifyProperty(c, x, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
-assert.sameValue(Object.hasOwnProperty.call(C, y), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, y),
+  "Symbol y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, y),
+  "Symbol y doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, y, {
   value: 42,
@@ -75,10 +99,28 @@ verifyProperty(c, y, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "y"),
+  "y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "y"),
+  "y doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "y"),
+  "y doesn't appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/multiple-stacked-definitions-grammar-privatename-identifier-semantics-stringvalue.js b/test/language/expressions/class/elements/multiple-stacked-definitions-grammar-privatename-identifier-semantics-stringvalue.js
index 73c7501316..4c839216f9 100644
--- a/test/language/expressions/class/elements/multiple-stacked-definitions-grammar-privatename-identifier-semantics-stringvalue.js
+++ b/test/language/expressions/class/elements/multiple-stacked-definitions-grammar-privatename-identifier-semantics-stringvalue.js
@@ -91,8 +91,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -102,8 +108,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-stacked-definitions-literal-names-asi.js b/test/language/expressions/class/elements/multiple-stacked-definitions-literal-names-asi.js
index 1863a4970a..22e54027a9 100644
--- a/test/language/expressions/class/elements/multiple-stacked-definitions-literal-names-asi.js
+++ b/test/language/expressions/class/elements/multiple-stacked-definitions-literal-names-asi.js
@@ -32,8 +32,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -43,8 +49,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
@@ -53,8 +65,14 @@ verifyProperty(c, "bar", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -63,8 +81,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
diff --git a/test/language/expressions/class/elements/multiple-stacked-definitions-literal-names.js b/test/language/expressions/class/elements/multiple-stacked-definitions-literal-names.js
index 668b21f408..0c6fd536ba 100644
--- a/test/language/expressions/class/elements/multiple-stacked-definitions-literal-names.js
+++ b/test/language/expressions/class/elements/multiple-stacked-definitions-literal-names.js
@@ -34,8 +34,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -45,8 +51,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
@@ -55,8 +67,14 @@ verifyProperty(c, "bar", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -65,8 +83,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -75,8 +99,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: fn,
diff --git a/test/language/expressions/class/elements/multiple-stacked-definitions-private-field-usage.js b/test/language/expressions/class/elements/multiple-stacked-definitions-private-field-usage.js
index d491af81bf..6d0312166f 100644
--- a/test/language/expressions/class/elements/multiple-stacked-definitions-private-field-usage.js
+++ b/test/language/expressions/class/elements/multiple-stacked-definitions-private-field-usage.js
@@ -34,8 +34,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -45,8 +51,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-stacked-definitions-private-method-getter-usage.js b/test/language/expressions/class/elements/multiple-stacked-definitions-private-method-getter-usage.js
index cc4803d5d4..5a1d453080 100644
--- a/test/language/expressions/class/elements/multiple-stacked-definitions-private-method-getter-usage.js
+++ b/test/language/expressions/class/elements/multiple-stacked-definitions-private-method-getter-usage.js
@@ -34,8 +34,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -45,8 +51,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-stacked-definitions-private-method-usage.js b/test/language/expressions/class/elements/multiple-stacked-definitions-private-method-usage.js
index f4f7fa08e7..6983bd2798 100644
--- a/test/language/expressions/class/elements/multiple-stacked-definitions-private-method-usage.js
+++ b/test/language/expressions/class/elements/multiple-stacked-definitions-private-method-usage.js
@@ -34,8 +34,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -45,8 +51,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-stacked-definitions-private-names.js b/test/language/expressions/class/elements/multiple-stacked-definitions-private-names.js
index 93eeeb7daf..093d9bfd66 100644
--- a/test/language/expressions/class/elements/multiple-stacked-definitions-private-names.js
+++ b/test/language/expressions/class/elements/multiple-stacked-definitions-private-names.js
@@ -41,8 +41,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -52,8 +58,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
@@ -63,18 +75,18 @@ verifyProperty(c, "bar", {
 });
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(c.x(), 42, "test 7");
 assert.sameValue(c.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 10");
diff --git a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-field-identifier-initializer.js b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-field-identifier-initializer.js
index 3a16a65832..e8aa94062a 100644
--- a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-field-identifier-initializer.js
+++ b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-field-identifier-initializer.js
@@ -67,8 +67,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -78,8 +84,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-field-identifier.js b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-field-identifier.js
index abc94789e3..a07fbdb0a1 100644
--- a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-field-identifier.js
+++ b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-field-identifier.js
@@ -67,8 +67,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -78,8 +84,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-private-getter-alt.js b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-private-getter-alt.js
index 1b72b9db20..e8a67e18f8 100644
--- a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-private-getter-alt.js
+++ b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-private-getter-alt.js
@@ -108,8 +108,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -119,8 +125,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-private-getter.js b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-private-getter.js
index fc8d202a96..dace487697 100644
--- a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-private-getter.js
+++ b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-private-getter.js
@@ -108,8 +108,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -119,8 +125,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-private-method-alt.js b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-private-method-alt.js
index a891e3765a..c8700e6ed6 100644
--- a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-private-method-alt.js
+++ b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-private-method-alt.js
@@ -107,8 +107,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -118,8 +124,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-private-method.js b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-private-method.js
index 2e6555af3b..8c080f39e6 100644
--- a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-private-method.js
+++ b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-private-method.js
@@ -107,8 +107,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -118,8 +124,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-private-setter-alt.js b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-private-setter-alt.js
index 79b83b19d4..fc21cdbae3 100644
--- a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-private-setter-alt.js
+++ b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-private-setter-alt.js
@@ -107,8 +107,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -118,8 +124,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-private-setter.js b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-private-setter.js
index 74a321bbec..69b7a4e43d 100644
--- a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-private-setter.js
+++ b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-private-setter.js
@@ -107,8 +107,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -118,8 +124,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-privatename-identifier-alt.js b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-privatename-identifier-alt.js
index 3b702fe428..6ed6a59b2b 100644
--- a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-privatename-identifier-alt.js
@@ -88,8 +88,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -99,8 +105,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-privatename-identifier-initializer-alt.js b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-privatename-identifier-initializer-alt.js
index e8536c28af..65dcb41aef 100644
--- a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-privatename-identifier-initializer-alt.js
+++ b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-privatename-identifier-initializer-alt.js
@@ -82,8 +82,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -93,8 +99,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-privatename-identifier-initializer.js b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-privatename-identifier-initializer.js
index bb0b882f8b..8bc53dac81 100644
--- a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-privatename-identifier-initializer.js
+++ b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-privatename-identifier-initializer.js
@@ -82,8 +82,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -93,8 +99,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-privatename-identifier.js b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-privatename-identifier.js
index d33bac507a..00fbbb862a 100644
--- a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-privatename-identifier.js
+++ b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-privatename-identifier.js
@@ -88,8 +88,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -99,8 +105,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-async-generator-method-privatename-identifier-alt.js
index 9927337b65..e83779c055 100644
--- a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -104,8 +104,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -115,8 +121,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-async-generator-method-privatename-identifier.js b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-async-generator-method-privatename-identifier.js
index d689fa9337..6f850fe09e 100644
--- a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-async-generator-method-privatename-identifier.js
@@ -104,8 +104,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -115,8 +121,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-async-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-async-method-privatename-identifier-alt.js
index 0dc88aecb7..917f5e9289 100644
--- a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-async-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-async-method-privatename-identifier-alt.js
@@ -104,8 +104,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -115,8 +121,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-async-method-privatename-identifier.js b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-async-method-privatename-identifier.js
index 0b776fcf3c..e92aa64382 100644
--- a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-async-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-async-method-privatename-identifier.js
@@ -104,8 +104,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -115,8 +121,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-generator-method-privatename-identifier-alt.js
index ea8f41381a..de86c8b348 100644
--- a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-generator-method-privatename-identifier-alt.js
@@ -104,8 +104,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -115,8 +121,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-generator-method-privatename-identifier.js b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-generator-method-privatename-identifier.js
index b86471ee64..f2553f554e 100644
--- a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-generator-method-privatename-identifier.js
@@ -104,8 +104,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -115,8 +121,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-method-privatename-identifier-alt.js
index 1788de7768..40be0f4997 100644
--- a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-method-privatename-identifier-alt.js
@@ -101,8 +101,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -112,8 +118,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-method-privatename-identifier.js b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-method-privatename-identifier.js
index c4f4677430..4761920ece 100644
--- a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-method-privatename-identifier.js
@@ -101,8 +101,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -112,8 +118,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-alt-by-classname.js b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-alt-by-classname.js
index 71488e051b..09021b9adb 100644
--- a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-alt-by-classname.js
+++ b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-alt-by-classname.js
@@ -89,8 +89,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -100,8 +106,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-alt.js b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-alt.js
index 7bee58abf8..34177bef27 100644
--- a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-alt.js
@@ -89,8 +89,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -100,8 +106,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-by-classname.js b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-by-classname.js
index 89fe8d4572..a06f92c425 100644
--- a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-by-classname.js
+++ b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-by-classname.js
@@ -89,8 +89,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -100,8 +106,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-initializer-alt-by-classname.js b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-initializer-alt-by-classname.js
index ddba90425f..102d2aac20 100644
--- a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-initializer-alt-by-classname.js
+++ b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-initializer-alt-by-classname.js
@@ -83,8 +83,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -94,8 +100,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-initializer-alt.js b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-initializer-alt.js
index 39f797b8ab..2eb02e5876 100644
--- a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-initializer-alt.js
+++ b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-initializer-alt.js
@@ -83,8 +83,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -94,8 +100,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-initializer.js b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-initializer.js
index 16b4882e08..038ce48335 100644
--- a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-initializer.js
+++ b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-initializer.js
@@ -83,8 +83,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -94,8 +100,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier.js b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier.js
index ebd9c80372..70452598a2 100644
--- a/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier.js
+++ b/test/language/expressions/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier.js
@@ -89,8 +89,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -100,8 +106,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/expressions/class/elements/multiple-stacked-definitions-static-private-fields.js b/test/language/expressions/class/elements/multiple-stacked-definitions-static-private-fields.js
index c49023ed45..003cad0fab 100644
--- a/test/language/expressions/class/elements/multiple-stacked-definitions-static-private-fields.js
+++ b/test/language/expressions/class/elements/multiple-stacked-definitions-static-private-fields.js
@@ -41,8 +41,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -52,8 +58,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
@@ -63,18 +75,18 @@ verifyProperty(c, "bar", {
 });
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/expressions/class/elements/multiple-stacked-definitions-static-private-methods-with-fields.js b/test/language/expressions/class/elements/multiple-stacked-definitions-static-private-methods-with-fields.js
index f1b8397089..b1ab995ab3 100644
--- a/test/language/expressions/class/elements/multiple-stacked-definitions-static-private-methods-with-fields.js
+++ b/test/language/expressions/class/elements/multiple-stacked-definitions-static-private-methods-with-fields.js
@@ -47,8 +47,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -58,8 +64,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
@@ -69,29 +81,29 @@ verifyProperty(c, "bar", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#xVal"), "test 7");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 8");
+assert(!Object.prototype.hasOwnProperty.call(c, "#xVal"), "test 9");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#yVal"), "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 11");
+assert(!Object.prototype.hasOwnProperty.call(c, "#yVal"), "test 12");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 13");
 assert.sameValue(C.y(), 43, "test 14");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 15");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 16");
 
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 17");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 18");
diff --git a/test/language/expressions/class/elements/multiple-stacked-definitions-static-private-methods.js b/test/language/expressions/class/elements/multiple-stacked-definitions-static-private-methods.js
index c3a3f783f2..e893f2bcf9 100644
--- a/test/language/expressions/class/elements/multiple-stacked-definitions-static-private-methods.js
+++ b/test/language/expressions/class/elements/multiple-stacked-definitions-static-private-methods.js
@@ -45,8 +45,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -56,8 +62,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
@@ -67,18 +79,18 @@ verifyProperty(c, "bar", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/expressions/class/elements/multiple-stacked-definitions-string-literal-names.js b/test/language/expressions/class/elements/multiple-stacked-definitions-string-literal-names.js
index cee4928a92..4029568397 100644
--- a/test/language/expressions/class/elements/multiple-stacked-definitions-string-literal-names.js
+++ b/test/language/expressions/class/elements/multiple-stacked-definitions-string-literal-names.js
@@ -32,8 +32,14 @@ var C = class {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -43,8 +49,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
@@ -53,8 +65,14 @@ verifyProperty(c, "bar", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -63,8 +81,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: undefined,
@@ -73,8 +97,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: 39,
@@ -83,8 +113,14 @@ verifyProperty(c, "c", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "d"),
+  "d does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "d"),
+  "d does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "d", {
   value: 42,
diff --git a/test/language/expressions/class/elements/new-no-sc-line-method-computed-names.js b/test/language/expressions/class/elements/new-no-sc-line-method-computed-names.js
index 128ac2523f..91c67f06c8 100644
--- a/test/language/expressions/class/elements/new-no-sc-line-method-computed-names.js
+++ b/test/language/expressions/class/elements/new-no-sc-line-method-computed-names.js
@@ -33,7 +33,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -41,8 +44,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -51,12 +60,27 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "10"),
+  "10 doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "10"),
+  "10 doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "10", {
   value: "meep",
@@ -65,8 +89,14 @@ verifyProperty(c, "10", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "not initialized", {
   value: undefined,
diff --git a/test/language/expressions/class/elements/new-no-sc-line-method-computed-symbol-names.js b/test/language/expressions/class/elements/new-no-sc-line-method-computed-symbol-names.js
index a685a1e67f..e5e7d68fae 100644
--- a/test/language/expressions/class/elements/new-no-sc-line-method-computed-symbol-names.js
+++ b/test/language/expressions/class/elements/new-no-sc-line-method-computed-symbol-names.js
@@ -34,7 +34,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -42,8 +45,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, x), false);
-assert.sameValue(Object.hasOwnProperty.call(C, x), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, x),
+  "Symbol x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, x),
+  "Symbol x doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, x, {
   value: undefined,
@@ -52,8 +61,14 @@ verifyProperty(c, x, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
-assert.sameValue(Object.hasOwnProperty.call(C, y), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, y),
+  "Symbol y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, y),
+  "Symbol y doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, y, {
   value: 42,
@@ -62,10 +77,28 @@ verifyProperty(c, y, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "y"),
+  "y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "y"),
+  "y doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "y"),
+  "y doesn't appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/new-no-sc-line-method-grammar-privatename-identifier-semantics-stringvalue.js b/test/language/expressions/class/elements/new-no-sc-line-method-grammar-privatename-identifier-semantics-stringvalue.js
index 5a586d0d71..91158cb44d 100644
--- a/test/language/expressions/class/elements/new-no-sc-line-method-grammar-privatename-identifier-semantics-stringvalue.js
+++ b/test/language/expressions/class/elements/new-no-sc-line-method-grammar-privatename-identifier-semantics-stringvalue.js
@@ -91,7 +91,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-no-sc-line-method-literal-names-asi.js b/test/language/expressions/class/elements/new-no-sc-line-method-literal-names-asi.js
index 156555fcac..a6359f40a0 100644
--- a/test/language/expressions/class/elements/new-no-sc-line-method-literal-names-asi.js
+++ b/test/language/expressions/class/elements/new-no-sc-line-method-literal-names-asi.js
@@ -32,7 +32,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -40,8 +43,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -50,8 +59,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
diff --git a/test/language/expressions/class/elements/new-no-sc-line-method-literal-names.js b/test/language/expressions/class/elements/new-no-sc-line-method-literal-names.js
index 146ec7af35..064f47e0f7 100644
--- a/test/language/expressions/class/elements/new-no-sc-line-method-literal-names.js
+++ b/test/language/expressions/class/elements/new-no-sc-line-method-literal-names.js
@@ -34,7 +34,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -42,8 +45,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -52,8 +61,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -62,8 +77,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: fn,
diff --git a/test/language/expressions/class/elements/new-no-sc-line-method-private-field-usage.js b/test/language/expressions/class/elements/new-no-sc-line-method-private-field-usage.js
index d569a310ee..b1def9b073 100644
--- a/test/language/expressions/class/elements/new-no-sc-line-method-private-field-usage.js
+++ b/test/language/expressions/class/elements/new-no-sc-line-method-private-field-usage.js
@@ -34,7 +34,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-no-sc-line-method-private-method-getter-usage.js b/test/language/expressions/class/elements/new-no-sc-line-method-private-method-getter-usage.js
index d46583c67f..8db102f31f 100644
--- a/test/language/expressions/class/elements/new-no-sc-line-method-private-method-getter-usage.js
+++ b/test/language/expressions/class/elements/new-no-sc-line-method-private-method-getter-usage.js
@@ -34,7 +34,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-no-sc-line-method-private-method-usage.js b/test/language/expressions/class/elements/new-no-sc-line-method-private-method-usage.js
index 45ee29a7d9..61ed9290f5 100644
--- a/test/language/expressions/class/elements/new-no-sc-line-method-private-method-usage.js
+++ b/test/language/expressions/class/elements/new-no-sc-line-method-private-method-usage.js
@@ -34,7 +34,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-no-sc-line-method-private-names.js b/test/language/expressions/class/elements/new-no-sc-line-method-private-names.js
index a6cb4a1789..ed4bec2435 100644
--- a/test/language/expressions/class/elements/new-no-sc-line-method-private-names.js
+++ b/test/language/expressions/class/elements/new-no-sc-line-method-private-names.js
@@ -41,7 +41,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -50,18 +53,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(c.x(), 42, "test 7");
 assert.sameValue(c.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 10");
diff --git a/test/language/expressions/class/elements/new-no-sc-line-method-rs-field-identifier-initializer.js b/test/language/expressions/class/elements/new-no-sc-line-method-rs-field-identifier-initializer.js
index 961c3f97b7..8e7ed6d8f5 100644
--- a/test/language/expressions/class/elements/new-no-sc-line-method-rs-field-identifier-initializer.js
+++ b/test/language/expressions/class/elements/new-no-sc-line-method-rs-field-identifier-initializer.js
@@ -67,7 +67,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-no-sc-line-method-rs-field-identifier.js b/test/language/expressions/class/elements/new-no-sc-line-method-rs-field-identifier.js
index 330fc38063..399d248f48 100644
--- a/test/language/expressions/class/elements/new-no-sc-line-method-rs-field-identifier.js
+++ b/test/language/expressions/class/elements/new-no-sc-line-method-rs-field-identifier.js
@@ -67,7 +67,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-no-sc-line-method-rs-private-getter-alt.js b/test/language/expressions/class/elements/new-no-sc-line-method-rs-private-getter-alt.js
index ff7fd78ade..b4daad43aa 100644
--- a/test/language/expressions/class/elements/new-no-sc-line-method-rs-private-getter-alt.js
+++ b/test/language/expressions/class/elements/new-no-sc-line-method-rs-private-getter-alt.js
@@ -108,7 +108,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-no-sc-line-method-rs-private-getter.js b/test/language/expressions/class/elements/new-no-sc-line-method-rs-private-getter.js
index 5f0ca85656..28749d3ddb 100644
--- a/test/language/expressions/class/elements/new-no-sc-line-method-rs-private-getter.js
+++ b/test/language/expressions/class/elements/new-no-sc-line-method-rs-private-getter.js
@@ -108,7 +108,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-no-sc-line-method-rs-private-method-alt.js b/test/language/expressions/class/elements/new-no-sc-line-method-rs-private-method-alt.js
index d50dc7ae88..e6a0a6ab7e 100644
--- a/test/language/expressions/class/elements/new-no-sc-line-method-rs-private-method-alt.js
+++ b/test/language/expressions/class/elements/new-no-sc-line-method-rs-private-method-alt.js
@@ -107,7 +107,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-no-sc-line-method-rs-private-method.js b/test/language/expressions/class/elements/new-no-sc-line-method-rs-private-method.js
index 0c72109a20..38d00e1614 100644
--- a/test/language/expressions/class/elements/new-no-sc-line-method-rs-private-method.js
+++ b/test/language/expressions/class/elements/new-no-sc-line-method-rs-private-method.js
@@ -107,7 +107,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-no-sc-line-method-rs-private-setter-alt.js b/test/language/expressions/class/elements/new-no-sc-line-method-rs-private-setter-alt.js
index bce0ab3b55..df6254f799 100644
--- a/test/language/expressions/class/elements/new-no-sc-line-method-rs-private-setter-alt.js
+++ b/test/language/expressions/class/elements/new-no-sc-line-method-rs-private-setter-alt.js
@@ -107,7 +107,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-no-sc-line-method-rs-private-setter.js b/test/language/expressions/class/elements/new-no-sc-line-method-rs-private-setter.js
index 321117386b..5f7f02c88f 100644
--- a/test/language/expressions/class/elements/new-no-sc-line-method-rs-private-setter.js
+++ b/test/language/expressions/class/elements/new-no-sc-line-method-rs-private-setter.js
@@ -107,7 +107,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-no-sc-line-method-rs-privatename-identifier-alt.js b/test/language/expressions/class/elements/new-no-sc-line-method-rs-privatename-identifier-alt.js
index 4eb2d6288a..c01c81c558 100644
--- a/test/language/expressions/class/elements/new-no-sc-line-method-rs-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/new-no-sc-line-method-rs-privatename-identifier-alt.js
@@ -88,7 +88,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-no-sc-line-method-rs-privatename-identifier-initializer-alt.js b/test/language/expressions/class/elements/new-no-sc-line-method-rs-privatename-identifier-initializer-alt.js
index 8dc0b1dd4d..41d6321304 100644
--- a/test/language/expressions/class/elements/new-no-sc-line-method-rs-privatename-identifier-initializer-alt.js
+++ b/test/language/expressions/class/elements/new-no-sc-line-method-rs-privatename-identifier-initializer-alt.js
@@ -82,7 +82,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-no-sc-line-method-rs-privatename-identifier-initializer.js b/test/language/expressions/class/elements/new-no-sc-line-method-rs-privatename-identifier-initializer.js
index 42bbdbe803..ccc64b90c4 100644
--- a/test/language/expressions/class/elements/new-no-sc-line-method-rs-privatename-identifier-initializer.js
+++ b/test/language/expressions/class/elements/new-no-sc-line-method-rs-privatename-identifier-initializer.js
@@ -82,7 +82,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-no-sc-line-method-rs-privatename-identifier.js b/test/language/expressions/class/elements/new-no-sc-line-method-rs-privatename-identifier.js
index e9510cfe70..50104bce9e 100644
--- a/test/language/expressions/class/elements/new-no-sc-line-method-rs-privatename-identifier.js
+++ b/test/language/expressions/class/elements/new-no-sc-line-method-rs-privatename-identifier.js
@@ -88,7 +88,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
index 4cd9b656eb..59dc2ede3b 100644
--- a/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -104,7 +104,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-async-generator-method-privatename-identifier.js b/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-async-generator-method-privatename-identifier.js
index 46b560496e..675f9676ef 100644
--- a/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-async-generator-method-privatename-identifier.js
@@ -104,7 +104,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-async-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-async-method-privatename-identifier-alt.js
index d5b0f10d3c..f95a8c3d3f 100644
--- a/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-async-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-async-method-privatename-identifier-alt.js
@@ -104,7 +104,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-async-method-privatename-identifier.js b/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-async-method-privatename-identifier.js
index 723133f74d..ca5c888624 100644
--- a/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-async-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-async-method-privatename-identifier.js
@@ -104,7 +104,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-generator-method-privatename-identifier-alt.js
index 51d6c40d1e..449eeb39c3 100644
--- a/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-generator-method-privatename-identifier-alt.js
@@ -104,7 +104,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-generator-method-privatename-identifier.js b/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-generator-method-privatename-identifier.js
index 0c6c75630d..184f11081a 100644
--- a/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-generator-method-privatename-identifier.js
@@ -104,7 +104,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-method-privatename-identifier-alt.js
index b8cbf0985b..57feb91660 100644
--- a/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-method-privatename-identifier-alt.js
@@ -101,7 +101,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-method-privatename-identifier.js b/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-method-privatename-identifier.js
index 15b390f696..323583c81d 100644
--- a/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-method-privatename-identifier.js
@@ -101,7 +101,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-alt-by-classname.js b/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-alt-by-classname.js
index bceb0cd101..35500ff208 100644
--- a/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-alt-by-classname.js
+++ b/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-alt-by-classname.js
@@ -89,7 +89,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-alt.js b/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-alt.js
index 32bee93b7f..f00cd87806 100644
--- a/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-alt.js
@@ -89,7 +89,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-by-classname.js b/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-by-classname.js
index f1f1ee08a4..8c9b9a9cf0 100644
--- a/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-by-classname.js
+++ b/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-by-classname.js
@@ -89,7 +89,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-initializer-alt-by-classname.js b/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
index b921f3fc54..94ec4c05ef 100644
--- a/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
+++ b/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
@@ -83,7 +83,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-initializer-alt.js b/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-initializer-alt.js
index 49db350f72..6121943e0d 100644
--- a/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-initializer-alt.js
+++ b/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-initializer-alt.js
@@ -83,7 +83,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-initializer.js b/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-initializer.js
index 15eadfa8b9..3bb6e31c5b 100644
--- a/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-initializer.js
+++ b/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-initializer.js
@@ -83,7 +83,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-privatename-identifier.js b/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-privatename-identifier.js
index a130dd2b37..9daa0097a5 100644
--- a/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-privatename-identifier.js
+++ b/test/language/expressions/class/elements/new-no-sc-line-method-rs-static-privatename-identifier.js
@@ -89,7 +89,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-no-sc-line-method-static-private-fields.js b/test/language/expressions/class/elements/new-no-sc-line-method-static-private-fields.js
index 9f30b9e138..58ffd54cf6 100644
--- a/test/language/expressions/class/elements/new-no-sc-line-method-static-private-fields.js
+++ b/test/language/expressions/class/elements/new-no-sc-line-method-static-private-fields.js
@@ -41,7 +41,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -50,18 +53,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/expressions/class/elements/new-no-sc-line-method-static-private-methods-with-fields.js b/test/language/expressions/class/elements/new-no-sc-line-method-static-private-methods-with-fields.js
index 6be9539def..3e77642f6d 100644
--- a/test/language/expressions/class/elements/new-no-sc-line-method-static-private-methods-with-fields.js
+++ b/test/language/expressions/class/elements/new-no-sc-line-method-static-private-methods-with-fields.js
@@ -47,7 +47,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -56,29 +59,29 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#xVal"), "test 7");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 8");
+assert(!Object.prototype.hasOwnProperty.call(c, "#xVal"), "test 9");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#yVal"), "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 11");
+assert(!Object.prototype.hasOwnProperty.call(c, "#yVal"), "test 12");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 13");
 assert.sameValue(C.y(), 43, "test 14");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 15");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 16");
 
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 17");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 18");
diff --git a/test/language/expressions/class/elements/new-no-sc-line-method-static-private-methods.js b/test/language/expressions/class/elements/new-no-sc-line-method-static-private-methods.js
index da5d137705..07cfd56c0d 100644
--- a/test/language/expressions/class/elements/new-no-sc-line-method-static-private-methods.js
+++ b/test/language/expressions/class/elements/new-no-sc-line-method-static-private-methods.js
@@ -45,7 +45,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -54,18 +57,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/expressions/class/elements/new-no-sc-line-method-string-literal-names.js b/test/language/expressions/class/elements/new-no-sc-line-method-string-literal-names.js
index 7688872a19..1e539ae073 100644
--- a/test/language/expressions/class/elements/new-no-sc-line-method-string-literal-names.js
+++ b/test/language/expressions/class/elements/new-no-sc-line-method-string-literal-names.js
@@ -32,7 +32,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -40,8 +43,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -50,8 +59,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: undefined,
@@ -60,8 +75,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: 39,
@@ -70,8 +91,14 @@ verifyProperty(c, "c", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "d"),
+  "d does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "d"),
+  "d does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "d", {
   value: 42,
diff --git a/test/language/expressions/class/elements/new-sc-line-gen-computed-names.js b/test/language/expressions/class/elements/new-sc-line-gen-computed-names.js
index b349f03b9c..d2bef58fc6 100644
--- a/test/language/expressions/class/elements/new-sc-line-gen-computed-names.js
+++ b/test/language/expressions/class/elements/new-sc-line-gen-computed-names.js
@@ -33,7 +33,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -41,8 +44,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -51,12 +60,27 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "10"),
+  "10 doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "10"),
+  "10 doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "10", {
   value: "meep",
@@ -65,8 +89,14 @@ verifyProperty(c, "10", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "not initialized", {
   value: undefined,
diff --git a/test/language/expressions/class/elements/new-sc-line-gen-computed-symbol-names.js b/test/language/expressions/class/elements/new-sc-line-gen-computed-symbol-names.js
index 223d5e37ca..848305f9a8 100644
--- a/test/language/expressions/class/elements/new-sc-line-gen-computed-symbol-names.js
+++ b/test/language/expressions/class/elements/new-sc-line-gen-computed-symbol-names.js
@@ -34,7 +34,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -42,8 +45,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, x), false);
-assert.sameValue(Object.hasOwnProperty.call(C, x), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, x),
+  "Symbol x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, x),
+  "Symbol x doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, x, {
   value: undefined,
@@ -52,8 +61,14 @@ verifyProperty(c, x, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
-assert.sameValue(Object.hasOwnProperty.call(C, y), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, y),
+  "Symbol y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, y),
+  "Symbol y doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, y, {
   value: 42,
@@ -62,10 +77,28 @@ verifyProperty(c, y, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "y"),
+  "y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "y"),
+  "y doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "y"),
+  "y doesn't appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/new-sc-line-gen-grammar-privatename-identifier-semantics-stringvalue.js b/test/language/expressions/class/elements/new-sc-line-gen-grammar-privatename-identifier-semantics-stringvalue.js
index a1e390b865..cdac1ea236 100644
--- a/test/language/expressions/class/elements/new-sc-line-gen-grammar-privatename-identifier-semantics-stringvalue.js
+++ b/test/language/expressions/class/elements/new-sc-line-gen-grammar-privatename-identifier-semantics-stringvalue.js
@@ -91,7 +91,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-gen-literal-names-asi.js b/test/language/expressions/class/elements/new-sc-line-gen-literal-names-asi.js
index e799221ddf..9384d5b0f7 100644
--- a/test/language/expressions/class/elements/new-sc-line-gen-literal-names-asi.js
+++ b/test/language/expressions/class/elements/new-sc-line-gen-literal-names-asi.js
@@ -32,7 +32,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -40,8 +43,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -50,8 +59,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
diff --git a/test/language/expressions/class/elements/new-sc-line-gen-literal-names.js b/test/language/expressions/class/elements/new-sc-line-gen-literal-names.js
index 7d3f2de560..ea836dde4f 100644
--- a/test/language/expressions/class/elements/new-sc-line-gen-literal-names.js
+++ b/test/language/expressions/class/elements/new-sc-line-gen-literal-names.js
@@ -34,7 +34,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -42,8 +45,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -52,8 +61,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -62,8 +77,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: fn,
diff --git a/test/language/expressions/class/elements/new-sc-line-gen-private-field-usage.js b/test/language/expressions/class/elements/new-sc-line-gen-private-field-usage.js
index 37c72b9bcb..5b7742c7e7 100644
--- a/test/language/expressions/class/elements/new-sc-line-gen-private-field-usage.js
+++ b/test/language/expressions/class/elements/new-sc-line-gen-private-field-usage.js
@@ -34,7 +34,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-gen-private-method-getter-usage.js b/test/language/expressions/class/elements/new-sc-line-gen-private-method-getter-usage.js
index a89962a5bc..7a8d21a369 100644
--- a/test/language/expressions/class/elements/new-sc-line-gen-private-method-getter-usage.js
+++ b/test/language/expressions/class/elements/new-sc-line-gen-private-method-getter-usage.js
@@ -34,7 +34,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-gen-private-method-usage.js b/test/language/expressions/class/elements/new-sc-line-gen-private-method-usage.js
index d27918c87d..82ee3307bb 100644
--- a/test/language/expressions/class/elements/new-sc-line-gen-private-method-usage.js
+++ b/test/language/expressions/class/elements/new-sc-line-gen-private-method-usage.js
@@ -34,7 +34,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-gen-private-names.js b/test/language/expressions/class/elements/new-sc-line-gen-private-names.js
index 5a4f2fbe80..137d834b2f 100644
--- a/test/language/expressions/class/elements/new-sc-line-gen-private-names.js
+++ b/test/language/expressions/class/elements/new-sc-line-gen-private-names.js
@@ -41,7 +41,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -50,18 +53,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(c.x(), 42, "test 7");
 assert.sameValue(c.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 10");
diff --git a/test/language/expressions/class/elements/new-sc-line-gen-rs-field-identifier-initializer.js b/test/language/expressions/class/elements/new-sc-line-gen-rs-field-identifier-initializer.js
index 7a65e05783..9be2b23da3 100644
--- a/test/language/expressions/class/elements/new-sc-line-gen-rs-field-identifier-initializer.js
+++ b/test/language/expressions/class/elements/new-sc-line-gen-rs-field-identifier-initializer.js
@@ -67,7 +67,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-gen-rs-field-identifier.js b/test/language/expressions/class/elements/new-sc-line-gen-rs-field-identifier.js
index 6bdfc94449..bf39e12ee3 100644
--- a/test/language/expressions/class/elements/new-sc-line-gen-rs-field-identifier.js
+++ b/test/language/expressions/class/elements/new-sc-line-gen-rs-field-identifier.js
@@ -67,7 +67,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-gen-rs-private-getter-alt.js b/test/language/expressions/class/elements/new-sc-line-gen-rs-private-getter-alt.js
index 4498446367..e696d60c21 100644
--- a/test/language/expressions/class/elements/new-sc-line-gen-rs-private-getter-alt.js
+++ b/test/language/expressions/class/elements/new-sc-line-gen-rs-private-getter-alt.js
@@ -108,7 +108,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-gen-rs-private-getter.js b/test/language/expressions/class/elements/new-sc-line-gen-rs-private-getter.js
index 68d2e8271a..64274f80e5 100644
--- a/test/language/expressions/class/elements/new-sc-line-gen-rs-private-getter.js
+++ b/test/language/expressions/class/elements/new-sc-line-gen-rs-private-getter.js
@@ -108,7 +108,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-gen-rs-private-method-alt.js b/test/language/expressions/class/elements/new-sc-line-gen-rs-private-method-alt.js
index 9bbac25e88..8c2ae4e646 100644
--- a/test/language/expressions/class/elements/new-sc-line-gen-rs-private-method-alt.js
+++ b/test/language/expressions/class/elements/new-sc-line-gen-rs-private-method-alt.js
@@ -107,7 +107,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-gen-rs-private-method.js b/test/language/expressions/class/elements/new-sc-line-gen-rs-private-method.js
index 0fbd2440b7..cd183ecdfe 100644
--- a/test/language/expressions/class/elements/new-sc-line-gen-rs-private-method.js
+++ b/test/language/expressions/class/elements/new-sc-line-gen-rs-private-method.js
@@ -107,7 +107,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-gen-rs-private-setter-alt.js b/test/language/expressions/class/elements/new-sc-line-gen-rs-private-setter-alt.js
index e3411658f9..fa147b655a 100644
--- a/test/language/expressions/class/elements/new-sc-line-gen-rs-private-setter-alt.js
+++ b/test/language/expressions/class/elements/new-sc-line-gen-rs-private-setter-alt.js
@@ -107,7 +107,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-gen-rs-private-setter.js b/test/language/expressions/class/elements/new-sc-line-gen-rs-private-setter.js
index 10b56317ef..fe8e3d0424 100644
--- a/test/language/expressions/class/elements/new-sc-line-gen-rs-private-setter.js
+++ b/test/language/expressions/class/elements/new-sc-line-gen-rs-private-setter.js
@@ -107,7 +107,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-gen-rs-privatename-identifier-alt.js b/test/language/expressions/class/elements/new-sc-line-gen-rs-privatename-identifier-alt.js
index 124f71f2e0..4eed3ea828 100644
--- a/test/language/expressions/class/elements/new-sc-line-gen-rs-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/new-sc-line-gen-rs-privatename-identifier-alt.js
@@ -88,7 +88,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-gen-rs-privatename-identifier-initializer-alt.js b/test/language/expressions/class/elements/new-sc-line-gen-rs-privatename-identifier-initializer-alt.js
index 05119a2b6d..cb30c6c408 100644
--- a/test/language/expressions/class/elements/new-sc-line-gen-rs-privatename-identifier-initializer-alt.js
+++ b/test/language/expressions/class/elements/new-sc-line-gen-rs-privatename-identifier-initializer-alt.js
@@ -82,7 +82,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-gen-rs-privatename-identifier-initializer.js b/test/language/expressions/class/elements/new-sc-line-gen-rs-privatename-identifier-initializer.js
index 4722cad50b..9f79b8a7cc 100644
--- a/test/language/expressions/class/elements/new-sc-line-gen-rs-privatename-identifier-initializer.js
+++ b/test/language/expressions/class/elements/new-sc-line-gen-rs-privatename-identifier-initializer.js
@@ -82,7 +82,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-gen-rs-privatename-identifier.js b/test/language/expressions/class/elements/new-sc-line-gen-rs-privatename-identifier.js
index 9dd47ad861..c07c28d5db 100644
--- a/test/language/expressions/class/elements/new-sc-line-gen-rs-privatename-identifier.js
+++ b/test/language/expressions/class/elements/new-sc-line-gen-rs-privatename-identifier.js
@@ -88,7 +88,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/new-sc-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js
index f364fc31a5..98433a66b5 100644
--- a/test/language/expressions/class/elements/new-sc-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/new-sc-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -104,7 +104,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-gen-rs-static-async-generator-method-privatename-identifier.js b/test/language/expressions/class/elements/new-sc-line-gen-rs-static-async-generator-method-privatename-identifier.js
index 2eba435aef..1af32e1559 100644
--- a/test/language/expressions/class/elements/new-sc-line-gen-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/new-sc-line-gen-rs-static-async-generator-method-privatename-identifier.js
@@ -104,7 +104,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-gen-rs-static-async-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/new-sc-line-gen-rs-static-async-method-privatename-identifier-alt.js
index 2d4ab1d35a..eabb31aca4 100644
--- a/test/language/expressions/class/elements/new-sc-line-gen-rs-static-async-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/new-sc-line-gen-rs-static-async-method-privatename-identifier-alt.js
@@ -104,7 +104,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-gen-rs-static-async-method-privatename-identifier.js b/test/language/expressions/class/elements/new-sc-line-gen-rs-static-async-method-privatename-identifier.js
index 1acc309052..f7f319ed03 100644
--- a/test/language/expressions/class/elements/new-sc-line-gen-rs-static-async-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/new-sc-line-gen-rs-static-async-method-privatename-identifier.js
@@ -104,7 +104,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-gen-rs-static-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/new-sc-line-gen-rs-static-generator-method-privatename-identifier-alt.js
index cf0844c645..663264f791 100644
--- a/test/language/expressions/class/elements/new-sc-line-gen-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/new-sc-line-gen-rs-static-generator-method-privatename-identifier-alt.js
@@ -104,7 +104,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-gen-rs-static-generator-method-privatename-identifier.js b/test/language/expressions/class/elements/new-sc-line-gen-rs-static-generator-method-privatename-identifier.js
index 48811d6f4f..90cdcb2f5b 100644
--- a/test/language/expressions/class/elements/new-sc-line-gen-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/new-sc-line-gen-rs-static-generator-method-privatename-identifier.js
@@ -104,7 +104,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-gen-rs-static-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/new-sc-line-gen-rs-static-method-privatename-identifier-alt.js
index b096785a18..34666def85 100644
--- a/test/language/expressions/class/elements/new-sc-line-gen-rs-static-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/new-sc-line-gen-rs-static-method-privatename-identifier-alt.js
@@ -101,7 +101,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-gen-rs-static-method-privatename-identifier.js b/test/language/expressions/class/elements/new-sc-line-gen-rs-static-method-privatename-identifier.js
index 8101b634d3..c9a1b4b334 100644
--- a/test/language/expressions/class/elements/new-sc-line-gen-rs-static-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/new-sc-line-gen-rs-static-method-privatename-identifier.js
@@ -101,7 +101,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-gen-rs-static-privatename-identifier-alt-by-classname.js b/test/language/expressions/class/elements/new-sc-line-gen-rs-static-privatename-identifier-alt-by-classname.js
index 8f1c54f971..f0f7e9bf9b 100644
--- a/test/language/expressions/class/elements/new-sc-line-gen-rs-static-privatename-identifier-alt-by-classname.js
+++ b/test/language/expressions/class/elements/new-sc-line-gen-rs-static-privatename-identifier-alt-by-classname.js
@@ -89,7 +89,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-gen-rs-static-privatename-identifier-alt.js b/test/language/expressions/class/elements/new-sc-line-gen-rs-static-privatename-identifier-alt.js
index 852a364117..726d30af98 100644
--- a/test/language/expressions/class/elements/new-sc-line-gen-rs-static-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/new-sc-line-gen-rs-static-privatename-identifier-alt.js
@@ -89,7 +89,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-gen-rs-static-privatename-identifier-by-classname.js b/test/language/expressions/class/elements/new-sc-line-gen-rs-static-privatename-identifier-by-classname.js
index 3b14af3ef9..90138d04e9 100644
--- a/test/language/expressions/class/elements/new-sc-line-gen-rs-static-privatename-identifier-by-classname.js
+++ b/test/language/expressions/class/elements/new-sc-line-gen-rs-static-privatename-identifier-by-classname.js
@@ -89,7 +89,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js b/test/language/expressions/class/elements/new-sc-line-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
index e7302bc460..6aafb641bb 100644
--- a/test/language/expressions/class/elements/new-sc-line-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
+++ b/test/language/expressions/class/elements/new-sc-line-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
@@ -83,7 +83,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-gen-rs-static-privatename-identifier-initializer-alt.js b/test/language/expressions/class/elements/new-sc-line-gen-rs-static-privatename-identifier-initializer-alt.js
index 355dd5be70..be9201fb17 100644
--- a/test/language/expressions/class/elements/new-sc-line-gen-rs-static-privatename-identifier-initializer-alt.js
+++ b/test/language/expressions/class/elements/new-sc-line-gen-rs-static-privatename-identifier-initializer-alt.js
@@ -83,7 +83,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-gen-rs-static-privatename-identifier-initializer.js b/test/language/expressions/class/elements/new-sc-line-gen-rs-static-privatename-identifier-initializer.js
index 82d0a9791d..1d2efa04cc 100644
--- a/test/language/expressions/class/elements/new-sc-line-gen-rs-static-privatename-identifier-initializer.js
+++ b/test/language/expressions/class/elements/new-sc-line-gen-rs-static-privatename-identifier-initializer.js
@@ -83,7 +83,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-gen-rs-static-privatename-identifier.js b/test/language/expressions/class/elements/new-sc-line-gen-rs-static-privatename-identifier.js
index b1e5c2e33d..9805b54119 100644
--- a/test/language/expressions/class/elements/new-sc-line-gen-rs-static-privatename-identifier.js
+++ b/test/language/expressions/class/elements/new-sc-line-gen-rs-static-privatename-identifier.js
@@ -89,7 +89,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-gen-static-private-fields.js b/test/language/expressions/class/elements/new-sc-line-gen-static-private-fields.js
index dbe4381a52..0968a04dc2 100644
--- a/test/language/expressions/class/elements/new-sc-line-gen-static-private-fields.js
+++ b/test/language/expressions/class/elements/new-sc-line-gen-static-private-fields.js
@@ -41,7 +41,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -50,18 +53,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/expressions/class/elements/new-sc-line-gen-static-private-methods-with-fields.js b/test/language/expressions/class/elements/new-sc-line-gen-static-private-methods-with-fields.js
index 23e38b34d5..18d50495bc 100644
--- a/test/language/expressions/class/elements/new-sc-line-gen-static-private-methods-with-fields.js
+++ b/test/language/expressions/class/elements/new-sc-line-gen-static-private-methods-with-fields.js
@@ -47,7 +47,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -56,29 +59,29 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#xVal"), "test 7");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 8");
+assert(!Object.prototype.hasOwnProperty.call(c, "#xVal"), "test 9");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#yVal"), "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 11");
+assert(!Object.prototype.hasOwnProperty.call(c, "#yVal"), "test 12");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 13");
 assert.sameValue(C.y(), 43, "test 14");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 15");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 16");
 
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 17");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 18");
diff --git a/test/language/expressions/class/elements/new-sc-line-gen-static-private-methods.js b/test/language/expressions/class/elements/new-sc-line-gen-static-private-methods.js
index b4d6c7de91..9c567c773b 100644
--- a/test/language/expressions/class/elements/new-sc-line-gen-static-private-methods.js
+++ b/test/language/expressions/class/elements/new-sc-line-gen-static-private-methods.js
@@ -45,7 +45,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -54,18 +57,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/expressions/class/elements/new-sc-line-gen-string-literal-names.js b/test/language/expressions/class/elements/new-sc-line-gen-string-literal-names.js
index c185da9e47..29941d8a1a 100644
--- a/test/language/expressions/class/elements/new-sc-line-gen-string-literal-names.js
+++ b/test/language/expressions/class/elements/new-sc-line-gen-string-literal-names.js
@@ -32,7 +32,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -40,8 +43,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -50,8 +59,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: undefined,
@@ -60,8 +75,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: 39,
@@ -70,8 +91,14 @@ verifyProperty(c, "c", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "d"),
+  "d does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "d"),
+  "d does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "d", {
   value: 42,
diff --git a/test/language/expressions/class/elements/new-sc-line-method-computed-names.js b/test/language/expressions/class/elements/new-sc-line-method-computed-names.js
index 11ae28fe01..79986761c7 100644
--- a/test/language/expressions/class/elements/new-sc-line-method-computed-names.js
+++ b/test/language/expressions/class/elements/new-sc-line-method-computed-names.js
@@ -33,7 +33,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -41,8 +44,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -51,12 +60,27 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "10"),
+  "10 doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "10"),
+  "10 doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "10", {
   value: "meep",
@@ -65,8 +89,14 @@ verifyProperty(c, "10", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "not initialized", {
   value: undefined,
diff --git a/test/language/expressions/class/elements/new-sc-line-method-computed-symbol-names.js b/test/language/expressions/class/elements/new-sc-line-method-computed-symbol-names.js
index dddee41262..da5b94cf7c 100644
--- a/test/language/expressions/class/elements/new-sc-line-method-computed-symbol-names.js
+++ b/test/language/expressions/class/elements/new-sc-line-method-computed-symbol-names.js
@@ -34,7 +34,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -42,8 +45,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, x), false);
-assert.sameValue(Object.hasOwnProperty.call(C, x), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, x),
+  "Symbol x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, x),
+  "Symbol x doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, x, {
   value: undefined,
@@ -52,8 +61,14 @@ verifyProperty(c, x, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
-assert.sameValue(Object.hasOwnProperty.call(C, y), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, y),
+  "Symbol y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, y),
+  "Symbol y doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, y, {
   value: 42,
@@ -62,10 +77,28 @@ verifyProperty(c, y, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "y"),
+  "y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "y"),
+  "y doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "y"),
+  "y doesn't appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/new-sc-line-method-grammar-privatename-identifier-semantics-stringvalue.js b/test/language/expressions/class/elements/new-sc-line-method-grammar-privatename-identifier-semantics-stringvalue.js
index 1b9a8ddbed..be6bc032ea 100644
--- a/test/language/expressions/class/elements/new-sc-line-method-grammar-privatename-identifier-semantics-stringvalue.js
+++ b/test/language/expressions/class/elements/new-sc-line-method-grammar-privatename-identifier-semantics-stringvalue.js
@@ -91,7 +91,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-method-literal-names-asi.js b/test/language/expressions/class/elements/new-sc-line-method-literal-names-asi.js
index 6a0318fb4c..0a7b916e53 100644
--- a/test/language/expressions/class/elements/new-sc-line-method-literal-names-asi.js
+++ b/test/language/expressions/class/elements/new-sc-line-method-literal-names-asi.js
@@ -32,7 +32,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -40,8 +43,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -50,8 +59,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
diff --git a/test/language/expressions/class/elements/new-sc-line-method-literal-names.js b/test/language/expressions/class/elements/new-sc-line-method-literal-names.js
index 2887c81a3b..12ace4b3d7 100644
--- a/test/language/expressions/class/elements/new-sc-line-method-literal-names.js
+++ b/test/language/expressions/class/elements/new-sc-line-method-literal-names.js
@@ -34,7 +34,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -42,8 +45,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -52,8 +61,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -62,8 +77,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: fn,
diff --git a/test/language/expressions/class/elements/new-sc-line-method-private-field-usage.js b/test/language/expressions/class/elements/new-sc-line-method-private-field-usage.js
index ec71a45c36..18454427d6 100644
--- a/test/language/expressions/class/elements/new-sc-line-method-private-field-usage.js
+++ b/test/language/expressions/class/elements/new-sc-line-method-private-field-usage.js
@@ -34,7 +34,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-method-private-method-getter-usage.js b/test/language/expressions/class/elements/new-sc-line-method-private-method-getter-usage.js
index 5f46aa8eb1..595109bb61 100644
--- a/test/language/expressions/class/elements/new-sc-line-method-private-method-getter-usage.js
+++ b/test/language/expressions/class/elements/new-sc-line-method-private-method-getter-usage.js
@@ -34,7 +34,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-method-private-method-usage.js b/test/language/expressions/class/elements/new-sc-line-method-private-method-usage.js
index 6ab38a019b..a5d19ace0e 100644
--- a/test/language/expressions/class/elements/new-sc-line-method-private-method-usage.js
+++ b/test/language/expressions/class/elements/new-sc-line-method-private-method-usage.js
@@ -34,7 +34,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-method-private-names.js b/test/language/expressions/class/elements/new-sc-line-method-private-names.js
index e103f31f87..a3fd60927c 100644
--- a/test/language/expressions/class/elements/new-sc-line-method-private-names.js
+++ b/test/language/expressions/class/elements/new-sc-line-method-private-names.js
@@ -41,7 +41,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -50,18 +53,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(c.x(), 42, "test 7");
 assert.sameValue(c.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 10");
diff --git a/test/language/expressions/class/elements/new-sc-line-method-rs-field-identifier-initializer.js b/test/language/expressions/class/elements/new-sc-line-method-rs-field-identifier-initializer.js
index 8b4b8bb37f..5ba82cff66 100644
--- a/test/language/expressions/class/elements/new-sc-line-method-rs-field-identifier-initializer.js
+++ b/test/language/expressions/class/elements/new-sc-line-method-rs-field-identifier-initializer.js
@@ -67,7 +67,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-method-rs-field-identifier.js b/test/language/expressions/class/elements/new-sc-line-method-rs-field-identifier.js
index 8d93062e94..8bec8dbbe3 100644
--- a/test/language/expressions/class/elements/new-sc-line-method-rs-field-identifier.js
+++ b/test/language/expressions/class/elements/new-sc-line-method-rs-field-identifier.js
@@ -67,7 +67,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-method-rs-private-getter-alt.js b/test/language/expressions/class/elements/new-sc-line-method-rs-private-getter-alt.js
index 20b26f4881..c9f0db2303 100644
--- a/test/language/expressions/class/elements/new-sc-line-method-rs-private-getter-alt.js
+++ b/test/language/expressions/class/elements/new-sc-line-method-rs-private-getter-alt.js
@@ -108,7 +108,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-method-rs-private-getter.js b/test/language/expressions/class/elements/new-sc-line-method-rs-private-getter.js
index 099f902a29..4456d54504 100644
--- a/test/language/expressions/class/elements/new-sc-line-method-rs-private-getter.js
+++ b/test/language/expressions/class/elements/new-sc-line-method-rs-private-getter.js
@@ -108,7 +108,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-method-rs-private-method-alt.js b/test/language/expressions/class/elements/new-sc-line-method-rs-private-method-alt.js
index 3526360274..e8a84ff31d 100644
--- a/test/language/expressions/class/elements/new-sc-line-method-rs-private-method-alt.js
+++ b/test/language/expressions/class/elements/new-sc-line-method-rs-private-method-alt.js
@@ -107,7 +107,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-method-rs-private-method.js b/test/language/expressions/class/elements/new-sc-line-method-rs-private-method.js
index 6f33fd11d1..559bb4ac44 100644
--- a/test/language/expressions/class/elements/new-sc-line-method-rs-private-method.js
+++ b/test/language/expressions/class/elements/new-sc-line-method-rs-private-method.js
@@ -107,7 +107,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-method-rs-private-setter-alt.js b/test/language/expressions/class/elements/new-sc-line-method-rs-private-setter-alt.js
index d7443763f7..8627fc5592 100644
--- a/test/language/expressions/class/elements/new-sc-line-method-rs-private-setter-alt.js
+++ b/test/language/expressions/class/elements/new-sc-line-method-rs-private-setter-alt.js
@@ -107,7 +107,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-method-rs-private-setter.js b/test/language/expressions/class/elements/new-sc-line-method-rs-private-setter.js
index d5da58791f..084a62a0bf 100644
--- a/test/language/expressions/class/elements/new-sc-line-method-rs-private-setter.js
+++ b/test/language/expressions/class/elements/new-sc-line-method-rs-private-setter.js
@@ -107,7 +107,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-method-rs-privatename-identifier-alt.js b/test/language/expressions/class/elements/new-sc-line-method-rs-privatename-identifier-alt.js
index f903f6cc14..1369d2998d 100644
--- a/test/language/expressions/class/elements/new-sc-line-method-rs-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/new-sc-line-method-rs-privatename-identifier-alt.js
@@ -88,7 +88,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-method-rs-privatename-identifier-initializer-alt.js b/test/language/expressions/class/elements/new-sc-line-method-rs-privatename-identifier-initializer-alt.js
index eb07037496..f97fe4100e 100644
--- a/test/language/expressions/class/elements/new-sc-line-method-rs-privatename-identifier-initializer-alt.js
+++ b/test/language/expressions/class/elements/new-sc-line-method-rs-privatename-identifier-initializer-alt.js
@@ -82,7 +82,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-method-rs-privatename-identifier-initializer.js b/test/language/expressions/class/elements/new-sc-line-method-rs-privatename-identifier-initializer.js
index 393a876d6c..2201924f51 100644
--- a/test/language/expressions/class/elements/new-sc-line-method-rs-privatename-identifier-initializer.js
+++ b/test/language/expressions/class/elements/new-sc-line-method-rs-privatename-identifier-initializer.js
@@ -82,7 +82,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-method-rs-privatename-identifier.js b/test/language/expressions/class/elements/new-sc-line-method-rs-privatename-identifier.js
index 0cbeb90ed5..0941f09dc0 100644
--- a/test/language/expressions/class/elements/new-sc-line-method-rs-privatename-identifier.js
+++ b/test/language/expressions/class/elements/new-sc-line-method-rs-privatename-identifier.js
@@ -88,7 +88,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-method-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/new-sc-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
index e730046f20..37240727e7 100644
--- a/test/language/expressions/class/elements/new-sc-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/new-sc-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -104,7 +104,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-method-rs-static-async-generator-method-privatename-identifier.js b/test/language/expressions/class/elements/new-sc-line-method-rs-static-async-generator-method-privatename-identifier.js
index 97729a97aa..a14eb2fcf9 100644
--- a/test/language/expressions/class/elements/new-sc-line-method-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/new-sc-line-method-rs-static-async-generator-method-privatename-identifier.js
@@ -104,7 +104,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-method-rs-static-async-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/new-sc-line-method-rs-static-async-method-privatename-identifier-alt.js
index 2093f613db..d5e3394809 100644
--- a/test/language/expressions/class/elements/new-sc-line-method-rs-static-async-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/new-sc-line-method-rs-static-async-method-privatename-identifier-alt.js
@@ -104,7 +104,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-method-rs-static-async-method-privatename-identifier.js b/test/language/expressions/class/elements/new-sc-line-method-rs-static-async-method-privatename-identifier.js
index 9f5267cd8d..00804ed8da 100644
--- a/test/language/expressions/class/elements/new-sc-line-method-rs-static-async-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/new-sc-line-method-rs-static-async-method-privatename-identifier.js
@@ -104,7 +104,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-method-rs-static-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/new-sc-line-method-rs-static-generator-method-privatename-identifier-alt.js
index a48c9a2d64..797e30a01b 100644
--- a/test/language/expressions/class/elements/new-sc-line-method-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/new-sc-line-method-rs-static-generator-method-privatename-identifier-alt.js
@@ -104,7 +104,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-method-rs-static-generator-method-privatename-identifier.js b/test/language/expressions/class/elements/new-sc-line-method-rs-static-generator-method-privatename-identifier.js
index a51934307f..b94c7f8957 100644
--- a/test/language/expressions/class/elements/new-sc-line-method-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/new-sc-line-method-rs-static-generator-method-privatename-identifier.js
@@ -104,7 +104,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-method-rs-static-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/new-sc-line-method-rs-static-method-privatename-identifier-alt.js
index 2cdef96fe5..595c4aa2b4 100644
--- a/test/language/expressions/class/elements/new-sc-line-method-rs-static-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/new-sc-line-method-rs-static-method-privatename-identifier-alt.js
@@ -101,7 +101,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-method-rs-static-method-privatename-identifier.js b/test/language/expressions/class/elements/new-sc-line-method-rs-static-method-privatename-identifier.js
index b9bdaaca7b..9655dcdee2 100644
--- a/test/language/expressions/class/elements/new-sc-line-method-rs-static-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/new-sc-line-method-rs-static-method-privatename-identifier.js
@@ -101,7 +101,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-method-rs-static-privatename-identifier-alt-by-classname.js b/test/language/expressions/class/elements/new-sc-line-method-rs-static-privatename-identifier-alt-by-classname.js
index b294134760..1f74d9a458 100644
--- a/test/language/expressions/class/elements/new-sc-line-method-rs-static-privatename-identifier-alt-by-classname.js
+++ b/test/language/expressions/class/elements/new-sc-line-method-rs-static-privatename-identifier-alt-by-classname.js
@@ -89,7 +89,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-method-rs-static-privatename-identifier-alt.js b/test/language/expressions/class/elements/new-sc-line-method-rs-static-privatename-identifier-alt.js
index e5e461ba54..baa43bb234 100644
--- a/test/language/expressions/class/elements/new-sc-line-method-rs-static-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/new-sc-line-method-rs-static-privatename-identifier-alt.js
@@ -89,7 +89,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-method-rs-static-privatename-identifier-by-classname.js b/test/language/expressions/class/elements/new-sc-line-method-rs-static-privatename-identifier-by-classname.js
index 60a755fa63..c067ccad3e 100644
--- a/test/language/expressions/class/elements/new-sc-line-method-rs-static-privatename-identifier-by-classname.js
+++ b/test/language/expressions/class/elements/new-sc-line-method-rs-static-privatename-identifier-by-classname.js
@@ -89,7 +89,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-method-rs-static-privatename-identifier-initializer-alt-by-classname.js b/test/language/expressions/class/elements/new-sc-line-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
index a1e13ce04d..1728f704c7 100644
--- a/test/language/expressions/class/elements/new-sc-line-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
+++ b/test/language/expressions/class/elements/new-sc-line-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
@@ -83,7 +83,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-method-rs-static-privatename-identifier-initializer-alt.js b/test/language/expressions/class/elements/new-sc-line-method-rs-static-privatename-identifier-initializer-alt.js
index 7757baf4fa..64d9812a08 100644
--- a/test/language/expressions/class/elements/new-sc-line-method-rs-static-privatename-identifier-initializer-alt.js
+++ b/test/language/expressions/class/elements/new-sc-line-method-rs-static-privatename-identifier-initializer-alt.js
@@ -83,7 +83,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-method-rs-static-privatename-identifier-initializer.js b/test/language/expressions/class/elements/new-sc-line-method-rs-static-privatename-identifier-initializer.js
index b46b5d6113..e15abcf2a9 100644
--- a/test/language/expressions/class/elements/new-sc-line-method-rs-static-privatename-identifier-initializer.js
+++ b/test/language/expressions/class/elements/new-sc-line-method-rs-static-privatename-identifier-initializer.js
@@ -83,7 +83,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-method-rs-static-privatename-identifier.js b/test/language/expressions/class/elements/new-sc-line-method-rs-static-privatename-identifier.js
index b38e5afbae..34ad55f879 100644
--- a/test/language/expressions/class/elements/new-sc-line-method-rs-static-privatename-identifier.js
+++ b/test/language/expressions/class/elements/new-sc-line-method-rs-static-privatename-identifier.js
@@ -89,7 +89,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/new-sc-line-method-static-private-fields.js b/test/language/expressions/class/elements/new-sc-line-method-static-private-fields.js
index 8827bb6d61..55956e90a9 100644
--- a/test/language/expressions/class/elements/new-sc-line-method-static-private-fields.js
+++ b/test/language/expressions/class/elements/new-sc-line-method-static-private-fields.js
@@ -41,7 +41,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -50,18 +53,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/expressions/class/elements/new-sc-line-method-static-private-methods-with-fields.js b/test/language/expressions/class/elements/new-sc-line-method-static-private-methods-with-fields.js
index 8467c85496..918341c3c5 100644
--- a/test/language/expressions/class/elements/new-sc-line-method-static-private-methods-with-fields.js
+++ b/test/language/expressions/class/elements/new-sc-line-method-static-private-methods-with-fields.js
@@ -47,7 +47,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -56,29 +59,29 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#xVal"), "test 7");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 8");
+assert(!Object.prototype.hasOwnProperty.call(c, "#xVal"), "test 9");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#yVal"), "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 11");
+assert(!Object.prototype.hasOwnProperty.call(c, "#yVal"), "test 12");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 13");
 assert.sameValue(C.y(), 43, "test 14");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 15");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 16");
 
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 17");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 18");
diff --git a/test/language/expressions/class/elements/new-sc-line-method-static-private-methods.js b/test/language/expressions/class/elements/new-sc-line-method-static-private-methods.js
index db0046942e..73e7850828 100644
--- a/test/language/expressions/class/elements/new-sc-line-method-static-private-methods.js
+++ b/test/language/expressions/class/elements/new-sc-line-method-static-private-methods.js
@@ -45,7 +45,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -54,18 +57,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/expressions/class/elements/new-sc-line-method-string-literal-names.js b/test/language/expressions/class/elements/new-sc-line-method-string-literal-names.js
index bbca638684..c5aaacca69 100644
--- a/test/language/expressions/class/elements/new-sc-line-method-string-literal-names.js
+++ b/test/language/expressions/class/elements/new-sc-line-method-string-literal-names.js
@@ -32,7 +32,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -40,8 +43,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -50,8 +59,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: undefined,
@@ -60,8 +75,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: 39,
@@ -70,8 +91,14 @@ verifyProperty(c, "c", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "d"),
+  "d does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "d"),
+  "d does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "d", {
   value: 42,
diff --git a/test/language/expressions/class/elements/redeclaration-symbol.js b/test/language/expressions/class/elements/redeclaration-symbol.js
index 5268fe2774..b7640ce6c9 100644
--- a/test/language/expressions/class/elements/redeclaration-symbol.js
+++ b/test/language/expressions/class/elements/redeclaration-symbol.js
@@ -42,8 +42,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
-assert.sameValue(Object.hasOwnProperty.call(C, y), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, y),
+  "y does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, y),
+  "y does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, y, {
   value: "same_value",
diff --git a/test/language/expressions/class/elements/redeclaration.js b/test/language/expressions/class/elements/redeclaration.js
index 131ed05b40..268a96dcc5 100644
--- a/test/language/expressions/class/elements/redeclaration.js
+++ b/test/language/expressions/class/elements/redeclaration.js
@@ -42,8 +42,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "y"),
+  "y does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "y"),
+  "y does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "y", {
   value: "same_value",
diff --git a/test/language/expressions/class/elements/regular-definitions-computed-names.js b/test/language/expressions/class/elements/regular-definitions-computed-names.js
index 14673323cc..13a4481877 100644
--- a/test/language/expressions/class/elements/regular-definitions-computed-names.js
+++ b/test/language/expressions/class/elements/regular-definitions-computed-names.js
@@ -30,8 +30,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -40,12 +46,27 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "10"),
+  "10 doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "10"),
+  "10 doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "10", {
   value: "meep",
@@ -54,8 +75,14 @@ verifyProperty(c, "10", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "not initialized", {
   value: undefined,
diff --git a/test/language/expressions/class/elements/regular-definitions-computed-symbol-names.js b/test/language/expressions/class/elements/regular-definitions-computed-symbol-names.js
index 57b3288a1a..13cb45ea2d 100644
--- a/test/language/expressions/class/elements/regular-definitions-computed-symbol-names.js
+++ b/test/language/expressions/class/elements/regular-definitions-computed-symbol-names.js
@@ -31,8 +31,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, x), false);
-assert.sameValue(Object.hasOwnProperty.call(C, x), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, x),
+  "Symbol x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, x),
+  "Symbol x doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, x, {
   value: undefined,
@@ -41,8 +47,14 @@ verifyProperty(c, x, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
-assert.sameValue(Object.hasOwnProperty.call(C, y), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, y),
+  "Symbol y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, y),
+  "Symbol y doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, y, {
   value: 42,
@@ -51,10 +63,28 @@ verifyProperty(c, y, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "y"),
+  "y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "y"),
+  "y doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "y"),
+  "y doesn't appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/regular-definitions-literal-names-asi.js b/test/language/expressions/class/elements/regular-definitions-literal-names-asi.js
index 26b3e21335..ef8fc7e665 100644
--- a/test/language/expressions/class/elements/regular-definitions-literal-names-asi.js
+++ b/test/language/expressions/class/elements/regular-definitions-literal-names-asi.js
@@ -29,8 +29,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -39,8 +45,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
diff --git a/test/language/expressions/class/elements/regular-definitions-literal-names.js b/test/language/expressions/class/elements/regular-definitions-literal-names.js
index 0b05523d1a..11aebd3912 100644
--- a/test/language/expressions/class/elements/regular-definitions-literal-names.js
+++ b/test/language/expressions/class/elements/regular-definitions-literal-names.js
@@ -31,8 +31,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -41,8 +47,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -51,8 +63,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: fn,
diff --git a/test/language/expressions/class/elements/regular-definitions-private-names.js b/test/language/expressions/class/elements/regular-definitions-private-names.js
index 6fc5f2d656..d75a80c38d 100644
--- a/test/language/expressions/class/elements/regular-definitions-private-names.js
+++ b/test/language/expressions/class/elements/regular-definitions-private-names.js
@@ -38,18 +38,18 @@ var C = class {
 var c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(c.x(), 42, "test 7");
 assert.sameValue(c.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 10");
diff --git a/test/language/expressions/class/elements/regular-definitions-static-private-fields.js b/test/language/expressions/class/elements/regular-definitions-static-private-fields.js
index 5702187030..0f7e54a97c 100644
--- a/test/language/expressions/class/elements/regular-definitions-static-private-fields.js
+++ b/test/language/expressions/class/elements/regular-definitions-static-private-fields.js
@@ -38,18 +38,18 @@ var C = class {
 var c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/expressions/class/elements/regular-definitions-static-private-methods-with-fields.js b/test/language/expressions/class/elements/regular-definitions-static-private-methods-with-fields.js
index d0fa7e23ed..1865288002 100644
--- a/test/language/expressions/class/elements/regular-definitions-static-private-methods-with-fields.js
+++ b/test/language/expressions/class/elements/regular-definitions-static-private-methods-with-fields.js
@@ -44,29 +44,29 @@ var C = class {
 var c = new C();
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#xVal"), "test 7");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 8");
+assert(!Object.prototype.hasOwnProperty.call(c, "#xVal"), "test 9");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#yVal"), "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 11");
+assert(!Object.prototype.hasOwnProperty.call(c, "#yVal"), "test 12");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 13");
 assert.sameValue(C.y(), 43, "test 14");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 15");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 16");
 
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 17");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 18");
diff --git a/test/language/expressions/class/elements/regular-definitions-static-private-methods.js b/test/language/expressions/class/elements/regular-definitions-static-private-methods.js
index 440638c2ae..c42ceaa371 100644
--- a/test/language/expressions/class/elements/regular-definitions-static-private-methods.js
+++ b/test/language/expressions/class/elements/regular-definitions-static-private-methods.js
@@ -42,18 +42,18 @@ var C = class {
 var c = new C();
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/expressions/class/elements/regular-definitions-string-literal-names.js b/test/language/expressions/class/elements/regular-definitions-string-literal-names.js
index 7aceff73e9..f3d9113494 100644
--- a/test/language/expressions/class/elements/regular-definitions-string-literal-names.js
+++ b/test/language/expressions/class/elements/regular-definitions-string-literal-names.js
@@ -29,8 +29,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -39,8 +45,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: undefined,
@@ -49,8 +61,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: 39,
@@ -59,8 +77,14 @@ verifyProperty(c, "c", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "d"),
+  "d does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "d"),
+  "d does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "d", {
   value: 42,
diff --git a/test/language/expressions/class/elements/same-line-async-gen-computed-names.js b/test/language/expressions/class/elements/same-line-async-gen-computed-names.js
index c6ff4f7ba7..409ca703ea 100644
--- a/test/language/expressions/class/elements/same-line-async-gen-computed-names.js
+++ b/test/language/expressions/class/elements/same-line-async-gen-computed-names.js
@@ -30,7 +30,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -50,8 +53,14 @@ c.m().next().then(function(v) {
         throw new Test262Error('Test262:AsyncTestFailure')
       }
     }
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+      "b doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "b"),
+      "b doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "b", {
       value: 42,
@@ -60,12 +69,27 @@ c.m().next().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-    assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+      "x doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "x"),
+      "x doesn't appear as an own property on C constructor"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(c, "x"),
+      "x doesn't appear as an own property on C instance"
+    );
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "10"),
+      "10 doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "10"),
+      "10 doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "10", {
       value: "meep",
@@ -74,8 +98,14 @@ c.m().next().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "not initialized"),
+      "'not initialized' doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "not initialized"),
+      "'not initialized' doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "not initialized", {
       value: undefined,
diff --git a/test/language/expressions/class/elements/same-line-async-gen-computed-symbol-names.js b/test/language/expressions/class/elements/same-line-async-gen-computed-symbol-names.js
index f21ac4c003..7aea54e5fb 100644
--- a/test/language/expressions/class/elements/same-line-async-gen-computed-symbol-names.js
+++ b/test/language/expressions/class/elements/same-line-async-gen-computed-symbol-names.js
@@ -31,7 +31,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -51,8 +54,14 @@ c.m().next().then(function(v) {
         throw new Test262Error('Test262:AsyncTestFailure')
       }
     }
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, x), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, x), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, x),
+      "Symbol x doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, x),
+      "Symbol x doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, x, {
       value: undefined,
@@ -61,8 +70,14 @@ c.m().next().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, y), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, y),
+      "Symbol y doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, y),
+      "Symbol y doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, y, {
       value: 42,
@@ -71,13 +86,31 @@ c.m().next().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-    assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+      "x doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "x"),
+      "x doesn't appear as an own property on C constructor"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(c, "x"),
+      "x doesn't appear as an own property on C instance"
+    );
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
-    assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "y"),
+      "y doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "y"),
+      "y doesn't appear as an own property on C constructor"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(c, "y"),
+      "y doesn't appear as an own property on C instance"
+    );
   }
 
   return Promise.resolve(assertions());
diff --git a/test/language/expressions/class/elements/same-line-async-gen-grammar-privatename-identifier-semantics-stringvalue.js b/test/language/expressions/class/elements/same-line-async-gen-grammar-privatename-identifier-semantics-stringvalue.js
index fcfb644227..966aca2bc3 100644
--- a/test/language/expressions/class/elements/same-line-async-gen-grammar-privatename-identifier-semantics-stringvalue.js
+++ b/test/language/expressions/class/elements/same-line-async-gen-grammar-privatename-identifier-semantics-stringvalue.js
@@ -88,7 +88,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-gen-literal-names-asi.js b/test/language/expressions/class/elements/same-line-async-gen-literal-names-asi.js
index be8673b083..9289e88a74 100644
--- a/test/language/expressions/class/elements/same-line-async-gen-literal-names-asi.js
+++ b/test/language/expressions/class/elements/same-line-async-gen-literal-names-asi.js
@@ -29,7 +29,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -49,8 +52,14 @@ c.m().next().then(function(v) {
         throw new Test262Error('Test262:AsyncTestFailure')
       }
     }
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+      "a doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "a"),
+      "a doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "a", {
       value: undefined,
@@ -59,8 +68,14 @@ c.m().next().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+      "b doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "b"),
+      "b doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "b", {
       value: 42,
diff --git a/test/language/expressions/class/elements/same-line-async-gen-literal-names.js b/test/language/expressions/class/elements/same-line-async-gen-literal-names.js
index 7791376e3c..2de54e81a0 100644
--- a/test/language/expressions/class/elements/same-line-async-gen-literal-names.js
+++ b/test/language/expressions/class/elements/same-line-async-gen-literal-names.js
@@ -31,7 +31,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -51,8 +54,14 @@ c.m().next().then(function(v) {
         throw new Test262Error('Test262:AsyncTestFailure')
       }
     }
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+      "a doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "a"),
+      "a doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "a", {
       value: undefined,
@@ -61,8 +70,14 @@ c.m().next().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+      "b doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "b"),
+      "b doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "b", {
       value: 42,
@@ -71,8 +86,14 @@ c.m().next().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+      "c doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "c"),
+      "c doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "c", {
       value: fn,
diff --git a/test/language/expressions/class/elements/same-line-async-gen-private-field-usage.js b/test/language/expressions/class/elements/same-line-async-gen-private-field-usage.js
index 8af932b171..bc9f9165f4 100644
--- a/test/language/expressions/class/elements/same-line-async-gen-private-field-usage.js
+++ b/test/language/expressions/class/elements/same-line-async-gen-private-field-usage.js
@@ -31,7 +31,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-gen-private-method-getter-usage.js b/test/language/expressions/class/elements/same-line-async-gen-private-method-getter-usage.js
index e50ec3abc6..32d14d9fc8 100644
--- a/test/language/expressions/class/elements/same-line-async-gen-private-method-getter-usage.js
+++ b/test/language/expressions/class/elements/same-line-async-gen-private-method-getter-usage.js
@@ -31,7 +31,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-gen-private-method-usage.js b/test/language/expressions/class/elements/same-line-async-gen-private-method-usage.js
index 4bbbb2de52..e046cabf38 100644
--- a/test/language/expressions/class/elements/same-line-async-gen-private-method-usage.js
+++ b/test/language/expressions/class/elements/same-line-async-gen-private-method-usage.js
@@ -31,7 +31,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-gen-private-names.js b/test/language/expressions/class/elements/same-line-async-gen-private-names.js
index 0b8c60c2e3..20f35a6859 100644
--- a/test/language/expressions/class/elements/same-line-async-gen-private-names.js
+++ b/test/language/expressions/class/elements/same-line-async-gen-private-names.js
@@ -38,7 +38,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -59,21 +62,21 @@ c.m().next().then(function(v) {
       }
     }
     // Test the private fields do not appear as properties before set to value
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
     // Test if private fields can be sucessfully accessed and set to value
     assert.sameValue(c.x(), 42, "test 7");
     assert.sameValue(c.y(), 43, "test 8");
 
     // Test the private fields do not appear as properties before after set to value
-    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 9");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 10");
   }
 
   return Promise.resolve(assertions());
diff --git a/test/language/expressions/class/elements/same-line-async-gen-rs-field-identifier-initializer.js b/test/language/expressions/class/elements/same-line-async-gen-rs-field-identifier-initializer.js
index e5baf8d400..91b9321cbd 100644
--- a/test/language/expressions/class/elements/same-line-async-gen-rs-field-identifier-initializer.js
+++ b/test/language/expressions/class/elements/same-line-async-gen-rs-field-identifier-initializer.js
@@ -64,7 +64,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-gen-rs-field-identifier.js b/test/language/expressions/class/elements/same-line-async-gen-rs-field-identifier.js
index bd3d2e3148..12e3b887e1 100644
--- a/test/language/expressions/class/elements/same-line-async-gen-rs-field-identifier.js
+++ b/test/language/expressions/class/elements/same-line-async-gen-rs-field-identifier.js
@@ -64,7 +64,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-gen-rs-private-getter-alt.js b/test/language/expressions/class/elements/same-line-async-gen-rs-private-getter-alt.js
index ebc47971ec..b967efe1e2 100644
--- a/test/language/expressions/class/elements/same-line-async-gen-rs-private-getter-alt.js
+++ b/test/language/expressions/class/elements/same-line-async-gen-rs-private-getter-alt.js
@@ -105,7 +105,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-gen-rs-private-getter.js b/test/language/expressions/class/elements/same-line-async-gen-rs-private-getter.js
index 676ce9693e..e7f71636e5 100644
--- a/test/language/expressions/class/elements/same-line-async-gen-rs-private-getter.js
+++ b/test/language/expressions/class/elements/same-line-async-gen-rs-private-getter.js
@@ -105,7 +105,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-gen-rs-private-method-alt.js b/test/language/expressions/class/elements/same-line-async-gen-rs-private-method-alt.js
index 5efd1522ba..958e35fd63 100644
--- a/test/language/expressions/class/elements/same-line-async-gen-rs-private-method-alt.js
+++ b/test/language/expressions/class/elements/same-line-async-gen-rs-private-method-alt.js
@@ -104,7 +104,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-gen-rs-private-method.js b/test/language/expressions/class/elements/same-line-async-gen-rs-private-method.js
index 1ba989297e..831e4adda7 100644
--- a/test/language/expressions/class/elements/same-line-async-gen-rs-private-method.js
+++ b/test/language/expressions/class/elements/same-line-async-gen-rs-private-method.js
@@ -104,7 +104,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-gen-rs-private-setter-alt.js b/test/language/expressions/class/elements/same-line-async-gen-rs-private-setter-alt.js
index f819607264..f8a9e60228 100644
--- a/test/language/expressions/class/elements/same-line-async-gen-rs-private-setter-alt.js
+++ b/test/language/expressions/class/elements/same-line-async-gen-rs-private-setter-alt.js
@@ -104,7 +104,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-gen-rs-private-setter.js b/test/language/expressions/class/elements/same-line-async-gen-rs-private-setter.js
index 4355cb4b4d..798ee1ff06 100644
--- a/test/language/expressions/class/elements/same-line-async-gen-rs-private-setter.js
+++ b/test/language/expressions/class/elements/same-line-async-gen-rs-private-setter.js
@@ -104,7 +104,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-gen-rs-privatename-identifier-alt.js b/test/language/expressions/class/elements/same-line-async-gen-rs-privatename-identifier-alt.js
index 6620bdb901..38ea01ea4a 100644
--- a/test/language/expressions/class/elements/same-line-async-gen-rs-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/same-line-async-gen-rs-privatename-identifier-alt.js
@@ -85,7 +85,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-gen-rs-privatename-identifier-initializer-alt.js b/test/language/expressions/class/elements/same-line-async-gen-rs-privatename-identifier-initializer-alt.js
index 9bbb244ef8..da1233b817 100644
--- a/test/language/expressions/class/elements/same-line-async-gen-rs-privatename-identifier-initializer-alt.js
+++ b/test/language/expressions/class/elements/same-line-async-gen-rs-privatename-identifier-initializer-alt.js
@@ -79,7 +79,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-gen-rs-privatename-identifier-initializer.js b/test/language/expressions/class/elements/same-line-async-gen-rs-privatename-identifier-initializer.js
index a2b33a6d2b..2ed7045d30 100644
--- a/test/language/expressions/class/elements/same-line-async-gen-rs-privatename-identifier-initializer.js
+++ b/test/language/expressions/class/elements/same-line-async-gen-rs-privatename-identifier-initializer.js
@@ -79,7 +79,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-gen-rs-privatename-identifier.js b/test/language/expressions/class/elements/same-line-async-gen-rs-privatename-identifier.js
index 49ccd4038e..2b677f019b 100644
--- a/test/language/expressions/class/elements/same-line-async-gen-rs-privatename-identifier.js
+++ b/test/language/expressions/class/elements/same-line-async-gen-rs-privatename-identifier.js
@@ -85,7 +85,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-gen-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/same-line-async-gen-rs-static-async-generator-method-privatename-identifier-alt.js
index 544591b731..faf8721e1f 100644
--- a/test/language/expressions/class/elements/same-line-async-gen-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/same-line-async-gen-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -101,7 +101,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-gen-rs-static-async-generator-method-privatename-identifier.js b/test/language/expressions/class/elements/same-line-async-gen-rs-static-async-generator-method-privatename-identifier.js
index b8390b2367..63255ba7e2 100644
--- a/test/language/expressions/class/elements/same-line-async-gen-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/same-line-async-gen-rs-static-async-generator-method-privatename-identifier.js
@@ -101,7 +101,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-gen-rs-static-async-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/same-line-async-gen-rs-static-async-method-privatename-identifier-alt.js
index 0572417d02..168fc28c18 100644
--- a/test/language/expressions/class/elements/same-line-async-gen-rs-static-async-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/same-line-async-gen-rs-static-async-method-privatename-identifier-alt.js
@@ -101,7 +101,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-gen-rs-static-async-method-privatename-identifier.js b/test/language/expressions/class/elements/same-line-async-gen-rs-static-async-method-privatename-identifier.js
index 1a4e1f6446..bac2f7cdd1 100644
--- a/test/language/expressions/class/elements/same-line-async-gen-rs-static-async-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/same-line-async-gen-rs-static-async-method-privatename-identifier.js
@@ -101,7 +101,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-gen-rs-static-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/same-line-async-gen-rs-static-generator-method-privatename-identifier-alt.js
index b6c96afc95..1c65123c7e 100644
--- a/test/language/expressions/class/elements/same-line-async-gen-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/same-line-async-gen-rs-static-generator-method-privatename-identifier-alt.js
@@ -101,7 +101,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-gen-rs-static-generator-method-privatename-identifier.js b/test/language/expressions/class/elements/same-line-async-gen-rs-static-generator-method-privatename-identifier.js
index dfe9db4a2c..332987efbf 100644
--- a/test/language/expressions/class/elements/same-line-async-gen-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/same-line-async-gen-rs-static-generator-method-privatename-identifier.js
@@ -101,7 +101,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-gen-rs-static-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/same-line-async-gen-rs-static-method-privatename-identifier-alt.js
index 6c2b3eb490..3630b4ef35 100644
--- a/test/language/expressions/class/elements/same-line-async-gen-rs-static-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/same-line-async-gen-rs-static-method-privatename-identifier-alt.js
@@ -98,7 +98,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-gen-rs-static-method-privatename-identifier.js b/test/language/expressions/class/elements/same-line-async-gen-rs-static-method-privatename-identifier.js
index 53dd15092b..de2ef443bf 100644
--- a/test/language/expressions/class/elements/same-line-async-gen-rs-static-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/same-line-async-gen-rs-static-method-privatename-identifier.js
@@ -98,7 +98,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-gen-rs-static-privatename-identifier-alt-by-classname.js b/test/language/expressions/class/elements/same-line-async-gen-rs-static-privatename-identifier-alt-by-classname.js
index 5f2909165f..fd22ca46a6 100644
--- a/test/language/expressions/class/elements/same-line-async-gen-rs-static-privatename-identifier-alt-by-classname.js
+++ b/test/language/expressions/class/elements/same-line-async-gen-rs-static-privatename-identifier-alt-by-classname.js
@@ -86,7 +86,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-gen-rs-static-privatename-identifier-alt.js b/test/language/expressions/class/elements/same-line-async-gen-rs-static-privatename-identifier-alt.js
index 2dd667b1b0..394ea7757e 100644
--- a/test/language/expressions/class/elements/same-line-async-gen-rs-static-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/same-line-async-gen-rs-static-privatename-identifier-alt.js
@@ -86,7 +86,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-gen-rs-static-privatename-identifier-by-classname.js b/test/language/expressions/class/elements/same-line-async-gen-rs-static-privatename-identifier-by-classname.js
index bf464f110c..94e50c8aa1 100644
--- a/test/language/expressions/class/elements/same-line-async-gen-rs-static-privatename-identifier-by-classname.js
+++ b/test/language/expressions/class/elements/same-line-async-gen-rs-static-privatename-identifier-by-classname.js
@@ -86,7 +86,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js b/test/language/expressions/class/elements/same-line-async-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
index 02291e750e..3df28ab2a7 100644
--- a/test/language/expressions/class/elements/same-line-async-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
+++ b/test/language/expressions/class/elements/same-line-async-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
@@ -80,7 +80,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-gen-rs-static-privatename-identifier-initializer-alt.js b/test/language/expressions/class/elements/same-line-async-gen-rs-static-privatename-identifier-initializer-alt.js
index f562673839..74c8423166 100644
--- a/test/language/expressions/class/elements/same-line-async-gen-rs-static-privatename-identifier-initializer-alt.js
+++ b/test/language/expressions/class/elements/same-line-async-gen-rs-static-privatename-identifier-initializer-alt.js
@@ -80,7 +80,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-gen-rs-static-privatename-identifier-initializer.js b/test/language/expressions/class/elements/same-line-async-gen-rs-static-privatename-identifier-initializer.js
index e31c466fb6..691fc8d857 100644
--- a/test/language/expressions/class/elements/same-line-async-gen-rs-static-privatename-identifier-initializer.js
+++ b/test/language/expressions/class/elements/same-line-async-gen-rs-static-privatename-identifier-initializer.js
@@ -80,7 +80,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-gen-rs-static-privatename-identifier.js b/test/language/expressions/class/elements/same-line-async-gen-rs-static-privatename-identifier.js
index 151ae710d0..4624e9033c 100644
--- a/test/language/expressions/class/elements/same-line-async-gen-rs-static-privatename-identifier.js
+++ b/test/language/expressions/class/elements/same-line-async-gen-rs-static-privatename-identifier.js
@@ -86,7 +86,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-gen-static-private-fields.js b/test/language/expressions/class/elements/same-line-async-gen-static-private-fields.js
index 9f370df2c1..d2ffcc2085 100644
--- a/test/language/expressions/class/elements/same-line-async-gen-static-private-fields.js
+++ b/test/language/expressions/class/elements/same-line-async-gen-static-private-fields.js
@@ -38,7 +38,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -59,21 +62,21 @@ c.m().next().then(function(v) {
       }
     }
     // Test the private fields do not appear as properties before set to value
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
     // Test if private fields can be sucessfully accessed and set to value
     assert.sameValue(C.x(), 42, "test 7");
     assert.sameValue(C.y(), 43, "test 8");
 
     // Test the private fields do not appear as properties before after set to value
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
   }
 
   return Promise.resolve(assertions());
diff --git a/test/language/expressions/class/elements/same-line-async-gen-static-private-methods-with-fields.js b/test/language/expressions/class/elements/same-line-async-gen-static-private-methods-with-fields.js
index bfb0f5f3c3..85d2249143 100644
--- a/test/language/expressions/class/elements/same-line-async-gen-static-private-methods-with-fields.js
+++ b/test/language/expressions/class/elements/same-line-async-gen-static-private-methods-with-fields.js
@@ -44,7 +44,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -65,32 +68,32 @@ c.m().next().then(function(v) {
       }
     }
     // Test the private methods do not appear as properties before set to value
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#xVal"), "test 7");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 8");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#xVal"), "test 9");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#yVal"), "test 10");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 11");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#yVal"), "test 12");
 
     // Test if private fields can be sucessfully accessed and set to value
     assert.sameValue(C.x(), 42, "test 13");
     assert.sameValue(C.y(), 43, "test 14");
 
     // Test the private fields do not appear as properties before after set to value
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 15");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 16");
 
-    assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 17");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 18");
   }
 
   return Promise.resolve(assertions());
diff --git a/test/language/expressions/class/elements/same-line-async-gen-static-private-methods.js b/test/language/expressions/class/elements/same-line-async-gen-static-private-methods.js
index 47ebcea63c..49df0db4e5 100644
--- a/test/language/expressions/class/elements/same-line-async-gen-static-private-methods.js
+++ b/test/language/expressions/class/elements/same-line-async-gen-static-private-methods.js
@@ -42,7 +42,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -63,21 +66,21 @@ c.m().next().then(function(v) {
       }
     }
     // Test the private methods do not appear as properties before set to value
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
     // Test if private fields can be sucessfully accessed and set to value
     assert.sameValue(C.x(), 42, "test 7");
     assert.sameValue(C.y(), 86, "test 8");
 
     // Test the private fields do not appear as properties before after set to value
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
   }
 
   return Promise.resolve(assertions());
diff --git a/test/language/expressions/class/elements/same-line-async-gen-string-literal-names.js b/test/language/expressions/class/elements/same-line-async-gen-string-literal-names.js
index 7cb592b099..62ec37a83f 100644
--- a/test/language/expressions/class/elements/same-line-async-gen-string-literal-names.js
+++ b/test/language/expressions/class/elements/same-line-async-gen-string-literal-names.js
@@ -29,7 +29,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -49,8 +52,14 @@ c.m().next().then(function(v) {
         throw new Test262Error('Test262:AsyncTestFailure')
       }
     }
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+      "a does not appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "a"),
+      "a does not appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "a", {
       value: undefined,
@@ -59,8 +68,14 @@ c.m().next().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+      "b does not appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "b"),
+      "b does not appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "b", {
       value: undefined,
@@ -69,8 +84,14 @@ c.m().next().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+      "c does not appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "c"),
+      "c does not appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "c", {
       value: 39,
@@ -79,8 +100,14 @@ c.m().next().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "d"),
+      "d does not appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "d"),
+      "d does not appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "d", {
       value: 42,
diff --git a/test/language/expressions/class/elements/same-line-async-method-computed-names.js b/test/language/expressions/class/elements/same-line-async-method-computed-names.js
index 62e12dc12d..f25c3a8d26 100644
--- a/test/language/expressions/class/elements/same-line-async-method-computed-names.js
+++ b/test/language/expressions/class/elements/same-line-async-method-computed-names.js
@@ -30,7 +30,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -49,8 +52,14 @@ c.m().then(function(v) {
         throw new Test262Error('Test262:AsyncTestFailure')
       }
     }
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+      "b doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "b"),
+      "b doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "b", {
       value: 42,
@@ -59,12 +68,27 @@ c.m().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-    assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+      "x doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "x"),
+      "x doesn't appear as an own property on C constructor"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(c, "x"),
+      "x doesn't appear as an own property on C instance"
+    );
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "10"),
+      "10 doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "10"),
+      "10 doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "10", {
       value: "meep",
@@ -73,8 +97,14 @@ c.m().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "not initialized"),
+      "'not initialized' doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "not initialized"),
+      "'not initialized' doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "not initialized", {
       value: undefined,
diff --git a/test/language/expressions/class/elements/same-line-async-method-computed-symbol-names.js b/test/language/expressions/class/elements/same-line-async-method-computed-symbol-names.js
index e7b2222cd2..13847f70ca 100644
--- a/test/language/expressions/class/elements/same-line-async-method-computed-symbol-names.js
+++ b/test/language/expressions/class/elements/same-line-async-method-computed-symbol-names.js
@@ -31,7 +31,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -50,8 +53,14 @@ c.m().then(function(v) {
         throw new Test262Error('Test262:AsyncTestFailure')
       }
     }
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, x), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, x), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, x),
+      "Symbol x doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, x),
+      "Symbol x doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, x, {
       value: undefined,
@@ -60,8 +69,14 @@ c.m().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, y), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, y),
+      "Symbol y doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, y),
+      "Symbol y doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, y, {
       value: 42,
@@ -70,13 +85,31 @@ c.m().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-    assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+      "x doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "x"),
+      "x doesn't appear as an own property on C constructor"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(c, "x"),
+      "x doesn't appear as an own property on C instance"
+    );
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
-    assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "y"),
+      "y doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "y"),
+      "y doesn't appear as an own property on C constructor"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(c, "y"),
+      "y doesn't appear as an own property on C instance"
+    );
   }
 
   return Promise.resolve(assertions());
diff --git a/test/language/expressions/class/elements/same-line-async-method-grammar-privatename-identifier-semantics-stringvalue.js b/test/language/expressions/class/elements/same-line-async-method-grammar-privatename-identifier-semantics-stringvalue.js
index 529c368501..50b2313e1a 100644
--- a/test/language/expressions/class/elements/same-line-async-method-grammar-privatename-identifier-semantics-stringvalue.js
+++ b/test/language/expressions/class/elements/same-line-async-method-grammar-privatename-identifier-semantics-stringvalue.js
@@ -88,7 +88,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-method-literal-names-asi.js b/test/language/expressions/class/elements/same-line-async-method-literal-names-asi.js
index 1702355f48..3fdf05ba91 100644
--- a/test/language/expressions/class/elements/same-line-async-method-literal-names-asi.js
+++ b/test/language/expressions/class/elements/same-line-async-method-literal-names-asi.js
@@ -29,7 +29,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -48,8 +51,14 @@ c.m().then(function(v) {
         throw new Test262Error('Test262:AsyncTestFailure')
       }
     }
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+      "a doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "a"),
+      "a doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "a", {
       value: undefined,
@@ -58,8 +67,14 @@ c.m().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+      "b doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "b"),
+      "b doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "b", {
       value: 42,
diff --git a/test/language/expressions/class/elements/same-line-async-method-literal-names.js b/test/language/expressions/class/elements/same-line-async-method-literal-names.js
index 972b15010a..556a3e3c49 100644
--- a/test/language/expressions/class/elements/same-line-async-method-literal-names.js
+++ b/test/language/expressions/class/elements/same-line-async-method-literal-names.js
@@ -31,7 +31,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -50,8 +53,14 @@ c.m().then(function(v) {
         throw new Test262Error('Test262:AsyncTestFailure')
       }
     }
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+      "a doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "a"),
+      "a doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "a", {
       value: undefined,
@@ -60,8 +69,14 @@ c.m().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+      "b doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "b"),
+      "b doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "b", {
       value: 42,
@@ -70,8 +85,14 @@ c.m().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+      "c doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "c"),
+      "c doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "c", {
       value: fn,
diff --git a/test/language/expressions/class/elements/same-line-async-method-private-field-usage.js b/test/language/expressions/class/elements/same-line-async-method-private-field-usage.js
index b3bdcc571d..4cfab38bc5 100644
--- a/test/language/expressions/class/elements/same-line-async-method-private-field-usage.js
+++ b/test/language/expressions/class/elements/same-line-async-method-private-field-usage.js
@@ -31,7 +31,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-method-private-method-getter-usage.js b/test/language/expressions/class/elements/same-line-async-method-private-method-getter-usage.js
index e68911c50b..47fedfe3e9 100644
--- a/test/language/expressions/class/elements/same-line-async-method-private-method-getter-usage.js
+++ b/test/language/expressions/class/elements/same-line-async-method-private-method-getter-usage.js
@@ -31,7 +31,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-method-private-method-usage.js b/test/language/expressions/class/elements/same-line-async-method-private-method-usage.js
index 30036aef74..0ebfab1229 100644
--- a/test/language/expressions/class/elements/same-line-async-method-private-method-usage.js
+++ b/test/language/expressions/class/elements/same-line-async-method-private-method-usage.js
@@ -31,7 +31,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-method-private-names.js b/test/language/expressions/class/elements/same-line-async-method-private-names.js
index 65d2a2dc18..72d8c37982 100644
--- a/test/language/expressions/class/elements/same-line-async-method-private-names.js
+++ b/test/language/expressions/class/elements/same-line-async-method-private-names.js
@@ -38,7 +38,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -58,21 +61,21 @@ c.m().then(function(v) {
       }
     }
     // Test the private fields do not appear as properties before set to value
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
     // Test if private fields can be sucessfully accessed and set to value
     assert.sameValue(c.x(), 42, "test 7");
     assert.sameValue(c.y(), 43, "test 8");
 
     // Test the private fields do not appear as properties before after set to value
-    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 9");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 10");
   }
 
   return Promise.resolve(assertions());
diff --git a/test/language/expressions/class/elements/same-line-async-method-rs-field-identifier-initializer.js b/test/language/expressions/class/elements/same-line-async-method-rs-field-identifier-initializer.js
index f5867be149..955f98a5b2 100644
--- a/test/language/expressions/class/elements/same-line-async-method-rs-field-identifier-initializer.js
+++ b/test/language/expressions/class/elements/same-line-async-method-rs-field-identifier-initializer.js
@@ -64,7 +64,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-method-rs-field-identifier.js b/test/language/expressions/class/elements/same-line-async-method-rs-field-identifier.js
index 12b3882db5..55635ebf34 100644
--- a/test/language/expressions/class/elements/same-line-async-method-rs-field-identifier.js
+++ b/test/language/expressions/class/elements/same-line-async-method-rs-field-identifier.js
@@ -64,7 +64,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-method-rs-private-getter-alt.js b/test/language/expressions/class/elements/same-line-async-method-rs-private-getter-alt.js
index 9de4428841..2423542a30 100644
--- a/test/language/expressions/class/elements/same-line-async-method-rs-private-getter-alt.js
+++ b/test/language/expressions/class/elements/same-line-async-method-rs-private-getter-alt.js
@@ -105,7 +105,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-method-rs-private-getter.js b/test/language/expressions/class/elements/same-line-async-method-rs-private-getter.js
index 474473bb4b..9b7bdc7363 100644
--- a/test/language/expressions/class/elements/same-line-async-method-rs-private-getter.js
+++ b/test/language/expressions/class/elements/same-line-async-method-rs-private-getter.js
@@ -105,7 +105,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-method-rs-private-method-alt.js b/test/language/expressions/class/elements/same-line-async-method-rs-private-method-alt.js
index b541160ed3..036e22519d 100644
--- a/test/language/expressions/class/elements/same-line-async-method-rs-private-method-alt.js
+++ b/test/language/expressions/class/elements/same-line-async-method-rs-private-method-alt.js
@@ -104,7 +104,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-method-rs-private-method.js b/test/language/expressions/class/elements/same-line-async-method-rs-private-method.js
index 3efc2a9565..aaf3d998b1 100644
--- a/test/language/expressions/class/elements/same-line-async-method-rs-private-method.js
+++ b/test/language/expressions/class/elements/same-line-async-method-rs-private-method.js
@@ -104,7 +104,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-method-rs-private-setter-alt.js b/test/language/expressions/class/elements/same-line-async-method-rs-private-setter-alt.js
index b007c17dab..7912c7d845 100644
--- a/test/language/expressions/class/elements/same-line-async-method-rs-private-setter-alt.js
+++ b/test/language/expressions/class/elements/same-line-async-method-rs-private-setter-alt.js
@@ -104,7 +104,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-method-rs-private-setter.js b/test/language/expressions/class/elements/same-line-async-method-rs-private-setter.js
index 5563446fd9..98e376b5ab 100644
--- a/test/language/expressions/class/elements/same-line-async-method-rs-private-setter.js
+++ b/test/language/expressions/class/elements/same-line-async-method-rs-private-setter.js
@@ -104,7 +104,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-method-rs-privatename-identifier-alt.js b/test/language/expressions/class/elements/same-line-async-method-rs-privatename-identifier-alt.js
index 5457b430ed..0f3bb21f20 100644
--- a/test/language/expressions/class/elements/same-line-async-method-rs-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/same-line-async-method-rs-privatename-identifier-alt.js
@@ -85,7 +85,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-method-rs-privatename-identifier-initializer-alt.js b/test/language/expressions/class/elements/same-line-async-method-rs-privatename-identifier-initializer-alt.js
index dc787e15e9..3823868fbd 100644
--- a/test/language/expressions/class/elements/same-line-async-method-rs-privatename-identifier-initializer-alt.js
+++ b/test/language/expressions/class/elements/same-line-async-method-rs-privatename-identifier-initializer-alt.js
@@ -79,7 +79,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-method-rs-privatename-identifier-initializer.js b/test/language/expressions/class/elements/same-line-async-method-rs-privatename-identifier-initializer.js
index ab32bff6e3..6b3d0ed75b 100644
--- a/test/language/expressions/class/elements/same-line-async-method-rs-privatename-identifier-initializer.js
+++ b/test/language/expressions/class/elements/same-line-async-method-rs-privatename-identifier-initializer.js
@@ -79,7 +79,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-method-rs-privatename-identifier.js b/test/language/expressions/class/elements/same-line-async-method-rs-privatename-identifier.js
index 432994daf9..c4c00729ee 100644
--- a/test/language/expressions/class/elements/same-line-async-method-rs-privatename-identifier.js
+++ b/test/language/expressions/class/elements/same-line-async-method-rs-privatename-identifier.js
@@ -85,7 +85,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-method-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/same-line-async-method-rs-static-async-generator-method-privatename-identifier-alt.js
index b6b55d65ff..7a109c2599 100644
--- a/test/language/expressions/class/elements/same-line-async-method-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/same-line-async-method-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -101,7 +101,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-method-rs-static-async-generator-method-privatename-identifier.js b/test/language/expressions/class/elements/same-line-async-method-rs-static-async-generator-method-privatename-identifier.js
index f662d02d0b..e6ec0e5db8 100644
--- a/test/language/expressions/class/elements/same-line-async-method-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/same-line-async-method-rs-static-async-generator-method-privatename-identifier.js
@@ -101,7 +101,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-method-rs-static-async-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/same-line-async-method-rs-static-async-method-privatename-identifier-alt.js
index c3628a6e93..89ff77f7a8 100644
--- a/test/language/expressions/class/elements/same-line-async-method-rs-static-async-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/same-line-async-method-rs-static-async-method-privatename-identifier-alt.js
@@ -101,7 +101,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-method-rs-static-async-method-privatename-identifier.js b/test/language/expressions/class/elements/same-line-async-method-rs-static-async-method-privatename-identifier.js
index 3424a4d129..dda2757f2c 100644
--- a/test/language/expressions/class/elements/same-line-async-method-rs-static-async-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/same-line-async-method-rs-static-async-method-privatename-identifier.js
@@ -101,7 +101,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-method-rs-static-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/same-line-async-method-rs-static-generator-method-privatename-identifier-alt.js
index 2073a7488a..7296c91f5a 100644
--- a/test/language/expressions/class/elements/same-line-async-method-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/same-line-async-method-rs-static-generator-method-privatename-identifier-alt.js
@@ -101,7 +101,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-method-rs-static-generator-method-privatename-identifier.js b/test/language/expressions/class/elements/same-line-async-method-rs-static-generator-method-privatename-identifier.js
index 639f72560b..ac591a5bb7 100644
--- a/test/language/expressions/class/elements/same-line-async-method-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/same-line-async-method-rs-static-generator-method-privatename-identifier.js
@@ -101,7 +101,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-method-rs-static-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/same-line-async-method-rs-static-method-privatename-identifier-alt.js
index e072317947..5e2552373a 100644
--- a/test/language/expressions/class/elements/same-line-async-method-rs-static-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/same-line-async-method-rs-static-method-privatename-identifier-alt.js
@@ -98,7 +98,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-method-rs-static-method-privatename-identifier.js b/test/language/expressions/class/elements/same-line-async-method-rs-static-method-privatename-identifier.js
index fc1e9fff3a..596a10a4df 100644
--- a/test/language/expressions/class/elements/same-line-async-method-rs-static-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/same-line-async-method-rs-static-method-privatename-identifier.js
@@ -98,7 +98,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-method-rs-static-privatename-identifier-alt-by-classname.js b/test/language/expressions/class/elements/same-line-async-method-rs-static-privatename-identifier-alt-by-classname.js
index 73b30efb55..bc6bad7847 100644
--- a/test/language/expressions/class/elements/same-line-async-method-rs-static-privatename-identifier-alt-by-classname.js
+++ b/test/language/expressions/class/elements/same-line-async-method-rs-static-privatename-identifier-alt-by-classname.js
@@ -86,7 +86,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-method-rs-static-privatename-identifier-alt.js b/test/language/expressions/class/elements/same-line-async-method-rs-static-privatename-identifier-alt.js
index 2329dd55a0..7c64088acc 100644
--- a/test/language/expressions/class/elements/same-line-async-method-rs-static-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/same-line-async-method-rs-static-privatename-identifier-alt.js
@@ -86,7 +86,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-method-rs-static-privatename-identifier-by-classname.js b/test/language/expressions/class/elements/same-line-async-method-rs-static-privatename-identifier-by-classname.js
index b4c8c27c1c..bc4be0e78b 100644
--- a/test/language/expressions/class/elements/same-line-async-method-rs-static-privatename-identifier-by-classname.js
+++ b/test/language/expressions/class/elements/same-line-async-method-rs-static-privatename-identifier-by-classname.js
@@ -86,7 +86,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-method-rs-static-privatename-identifier-initializer-alt-by-classname.js b/test/language/expressions/class/elements/same-line-async-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
index 74a864f14a..1f7ca775c5 100644
--- a/test/language/expressions/class/elements/same-line-async-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
+++ b/test/language/expressions/class/elements/same-line-async-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
@@ -80,7 +80,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-method-rs-static-privatename-identifier-initializer-alt.js b/test/language/expressions/class/elements/same-line-async-method-rs-static-privatename-identifier-initializer-alt.js
index e17e1781ae..8721c835a0 100644
--- a/test/language/expressions/class/elements/same-line-async-method-rs-static-privatename-identifier-initializer-alt.js
+++ b/test/language/expressions/class/elements/same-line-async-method-rs-static-privatename-identifier-initializer-alt.js
@@ -80,7 +80,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-method-rs-static-privatename-identifier-initializer.js b/test/language/expressions/class/elements/same-line-async-method-rs-static-privatename-identifier-initializer.js
index 13a2887214..1feebee462 100644
--- a/test/language/expressions/class/elements/same-line-async-method-rs-static-privatename-identifier-initializer.js
+++ b/test/language/expressions/class/elements/same-line-async-method-rs-static-privatename-identifier-initializer.js
@@ -80,7 +80,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-method-rs-static-privatename-identifier.js b/test/language/expressions/class/elements/same-line-async-method-rs-static-privatename-identifier.js
index e0591f4983..63144e7288 100644
--- a/test/language/expressions/class/elements/same-line-async-method-rs-static-privatename-identifier.js
+++ b/test/language/expressions/class/elements/same-line-async-method-rs-static-privatename-identifier.js
@@ -86,7 +86,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/expressions/class/elements/same-line-async-method-static-private-fields.js b/test/language/expressions/class/elements/same-line-async-method-static-private-fields.js
index 4fedacd1f8..fd83a3818a 100644
--- a/test/language/expressions/class/elements/same-line-async-method-static-private-fields.js
+++ b/test/language/expressions/class/elements/same-line-async-method-static-private-fields.js
@@ -38,7 +38,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -58,21 +61,21 @@ c.m().then(function(v) {
       }
     }
     // Test the private fields do not appear as properties before set to value
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
     // Test if private fields can be sucessfully accessed and set to value
     assert.sameValue(C.x(), 42, "test 7");
     assert.sameValue(C.y(), 43, "test 8");
 
     // Test the private fields do not appear as properties before after set to value
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
   }
 
   return Promise.resolve(assertions());
diff --git a/test/language/expressions/class/elements/same-line-async-method-static-private-methods-with-fields.js b/test/language/expressions/class/elements/same-line-async-method-static-private-methods-with-fields.js
index 27724bef7b..6dbc70a7d8 100644
--- a/test/language/expressions/class/elements/same-line-async-method-static-private-methods-with-fields.js
+++ b/test/language/expressions/class/elements/same-line-async-method-static-private-methods-with-fields.js
@@ -44,7 +44,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -64,32 +67,32 @@ c.m().then(function(v) {
       }
     }
     // Test the private methods do not appear as properties before set to value
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#xVal"), "test 7");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 8");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#xVal"), "test 9");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#yVal"), "test 10");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 11");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#yVal"), "test 12");
 
     // Test if private fields can be sucessfully accessed and set to value
     assert.sameValue(C.x(), 42, "test 13");
     assert.sameValue(C.y(), 43, "test 14");
 
     // Test the private fields do not appear as properties before after set to value
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 15");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 16");
 
-    assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 17");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 18");
   }
 
   return Promise.resolve(assertions());
diff --git a/test/language/expressions/class/elements/same-line-async-method-static-private-methods.js b/test/language/expressions/class/elements/same-line-async-method-static-private-methods.js
index dbd0c5632e..fd49f2a7a9 100644
--- a/test/language/expressions/class/elements/same-line-async-method-static-private-methods.js
+++ b/test/language/expressions/class/elements/same-line-async-method-static-private-methods.js
@@ -42,7 +42,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -62,21 +65,21 @@ c.m().then(function(v) {
       }
     }
     // Test the private methods do not appear as properties before set to value
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
     // Test if private fields can be sucessfully accessed and set to value
     assert.sameValue(C.x(), 42, "test 7");
     assert.sameValue(C.y(), 86, "test 8");
 
     // Test the private fields do not appear as properties before after set to value
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
   }
 
   return Promise.resolve(assertions());
diff --git a/test/language/expressions/class/elements/same-line-async-method-string-literal-names.js b/test/language/expressions/class/elements/same-line-async-method-string-literal-names.js
index 7ce2a9ed4b..8b2f741f6f 100644
--- a/test/language/expressions/class/elements/same-line-async-method-string-literal-names.js
+++ b/test/language/expressions/class/elements/same-line-async-method-string-literal-names.js
@@ -29,7 +29,10 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -48,8 +51,14 @@ c.m().then(function(v) {
         throw new Test262Error('Test262:AsyncTestFailure')
       }
     }
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+      "a does not appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "a"),
+      "a does not appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "a", {
       value: undefined,
@@ -58,8 +67,14 @@ c.m().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+      "b does not appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "b"),
+      "b does not appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "b", {
       value: undefined,
@@ -68,8 +83,14 @@ c.m().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+      "c does not appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "c"),
+      "c does not appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "c", {
       value: 39,
@@ -78,8 +99,14 @@ c.m().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "d"),
+      "d does not appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "d"),
+      "d does not appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "d", {
       value: 42,
diff --git a/test/language/expressions/class/elements/same-line-gen-computed-names.js b/test/language/expressions/class/elements/same-line-gen-computed-names.js
index b052eeacf7..b8101c0d78 100644
--- a/test/language/expressions/class/elements/same-line-gen-computed-names.js
+++ b/test/language/expressions/class/elements/same-line-gen-computed-names.js
@@ -32,7 +32,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -40,8 +43,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -50,12 +59,27 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "10"),
+  "10 doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "10"),
+  "10 doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "10", {
   value: "meep",
@@ -64,8 +88,14 @@ verifyProperty(c, "10", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "not initialized", {
   value: undefined,
diff --git a/test/language/expressions/class/elements/same-line-gen-computed-symbol-names.js b/test/language/expressions/class/elements/same-line-gen-computed-symbol-names.js
index 00899de9d3..d29d3a5180 100644
--- a/test/language/expressions/class/elements/same-line-gen-computed-symbol-names.js
+++ b/test/language/expressions/class/elements/same-line-gen-computed-symbol-names.js
@@ -33,7 +33,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -41,8 +44,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, x), false);
-assert.sameValue(Object.hasOwnProperty.call(C, x), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, x),
+  "Symbol x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, x),
+  "Symbol x doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, x, {
   value: undefined,
@@ -51,8 +60,14 @@ verifyProperty(c, x, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
-assert.sameValue(Object.hasOwnProperty.call(C, y), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, y),
+  "Symbol y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, y),
+  "Symbol y doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, y, {
   value: 42,
@@ -61,10 +76,28 @@ verifyProperty(c, y, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "y"),
+  "y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "y"),
+  "y doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "y"),
+  "y doesn't appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/same-line-gen-grammar-privatename-identifier-semantics-stringvalue.js b/test/language/expressions/class/elements/same-line-gen-grammar-privatename-identifier-semantics-stringvalue.js
index 11f6eb9850..f2b59c03a7 100644
--- a/test/language/expressions/class/elements/same-line-gen-grammar-privatename-identifier-semantics-stringvalue.js
+++ b/test/language/expressions/class/elements/same-line-gen-grammar-privatename-identifier-semantics-stringvalue.js
@@ -90,7 +90,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-gen-literal-names-asi.js b/test/language/expressions/class/elements/same-line-gen-literal-names-asi.js
index 929daaabed..89e4a7171b 100644
--- a/test/language/expressions/class/elements/same-line-gen-literal-names-asi.js
+++ b/test/language/expressions/class/elements/same-line-gen-literal-names-asi.js
@@ -31,7 +31,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -39,8 +42,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -49,8 +58,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
diff --git a/test/language/expressions/class/elements/same-line-gen-literal-names.js b/test/language/expressions/class/elements/same-line-gen-literal-names.js
index 7bd10a5851..93b143a876 100644
--- a/test/language/expressions/class/elements/same-line-gen-literal-names.js
+++ b/test/language/expressions/class/elements/same-line-gen-literal-names.js
@@ -33,7 +33,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -41,8 +44,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -51,8 +60,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -61,8 +76,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: fn,
diff --git a/test/language/expressions/class/elements/same-line-gen-private-field-usage.js b/test/language/expressions/class/elements/same-line-gen-private-field-usage.js
index 7c74c26748..c6a6165f66 100644
--- a/test/language/expressions/class/elements/same-line-gen-private-field-usage.js
+++ b/test/language/expressions/class/elements/same-line-gen-private-field-usage.js
@@ -33,7 +33,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-gen-private-method-getter-usage.js b/test/language/expressions/class/elements/same-line-gen-private-method-getter-usage.js
index 7066d93742..0af4c3d25b 100644
--- a/test/language/expressions/class/elements/same-line-gen-private-method-getter-usage.js
+++ b/test/language/expressions/class/elements/same-line-gen-private-method-getter-usage.js
@@ -33,7 +33,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-gen-private-method-usage.js b/test/language/expressions/class/elements/same-line-gen-private-method-usage.js
index cd280de1b2..94dfca213d 100644
--- a/test/language/expressions/class/elements/same-line-gen-private-method-usage.js
+++ b/test/language/expressions/class/elements/same-line-gen-private-method-usage.js
@@ -33,7 +33,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-gen-private-names.js b/test/language/expressions/class/elements/same-line-gen-private-names.js
index 0f0ad3c1ca..c9ac52194e 100644
--- a/test/language/expressions/class/elements/same-line-gen-private-names.js
+++ b/test/language/expressions/class/elements/same-line-gen-private-names.js
@@ -40,7 +40,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -49,18 +52,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(c.x(), 42, "test 7");
 assert.sameValue(c.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 10");
diff --git a/test/language/expressions/class/elements/same-line-gen-rs-field-identifier-initializer.js b/test/language/expressions/class/elements/same-line-gen-rs-field-identifier-initializer.js
index 3bad200899..fcd2866f2e 100644
--- a/test/language/expressions/class/elements/same-line-gen-rs-field-identifier-initializer.js
+++ b/test/language/expressions/class/elements/same-line-gen-rs-field-identifier-initializer.js
@@ -66,7 +66,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-gen-rs-field-identifier.js b/test/language/expressions/class/elements/same-line-gen-rs-field-identifier.js
index 08ff8eaec6..d243d479fd 100644
--- a/test/language/expressions/class/elements/same-line-gen-rs-field-identifier.js
+++ b/test/language/expressions/class/elements/same-line-gen-rs-field-identifier.js
@@ -66,7 +66,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-gen-rs-private-getter-alt.js b/test/language/expressions/class/elements/same-line-gen-rs-private-getter-alt.js
index c4bcc8b81a..1af87334c7 100644
--- a/test/language/expressions/class/elements/same-line-gen-rs-private-getter-alt.js
+++ b/test/language/expressions/class/elements/same-line-gen-rs-private-getter-alt.js
@@ -107,7 +107,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-gen-rs-private-getter.js b/test/language/expressions/class/elements/same-line-gen-rs-private-getter.js
index 8660847c64..b972144b9b 100644
--- a/test/language/expressions/class/elements/same-line-gen-rs-private-getter.js
+++ b/test/language/expressions/class/elements/same-line-gen-rs-private-getter.js
@@ -107,7 +107,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-gen-rs-private-method-alt.js b/test/language/expressions/class/elements/same-line-gen-rs-private-method-alt.js
index bf7f7a8b61..565ba82880 100644
--- a/test/language/expressions/class/elements/same-line-gen-rs-private-method-alt.js
+++ b/test/language/expressions/class/elements/same-line-gen-rs-private-method-alt.js
@@ -106,7 +106,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-gen-rs-private-method.js b/test/language/expressions/class/elements/same-line-gen-rs-private-method.js
index 98c21d319e..fce1ebcf85 100644
--- a/test/language/expressions/class/elements/same-line-gen-rs-private-method.js
+++ b/test/language/expressions/class/elements/same-line-gen-rs-private-method.js
@@ -106,7 +106,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-gen-rs-private-setter-alt.js b/test/language/expressions/class/elements/same-line-gen-rs-private-setter-alt.js
index b6f7f06c99..4eee11ce90 100644
--- a/test/language/expressions/class/elements/same-line-gen-rs-private-setter-alt.js
+++ b/test/language/expressions/class/elements/same-line-gen-rs-private-setter-alt.js
@@ -106,7 +106,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-gen-rs-private-setter.js b/test/language/expressions/class/elements/same-line-gen-rs-private-setter.js
index dba8dc83a8..2991d67964 100644
--- a/test/language/expressions/class/elements/same-line-gen-rs-private-setter.js
+++ b/test/language/expressions/class/elements/same-line-gen-rs-private-setter.js
@@ -106,7 +106,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-gen-rs-privatename-identifier-alt.js b/test/language/expressions/class/elements/same-line-gen-rs-privatename-identifier-alt.js
index d5f32ea4a8..2813b38ee6 100644
--- a/test/language/expressions/class/elements/same-line-gen-rs-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/same-line-gen-rs-privatename-identifier-alt.js
@@ -87,7 +87,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-gen-rs-privatename-identifier-initializer-alt.js b/test/language/expressions/class/elements/same-line-gen-rs-privatename-identifier-initializer-alt.js
index 69794ef32d..7c4c40c3e9 100644
--- a/test/language/expressions/class/elements/same-line-gen-rs-privatename-identifier-initializer-alt.js
+++ b/test/language/expressions/class/elements/same-line-gen-rs-privatename-identifier-initializer-alt.js
@@ -81,7 +81,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-gen-rs-privatename-identifier-initializer.js b/test/language/expressions/class/elements/same-line-gen-rs-privatename-identifier-initializer.js
index 111096ce53..d4d5823f85 100644
--- a/test/language/expressions/class/elements/same-line-gen-rs-privatename-identifier-initializer.js
+++ b/test/language/expressions/class/elements/same-line-gen-rs-privatename-identifier-initializer.js
@@ -81,7 +81,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-gen-rs-privatename-identifier.js b/test/language/expressions/class/elements/same-line-gen-rs-privatename-identifier.js
index 8332475bba..df8df7ed60 100644
--- a/test/language/expressions/class/elements/same-line-gen-rs-privatename-identifier.js
+++ b/test/language/expressions/class/elements/same-line-gen-rs-privatename-identifier.js
@@ -87,7 +87,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/same-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js
index 4fb5170452..24f8fb0f58 100644
--- a/test/language/expressions/class/elements/same-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/same-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -103,7 +103,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-gen-rs-static-async-generator-method-privatename-identifier.js b/test/language/expressions/class/elements/same-line-gen-rs-static-async-generator-method-privatename-identifier.js
index 2b0e9a7cda..37b3a55459 100644
--- a/test/language/expressions/class/elements/same-line-gen-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/same-line-gen-rs-static-async-generator-method-privatename-identifier.js
@@ -103,7 +103,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-gen-rs-static-async-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/same-line-gen-rs-static-async-method-privatename-identifier-alt.js
index 0b6a9ac8de..4a1483bd04 100644
--- a/test/language/expressions/class/elements/same-line-gen-rs-static-async-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/same-line-gen-rs-static-async-method-privatename-identifier-alt.js
@@ -103,7 +103,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-gen-rs-static-async-method-privatename-identifier.js b/test/language/expressions/class/elements/same-line-gen-rs-static-async-method-privatename-identifier.js
index 3f96f3efc4..c77c3f25b3 100644
--- a/test/language/expressions/class/elements/same-line-gen-rs-static-async-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/same-line-gen-rs-static-async-method-privatename-identifier.js
@@ -103,7 +103,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-gen-rs-static-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/same-line-gen-rs-static-generator-method-privatename-identifier-alt.js
index 7208ef1ad3..0aad7a4563 100644
--- a/test/language/expressions/class/elements/same-line-gen-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/same-line-gen-rs-static-generator-method-privatename-identifier-alt.js
@@ -103,7 +103,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-gen-rs-static-generator-method-privatename-identifier.js b/test/language/expressions/class/elements/same-line-gen-rs-static-generator-method-privatename-identifier.js
index d1c12dd8aa..d7bd173a95 100644
--- a/test/language/expressions/class/elements/same-line-gen-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/same-line-gen-rs-static-generator-method-privatename-identifier.js
@@ -103,7 +103,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-gen-rs-static-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/same-line-gen-rs-static-method-privatename-identifier-alt.js
index 6796a20fe7..1b3e5f3d0f 100644
--- a/test/language/expressions/class/elements/same-line-gen-rs-static-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/same-line-gen-rs-static-method-privatename-identifier-alt.js
@@ -100,7 +100,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-gen-rs-static-method-privatename-identifier.js b/test/language/expressions/class/elements/same-line-gen-rs-static-method-privatename-identifier.js
index d9e93fc86e..7bb02a2b56 100644
--- a/test/language/expressions/class/elements/same-line-gen-rs-static-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/same-line-gen-rs-static-method-privatename-identifier.js
@@ -100,7 +100,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-gen-rs-static-privatename-identifier-alt-by-classname.js b/test/language/expressions/class/elements/same-line-gen-rs-static-privatename-identifier-alt-by-classname.js
index d74cefcb55..1242fdfb95 100644
--- a/test/language/expressions/class/elements/same-line-gen-rs-static-privatename-identifier-alt-by-classname.js
+++ b/test/language/expressions/class/elements/same-line-gen-rs-static-privatename-identifier-alt-by-classname.js
@@ -88,7 +88,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-gen-rs-static-privatename-identifier-alt.js b/test/language/expressions/class/elements/same-line-gen-rs-static-privatename-identifier-alt.js
index 5167dcd581..0df2e3324b 100644
--- a/test/language/expressions/class/elements/same-line-gen-rs-static-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/same-line-gen-rs-static-privatename-identifier-alt.js
@@ -88,7 +88,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-gen-rs-static-privatename-identifier-by-classname.js b/test/language/expressions/class/elements/same-line-gen-rs-static-privatename-identifier-by-classname.js
index 3f250768bf..b7520d2714 100644
--- a/test/language/expressions/class/elements/same-line-gen-rs-static-privatename-identifier-by-classname.js
+++ b/test/language/expressions/class/elements/same-line-gen-rs-static-privatename-identifier-by-classname.js
@@ -88,7 +88,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js b/test/language/expressions/class/elements/same-line-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
index 76d532eb5d..dba649b9b2 100644
--- a/test/language/expressions/class/elements/same-line-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
+++ b/test/language/expressions/class/elements/same-line-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
@@ -82,7 +82,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-gen-rs-static-privatename-identifier-initializer-alt.js b/test/language/expressions/class/elements/same-line-gen-rs-static-privatename-identifier-initializer-alt.js
index 3f2de103b6..5d747bec7e 100644
--- a/test/language/expressions/class/elements/same-line-gen-rs-static-privatename-identifier-initializer-alt.js
+++ b/test/language/expressions/class/elements/same-line-gen-rs-static-privatename-identifier-initializer-alt.js
@@ -82,7 +82,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-gen-rs-static-privatename-identifier-initializer.js b/test/language/expressions/class/elements/same-line-gen-rs-static-privatename-identifier-initializer.js
index 0c471477ae..1a03cb88d9 100644
--- a/test/language/expressions/class/elements/same-line-gen-rs-static-privatename-identifier-initializer.js
+++ b/test/language/expressions/class/elements/same-line-gen-rs-static-privatename-identifier-initializer.js
@@ -82,7 +82,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-gen-rs-static-privatename-identifier.js b/test/language/expressions/class/elements/same-line-gen-rs-static-privatename-identifier.js
index 30be44c8d0..d7447c9acb 100644
--- a/test/language/expressions/class/elements/same-line-gen-rs-static-privatename-identifier.js
+++ b/test/language/expressions/class/elements/same-line-gen-rs-static-privatename-identifier.js
@@ -88,7 +88,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-gen-static-private-fields.js b/test/language/expressions/class/elements/same-line-gen-static-private-fields.js
index d6bfef9c57..6dba21c254 100644
--- a/test/language/expressions/class/elements/same-line-gen-static-private-fields.js
+++ b/test/language/expressions/class/elements/same-line-gen-static-private-fields.js
@@ -40,7 +40,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -49,18 +52,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/expressions/class/elements/same-line-gen-static-private-methods-with-fields.js b/test/language/expressions/class/elements/same-line-gen-static-private-methods-with-fields.js
index 1fdc8bd573..3307016ffd 100644
--- a/test/language/expressions/class/elements/same-line-gen-static-private-methods-with-fields.js
+++ b/test/language/expressions/class/elements/same-line-gen-static-private-methods-with-fields.js
@@ -46,7 +46,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -55,29 +58,29 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#xVal"), "test 7");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 8");
+assert(!Object.prototype.hasOwnProperty.call(c, "#xVal"), "test 9");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#yVal"), "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 11");
+assert(!Object.prototype.hasOwnProperty.call(c, "#yVal"), "test 12");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 13");
 assert.sameValue(C.y(), 43, "test 14");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 15");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 16");
 
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 17");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 18");
diff --git a/test/language/expressions/class/elements/same-line-gen-static-private-methods.js b/test/language/expressions/class/elements/same-line-gen-static-private-methods.js
index e4ccf58f9d..dd0cc87e78 100644
--- a/test/language/expressions/class/elements/same-line-gen-static-private-methods.js
+++ b/test/language/expressions/class/elements/same-line-gen-static-private-methods.js
@@ -44,7 +44,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -53,18 +56,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/expressions/class/elements/same-line-gen-string-literal-names.js b/test/language/expressions/class/elements/same-line-gen-string-literal-names.js
index 39fe11bc62..9f79b1402f 100644
--- a/test/language/expressions/class/elements/same-line-gen-string-literal-names.js
+++ b/test/language/expressions/class/elements/same-line-gen-string-literal-names.js
@@ -31,7 +31,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -39,8 +42,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -49,8 +58,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: undefined,
@@ -59,8 +74,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: 39,
@@ -69,8 +90,14 @@ verifyProperty(c, "c", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "d"),
+  "d does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "d"),
+  "d does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "d", {
   value: 42,
diff --git a/test/language/expressions/class/elements/same-line-method-computed-names.js b/test/language/expressions/class/elements/same-line-method-computed-names.js
index 650f131b99..42822e2dfe 100644
--- a/test/language/expressions/class/elements/same-line-method-computed-names.js
+++ b/test/language/expressions/class/elements/same-line-method-computed-names.js
@@ -32,7 +32,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -40,8 +43,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -50,12 +59,27 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "10"),
+  "10 doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "10"),
+  "10 doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "10", {
   value: "meep",
@@ -64,8 +88,14 @@ verifyProperty(c, "10", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "not initialized", {
   value: undefined,
diff --git a/test/language/expressions/class/elements/same-line-method-computed-symbol-names.js b/test/language/expressions/class/elements/same-line-method-computed-symbol-names.js
index c17d175738..028bec30a7 100644
--- a/test/language/expressions/class/elements/same-line-method-computed-symbol-names.js
+++ b/test/language/expressions/class/elements/same-line-method-computed-symbol-names.js
@@ -33,7 +33,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -41,8 +44,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, x), false);
-assert.sameValue(Object.hasOwnProperty.call(C, x), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, x),
+  "Symbol x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, x),
+  "Symbol x doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, x, {
   value: undefined,
@@ -51,8 +60,14 @@ verifyProperty(c, x, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
-assert.sameValue(Object.hasOwnProperty.call(C, y), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, y),
+  "Symbol y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, y),
+  "Symbol y doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, y, {
   value: 42,
@@ -61,10 +76,28 @@ verifyProperty(c, y, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "y"),
+  "y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "y"),
+  "y doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "y"),
+  "y doesn't appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/same-line-method-grammar-privatename-identifier-semantics-stringvalue.js b/test/language/expressions/class/elements/same-line-method-grammar-privatename-identifier-semantics-stringvalue.js
index 0856786c3b..735aa8d9f0 100644
--- a/test/language/expressions/class/elements/same-line-method-grammar-privatename-identifier-semantics-stringvalue.js
+++ b/test/language/expressions/class/elements/same-line-method-grammar-privatename-identifier-semantics-stringvalue.js
@@ -90,7 +90,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-method-literal-names-asi.js b/test/language/expressions/class/elements/same-line-method-literal-names-asi.js
index b2dc3f9767..765d37b943 100644
--- a/test/language/expressions/class/elements/same-line-method-literal-names-asi.js
+++ b/test/language/expressions/class/elements/same-line-method-literal-names-asi.js
@@ -31,7 +31,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -39,8 +42,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -49,8 +58,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
diff --git a/test/language/expressions/class/elements/same-line-method-literal-names.js b/test/language/expressions/class/elements/same-line-method-literal-names.js
index 6d2edfd9f7..22e376225e 100644
--- a/test/language/expressions/class/elements/same-line-method-literal-names.js
+++ b/test/language/expressions/class/elements/same-line-method-literal-names.js
@@ -33,7 +33,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -41,8 +44,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -51,8 +60,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -61,8 +76,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: fn,
diff --git a/test/language/expressions/class/elements/same-line-method-private-field-usage.js b/test/language/expressions/class/elements/same-line-method-private-field-usage.js
index a9924f8470..996ab985a5 100644
--- a/test/language/expressions/class/elements/same-line-method-private-field-usage.js
+++ b/test/language/expressions/class/elements/same-line-method-private-field-usage.js
@@ -33,7 +33,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-method-private-method-getter-usage.js b/test/language/expressions/class/elements/same-line-method-private-method-getter-usage.js
index 7b881f662d..efc33ead46 100644
--- a/test/language/expressions/class/elements/same-line-method-private-method-getter-usage.js
+++ b/test/language/expressions/class/elements/same-line-method-private-method-getter-usage.js
@@ -33,7 +33,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-method-private-method-usage.js b/test/language/expressions/class/elements/same-line-method-private-method-usage.js
index d191c1c202..6305ecc53f 100644
--- a/test/language/expressions/class/elements/same-line-method-private-method-usage.js
+++ b/test/language/expressions/class/elements/same-line-method-private-method-usage.js
@@ -33,7 +33,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-method-private-names.js b/test/language/expressions/class/elements/same-line-method-private-names.js
index 5e84bd7b1f..066a630f2e 100644
--- a/test/language/expressions/class/elements/same-line-method-private-names.js
+++ b/test/language/expressions/class/elements/same-line-method-private-names.js
@@ -40,7 +40,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -49,18 +52,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(c.x(), 42, "test 7");
 assert.sameValue(c.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 10");
diff --git a/test/language/expressions/class/elements/same-line-method-rs-field-identifier-initializer.js b/test/language/expressions/class/elements/same-line-method-rs-field-identifier-initializer.js
index 0f5d95a7b3..2a7a640c2f 100644
--- a/test/language/expressions/class/elements/same-line-method-rs-field-identifier-initializer.js
+++ b/test/language/expressions/class/elements/same-line-method-rs-field-identifier-initializer.js
@@ -66,7 +66,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-method-rs-field-identifier.js b/test/language/expressions/class/elements/same-line-method-rs-field-identifier.js
index 0ead790477..900a39fd70 100644
--- a/test/language/expressions/class/elements/same-line-method-rs-field-identifier.js
+++ b/test/language/expressions/class/elements/same-line-method-rs-field-identifier.js
@@ -66,7 +66,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-method-rs-private-getter-alt.js b/test/language/expressions/class/elements/same-line-method-rs-private-getter-alt.js
index fa413b7a84..007ede757c 100644
--- a/test/language/expressions/class/elements/same-line-method-rs-private-getter-alt.js
+++ b/test/language/expressions/class/elements/same-line-method-rs-private-getter-alt.js
@@ -107,7 +107,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-method-rs-private-getter.js b/test/language/expressions/class/elements/same-line-method-rs-private-getter.js
index baa04f600b..d5bddc02cd 100644
--- a/test/language/expressions/class/elements/same-line-method-rs-private-getter.js
+++ b/test/language/expressions/class/elements/same-line-method-rs-private-getter.js
@@ -107,7 +107,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-method-rs-private-method-alt.js b/test/language/expressions/class/elements/same-line-method-rs-private-method-alt.js
index 071292fbb0..195d4794b4 100644
--- a/test/language/expressions/class/elements/same-line-method-rs-private-method-alt.js
+++ b/test/language/expressions/class/elements/same-line-method-rs-private-method-alt.js
@@ -106,7 +106,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-method-rs-private-method.js b/test/language/expressions/class/elements/same-line-method-rs-private-method.js
index 56da65c5f8..d4791f6a42 100644
--- a/test/language/expressions/class/elements/same-line-method-rs-private-method.js
+++ b/test/language/expressions/class/elements/same-line-method-rs-private-method.js
@@ -106,7 +106,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-method-rs-private-setter-alt.js b/test/language/expressions/class/elements/same-line-method-rs-private-setter-alt.js
index ef3dbb7e19..32860aa061 100644
--- a/test/language/expressions/class/elements/same-line-method-rs-private-setter-alt.js
+++ b/test/language/expressions/class/elements/same-line-method-rs-private-setter-alt.js
@@ -106,7 +106,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-method-rs-private-setter.js b/test/language/expressions/class/elements/same-line-method-rs-private-setter.js
index 6495b99284..f53f2571dc 100644
--- a/test/language/expressions/class/elements/same-line-method-rs-private-setter.js
+++ b/test/language/expressions/class/elements/same-line-method-rs-private-setter.js
@@ -106,7 +106,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-method-rs-privatename-identifier-alt.js b/test/language/expressions/class/elements/same-line-method-rs-privatename-identifier-alt.js
index 813ca99c92..e25683cff3 100644
--- a/test/language/expressions/class/elements/same-line-method-rs-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/same-line-method-rs-privatename-identifier-alt.js
@@ -87,7 +87,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-method-rs-privatename-identifier-initializer-alt.js b/test/language/expressions/class/elements/same-line-method-rs-privatename-identifier-initializer-alt.js
index b2a3fbd7f0..8d602aeee6 100644
--- a/test/language/expressions/class/elements/same-line-method-rs-privatename-identifier-initializer-alt.js
+++ b/test/language/expressions/class/elements/same-line-method-rs-privatename-identifier-initializer-alt.js
@@ -81,7 +81,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-method-rs-privatename-identifier-initializer.js b/test/language/expressions/class/elements/same-line-method-rs-privatename-identifier-initializer.js
index 930b78c8d3..9ee540d2cd 100644
--- a/test/language/expressions/class/elements/same-line-method-rs-privatename-identifier-initializer.js
+++ b/test/language/expressions/class/elements/same-line-method-rs-privatename-identifier-initializer.js
@@ -81,7 +81,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-method-rs-privatename-identifier.js b/test/language/expressions/class/elements/same-line-method-rs-privatename-identifier.js
index a9abae21cc..02561104c5 100644
--- a/test/language/expressions/class/elements/same-line-method-rs-privatename-identifier.js
+++ b/test/language/expressions/class/elements/same-line-method-rs-privatename-identifier.js
@@ -87,7 +87,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-method-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/same-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
index 9df51a2c34..a13b4056ce 100644
--- a/test/language/expressions/class/elements/same-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/same-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -103,7 +103,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-method-rs-static-async-generator-method-privatename-identifier.js b/test/language/expressions/class/elements/same-line-method-rs-static-async-generator-method-privatename-identifier.js
index 1a5af5896d..b83c808669 100644
--- a/test/language/expressions/class/elements/same-line-method-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/same-line-method-rs-static-async-generator-method-privatename-identifier.js
@@ -103,7 +103,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-method-rs-static-async-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/same-line-method-rs-static-async-method-privatename-identifier-alt.js
index 6b11c9bfc7..4f7671099d 100644
--- a/test/language/expressions/class/elements/same-line-method-rs-static-async-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/same-line-method-rs-static-async-method-privatename-identifier-alt.js
@@ -103,7 +103,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-method-rs-static-async-method-privatename-identifier.js b/test/language/expressions/class/elements/same-line-method-rs-static-async-method-privatename-identifier.js
index ca91a358f5..ea178d7dc9 100644
--- a/test/language/expressions/class/elements/same-line-method-rs-static-async-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/same-line-method-rs-static-async-method-privatename-identifier.js
@@ -103,7 +103,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-method-rs-static-generator-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/same-line-method-rs-static-generator-method-privatename-identifier-alt.js
index 6a5c6b2150..532156354e 100644
--- a/test/language/expressions/class/elements/same-line-method-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/same-line-method-rs-static-generator-method-privatename-identifier-alt.js
@@ -103,7 +103,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-method-rs-static-generator-method-privatename-identifier.js b/test/language/expressions/class/elements/same-line-method-rs-static-generator-method-privatename-identifier.js
index 0982e74728..55a6799561 100644
--- a/test/language/expressions/class/elements/same-line-method-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/same-line-method-rs-static-generator-method-privatename-identifier.js
@@ -103,7 +103,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-method-rs-static-method-privatename-identifier-alt.js b/test/language/expressions/class/elements/same-line-method-rs-static-method-privatename-identifier-alt.js
index dcfe25064a..5c01876da8 100644
--- a/test/language/expressions/class/elements/same-line-method-rs-static-method-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/same-line-method-rs-static-method-privatename-identifier-alt.js
@@ -100,7 +100,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-method-rs-static-method-privatename-identifier.js b/test/language/expressions/class/elements/same-line-method-rs-static-method-privatename-identifier.js
index a9de85d4a9..ee972bcc79 100644
--- a/test/language/expressions/class/elements/same-line-method-rs-static-method-privatename-identifier.js
+++ b/test/language/expressions/class/elements/same-line-method-rs-static-method-privatename-identifier.js
@@ -100,7 +100,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-method-rs-static-privatename-identifier-alt-by-classname.js b/test/language/expressions/class/elements/same-line-method-rs-static-privatename-identifier-alt-by-classname.js
index 6b940ae7bf..d38069abcd 100644
--- a/test/language/expressions/class/elements/same-line-method-rs-static-privatename-identifier-alt-by-classname.js
+++ b/test/language/expressions/class/elements/same-line-method-rs-static-privatename-identifier-alt-by-classname.js
@@ -88,7 +88,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-method-rs-static-privatename-identifier-alt.js b/test/language/expressions/class/elements/same-line-method-rs-static-privatename-identifier-alt.js
index bd0e5587ac..be21ed4601 100644
--- a/test/language/expressions/class/elements/same-line-method-rs-static-privatename-identifier-alt.js
+++ b/test/language/expressions/class/elements/same-line-method-rs-static-privatename-identifier-alt.js
@@ -88,7 +88,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-method-rs-static-privatename-identifier-by-classname.js b/test/language/expressions/class/elements/same-line-method-rs-static-privatename-identifier-by-classname.js
index 48b5ab634e..6cc697724d 100644
--- a/test/language/expressions/class/elements/same-line-method-rs-static-privatename-identifier-by-classname.js
+++ b/test/language/expressions/class/elements/same-line-method-rs-static-privatename-identifier-by-classname.js
@@ -88,7 +88,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-method-rs-static-privatename-identifier-initializer-alt-by-classname.js b/test/language/expressions/class/elements/same-line-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
index b5f99fa010..b1966d1515 100644
--- a/test/language/expressions/class/elements/same-line-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
+++ b/test/language/expressions/class/elements/same-line-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
@@ -82,7 +82,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-method-rs-static-privatename-identifier-initializer-alt.js b/test/language/expressions/class/elements/same-line-method-rs-static-privatename-identifier-initializer-alt.js
index a08d2d0433..c177ae62f3 100644
--- a/test/language/expressions/class/elements/same-line-method-rs-static-privatename-identifier-initializer-alt.js
+++ b/test/language/expressions/class/elements/same-line-method-rs-static-privatename-identifier-initializer-alt.js
@@ -82,7 +82,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-method-rs-static-privatename-identifier-initializer.js b/test/language/expressions/class/elements/same-line-method-rs-static-privatename-identifier-initializer.js
index 69a83afbbe..072129cbfe 100644
--- a/test/language/expressions/class/elements/same-line-method-rs-static-privatename-identifier-initializer.js
+++ b/test/language/expressions/class/elements/same-line-method-rs-static-privatename-identifier-initializer.js
@@ -82,7 +82,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-method-rs-static-privatename-identifier.js b/test/language/expressions/class/elements/same-line-method-rs-static-privatename-identifier.js
index 4dbb68461a..54d21e0f41 100644
--- a/test/language/expressions/class/elements/same-line-method-rs-static-privatename-identifier.js
+++ b/test/language/expressions/class/elements/same-line-method-rs-static-privatename-identifier.js
@@ -88,7 +88,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/expressions/class/elements/same-line-method-static-private-fields.js b/test/language/expressions/class/elements/same-line-method-static-private-fields.js
index 8a0987bae9..c47b6f3bb7 100644
--- a/test/language/expressions/class/elements/same-line-method-static-private-fields.js
+++ b/test/language/expressions/class/elements/same-line-method-static-private-fields.js
@@ -40,7 +40,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -49,18 +52,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/expressions/class/elements/same-line-method-static-private-methods-with-fields.js b/test/language/expressions/class/elements/same-line-method-static-private-methods-with-fields.js
index 4105cf4b97..365e791268 100644
--- a/test/language/expressions/class/elements/same-line-method-static-private-methods-with-fields.js
+++ b/test/language/expressions/class/elements/same-line-method-static-private-methods-with-fields.js
@@ -46,7 +46,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -55,29 +58,29 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#xVal"), "test 7");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 8");
+assert(!Object.prototype.hasOwnProperty.call(c, "#xVal"), "test 9");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#yVal"), "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 11");
+assert(!Object.prototype.hasOwnProperty.call(c, "#yVal"), "test 12");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 13");
 assert.sameValue(C.y(), 43, "test 14");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 15");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 16");
 
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 17");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 18");
diff --git a/test/language/expressions/class/elements/same-line-method-static-private-methods.js b/test/language/expressions/class/elements/same-line-method-static-private-methods.js
index ad35306358..025a502a49 100644
--- a/test/language/expressions/class/elements/same-line-method-static-private-methods.js
+++ b/test/language/expressions/class/elements/same-line-method-static-private-methods.js
@@ -44,7 +44,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -53,18 +56,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/expressions/class/elements/same-line-method-string-literal-names.js b/test/language/expressions/class/elements/same-line-method-string-literal-names.js
index 348e2e7521..734ef955c5 100644
--- a/test/language/expressions/class/elements/same-line-method-string-literal-names.js
+++ b/test/language/expressions/class/elements/same-line-method-string-literal-names.js
@@ -31,7 +31,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -39,8 +42,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -49,8 +58,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: undefined,
@@ -59,8 +74,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: 39,
@@ -69,8 +90,14 @@ verifyProperty(c, "c", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "d"),
+  "d does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "d"),
+  "d does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "d", {
   value: 42,
diff --git a/test/language/expressions/class/elements/static-field-declaration.js b/test/language/expressions/class/elements/static-field-declaration.js
index 3cea2ffafe..fb37224607 100644
--- a/test/language/expressions/class/elements/static-field-declaration.js
+++ b/test/language/expressions/class/elements/static-field-declaration.js
@@ -84,10 +84,22 @@ assert.sameValue(c.g, undefined);
 assert.sameValue(c.h, undefined);
 assert.sameValue(c[0], undefined);
 
-assert.sameValue(Object.hasOwnProperty.call(c, 'f'), false);
-assert.sameValue(Object.hasOwnProperty.call(c, 'g'), false);
-assert.sameValue(Object.hasOwnProperty.call(c, 'h'), false);
-assert.sameValue(Object.hasOwnProperty.call(c, 0), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, 'f'),
+  "f does not appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, 'g'),
+  "g does not appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, 'h'),
+  "h does not appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, 0),
+  "0 does not appear as an own property on the C instance"
+);
 
 verifyProperty(C, 'f', {
   value: 'test262',
diff --git a/test/language/expressions/class/elements/wrapped-in-sc-computed-names.js b/test/language/expressions/class/elements/wrapped-in-sc-computed-names.js
index 59c76da803..386fa0efda 100644
--- a/test/language/expressions/class/elements/wrapped-in-sc-computed-names.js
+++ b/test/language/expressions/class/elements/wrapped-in-sc-computed-names.js
@@ -32,8 +32,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -42,12 +48,27 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "10"),
+  "10 doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "10"),
+  "10 doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "10", {
   value: "meep",
@@ -56,8 +77,14 @@ verifyProperty(c, "10", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "not initialized", {
   value: undefined,
diff --git a/test/language/expressions/class/elements/wrapped-in-sc-computed-symbol-names.js b/test/language/expressions/class/elements/wrapped-in-sc-computed-symbol-names.js
index 86211887ef..fa60a24c60 100644
--- a/test/language/expressions/class/elements/wrapped-in-sc-computed-symbol-names.js
+++ b/test/language/expressions/class/elements/wrapped-in-sc-computed-symbol-names.js
@@ -33,8 +33,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, x), false);
-assert.sameValue(Object.hasOwnProperty.call(C, x), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, x),
+  "Symbol x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, x),
+  "Symbol x doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, x, {
   value: undefined,
@@ -43,8 +49,14 @@ verifyProperty(c, x, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
-assert.sameValue(Object.hasOwnProperty.call(C, y), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, y),
+  "Symbol y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, y),
+  "Symbol y doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, y, {
   value: 42,
@@ -53,10 +65,28 @@ verifyProperty(c, y, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "y"),
+  "y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "y"),
+  "y doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "y"),
+  "y doesn't appear as an own property on C instance"
+);
diff --git a/test/language/expressions/class/elements/wrapped-in-sc-literal-names-asi.js b/test/language/expressions/class/elements/wrapped-in-sc-literal-names-asi.js
index 302a23abdb..e8eb34edc1 100644
--- a/test/language/expressions/class/elements/wrapped-in-sc-literal-names-asi.js
+++ b/test/language/expressions/class/elements/wrapped-in-sc-literal-names-asi.js
@@ -31,8 +31,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -41,8 +47,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
diff --git a/test/language/expressions/class/elements/wrapped-in-sc-literal-names.js b/test/language/expressions/class/elements/wrapped-in-sc-literal-names.js
index 4373bffb98..5cb1dd104b 100644
--- a/test/language/expressions/class/elements/wrapped-in-sc-literal-names.js
+++ b/test/language/expressions/class/elements/wrapped-in-sc-literal-names.js
@@ -33,8 +33,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -43,8 +49,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -53,8 +65,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: fn,
diff --git a/test/language/expressions/class/elements/wrapped-in-sc-private-names.js b/test/language/expressions/class/elements/wrapped-in-sc-private-names.js
index da7575e245..01288ecf8d 100644
--- a/test/language/expressions/class/elements/wrapped-in-sc-private-names.js
+++ b/test/language/expressions/class/elements/wrapped-in-sc-private-names.js
@@ -40,18 +40,18 @@ var C = class {
 var c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(c.x(), 42, "test 7");
 assert.sameValue(c.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 10");
diff --git a/test/language/expressions/class/elements/wrapped-in-sc-static-private-fields.js b/test/language/expressions/class/elements/wrapped-in-sc-static-private-fields.js
index f14edfa704..3b724ac63f 100644
--- a/test/language/expressions/class/elements/wrapped-in-sc-static-private-fields.js
+++ b/test/language/expressions/class/elements/wrapped-in-sc-static-private-fields.js
@@ -40,18 +40,18 @@ var C = class {
 var c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/expressions/class/elements/wrapped-in-sc-static-private-methods-with-fields.js b/test/language/expressions/class/elements/wrapped-in-sc-static-private-methods-with-fields.js
index 006c53b68c..afa1353508 100644
--- a/test/language/expressions/class/elements/wrapped-in-sc-static-private-methods-with-fields.js
+++ b/test/language/expressions/class/elements/wrapped-in-sc-static-private-methods-with-fields.js
@@ -46,29 +46,29 @@ var C = class {
 var c = new C();
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#xVal"), "test 7");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 8");
+assert(!Object.prototype.hasOwnProperty.call(c, "#xVal"), "test 9");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#yVal"), "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 11");
+assert(!Object.prototype.hasOwnProperty.call(c, "#yVal"), "test 12");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 13");
 assert.sameValue(C.y(), 43, "test 14");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 15");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 16");
 
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 17");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 18");
diff --git a/test/language/expressions/class/elements/wrapped-in-sc-static-private-methods.js b/test/language/expressions/class/elements/wrapped-in-sc-static-private-methods.js
index d547b08195..b3287787b7 100644
--- a/test/language/expressions/class/elements/wrapped-in-sc-static-private-methods.js
+++ b/test/language/expressions/class/elements/wrapped-in-sc-static-private-methods.js
@@ -44,18 +44,18 @@ var C = class {
 var c = new C();
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/expressions/class/elements/wrapped-in-sc-string-literal-names.js b/test/language/expressions/class/elements/wrapped-in-sc-string-literal-names.js
index 2f13166cb7..e2faf5f7ea 100644
--- a/test/language/expressions/class/elements/wrapped-in-sc-string-literal-names.js
+++ b/test/language/expressions/class/elements/wrapped-in-sc-string-literal-names.js
@@ -31,8 +31,14 @@ var C = class {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -41,8 +47,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: undefined,
@@ -51,8 +63,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: 39,
@@ -61,8 +79,14 @@ verifyProperty(c, "c", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "d"),
+  "d does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "d"),
+  "d does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "d", {
   value: 42,
diff --git a/test/language/expressions/generators/named-yield-identifier-spread-non-strict.js b/test/language/expressions/generators/named-yield-identifier-spread-non-strict.js
index 54121d9cc4..c3fa39e96e 100644
--- a/test/language/expressions/generators/named-yield-identifier-spread-non-strict.js
+++ b/test/language/expressions/generators/named-yield-identifier-spread-non-strict.js
@@ -55,7 +55,7 @@ assert.sameValue(value.z, 30);
 assert.sameValue(value.a, 1);
 assert.sameValue(value.b, 2);
 assert.sameValue(value[s], 42);
-assert(Object.hasOwnProperty.call(value, s));
+assert(Object.prototype.hasOwnProperty.call(value, s), "s is an own property");
 assert.sameValue(Object.keys(value).length, 5);
 
 assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/generators/yield-identifier-spread-non-strict.js b/test/language/expressions/generators/yield-identifier-spread-non-strict.js
index e4b123e3ca..a4a4360733 100644
--- a/test/language/expressions/generators/yield-identifier-spread-non-strict.js
+++ b/test/language/expressions/generators/yield-identifier-spread-non-strict.js
@@ -55,7 +55,7 @@ assert.sameValue(value.z, 30);
 assert.sameValue(value.a, 1);
 assert.sameValue(value.b, 2);
 assert.sameValue(value[s], 42);
-assert(Object.hasOwnProperty.call(value, s));
+assert(Object.prototype.hasOwnProperty.call(value, s), "s is an own property");
 assert.sameValue(Object.keys(value).length, 5);
 
 assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/new/spread-obj-symbol-property.js b/test/language/expressions/new/spread-obj-symbol-property.js
index a5c5d79c9c..954266c447 100644
--- a/test/language/expressions/new/spread-obj-symbol-property.js
+++ b/test/language/expressions/new/spread-obj-symbol-property.js
@@ -38,7 +38,7 @@ var callCount = 0;
 
 new function(obj) {
   assert.sameValue(obj[symbol], 1);
-  assert(Object.hasOwnProperty.call(obj, symbol));
+  assert(Object.prototype.hasOwnProperty.call(obj, symbol), "symbol is an own property");
   assert.sameValue(obj.c, 4);
   assert.sameValue(obj.d, 5);
   assert.sameValue(Object.keys(obj).length, 2);
diff --git a/test/language/expressions/object/method-definition/async-gen-yield-identifier-spread-non-strict.js b/test/language/expressions/object/method-definition/async-gen-yield-identifier-spread-non-strict.js
index a5de60e21b..9ad93acd6d 100644
--- a/test/language/expressions/object/method-definition/async-gen-yield-identifier-spread-non-strict.js
+++ b/test/language/expressions/object/method-definition/async-gen-yield-identifier-spread-non-strict.js
@@ -58,7 +58,7 @@ item.then(({ done, value }) => {
   assert.sameValue(value.b, 2);
   assert.sameValue(value[s], 42);
   assert.sameValue(Object.keys(value).length, 5);
-  assert(Object.hasOwnProperty.call(value, s));
+  assert(Object.prototype.hasOwnProperty.call(value, s), "s is an own property");
 }).then($DONE, $DONE);
 
 assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/object/method-definition/gen-yield-identifier-spread-non-strict.js b/test/language/expressions/object/method-definition/gen-yield-identifier-spread-non-strict.js
index 3ba4b1098f..e685131c0c 100644
--- a/test/language/expressions/object/method-definition/gen-yield-identifier-spread-non-strict.js
+++ b/test/language/expressions/object/method-definition/gen-yield-identifier-spread-non-strict.js
@@ -57,7 +57,7 @@ assert.sameValue(value.z, 30);
 assert.sameValue(value.a, 1);
 assert.sameValue(value.b, 2);
 assert.sameValue(value[s], 42);
-assert(Object.hasOwnProperty.call(value, s));
+assert(Object.prototype.hasOwnProperty.call(value, s), "s is an own property");
 assert.sameValue(Object.keys(value).length, 5);
 
 assert.sameValue(callCount, 1);
diff --git a/test/language/expressions/super/call-spread-obj-symbol-property.js b/test/language/expressions/super/call-spread-obj-symbol-property.js
index a1942045e2..0c2567e3fd 100644
--- a/test/language/expressions/super/call-spread-obj-symbol-property.js
+++ b/test/language/expressions/super/call-spread-obj-symbol-property.js
@@ -37,7 +37,7 @@ var callCount = 0;
 class Test262ParentClass {
   constructor(obj) {
     assert.sameValue(obj[symbol], 1);
-    assert(Object.hasOwnProperty.call(obj, symbol));
+    assert(Object.prototype.hasOwnProperty.call(obj, symbol), "symbol is an own property");
     assert.sameValue(obj.c, 4);
     assert.sameValue(obj.d, 5);
     assert.sameValue(Object.keys(obj).length, 2);
diff --git a/test/language/statements/async-generator/yield-identifier-spread-non-strict.js b/test/language/statements/async-generator/yield-identifier-spread-non-strict.js
index 6d84d52686..062b5ed32c 100644
--- a/test/language/statements/async-generator/yield-identifier-spread-non-strict.js
+++ b/test/language/statements/async-generator/yield-identifier-spread-non-strict.js
@@ -57,7 +57,7 @@ item.then(({ done, value }) => {
   assert.sameValue(value.b, 2);
   assert.sameValue(value[s], 42);
   assert.sameValue(Object.keys(value).length, 5);
-  assert(Object.hasOwnProperty.call(value, s));
+  assert(Object.prototype.hasOwnProperty.call(value, s), "s is an own property");
 }).then($DONE, $DONE);
 
 assert.sameValue(callCount, 1);
diff --git a/test/language/statements/class/decorator/syntax/valid/decorator-call-expr-identifier-reference-yield.js b/test/language/statements/class/decorator/syntax/valid/decorator-call-expr-identifier-reference-yield.js
index 1d16c6877a..318fb36618 100644
--- a/test/language/statements/class/decorator/syntax/valid/decorator-call-expr-identifier-reference-yield.js
+++ b/test/language/statements/class/decorator/syntax/valid/decorator-call-expr-identifier-reference-yield.js
@@ -1,15 +1,19 @@
 // This file was procedurally generated from the following sources:
 // - src/decorator/decorator-call-expr-identifier-reference-yield.case
-// - src/decorator/syntax/valid/cls-decl-decorators-valid-syntax.template
+// - src/decorator/syntax/valid/cls-element-decorators-valid-syntax.template
 /*---
 description: Decorator @ DecoratorCallExpression (Valid syntax for decorator on class.)
 esid: prod-ClassDeclaration
 features: [class, decorators]
 flags: [generated, noStrict]
 info: |
-    ClassDeclaration[Yield, Await, Default] :
-      DecoratorList[?Yield, ?Await]opt class BindingIdentifier[?Yield, ?Await] ClassTail[?Yield, ?Await]
-      [+Default] DecoratorList[?Yield, ?Await]opt class ClassTail[?Yield, ?Await]
+    ClassElement[Yield, Await] :
+      DecoratorList[?Yield, ?Await]opt MethodDefinition[?Yield, ?Await]
+      DecoratorList[?Yield, ?Await]opt static MethodDefinition[?Yield, ?Await]
+      DecoratorList[?Yield, ?Await]opt FieldDefinition[?Yield, ?Await] ;
+      DecoratorList[?Yield, ?Await]opt static FieldDefinition[?Yield, ?Await] ;
+      ClassStaticBlock
+      ;
 
     DecoratorList[Yield, Await] :
       DecoratorList[?Yield, ?Await]opt Decorator[?Yield, ?Await]
@@ -42,4 +46,9 @@ var yield = decorator;
 
 
 
-@yield() class C {}
+class C {
+  @yield() method() {}
+  @yield() static method() {}
+  @yield() field;
+  @yield() static field;
+}
diff --git a/test/language/statements/class/decorator/syntax/valid/decorator-call-expr-identifier-reference.js b/test/language/statements/class/decorator/syntax/valid/decorator-call-expr-identifier-reference.js
index 86b8919f74..52216da39f 100644
--- a/test/language/statements/class/decorator/syntax/valid/decorator-call-expr-identifier-reference.js
+++ b/test/language/statements/class/decorator/syntax/valid/decorator-call-expr-identifier-reference.js
@@ -1,15 +1,19 @@
 // This file was procedurally generated from the following sources:
 // - src/decorator/decorator-call-expr-identifier-reference.case
-// - src/decorator/syntax/valid/cls-decl-decorators-valid-syntax.template
+// - src/decorator/syntax/valid/cls-element-decorators-valid-syntax.template
 /*---
 description: Decorator @ DecoratorCallExpression (Valid syntax for decorator on class.)
 esid: prod-ClassDeclaration
 features: [class, decorators]
 flags: [generated]
 info: |
-    ClassDeclaration[Yield, Await, Default] :
-      DecoratorList[?Yield, ?Await]opt class BindingIdentifier[?Yield, ?Await] ClassTail[?Yield, ?Await]
-      [+Default] DecoratorList[?Yield, ?Await]opt class ClassTail[?Yield, ?Await]
+    ClassElement[Yield, Await] :
+      DecoratorList[?Yield, ?Await]opt MethodDefinition[?Yield, ?Await]
+      DecoratorList[?Yield, ?Await]opt static MethodDefinition[?Yield, ?Await]
+      DecoratorList[?Yield, ?Await]opt FieldDefinition[?Yield, ?Await] ;
+      DecoratorList[?Yield, ?Await]opt static FieldDefinition[?Yield, ?Await] ;
+      ClassStaticBlock
+      ;
 
     DecoratorList[Yield, Await] :
       DecoratorList[?Yield, ?Await]opt Decorator[?Yield, ?Await]
@@ -49,10 +53,33 @@ var await = decorator;
 
 
 
-@$()
-@_()
-@\u{6F}()
-@\u2118()
-@ZW_\u200C_NJ()
-@ZW_\u200D_J()
-@await() class C {}
+class C {
+  @$()
+  @_()
+  @\u{6F}()
+  @\u2118()
+  @ZW_\u200C_NJ()
+  @ZW_\u200D_J()
+  @await() method() {}
+  @$()
+  @_()
+  @\u{6F}()
+  @\u2118()
+  @ZW_\u200C_NJ()
+  @ZW_\u200D_J()
+  @await() static method() {}
+  @$()
+  @_()
+  @\u{6F}()
+  @\u2118()
+  @ZW_\u200C_NJ()
+  @ZW_\u200D_J()
+  @await() field;
+  @$()
+  @_()
+  @\u{6F}()
+  @\u2118()
+  @ZW_\u200C_NJ()
+  @ZW_\u200D_J()
+  @await() static field;
+}
diff --git a/test/language/statements/class/decorator/syntax/valid/decorator-member-expr-decorator-member-expr.js b/test/language/statements/class/decorator/syntax/valid/decorator-member-expr-decorator-member-expr.js
index a43627049c..48c7d2b19d 100644
--- a/test/language/statements/class/decorator/syntax/valid/decorator-member-expr-decorator-member-expr.js
+++ b/test/language/statements/class/decorator/syntax/valid/decorator-member-expr-decorator-member-expr.js
@@ -1,15 +1,19 @@
 // This file was procedurally generated from the following sources:
 // - src/decorator/decorator-member-expr-decorator-member-expr.case
-// - src/decorator/syntax/valid/cls-decl-decorators-valid-syntax.template
+// - src/decorator/syntax/valid/cls-element-decorators-valid-syntax.template
 /*---
 description: Decorator @ DecoratorMemberExpression (Valid syntax for decorator on class.)
 esid: prod-ClassDeclaration
 features: [class, decorators]
 flags: [generated]
 info: |
-    ClassDeclaration[Yield, Await, Default] :
-      DecoratorList[?Yield, ?Await]opt class BindingIdentifier[?Yield, ?Await] ClassTail[?Yield, ?Await]
-      [+Default] DecoratorList[?Yield, ?Await]opt class ClassTail[?Yield, ?Await]
+    ClassElement[Yield, Await] :
+      DecoratorList[?Yield, ?Await]opt MethodDefinition[?Yield, ?Await]
+      DecoratorList[?Yield, ?Await]opt static MethodDefinition[?Yield, ?Await]
+      DecoratorList[?Yield, ?Await]opt FieldDefinition[?Yield, ?Await] ;
+      DecoratorList[?Yield, ?Await]opt static FieldDefinition[?Yield, ?Await] ;
+      ClassStaticBlock
+      ;
 
     DecoratorList[Yield, Await] :
       DecoratorList[?Yield, ?Await]opt Decorator[?Yield, ?Await]
@@ -41,11 +45,37 @@ let ns = {
 
 
 
-@ns.$
-@ns._
-@ns.\u{6F}
-@ns.\u2118
-@ns.ZW_\u200C_NJ
-@ns.ZW_\u200D_J
-@ns.yield
-@ns.await class C {}
+class C {
+  @ns.$
+  @ns._
+  @ns.\u{6F}
+  @ns.\u2118
+  @ns.ZW_\u200C_NJ
+  @ns.ZW_\u200D_J
+  @ns.yield
+  @ns.await method() {}
+  @ns.$
+  @ns._
+  @ns.\u{6F}
+  @ns.\u2118
+  @ns.ZW_\u200C_NJ
+  @ns.ZW_\u200D_J
+  @ns.yield
+  @ns.await static method() {}
+  @ns.$
+  @ns._
+  @ns.\u{6F}
+  @ns.\u2118
+  @ns.ZW_\u200C_NJ
+  @ns.ZW_\u200D_J
+  @ns.yield
+  @ns.await field;
+  @ns.$
+  @ns._
+  @ns.\u{6F}
+  @ns.\u2118
+  @ns.ZW_\u200C_NJ
+  @ns.ZW_\u200D_J
+  @ns.yield
+  @ns.await static field;
+}
diff --git a/test/language/statements/class/decorator/syntax/valid/decorator-member-expr-identifier-reference-yield.js b/test/language/statements/class/decorator/syntax/valid/decorator-member-expr-identifier-reference-yield.js
index 388a12ef6f..a685b425f4 100644
--- a/test/language/statements/class/decorator/syntax/valid/decorator-member-expr-identifier-reference-yield.js
+++ b/test/language/statements/class/decorator/syntax/valid/decorator-member-expr-identifier-reference-yield.js
@@ -1,15 +1,19 @@
 // This file was procedurally generated from the following sources:
 // - src/decorator/decorator-member-expr-identifier-reference-yield.case
-// - src/decorator/syntax/valid/cls-decl-decorators-valid-syntax.template
+// - src/decorator/syntax/valid/cls-element-decorators-valid-syntax.template
 /*---
 description: Decorator @ DecoratorMemberExpression (Valid syntax for decorator on class.)
 esid: prod-ClassDeclaration
 features: [class, decorators]
 flags: [generated, noStrict]
 info: |
-    ClassDeclaration[Yield, Await, Default] :
-      DecoratorList[?Yield, ?Await]opt class BindingIdentifier[?Yield, ?Await] ClassTail[?Yield, ?Await]
-      [+Default] DecoratorList[?Yield, ?Await]opt class ClassTail[?Yield, ?Await]
+    ClassElement[Yield, Await] :
+      DecoratorList[?Yield, ?Await]opt MethodDefinition[?Yield, ?Await]
+      DecoratorList[?Yield, ?Await]opt static MethodDefinition[?Yield, ?Await]
+      DecoratorList[?Yield, ?Await]opt FieldDefinition[?Yield, ?Await] ;
+      DecoratorList[?Yield, ?Await]opt static FieldDefinition[?Yield, ?Await] ;
+      ClassStaticBlock
+      ;
 
     DecoratorList[Yield, Await] :
       DecoratorList[?Yield, ?Await]opt Decorator[?Yield, ?Await]
@@ -31,4 +35,9 @@ function yield() {}
 
 
 
-@yield class C {}
+class C {
+  @yield method() {}
+  @yield static method() {}
+  @yield field;
+  @yield static field;
+}
diff --git a/test/language/statements/class/decorator/syntax/valid/decorator-member-expr-identifier-reference.js b/test/language/statements/class/decorator/syntax/valid/decorator-member-expr-identifier-reference.js
index a17dc8a49d..d02c11aa57 100644
--- a/test/language/statements/class/decorator/syntax/valid/decorator-member-expr-identifier-reference.js
+++ b/test/language/statements/class/decorator/syntax/valid/decorator-member-expr-identifier-reference.js
@@ -1,15 +1,19 @@
 // This file was procedurally generated from the following sources:
 // - src/decorator/decorator-member-expr-identifier-reference.case
-// - src/decorator/syntax/valid/cls-decl-decorators-valid-syntax.template
+// - src/decorator/syntax/valid/cls-element-decorators-valid-syntax.template
 /*---
 description: Decorator @ DecoratorMemberExpression (Valid syntax for decorator on class.)
 esid: prod-ClassDeclaration
 features: [class, decorators]
 flags: [generated]
 info: |
-    ClassDeclaration[Yield, Await, Default] :
-      DecoratorList[?Yield, ?Await]opt class BindingIdentifier[?Yield, ?Await] ClassTail[?Yield, ?Await]
-      [+Default] DecoratorList[?Yield, ?Await]opt class ClassTail[?Yield, ?Await]
+    ClassElement[Yield, Await] :
+      DecoratorList[?Yield, ?Await]opt MethodDefinition[?Yield, ?Await]
+      DecoratorList[?Yield, ?Await]opt static MethodDefinition[?Yield, ?Await]
+      DecoratorList[?Yield, ?Await]opt FieldDefinition[?Yield, ?Await] ;
+      DecoratorList[?Yield, ?Await]opt static FieldDefinition[?Yield, ?Await] ;
+      ClassStaticBlock
+      ;
 
     DecoratorList[Yield, Await] :
       DecoratorList[?Yield, ?Await]opt Decorator[?Yield, ?Await]
@@ -38,10 +42,33 @@ function await() {}
 
 
 
-@$
-@_
-@\u{6F}
-@\u2118
-@ZW_\u200C_NJ
-@ZW_\u200D_J
-@await class C {}
+class C {
+  @$
+  @_
+  @\u{6F}
+  @\u2118
+  @ZW_\u200C_NJ
+  @ZW_\u200D_J
+  @await method() {}
+  @$
+  @_
+  @\u{6F}
+  @\u2118
+  @ZW_\u200C_NJ
+  @ZW_\u200D_J
+  @await static method() {}
+  @$
+  @_
+  @\u{6F}
+  @\u2118
+  @ZW_\u200C_NJ
+  @ZW_\u200D_J
+  @await field;
+  @$
+  @_
+  @\u{6F}
+  @\u2118
+  @ZW_\u200C_NJ
+  @ZW_\u200D_J
+  @await static field;
+}
diff --git a/test/language/statements/class/decorator/syntax/valid/decorator-parenthesized-expr-identifier-reference-yield.js b/test/language/statements/class/decorator/syntax/valid/decorator-parenthesized-expr-identifier-reference-yield.js
index 157739fb0d..ab8ebcc0b1 100644
--- a/test/language/statements/class/decorator/syntax/valid/decorator-parenthesized-expr-identifier-reference-yield.js
+++ b/test/language/statements/class/decorator/syntax/valid/decorator-parenthesized-expr-identifier-reference-yield.js
@@ -1,15 +1,19 @@
 // This file was procedurally generated from the following sources:
 // - src/decorator/decorator-parenthesized-expr-identifier-reference-yield.case
-// - src/decorator/syntax/valid/cls-decl-decorators-valid-syntax.template
+// - src/decorator/syntax/valid/cls-element-decorators-valid-syntax.template
 /*---
 description: Decorator @ DecoratorParenthesizedExpression (Valid syntax for decorator on class.)
 esid: prod-ClassDeclaration
 features: [class, decorators]
 flags: [generated, noStrict]
 info: |
-    ClassDeclaration[Yield, Await, Default] :
-      DecoratorList[?Yield, ?Await]opt class BindingIdentifier[?Yield, ?Await] ClassTail[?Yield, ?Await]
-      [+Default] DecoratorList[?Yield, ?Await]opt class ClassTail[?Yield, ?Await]
+    ClassElement[Yield, Await] :
+      DecoratorList[?Yield, ?Await]opt MethodDefinition[?Yield, ?Await]
+      DecoratorList[?Yield, ?Await]opt static MethodDefinition[?Yield, ?Await]
+      DecoratorList[?Yield, ?Await]opt FieldDefinition[?Yield, ?Await] ;
+      DecoratorList[?Yield, ?Await]opt static FieldDefinition[?Yield, ?Await] ;
+      ClassStaticBlock
+      ;
 
     DecoratorList[Yield, Await] :
       DecoratorList[?Yield, ?Await]opt Decorator[?Yield, ?Await]
@@ -49,4 +53,9 @@ function yield() {}
 
 
 
-@(yield) class C {}
+class C {
+  @(yield) method() {}
+  @(yield) static method() {}
+  @(yield) field;
+  @(yield) static field;
+}
diff --git a/test/language/statements/class/decorator/syntax/valid/decorator-parenthesized-expr-identifier-reference.js b/test/language/statements/class/decorator/syntax/valid/decorator-parenthesized-expr-identifier-reference.js
index 4f8d89aac3..15102f6a93 100644
--- a/test/language/statements/class/decorator/syntax/valid/decorator-parenthesized-expr-identifier-reference.js
+++ b/test/language/statements/class/decorator/syntax/valid/decorator-parenthesized-expr-identifier-reference.js
@@ -1,15 +1,19 @@
 // This file was procedurally generated from the following sources:
 // - src/decorator/decorator-parenthesized-expr-identifier-reference.case
-// - src/decorator/syntax/valid/cls-decl-decorators-valid-syntax.template
+// - src/decorator/syntax/valid/cls-element-decorators-valid-syntax.template
 /*---
 description: Decorator @ DecoratorParenthesizedExpression (Valid syntax for decorator on class.)
 esid: prod-ClassDeclaration
 features: [class, decorators]
 flags: [generated]
 info: |
-    ClassDeclaration[Yield, Await, Default] :
-      DecoratorList[?Yield, ?Await]opt class BindingIdentifier[?Yield, ?Await] ClassTail[?Yield, ?Await]
-      [+Default] DecoratorList[?Yield, ?Await]opt class ClassTail[?Yield, ?Await]
+    ClassElement[Yield, Await] :
+      DecoratorList[?Yield, ?Await]opt MethodDefinition[?Yield, ?Await]
+      DecoratorList[?Yield, ?Await]opt static MethodDefinition[?Yield, ?Await]
+      DecoratorList[?Yield, ?Await]opt FieldDefinition[?Yield, ?Await] ;
+      DecoratorList[?Yield, ?Await]opt static FieldDefinition[?Yield, ?Await] ;
+      ClassStaticBlock
+      ;
 
     DecoratorList[Yield, Await] :
       DecoratorList[?Yield, ?Await]opt Decorator[?Yield, ?Await]
@@ -51,10 +55,33 @@ function await() {}
 
 
 
-@($)
-@(_)
-@(\u{6F})
-@(\u2118)
-@(ZW_\u200C_NJ)
-@(ZW_\u200D_J)
-@(await) class C {}
+class C {
+  @($)
+  @(_)
+  @(\u{6F})
+  @(\u2118)
+  @(ZW_\u200C_NJ)
+  @(ZW_\u200D_J)
+  @(await) method() {}
+  @($)
+  @(_)
+  @(\u{6F})
+  @(\u2118)
+  @(ZW_\u200C_NJ)
+  @(ZW_\u200D_J)
+  @(await) static method() {}
+  @($)
+  @(_)
+  @(\u{6F})
+  @(\u2118)
+  @(ZW_\u200C_NJ)
+  @(ZW_\u200D_J)
+  @(await) field;
+  @($)
+  @(_)
+  @(\u{6F})
+  @(\u2118)
+  @(ZW_\u200C_NJ)
+  @(ZW_\u200D_J)
+  @(await) static field;
+}
diff --git a/test/language/statements/class/elements/after-same-line-gen-computed-names.js b/test/language/statements/class/elements/after-same-line-gen-computed-names.js
index 5c76062abe..af78247e22 100644
--- a/test/language/statements/class/elements/after-same-line-gen-computed-names.js
+++ b/test/language/statements/class/elements/after-same-line-gen-computed-names.js
@@ -31,7 +31,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -40,8 +43,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -50,12 +59,27 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "10"),
+  "10 doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "10"),
+  "10 doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "10", {
   value: "meep",
@@ -64,8 +88,14 @@ verifyProperty(c, "10", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "not initialized", {
   value: undefined,
diff --git a/test/language/statements/class/elements/after-same-line-gen-computed-symbol-names.js b/test/language/statements/class/elements/after-same-line-gen-computed-symbol-names.js
index e697704571..ff7034025e 100644
--- a/test/language/statements/class/elements/after-same-line-gen-computed-symbol-names.js
+++ b/test/language/statements/class/elements/after-same-line-gen-computed-symbol-names.js
@@ -32,7 +32,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -41,8 +44,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, x), false);
-assert.sameValue(Object.hasOwnProperty.call(C, x), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, x),
+  "Symbol x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, x),
+  "Symbol x doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, x, {
   value: undefined,
@@ -51,8 +60,14 @@ verifyProperty(c, x, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
-assert.sameValue(Object.hasOwnProperty.call(C, y), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, y),
+  "Symbol y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, y),
+  "Symbol y doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, y, {
   value: 42,
@@ -61,10 +76,28 @@ verifyProperty(c, y, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "y"),
+  "y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "y"),
+  "y doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "y"),
+  "y doesn't appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/after-same-line-gen-grammar-privatename-identifier-semantics-stringvalue.js b/test/language/statements/class/elements/after-same-line-gen-grammar-privatename-identifier-semantics-stringvalue.js
index f4c721ed7e..f52d5c013a 100644
--- a/test/language/statements/class/elements/after-same-line-gen-grammar-privatename-identifier-semantics-stringvalue.js
+++ b/test/language/statements/class/elements/after-same-line-gen-grammar-privatename-identifier-semantics-stringvalue.js
@@ -89,7 +89,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-gen-literal-names-asi.js b/test/language/statements/class/elements/after-same-line-gen-literal-names-asi.js
index db6421e278..31153f2959 100644
--- a/test/language/statements/class/elements/after-same-line-gen-literal-names-asi.js
+++ b/test/language/statements/class/elements/after-same-line-gen-literal-names-asi.js
@@ -30,7 +30,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -39,8 +42,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -49,8 +58,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
diff --git a/test/language/statements/class/elements/after-same-line-gen-literal-names.js b/test/language/statements/class/elements/after-same-line-gen-literal-names.js
index 0e46d145ff..8f241a826f 100644
--- a/test/language/statements/class/elements/after-same-line-gen-literal-names.js
+++ b/test/language/statements/class/elements/after-same-line-gen-literal-names.js
@@ -32,7 +32,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -41,8 +44,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -51,8 +60,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -61,8 +76,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: fn,
diff --git a/test/language/statements/class/elements/after-same-line-gen-private-field-usage.js b/test/language/statements/class/elements/after-same-line-gen-private-field-usage.js
index c4773288e1..ba5fb2e783 100644
--- a/test/language/statements/class/elements/after-same-line-gen-private-field-usage.js
+++ b/test/language/statements/class/elements/after-same-line-gen-private-field-usage.js
@@ -32,7 +32,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-gen-private-method-getter-usage.js b/test/language/statements/class/elements/after-same-line-gen-private-method-getter-usage.js
index 85cab8b982..7cedde737a 100644
--- a/test/language/statements/class/elements/after-same-line-gen-private-method-getter-usage.js
+++ b/test/language/statements/class/elements/after-same-line-gen-private-method-getter-usage.js
@@ -32,7 +32,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-gen-private-method-usage.js b/test/language/statements/class/elements/after-same-line-gen-private-method-usage.js
index 3a33efb763..a4b681dcfb 100644
--- a/test/language/statements/class/elements/after-same-line-gen-private-method-usage.js
+++ b/test/language/statements/class/elements/after-same-line-gen-private-method-usage.js
@@ -32,7 +32,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-gen-private-names.js b/test/language/statements/class/elements/after-same-line-gen-private-names.js
index ef6c1fd75a..c07832f57e 100644
--- a/test/language/statements/class/elements/after-same-line-gen-private-names.js
+++ b/test/language/statements/class/elements/after-same-line-gen-private-names.js
@@ -39,7 +39,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -49,18 +52,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(c.x(), 42, "test 7");
 assert.sameValue(c.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 10");
diff --git a/test/language/statements/class/elements/after-same-line-gen-rs-field-identifier-initializer.js b/test/language/statements/class/elements/after-same-line-gen-rs-field-identifier-initializer.js
index b556d8af65..c286764567 100644
--- a/test/language/statements/class/elements/after-same-line-gen-rs-field-identifier-initializer.js
+++ b/test/language/statements/class/elements/after-same-line-gen-rs-field-identifier-initializer.js
@@ -65,7 +65,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-gen-rs-field-identifier.js b/test/language/statements/class/elements/after-same-line-gen-rs-field-identifier.js
index e2979d328c..38b5ee91a8 100644
--- a/test/language/statements/class/elements/after-same-line-gen-rs-field-identifier.js
+++ b/test/language/statements/class/elements/after-same-line-gen-rs-field-identifier.js
@@ -65,7 +65,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-gen-rs-private-getter-alt.js b/test/language/statements/class/elements/after-same-line-gen-rs-private-getter-alt.js
index 66093c0747..450c0a8ad1 100644
--- a/test/language/statements/class/elements/after-same-line-gen-rs-private-getter-alt.js
+++ b/test/language/statements/class/elements/after-same-line-gen-rs-private-getter-alt.js
@@ -106,7 +106,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-gen-rs-private-getter.js b/test/language/statements/class/elements/after-same-line-gen-rs-private-getter.js
index af7ce719fa..585f8f87ea 100644
--- a/test/language/statements/class/elements/after-same-line-gen-rs-private-getter.js
+++ b/test/language/statements/class/elements/after-same-line-gen-rs-private-getter.js
@@ -106,7 +106,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-gen-rs-private-method-alt.js b/test/language/statements/class/elements/after-same-line-gen-rs-private-method-alt.js
index 73d036ee4b..85a45fe994 100644
--- a/test/language/statements/class/elements/after-same-line-gen-rs-private-method-alt.js
+++ b/test/language/statements/class/elements/after-same-line-gen-rs-private-method-alt.js
@@ -105,7 +105,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-gen-rs-private-method.js b/test/language/statements/class/elements/after-same-line-gen-rs-private-method.js
index a8d96a9cb1..8c4681bc83 100644
--- a/test/language/statements/class/elements/after-same-line-gen-rs-private-method.js
+++ b/test/language/statements/class/elements/after-same-line-gen-rs-private-method.js
@@ -105,7 +105,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-gen-rs-private-setter-alt.js b/test/language/statements/class/elements/after-same-line-gen-rs-private-setter-alt.js
index b98a3ed483..368af32005 100644
--- a/test/language/statements/class/elements/after-same-line-gen-rs-private-setter-alt.js
+++ b/test/language/statements/class/elements/after-same-line-gen-rs-private-setter-alt.js
@@ -105,7 +105,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-gen-rs-private-setter.js b/test/language/statements/class/elements/after-same-line-gen-rs-private-setter.js
index e584ddf146..5b21ac9147 100644
--- a/test/language/statements/class/elements/after-same-line-gen-rs-private-setter.js
+++ b/test/language/statements/class/elements/after-same-line-gen-rs-private-setter.js
@@ -105,7 +105,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-gen-rs-privatename-identifier-alt.js b/test/language/statements/class/elements/after-same-line-gen-rs-privatename-identifier-alt.js
index 088c345445..344f8e413a 100644
--- a/test/language/statements/class/elements/after-same-line-gen-rs-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/after-same-line-gen-rs-privatename-identifier-alt.js
@@ -86,7 +86,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-gen-rs-privatename-identifier-initializer-alt.js b/test/language/statements/class/elements/after-same-line-gen-rs-privatename-identifier-initializer-alt.js
index 84101bc73e..9736d0dd4c 100644
--- a/test/language/statements/class/elements/after-same-line-gen-rs-privatename-identifier-initializer-alt.js
+++ b/test/language/statements/class/elements/after-same-line-gen-rs-privatename-identifier-initializer-alt.js
@@ -80,7 +80,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-gen-rs-privatename-identifier-initializer.js b/test/language/statements/class/elements/after-same-line-gen-rs-privatename-identifier-initializer.js
index 7c281e49be..837c1c4196 100644
--- a/test/language/statements/class/elements/after-same-line-gen-rs-privatename-identifier-initializer.js
+++ b/test/language/statements/class/elements/after-same-line-gen-rs-privatename-identifier-initializer.js
@@ -80,7 +80,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-gen-rs-privatename-identifier.js b/test/language/statements/class/elements/after-same-line-gen-rs-privatename-identifier.js
index 5301106a15..43c4351c83 100644
--- a/test/language/statements/class/elements/after-same-line-gen-rs-privatename-identifier.js
+++ b/test/language/statements/class/elements/after-same-line-gen-rs-privatename-identifier.js
@@ -86,7 +86,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/statements/class/elements/after-same-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js
index 471f665f08..62c60d53a9 100644
--- a/test/language/statements/class/elements/after-same-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/after-same-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -102,7 +102,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-gen-rs-static-async-generator-method-privatename-identifier.js b/test/language/statements/class/elements/after-same-line-gen-rs-static-async-generator-method-privatename-identifier.js
index e874a40190..80d1a36d57 100644
--- a/test/language/statements/class/elements/after-same-line-gen-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/after-same-line-gen-rs-static-async-generator-method-privatename-identifier.js
@@ -102,7 +102,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-gen-rs-static-async-method-privatename-identifier-alt.js b/test/language/statements/class/elements/after-same-line-gen-rs-static-async-method-privatename-identifier-alt.js
index 7b211cd9d1..124e65ebb9 100644
--- a/test/language/statements/class/elements/after-same-line-gen-rs-static-async-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/after-same-line-gen-rs-static-async-method-privatename-identifier-alt.js
@@ -102,7 +102,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-gen-rs-static-async-method-privatename-identifier.js b/test/language/statements/class/elements/after-same-line-gen-rs-static-async-method-privatename-identifier.js
index 5f399527c2..b247009cab 100644
--- a/test/language/statements/class/elements/after-same-line-gen-rs-static-async-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/after-same-line-gen-rs-static-async-method-privatename-identifier.js
@@ -102,7 +102,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-gen-rs-static-generator-method-privatename-identifier-alt.js b/test/language/statements/class/elements/after-same-line-gen-rs-static-generator-method-privatename-identifier-alt.js
index 4aff317ff3..f39a02a29c 100644
--- a/test/language/statements/class/elements/after-same-line-gen-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/after-same-line-gen-rs-static-generator-method-privatename-identifier-alt.js
@@ -102,7 +102,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-gen-rs-static-generator-method-privatename-identifier.js b/test/language/statements/class/elements/after-same-line-gen-rs-static-generator-method-privatename-identifier.js
index c794e9ac25..d4b3f45211 100644
--- a/test/language/statements/class/elements/after-same-line-gen-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/after-same-line-gen-rs-static-generator-method-privatename-identifier.js
@@ -102,7 +102,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-gen-rs-static-method-privatename-identifier-alt.js b/test/language/statements/class/elements/after-same-line-gen-rs-static-method-privatename-identifier-alt.js
index ce76ac36c1..31f9843b63 100644
--- a/test/language/statements/class/elements/after-same-line-gen-rs-static-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/after-same-line-gen-rs-static-method-privatename-identifier-alt.js
@@ -99,7 +99,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-gen-rs-static-method-privatename-identifier.js b/test/language/statements/class/elements/after-same-line-gen-rs-static-method-privatename-identifier.js
index 5a16d06dfb..760c5225cf 100644
--- a/test/language/statements/class/elements/after-same-line-gen-rs-static-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/after-same-line-gen-rs-static-method-privatename-identifier.js
@@ -99,7 +99,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-gen-rs-static-privatename-identifier-alt-by-classname.js b/test/language/statements/class/elements/after-same-line-gen-rs-static-privatename-identifier-alt-by-classname.js
index 79a4f6f404..53cc2e6ca3 100644
--- a/test/language/statements/class/elements/after-same-line-gen-rs-static-privatename-identifier-alt-by-classname.js
+++ b/test/language/statements/class/elements/after-same-line-gen-rs-static-privatename-identifier-alt-by-classname.js
@@ -87,7 +87,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-gen-rs-static-privatename-identifier-alt.js b/test/language/statements/class/elements/after-same-line-gen-rs-static-privatename-identifier-alt.js
index 3b03f1f1da..9f1c0de603 100644
--- a/test/language/statements/class/elements/after-same-line-gen-rs-static-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/after-same-line-gen-rs-static-privatename-identifier-alt.js
@@ -87,7 +87,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-gen-rs-static-privatename-identifier-by-classname.js b/test/language/statements/class/elements/after-same-line-gen-rs-static-privatename-identifier-by-classname.js
index 43eeacc343..cc9d58d372 100644
--- a/test/language/statements/class/elements/after-same-line-gen-rs-static-privatename-identifier-by-classname.js
+++ b/test/language/statements/class/elements/after-same-line-gen-rs-static-privatename-identifier-by-classname.js
@@ -87,7 +87,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js b/test/language/statements/class/elements/after-same-line-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
index 8fab85b31f..798a3c55e5 100644
--- a/test/language/statements/class/elements/after-same-line-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
+++ b/test/language/statements/class/elements/after-same-line-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
@@ -81,7 +81,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-gen-rs-static-privatename-identifier-initializer-alt.js b/test/language/statements/class/elements/after-same-line-gen-rs-static-privatename-identifier-initializer-alt.js
index 7d1782cb5b..538b9f5dd1 100644
--- a/test/language/statements/class/elements/after-same-line-gen-rs-static-privatename-identifier-initializer-alt.js
+++ b/test/language/statements/class/elements/after-same-line-gen-rs-static-privatename-identifier-initializer-alt.js
@@ -81,7 +81,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-gen-rs-static-privatename-identifier-initializer.js b/test/language/statements/class/elements/after-same-line-gen-rs-static-privatename-identifier-initializer.js
index 727e5e9965..6a80467a61 100644
--- a/test/language/statements/class/elements/after-same-line-gen-rs-static-privatename-identifier-initializer.js
+++ b/test/language/statements/class/elements/after-same-line-gen-rs-static-privatename-identifier-initializer.js
@@ -81,7 +81,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-gen-rs-static-privatename-identifier.js b/test/language/statements/class/elements/after-same-line-gen-rs-static-privatename-identifier.js
index 3f17970684..d12e6afa7a 100644
--- a/test/language/statements/class/elements/after-same-line-gen-rs-static-privatename-identifier.js
+++ b/test/language/statements/class/elements/after-same-line-gen-rs-static-privatename-identifier.js
@@ -87,7 +87,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-gen-static-private-fields.js b/test/language/statements/class/elements/after-same-line-gen-static-private-fields.js
index 2ea6721f13..19de3c4cf1 100644
--- a/test/language/statements/class/elements/after-same-line-gen-static-private-fields.js
+++ b/test/language/statements/class/elements/after-same-line-gen-static-private-fields.js
@@ -39,7 +39,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -49,18 +52,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/statements/class/elements/after-same-line-gen-static-private-methods-with-fields.js b/test/language/statements/class/elements/after-same-line-gen-static-private-methods-with-fields.js
index 9c654b4239..4378dfbae7 100644
--- a/test/language/statements/class/elements/after-same-line-gen-static-private-methods-with-fields.js
+++ b/test/language/statements/class/elements/after-same-line-gen-static-private-methods-with-fields.js
@@ -45,7 +45,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -55,29 +58,29 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#xVal"), "test 7");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 8");
+assert(!Object.prototype.hasOwnProperty.call(c, "#xVal"), "test 9");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#yVal"), "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 11");
+assert(!Object.prototype.hasOwnProperty.call(c, "#yVal"), "test 12");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 13");
 assert.sameValue(C.y(), 43, "test 14");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 15");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 16");
 
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 17");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 18");
diff --git a/test/language/statements/class/elements/after-same-line-gen-static-private-methods.js b/test/language/statements/class/elements/after-same-line-gen-static-private-methods.js
index 7f0cb24eaf..f59a35ad49 100644
--- a/test/language/statements/class/elements/after-same-line-gen-static-private-methods.js
+++ b/test/language/statements/class/elements/after-same-line-gen-static-private-methods.js
@@ -43,7 +43,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -53,18 +56,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/statements/class/elements/after-same-line-gen-string-literal-names.js b/test/language/statements/class/elements/after-same-line-gen-string-literal-names.js
index 16c5ff8898..eb029f17a1 100644
--- a/test/language/statements/class/elements/after-same-line-gen-string-literal-names.js
+++ b/test/language/statements/class/elements/after-same-line-gen-string-literal-names.js
@@ -30,7 +30,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -39,8 +42,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -49,8 +58,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: undefined,
@@ -59,8 +74,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: 39,
@@ -69,8 +90,14 @@ verifyProperty(c, "c", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "d"),
+  "d does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "d"),
+  "d does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "d", {
   value: 42,
diff --git a/test/language/statements/class/elements/after-same-line-method-computed-names.js b/test/language/statements/class/elements/after-same-line-method-computed-names.js
index 458b8eaa8a..e3c5a5b8f5 100644
--- a/test/language/statements/class/elements/after-same-line-method-computed-names.js
+++ b/test/language/statements/class/elements/after-same-line-method-computed-names.js
@@ -31,7 +31,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -40,8 +43,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -50,12 +59,27 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "10"),
+  "10 doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "10"),
+  "10 doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "10", {
   value: "meep",
@@ -64,8 +88,14 @@ verifyProperty(c, "10", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "not initialized", {
   value: undefined,
diff --git a/test/language/statements/class/elements/after-same-line-method-computed-symbol-names.js b/test/language/statements/class/elements/after-same-line-method-computed-symbol-names.js
index dabb91a906..d1ba914b4c 100644
--- a/test/language/statements/class/elements/after-same-line-method-computed-symbol-names.js
+++ b/test/language/statements/class/elements/after-same-line-method-computed-symbol-names.js
@@ -32,7 +32,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -41,8 +44,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, x), false);
-assert.sameValue(Object.hasOwnProperty.call(C, x), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, x),
+  "Symbol x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, x),
+  "Symbol x doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, x, {
   value: undefined,
@@ -51,8 +60,14 @@ verifyProperty(c, x, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
-assert.sameValue(Object.hasOwnProperty.call(C, y), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, y),
+  "Symbol y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, y),
+  "Symbol y doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, y, {
   value: 42,
@@ -61,10 +76,28 @@ verifyProperty(c, y, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "y"),
+  "y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "y"),
+  "y doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "y"),
+  "y doesn't appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/after-same-line-method-grammar-privatename-identifier-semantics-stringvalue.js b/test/language/statements/class/elements/after-same-line-method-grammar-privatename-identifier-semantics-stringvalue.js
index bf4725282d..e8ff5b4465 100644
--- a/test/language/statements/class/elements/after-same-line-method-grammar-privatename-identifier-semantics-stringvalue.js
+++ b/test/language/statements/class/elements/after-same-line-method-grammar-privatename-identifier-semantics-stringvalue.js
@@ -89,7 +89,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-method-literal-names-asi.js b/test/language/statements/class/elements/after-same-line-method-literal-names-asi.js
index 9d7283b150..aa59e47439 100644
--- a/test/language/statements/class/elements/after-same-line-method-literal-names-asi.js
+++ b/test/language/statements/class/elements/after-same-line-method-literal-names-asi.js
@@ -30,7 +30,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -39,8 +42,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -49,8 +58,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
diff --git a/test/language/statements/class/elements/after-same-line-method-literal-names.js b/test/language/statements/class/elements/after-same-line-method-literal-names.js
index 8b415bbcd2..fddf14ebc8 100644
--- a/test/language/statements/class/elements/after-same-line-method-literal-names.js
+++ b/test/language/statements/class/elements/after-same-line-method-literal-names.js
@@ -32,7 +32,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -41,8 +44,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -51,8 +60,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -61,8 +76,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: fn,
diff --git a/test/language/statements/class/elements/after-same-line-method-private-field-usage.js b/test/language/statements/class/elements/after-same-line-method-private-field-usage.js
index 09fff472c7..dbc2cd69e5 100644
--- a/test/language/statements/class/elements/after-same-line-method-private-field-usage.js
+++ b/test/language/statements/class/elements/after-same-line-method-private-field-usage.js
@@ -32,7 +32,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-method-private-method-getter-usage.js b/test/language/statements/class/elements/after-same-line-method-private-method-getter-usage.js
index e9582f50f8..f360bbf8fa 100644
--- a/test/language/statements/class/elements/after-same-line-method-private-method-getter-usage.js
+++ b/test/language/statements/class/elements/after-same-line-method-private-method-getter-usage.js
@@ -32,7 +32,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-method-private-method-usage.js b/test/language/statements/class/elements/after-same-line-method-private-method-usage.js
index 85544cd901..34e41373fe 100644
--- a/test/language/statements/class/elements/after-same-line-method-private-method-usage.js
+++ b/test/language/statements/class/elements/after-same-line-method-private-method-usage.js
@@ -32,7 +32,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-method-private-names.js b/test/language/statements/class/elements/after-same-line-method-private-names.js
index 3c61280b9a..f5c6dfd9ac 100644
--- a/test/language/statements/class/elements/after-same-line-method-private-names.js
+++ b/test/language/statements/class/elements/after-same-line-method-private-names.js
@@ -39,7 +39,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -49,18 +52,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(c.x(), 42, "test 7");
 assert.sameValue(c.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 10");
diff --git a/test/language/statements/class/elements/after-same-line-method-rs-field-identifier-initializer.js b/test/language/statements/class/elements/after-same-line-method-rs-field-identifier-initializer.js
index b6eae891a9..574830dcaf 100644
--- a/test/language/statements/class/elements/after-same-line-method-rs-field-identifier-initializer.js
+++ b/test/language/statements/class/elements/after-same-line-method-rs-field-identifier-initializer.js
@@ -65,7 +65,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-method-rs-field-identifier.js b/test/language/statements/class/elements/after-same-line-method-rs-field-identifier.js
index e7e4d7539f..8fba96dcc1 100644
--- a/test/language/statements/class/elements/after-same-line-method-rs-field-identifier.js
+++ b/test/language/statements/class/elements/after-same-line-method-rs-field-identifier.js
@@ -65,7 +65,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-method-rs-private-getter-alt.js b/test/language/statements/class/elements/after-same-line-method-rs-private-getter-alt.js
index cceb398b4d..d5cf69ae6b 100644
--- a/test/language/statements/class/elements/after-same-line-method-rs-private-getter-alt.js
+++ b/test/language/statements/class/elements/after-same-line-method-rs-private-getter-alt.js
@@ -106,7 +106,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-method-rs-private-getter.js b/test/language/statements/class/elements/after-same-line-method-rs-private-getter.js
index 7ded588e53..2f7eecdc6b 100644
--- a/test/language/statements/class/elements/after-same-line-method-rs-private-getter.js
+++ b/test/language/statements/class/elements/after-same-line-method-rs-private-getter.js
@@ -106,7 +106,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-method-rs-private-method-alt.js b/test/language/statements/class/elements/after-same-line-method-rs-private-method-alt.js
index 0be96cb03e..6582c1de48 100644
--- a/test/language/statements/class/elements/after-same-line-method-rs-private-method-alt.js
+++ b/test/language/statements/class/elements/after-same-line-method-rs-private-method-alt.js
@@ -105,7 +105,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-method-rs-private-method.js b/test/language/statements/class/elements/after-same-line-method-rs-private-method.js
index cd8c7aa1e7..7fb150a5a3 100644
--- a/test/language/statements/class/elements/after-same-line-method-rs-private-method.js
+++ b/test/language/statements/class/elements/after-same-line-method-rs-private-method.js
@@ -105,7 +105,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-method-rs-private-setter-alt.js b/test/language/statements/class/elements/after-same-line-method-rs-private-setter-alt.js
index 05ad6a8537..181f792c38 100644
--- a/test/language/statements/class/elements/after-same-line-method-rs-private-setter-alt.js
+++ b/test/language/statements/class/elements/after-same-line-method-rs-private-setter-alt.js
@@ -105,7 +105,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-method-rs-private-setter.js b/test/language/statements/class/elements/after-same-line-method-rs-private-setter.js
index dc738f1fc8..b250e6a24f 100644
--- a/test/language/statements/class/elements/after-same-line-method-rs-private-setter.js
+++ b/test/language/statements/class/elements/after-same-line-method-rs-private-setter.js
@@ -105,7 +105,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-method-rs-privatename-identifier-alt.js b/test/language/statements/class/elements/after-same-line-method-rs-privatename-identifier-alt.js
index b9c3b49e05..95df5f7a83 100644
--- a/test/language/statements/class/elements/after-same-line-method-rs-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/after-same-line-method-rs-privatename-identifier-alt.js
@@ -86,7 +86,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-method-rs-privatename-identifier-initializer-alt.js b/test/language/statements/class/elements/after-same-line-method-rs-privatename-identifier-initializer-alt.js
index 47028559bd..f167b68da7 100644
--- a/test/language/statements/class/elements/after-same-line-method-rs-privatename-identifier-initializer-alt.js
+++ b/test/language/statements/class/elements/after-same-line-method-rs-privatename-identifier-initializer-alt.js
@@ -80,7 +80,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-method-rs-privatename-identifier-initializer.js b/test/language/statements/class/elements/after-same-line-method-rs-privatename-identifier-initializer.js
index f0ea9a0c2c..d7c90e2b38 100644
--- a/test/language/statements/class/elements/after-same-line-method-rs-privatename-identifier-initializer.js
+++ b/test/language/statements/class/elements/after-same-line-method-rs-privatename-identifier-initializer.js
@@ -80,7 +80,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-method-rs-privatename-identifier.js b/test/language/statements/class/elements/after-same-line-method-rs-privatename-identifier.js
index e6af2d578b..85f2c81202 100644
--- a/test/language/statements/class/elements/after-same-line-method-rs-privatename-identifier.js
+++ b/test/language/statements/class/elements/after-same-line-method-rs-privatename-identifier.js
@@ -86,7 +86,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-method-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/statements/class/elements/after-same-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
index 36acfe53ff..a4b409f354 100644
--- a/test/language/statements/class/elements/after-same-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/after-same-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -102,7 +102,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-method-rs-static-async-generator-method-privatename-identifier.js b/test/language/statements/class/elements/after-same-line-method-rs-static-async-generator-method-privatename-identifier.js
index 966fe5aad5..990429405d 100644
--- a/test/language/statements/class/elements/after-same-line-method-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/after-same-line-method-rs-static-async-generator-method-privatename-identifier.js
@@ -102,7 +102,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-method-rs-static-async-method-privatename-identifier-alt.js b/test/language/statements/class/elements/after-same-line-method-rs-static-async-method-privatename-identifier-alt.js
index 1dd02a0978..2becfe9d7e 100644
--- a/test/language/statements/class/elements/after-same-line-method-rs-static-async-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/after-same-line-method-rs-static-async-method-privatename-identifier-alt.js
@@ -102,7 +102,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-method-rs-static-async-method-privatename-identifier.js b/test/language/statements/class/elements/after-same-line-method-rs-static-async-method-privatename-identifier.js
index 69f46ac917..3b4e11f771 100644
--- a/test/language/statements/class/elements/after-same-line-method-rs-static-async-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/after-same-line-method-rs-static-async-method-privatename-identifier.js
@@ -102,7 +102,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-method-rs-static-generator-method-privatename-identifier-alt.js b/test/language/statements/class/elements/after-same-line-method-rs-static-generator-method-privatename-identifier-alt.js
index 63650ff01f..469aa4d968 100644
--- a/test/language/statements/class/elements/after-same-line-method-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/after-same-line-method-rs-static-generator-method-privatename-identifier-alt.js
@@ -102,7 +102,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-method-rs-static-generator-method-privatename-identifier.js b/test/language/statements/class/elements/after-same-line-method-rs-static-generator-method-privatename-identifier.js
index a329999404..8ffdf5eb92 100644
--- a/test/language/statements/class/elements/after-same-line-method-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/after-same-line-method-rs-static-generator-method-privatename-identifier.js
@@ -102,7 +102,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-method-rs-static-method-privatename-identifier-alt.js b/test/language/statements/class/elements/after-same-line-method-rs-static-method-privatename-identifier-alt.js
index daf47ce7e9..090367f59a 100644
--- a/test/language/statements/class/elements/after-same-line-method-rs-static-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/after-same-line-method-rs-static-method-privatename-identifier-alt.js
@@ -99,7 +99,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-method-rs-static-method-privatename-identifier.js b/test/language/statements/class/elements/after-same-line-method-rs-static-method-privatename-identifier.js
index 8d727112bf..6d7d7684bd 100644
--- a/test/language/statements/class/elements/after-same-line-method-rs-static-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/after-same-line-method-rs-static-method-privatename-identifier.js
@@ -99,7 +99,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-method-rs-static-privatename-identifier-alt-by-classname.js b/test/language/statements/class/elements/after-same-line-method-rs-static-privatename-identifier-alt-by-classname.js
index c969d1f165..7a78fc3823 100644
--- a/test/language/statements/class/elements/after-same-line-method-rs-static-privatename-identifier-alt-by-classname.js
+++ b/test/language/statements/class/elements/after-same-line-method-rs-static-privatename-identifier-alt-by-classname.js
@@ -87,7 +87,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-method-rs-static-privatename-identifier-alt.js b/test/language/statements/class/elements/after-same-line-method-rs-static-privatename-identifier-alt.js
index d8c550bfc3..ddfeb2035d 100644
--- a/test/language/statements/class/elements/after-same-line-method-rs-static-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/after-same-line-method-rs-static-privatename-identifier-alt.js
@@ -87,7 +87,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-method-rs-static-privatename-identifier-by-classname.js b/test/language/statements/class/elements/after-same-line-method-rs-static-privatename-identifier-by-classname.js
index 386e4172cd..7121b1e3d6 100644
--- a/test/language/statements/class/elements/after-same-line-method-rs-static-privatename-identifier-by-classname.js
+++ b/test/language/statements/class/elements/after-same-line-method-rs-static-privatename-identifier-by-classname.js
@@ -87,7 +87,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-method-rs-static-privatename-identifier-initializer-alt-by-classname.js b/test/language/statements/class/elements/after-same-line-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
index bea6ff930d..aed73210b8 100644
--- a/test/language/statements/class/elements/after-same-line-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
+++ b/test/language/statements/class/elements/after-same-line-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
@@ -81,7 +81,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-method-rs-static-privatename-identifier-initializer-alt.js b/test/language/statements/class/elements/after-same-line-method-rs-static-privatename-identifier-initializer-alt.js
index dc71d14ff4..174956413f 100644
--- a/test/language/statements/class/elements/after-same-line-method-rs-static-privatename-identifier-initializer-alt.js
+++ b/test/language/statements/class/elements/after-same-line-method-rs-static-privatename-identifier-initializer-alt.js
@@ -81,7 +81,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-method-rs-static-privatename-identifier-initializer.js b/test/language/statements/class/elements/after-same-line-method-rs-static-privatename-identifier-initializer.js
index dace7d254c..2ad8625e2e 100644
--- a/test/language/statements/class/elements/after-same-line-method-rs-static-privatename-identifier-initializer.js
+++ b/test/language/statements/class/elements/after-same-line-method-rs-static-privatename-identifier-initializer.js
@@ -81,7 +81,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-method-rs-static-privatename-identifier.js b/test/language/statements/class/elements/after-same-line-method-rs-static-privatename-identifier.js
index 7ebf132e19..afb6d8e772 100644
--- a/test/language/statements/class/elements/after-same-line-method-rs-static-privatename-identifier.js
+++ b/test/language/statements/class/elements/after-same-line-method-rs-static-privatename-identifier.js
@@ -87,7 +87,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/after-same-line-method-static-private-fields.js b/test/language/statements/class/elements/after-same-line-method-static-private-fields.js
index 0691285946..444d8c3e3c 100644
--- a/test/language/statements/class/elements/after-same-line-method-static-private-fields.js
+++ b/test/language/statements/class/elements/after-same-line-method-static-private-fields.js
@@ -39,7 +39,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -49,18 +52,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/statements/class/elements/after-same-line-method-static-private-methods-with-fields.js b/test/language/statements/class/elements/after-same-line-method-static-private-methods-with-fields.js
index 3a5db0ac7b..2ec4ffe4a8 100644
--- a/test/language/statements/class/elements/after-same-line-method-static-private-methods-with-fields.js
+++ b/test/language/statements/class/elements/after-same-line-method-static-private-methods-with-fields.js
@@ -45,7 +45,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -55,29 +58,29 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#xVal"), "test 7");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 8");
+assert(!Object.prototype.hasOwnProperty.call(c, "#xVal"), "test 9");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#yVal"), "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 11");
+assert(!Object.prototype.hasOwnProperty.call(c, "#yVal"), "test 12");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 13");
 assert.sameValue(C.y(), 43, "test 14");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 15");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 16");
 
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 17");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 18");
diff --git a/test/language/statements/class/elements/after-same-line-method-static-private-methods.js b/test/language/statements/class/elements/after-same-line-method-static-private-methods.js
index a5bb775c21..5d4e65c7b4 100644
--- a/test/language/statements/class/elements/after-same-line-method-static-private-methods.js
+++ b/test/language/statements/class/elements/after-same-line-method-static-private-methods.js
@@ -43,7 +43,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -53,18 +56,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/statements/class/elements/after-same-line-method-string-literal-names.js b/test/language/statements/class/elements/after-same-line-method-string-literal-names.js
index 24dc274172..21025ec5b0 100644
--- a/test/language/statements/class/elements/after-same-line-method-string-literal-names.js
+++ b/test/language/statements/class/elements/after-same-line-method-string-literal-names.js
@@ -30,7 +30,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -39,8 +42,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -49,8 +58,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: undefined,
@@ -59,8 +74,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: 39,
@@ -69,8 +90,14 @@ verifyProperty(c, "c", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "d"),
+  "d does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "d"),
+  "d does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "d", {
   value: 42,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-gen-computed-names.js b/test/language/statements/class/elements/after-same-line-static-async-gen-computed-names.js
index 3034f10ad1..e430947877 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-gen-computed-names.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-gen-computed-names.js
@@ -30,8 +30,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -50,8 +56,14 @@ C.m().next().then(function(v) {
         throw new Test262Error('Test262:AsyncTestFailure')
       }
     }
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+      "b doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "b"),
+      "b doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "b", {
       value: 42,
@@ -60,12 +72,27 @@ C.m().next().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-    assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+      "x doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "x"),
+      "x doesn't appear as an own property on C constructor"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(c, "x"),
+      "x doesn't appear as an own property on C instance"
+    );
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "10"),
+      "10 doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "10"),
+      "10 doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "10", {
       value: "meep",
@@ -74,8 +101,14 @@ C.m().next().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "not initialized"),
+      "'not initialized' doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "not initialized"),
+      "'not initialized' doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "not initialized", {
       value: undefined,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-gen-computed-symbol-names.js b/test/language/statements/class/elements/after-same-line-static-async-gen-computed-symbol-names.js
index 6265c9f114..a3ff4e970c 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-gen-computed-symbol-names.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-gen-computed-symbol-names.js
@@ -31,8 +31,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -51,8 +57,14 @@ C.m().next().then(function(v) {
         throw new Test262Error('Test262:AsyncTestFailure')
       }
     }
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, x), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, x), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, x),
+      "Symbol x doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, x),
+      "Symbol x doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, x, {
       value: undefined,
@@ -61,8 +73,14 @@ C.m().next().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, y), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, y),
+      "Symbol y doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, y),
+      "Symbol y doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, y, {
       value: 42,
@@ -71,13 +89,31 @@ C.m().next().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-    assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+      "x doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "x"),
+      "x doesn't appear as an own property on C constructor"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(c, "x"),
+      "x doesn't appear as an own property on C instance"
+    );
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
-    assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "y"),
+      "y doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "y"),
+      "y doesn't appear as an own property on C constructor"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(c, "y"),
+      "y doesn't appear as an own property on C instance"
+    );
   }
 
   return Promise.resolve(assertions());
diff --git a/test/language/statements/class/elements/after-same-line-static-async-gen-grammar-privatename-identifier-semantics-stringvalue.js b/test/language/statements/class/elements/after-same-line-static-async-gen-grammar-privatename-identifier-semantics-stringvalue.js
index 4f28cd139d..530498702e 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-gen-grammar-privatename-identifier-semantics-stringvalue.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-gen-grammar-privatename-identifier-semantics-stringvalue.js
@@ -88,8 +88,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-gen-literal-names-asi.js b/test/language/statements/class/elements/after-same-line-static-async-gen-literal-names-asi.js
index fdca9b7b46..f0b9ebd4ff 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-gen-literal-names-asi.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-gen-literal-names-asi.js
@@ -29,8 +29,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -49,8 +55,14 @@ C.m().next().then(function(v) {
         throw new Test262Error('Test262:AsyncTestFailure')
       }
     }
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+      "a doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "a"),
+      "a doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "a", {
       value: undefined,
@@ -59,8 +71,14 @@ C.m().next().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+      "b doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "b"),
+      "b doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "b", {
       value: 42,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-gen-literal-names.js b/test/language/statements/class/elements/after-same-line-static-async-gen-literal-names.js
index d323f84de4..048e4efc84 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-gen-literal-names.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-gen-literal-names.js
@@ -31,8 +31,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -51,8 +57,14 @@ C.m().next().then(function(v) {
         throw new Test262Error('Test262:AsyncTestFailure')
       }
     }
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+      "a doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "a"),
+      "a doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "a", {
       value: undefined,
@@ -61,8 +73,14 @@ C.m().next().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+      "b doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "b"),
+      "b doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "b", {
       value: 42,
@@ -71,8 +89,14 @@ C.m().next().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+      "c doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "c"),
+      "c doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "c", {
       value: fn,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-gen-private-field-usage.js b/test/language/statements/class/elements/after-same-line-static-async-gen-private-field-usage.js
index d7d3d72a6a..a80633da9c 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-gen-private-field-usage.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-gen-private-field-usage.js
@@ -31,8 +31,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-gen-private-method-getter-usage.js b/test/language/statements/class/elements/after-same-line-static-async-gen-private-method-getter-usage.js
index b292ef40fd..da3b8b0f3b 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-gen-private-method-getter-usage.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-gen-private-method-getter-usage.js
@@ -31,8 +31,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-gen-private-method-usage.js b/test/language/statements/class/elements/after-same-line-static-async-gen-private-method-usage.js
index 3fd229ffd2..b3648390fd 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-gen-private-method-usage.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-gen-private-method-usage.js
@@ -31,8 +31,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-gen-private-names.js b/test/language/statements/class/elements/after-same-line-static-async-gen-private-names.js
index 0cdbaee742..b5e980fa18 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-gen-private-names.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-gen-private-names.js
@@ -38,8 +38,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -59,21 +65,21 @@ C.m().next().then(function(v) {
       }
     }
     // Test the private fields do not appear as properties before set to value
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
     // Test if private fields can be sucessfully accessed and set to value
     assert.sameValue(c.x(), 42, "test 7");
     assert.sameValue(c.y(), 43, "test 8");
 
     // Test the private fields do not appear as properties before after set to value
-    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 9");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 10");
   }
 
   return Promise.resolve(assertions());
diff --git a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-field-identifier-initializer.js b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-field-identifier-initializer.js
index e81f4844c7..89eaff8711 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-field-identifier-initializer.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-field-identifier-initializer.js
@@ -64,8 +64,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-field-identifier.js b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-field-identifier.js
index 9453492e67..8b740b0519 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-field-identifier.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-field-identifier.js
@@ -64,8 +64,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-private-getter-alt.js b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-private-getter-alt.js
index a0eb6bb799..45ff0ac7dd 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-private-getter-alt.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-private-getter-alt.js
@@ -105,8 +105,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-private-getter.js b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-private-getter.js
index 1075a314ef..f1785cba2d 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-private-getter.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-private-getter.js
@@ -105,8 +105,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-private-method-alt.js b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-private-method-alt.js
index 0810a5ddf9..c0d1163e69 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-private-method-alt.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-private-method-alt.js
@@ -104,8 +104,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-private-method.js b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-private-method.js
index 1de07ae489..b38fceb1c9 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-private-method.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-private-method.js
@@ -104,8 +104,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-private-setter-alt.js b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-private-setter-alt.js
index b17cbe3a4d..199fe1e3a3 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-private-setter-alt.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-private-setter-alt.js
@@ -104,8 +104,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-private-setter.js b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-private-setter.js
index 44ac347b7d..8834b6aafd 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-private-setter.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-private-setter.js
@@ -104,8 +104,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-privatename-identifier-alt.js b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-privatename-identifier-alt.js
index ae38cb4731..801430bef7 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-privatename-identifier-alt.js
@@ -85,8 +85,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-privatename-identifier-initializer-alt.js b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-privatename-identifier-initializer-alt.js
index bcb4a0ef6f..ac43ff5ba5 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-privatename-identifier-initializer-alt.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-privatename-identifier-initializer-alt.js
@@ -79,8 +79,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-privatename-identifier-initializer.js b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-privatename-identifier-initializer.js
index 914aec5522..cec43f411b 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-privatename-identifier-initializer.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-privatename-identifier-initializer.js
@@ -79,8 +79,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-privatename-identifier.js b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-privatename-identifier.js
index 570f511296..f6409e8ca6 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-privatename-identifier.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-privatename-identifier.js
@@ -85,8 +85,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-async-generator-method-privatename-identifier-alt.js
index d41131fc36..9972782087 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -101,8 +101,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-async-generator-method-privatename-identifier.js b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-async-generator-method-privatename-identifier.js
index c4f7be434b..e52cab4e4b 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-async-generator-method-privatename-identifier.js
@@ -101,8 +101,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-async-method-privatename-identifier-alt.js b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-async-method-privatename-identifier-alt.js
index 4f10818e5a..3f47af0289 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-async-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-async-method-privatename-identifier-alt.js
@@ -101,8 +101,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-async-method-privatename-identifier.js b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-async-method-privatename-identifier.js
index 7630334f2f..6fdb3d8733 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-async-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-async-method-privatename-identifier.js
@@ -101,8 +101,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-generator-method-privatename-identifier-alt.js b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-generator-method-privatename-identifier-alt.js
index c23a45ca31..6cf0d5d91c 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-generator-method-privatename-identifier-alt.js
@@ -101,8 +101,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-generator-method-privatename-identifier.js b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-generator-method-privatename-identifier.js
index f010f4b686..688d400300 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-generator-method-privatename-identifier.js
@@ -101,8 +101,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-method-privatename-identifier-alt.js b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-method-privatename-identifier-alt.js
index 0d5376361a..94f71449c3 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-method-privatename-identifier-alt.js
@@ -98,8 +98,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-method-privatename-identifier.js b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-method-privatename-identifier.js
index d5152897f4..3f334db345 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-method-privatename-identifier.js
@@ -98,8 +98,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-alt-by-classname.js b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-alt-by-classname.js
index 2b6482e075..7bd1c3a1cc 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-alt-by-classname.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-alt-by-classname.js
@@ -86,8 +86,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-alt.js b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-alt.js
index f4f46c4339..c4bece73bf 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-alt.js
@@ -86,8 +86,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-by-classname.js b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-by-classname.js
index 2a7c991453..d2a0466e44 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-by-classname.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-by-classname.js
@@ -86,8 +86,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
index 348b3b2490..12dae8ded5 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
@@ -80,8 +80,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-initializer-alt.js b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-initializer-alt.js
index 8d4eab1003..f572642a2e 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-initializer-alt.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-initializer-alt.js
@@ -80,8 +80,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-initializer.js b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-initializer.js
index bba73b7881..af9045b102 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-initializer.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier-initializer.js
@@ -80,8 +80,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier.js b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier.js
index 91fac08562..a30bb4d729 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-gen-rs-static-privatename-identifier.js
@@ -86,8 +86,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-gen-static-private-fields.js b/test/language/statements/class/elements/after-same-line-static-async-gen-static-private-fields.js
index 4bf4e27479..612e5d17dc 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-gen-static-private-fields.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-gen-static-private-fields.js
@@ -38,8 +38,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -59,21 +65,21 @@ C.m().next().then(function(v) {
       }
     }
     // Test the private fields do not appear as properties before set to value
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
     // Test if private fields can be sucessfully accessed and set to value
     assert.sameValue(C.x(), 42, "test 7");
     assert.sameValue(C.y(), 43, "test 8");
 
     // Test the private fields do not appear as properties before after set to value
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
   }
 
   return Promise.resolve(assertions());
diff --git a/test/language/statements/class/elements/after-same-line-static-async-gen-static-private-methods-with-fields.js b/test/language/statements/class/elements/after-same-line-static-async-gen-static-private-methods-with-fields.js
index 458cd682b7..20b3e8ba7a 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-gen-static-private-methods-with-fields.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-gen-static-private-methods-with-fields.js
@@ -44,8 +44,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -65,32 +71,32 @@ C.m().next().then(function(v) {
       }
     }
     // Test the private methods do not appear as properties before set to value
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#xVal"), "test 7");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 8");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#xVal"), "test 9");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#yVal"), "test 10");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 11");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#yVal"), "test 12");
 
     // Test if private fields can be sucessfully accessed and set to value
     assert.sameValue(C.x(), 42, "test 13");
     assert.sameValue(C.y(), 43, "test 14");
 
     // Test the private fields do not appear as properties before after set to value
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 15");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 16");
 
-    assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 17");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 18");
   }
 
   return Promise.resolve(assertions());
diff --git a/test/language/statements/class/elements/after-same-line-static-async-gen-static-private-methods.js b/test/language/statements/class/elements/after-same-line-static-async-gen-static-private-methods.js
index 3510066174..a817bc5d0b 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-gen-static-private-methods.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-gen-static-private-methods.js
@@ -42,8 +42,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -63,21 +69,21 @@ C.m().next().then(function(v) {
       }
     }
     // Test the private methods do not appear as properties before set to value
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
     // Test if private fields can be sucessfully accessed and set to value
     assert.sameValue(C.x(), 42, "test 7");
     assert.sameValue(C.y(), 86, "test 8");
 
     // Test the private fields do not appear as properties before after set to value
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
   }
 
   return Promise.resolve(assertions());
diff --git a/test/language/statements/class/elements/after-same-line-static-async-gen-string-literal-names.js b/test/language/statements/class/elements/after-same-line-static-async-gen-string-literal-names.js
index 298d9309d2..85979853be 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-gen-string-literal-names.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-gen-string-literal-names.js
@@ -29,8 +29,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -49,8 +55,14 @@ C.m().next().then(function(v) {
         throw new Test262Error('Test262:AsyncTestFailure')
       }
     }
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+      "a does not appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "a"),
+      "a does not appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "a", {
       value: undefined,
@@ -59,8 +71,14 @@ C.m().next().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+      "b does not appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "b"),
+      "b does not appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "b", {
       value: undefined,
@@ -69,8 +87,14 @@ C.m().next().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+      "c does not appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "c"),
+      "c does not appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "c", {
       value: 39,
@@ -79,8 +103,14 @@ C.m().next().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "d"),
+      "d does not appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "d"),
+      "d does not appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "d", {
       value: 42,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-method-computed-names.js b/test/language/statements/class/elements/after-same-line-static-async-method-computed-names.js
index 7b2418e531..8f75e14955 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-method-computed-names.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-method-computed-names.js
@@ -30,8 +30,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -49,8 +55,14 @@ C.m().then(function(v) {
         throw new Test262Error('Test262:AsyncTestFailure')
       }
     }
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+      "b doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "b"),
+      "b doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "b", {
       value: 42,
@@ -59,12 +71,27 @@ C.m().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-    assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+      "x doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "x"),
+      "x doesn't appear as an own property on C constructor"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(c, "x"),
+      "x doesn't appear as an own property on C instance"
+    );
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "10"),
+      "10 doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "10"),
+      "10 doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "10", {
       value: "meep",
@@ -73,8 +100,14 @@ C.m().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "not initialized"),
+      "'not initialized' doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "not initialized"),
+      "'not initialized' doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "not initialized", {
       value: undefined,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-method-computed-symbol-names.js b/test/language/statements/class/elements/after-same-line-static-async-method-computed-symbol-names.js
index 1ca907887b..b411c5d7a0 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-method-computed-symbol-names.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-method-computed-symbol-names.js
@@ -31,8 +31,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -50,8 +56,14 @@ C.m().then(function(v) {
         throw new Test262Error('Test262:AsyncTestFailure')
       }
     }
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, x), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, x), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, x),
+      "Symbol x doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, x),
+      "Symbol x doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, x, {
       value: undefined,
@@ -60,8 +72,14 @@ C.m().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, y), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, y),
+      "Symbol y doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, y),
+      "Symbol y doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, y, {
       value: 42,
@@ -70,13 +88,31 @@ C.m().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-    assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+      "x doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "x"),
+      "x doesn't appear as an own property on C constructor"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(c, "x"),
+      "x doesn't appear as an own property on C instance"
+    );
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
-    assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "y"),
+      "y doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "y"),
+      "y doesn't appear as an own property on C constructor"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(c, "y"),
+      "y doesn't appear as an own property on C instance"
+    );
   }
 
   return Promise.resolve(assertions());
diff --git a/test/language/statements/class/elements/after-same-line-static-async-method-grammar-privatename-identifier-semantics-stringvalue.js b/test/language/statements/class/elements/after-same-line-static-async-method-grammar-privatename-identifier-semantics-stringvalue.js
index 7b3024389a..cbd6a6a41e 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-method-grammar-privatename-identifier-semantics-stringvalue.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-method-grammar-privatename-identifier-semantics-stringvalue.js
@@ -88,8 +88,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-method-literal-names-asi.js b/test/language/statements/class/elements/after-same-line-static-async-method-literal-names-asi.js
index 21c0069671..894e5cedf6 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-method-literal-names-asi.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-method-literal-names-asi.js
@@ -29,8 +29,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -48,8 +54,14 @@ C.m().then(function(v) {
         throw new Test262Error('Test262:AsyncTestFailure')
       }
     }
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+      "a doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "a"),
+      "a doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "a", {
       value: undefined,
@@ -58,8 +70,14 @@ C.m().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+      "b doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "b"),
+      "b doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "b", {
       value: 42,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-method-literal-names.js b/test/language/statements/class/elements/after-same-line-static-async-method-literal-names.js
index 89e718bd0f..6d5e1b1aa4 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-method-literal-names.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-method-literal-names.js
@@ -31,8 +31,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -50,8 +56,14 @@ C.m().then(function(v) {
         throw new Test262Error('Test262:AsyncTestFailure')
       }
     }
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+      "a doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "a"),
+      "a doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "a", {
       value: undefined,
@@ -60,8 +72,14 @@ C.m().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+      "b doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "b"),
+      "b doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "b", {
       value: 42,
@@ -70,8 +88,14 @@ C.m().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+      "c doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "c"),
+      "c doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "c", {
       value: fn,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-method-private-field-usage.js b/test/language/statements/class/elements/after-same-line-static-async-method-private-field-usage.js
index 21b64099c7..c4f781214c 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-method-private-field-usage.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-method-private-field-usage.js
@@ -31,8 +31,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-method-private-method-getter-usage.js b/test/language/statements/class/elements/after-same-line-static-async-method-private-method-getter-usage.js
index 53b6ca81a3..ff83216764 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-method-private-method-getter-usage.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-method-private-method-getter-usage.js
@@ -31,8 +31,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-method-private-method-usage.js b/test/language/statements/class/elements/after-same-line-static-async-method-private-method-usage.js
index 4880317a0c..1c9bb88883 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-method-private-method-usage.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-method-private-method-usage.js
@@ -31,8 +31,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-method-private-names.js b/test/language/statements/class/elements/after-same-line-static-async-method-private-names.js
index 9b2aa7a8bd..1fac20cc3f 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-method-private-names.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-method-private-names.js
@@ -38,8 +38,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -58,21 +64,21 @@ C.m().then(function(v) {
       }
     }
     // Test the private fields do not appear as properties before set to value
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
     // Test if private fields can be sucessfully accessed and set to value
     assert.sameValue(c.x(), 42, "test 7");
     assert.sameValue(c.y(), 43, "test 8");
 
     // Test the private fields do not appear as properties before after set to value
-    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 9");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 10");
   }
 
   return Promise.resolve(assertions());
diff --git a/test/language/statements/class/elements/after-same-line-static-async-method-rs-field-identifier-initializer.js b/test/language/statements/class/elements/after-same-line-static-async-method-rs-field-identifier-initializer.js
index 208ebaf155..e972771b08 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-method-rs-field-identifier-initializer.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-method-rs-field-identifier-initializer.js
@@ -64,8 +64,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-method-rs-field-identifier.js b/test/language/statements/class/elements/after-same-line-static-async-method-rs-field-identifier.js
index cd26e9c964..8fbefb0d9e 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-method-rs-field-identifier.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-method-rs-field-identifier.js
@@ -64,8 +64,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-method-rs-private-getter-alt.js b/test/language/statements/class/elements/after-same-line-static-async-method-rs-private-getter-alt.js
index 1121d7ee4f..bf853aa88b 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-method-rs-private-getter-alt.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-method-rs-private-getter-alt.js
@@ -105,8 +105,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-method-rs-private-getter.js b/test/language/statements/class/elements/after-same-line-static-async-method-rs-private-getter.js
index 2ae3db5019..d1ee7e5cc7 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-method-rs-private-getter.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-method-rs-private-getter.js
@@ -105,8 +105,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-method-rs-private-method-alt.js b/test/language/statements/class/elements/after-same-line-static-async-method-rs-private-method-alt.js
index dc29e03d55..6fb04abf29 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-method-rs-private-method-alt.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-method-rs-private-method-alt.js
@@ -104,8 +104,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-method-rs-private-method.js b/test/language/statements/class/elements/after-same-line-static-async-method-rs-private-method.js
index 935791096e..72912225c4 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-method-rs-private-method.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-method-rs-private-method.js
@@ -104,8 +104,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-method-rs-private-setter-alt.js b/test/language/statements/class/elements/after-same-line-static-async-method-rs-private-setter-alt.js
index 0173d25168..f3da226189 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-method-rs-private-setter-alt.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-method-rs-private-setter-alt.js
@@ -104,8 +104,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-method-rs-private-setter.js b/test/language/statements/class/elements/after-same-line-static-async-method-rs-private-setter.js
index 54975d15f5..9ec76ddd3c 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-method-rs-private-setter.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-method-rs-private-setter.js
@@ -104,8 +104,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-method-rs-privatename-identifier-alt.js b/test/language/statements/class/elements/after-same-line-static-async-method-rs-privatename-identifier-alt.js
index db12882289..2891ae6424 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-method-rs-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-method-rs-privatename-identifier-alt.js
@@ -85,8 +85,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-method-rs-privatename-identifier-initializer-alt.js b/test/language/statements/class/elements/after-same-line-static-async-method-rs-privatename-identifier-initializer-alt.js
index 239a6976b0..7ac4b32f5e 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-method-rs-privatename-identifier-initializer-alt.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-method-rs-privatename-identifier-initializer-alt.js
@@ -79,8 +79,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-method-rs-privatename-identifier-initializer.js b/test/language/statements/class/elements/after-same-line-static-async-method-rs-privatename-identifier-initializer.js
index 0fc0584872..db07609f81 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-method-rs-privatename-identifier-initializer.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-method-rs-privatename-identifier-initializer.js
@@ -79,8 +79,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-method-rs-privatename-identifier.js b/test/language/statements/class/elements/after-same-line-static-async-method-rs-privatename-identifier.js
index 2ac9fb5137..4db464127c 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-method-rs-privatename-identifier.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-method-rs-privatename-identifier.js
@@ -85,8 +85,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-async-generator-method-privatename-identifier-alt.js
index ef25143c27..6a81038ac7 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -101,8 +101,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-async-generator-method-privatename-identifier.js b/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-async-generator-method-privatename-identifier.js
index 822d0a5321..6948f96d04 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-async-generator-method-privatename-identifier.js
@@ -101,8 +101,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-async-method-privatename-identifier-alt.js b/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-async-method-privatename-identifier-alt.js
index 4a485e6e3f..9ef0c9092c 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-async-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-async-method-privatename-identifier-alt.js
@@ -101,8 +101,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-async-method-privatename-identifier.js b/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-async-method-privatename-identifier.js
index 8734ef2c30..3ac8cff942 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-async-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-async-method-privatename-identifier.js
@@ -101,8 +101,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-generator-method-privatename-identifier-alt.js b/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-generator-method-privatename-identifier-alt.js
index ed311c8ed5..58db94625d 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-generator-method-privatename-identifier-alt.js
@@ -101,8 +101,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-generator-method-privatename-identifier.js b/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-generator-method-privatename-identifier.js
index 4727fb5b39..3927a414c7 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-generator-method-privatename-identifier.js
@@ -101,8 +101,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-method-privatename-identifier-alt.js b/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-method-privatename-identifier-alt.js
index b4ba20daea..9ff37ab632 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-method-privatename-identifier-alt.js
@@ -98,8 +98,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-method-privatename-identifier.js b/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-method-privatename-identifier.js
index 87f0f5a4c8..a94a9cf864 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-method-privatename-identifier.js
@@ -98,8 +98,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-alt-by-classname.js b/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-alt-by-classname.js
index 544e59ce33..885ebcb925 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-alt-by-classname.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-alt-by-classname.js
@@ -86,8 +86,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-alt.js b/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-alt.js
index 08ba24c563..f9326d7043 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-alt.js
@@ -86,8 +86,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-by-classname.js b/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-by-classname.js
index 3c4677d667..990d5c4492 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-by-classname.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-by-classname.js
@@ -86,8 +86,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-initializer-alt-by-classname.js b/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
index 19942283de..19f9ef7dd6 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
@@ -80,8 +80,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-initializer-alt.js b/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-initializer-alt.js
index a40951ad74..673db72348 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-initializer-alt.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-initializer-alt.js
@@ -80,8 +80,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-initializer.js b/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-initializer.js
index d75cc52b25..d439d961cf 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-initializer.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier-initializer.js
@@ -80,8 +80,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier.js b/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier.js
index 700a20c925..aeba7f6520 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-method-rs-static-privatename-identifier.js
@@ -86,8 +86,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-async-method-static-private-fields.js b/test/language/statements/class/elements/after-same-line-static-async-method-static-private-fields.js
index a818ede05d..7d75162d63 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-method-static-private-fields.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-method-static-private-fields.js
@@ -38,8 +38,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -58,21 +64,21 @@ C.m().then(function(v) {
       }
     }
     // Test the private fields do not appear as properties before set to value
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
     // Test if private fields can be sucessfully accessed and set to value
     assert.sameValue(C.x(), 42, "test 7");
     assert.sameValue(C.y(), 43, "test 8");
 
     // Test the private fields do not appear as properties before after set to value
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
   }
 
   return Promise.resolve(assertions());
diff --git a/test/language/statements/class/elements/after-same-line-static-async-method-static-private-methods-with-fields.js b/test/language/statements/class/elements/after-same-line-static-async-method-static-private-methods-with-fields.js
index 1decdcdbed..1b84e0fcb1 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-method-static-private-methods-with-fields.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-method-static-private-methods-with-fields.js
@@ -44,8 +44,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -64,32 +70,32 @@ C.m().then(function(v) {
       }
     }
     // Test the private methods do not appear as properties before set to value
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#xVal"), "test 7");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 8");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#xVal"), "test 9");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#yVal"), "test 10");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 11");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#yVal"), "test 12");
 
     // Test if private fields can be sucessfully accessed and set to value
     assert.sameValue(C.x(), 42, "test 13");
     assert.sameValue(C.y(), 43, "test 14");
 
     // Test the private fields do not appear as properties before after set to value
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 15");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 16");
 
-    assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 17");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 18");
   }
 
   return Promise.resolve(assertions());
diff --git a/test/language/statements/class/elements/after-same-line-static-async-method-static-private-methods.js b/test/language/statements/class/elements/after-same-line-static-async-method-static-private-methods.js
index 6e40d6b3ab..903d847e9f 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-method-static-private-methods.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-method-static-private-methods.js
@@ -42,8 +42,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -62,21 +68,21 @@ C.m().then(function(v) {
       }
     }
     // Test the private methods do not appear as properties before set to value
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
     // Test if private fields can be sucessfully accessed and set to value
     assert.sameValue(C.x(), 42, "test 7");
     assert.sameValue(C.y(), 86, "test 8");
 
     // Test the private fields do not appear as properties before after set to value
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
   }
 
   return Promise.resolve(assertions());
diff --git a/test/language/statements/class/elements/after-same-line-static-async-method-string-literal-names.js b/test/language/statements/class/elements/after-same-line-static-async-method-string-literal-names.js
index dfc42d225d..dee8af6f58 100644
--- a/test/language/statements/class/elements/after-same-line-static-async-method-string-literal-names.js
+++ b/test/language/statements/class/elements/after-same-line-static-async-method-string-literal-names.js
@@ -29,8 +29,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -48,8 +54,14 @@ C.m().then(function(v) {
         throw new Test262Error('Test262:AsyncTestFailure')
       }
     }
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+      "a does not appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "a"),
+      "a does not appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "a", {
       value: undefined,
@@ -58,8 +70,14 @@ C.m().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+      "b does not appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "b"),
+      "b does not appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "b", {
       value: undefined,
@@ -68,8 +86,14 @@ C.m().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+      "c does not appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "c"),
+      "c does not appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "c", {
       value: 39,
@@ -78,8 +102,14 @@ C.m().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "d"),
+      "d does not appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "d"),
+      "d does not appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "d", {
       value: 42,
diff --git a/test/language/statements/class/elements/after-same-line-static-gen-computed-names.js b/test/language/statements/class/elements/after-same-line-static-gen-computed-names.js
index 05da2edeef..5033b2456e 100644
--- a/test/language/statements/class/elements/after-same-line-static-gen-computed-names.js
+++ b/test/language/statements/class/elements/after-same-line-static-gen-computed-names.js
@@ -31,8 +31,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -40,8 +46,14 @@ verifyProperty(C, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -50,12 +62,27 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "10"),
+  "10 doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "10"),
+  "10 doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "10", {
   value: "meep",
@@ -64,8 +91,14 @@ verifyProperty(c, "10", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "not initialized", {
   value: undefined,
diff --git a/test/language/statements/class/elements/after-same-line-static-gen-computed-symbol-names.js b/test/language/statements/class/elements/after-same-line-static-gen-computed-symbol-names.js
index cc6616dfb1..fda1f44e78 100644
--- a/test/language/statements/class/elements/after-same-line-static-gen-computed-symbol-names.js
+++ b/test/language/statements/class/elements/after-same-line-static-gen-computed-symbol-names.js
@@ -32,8 +32,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -41,8 +47,14 @@ verifyProperty(C, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, x), false);
-assert.sameValue(Object.hasOwnProperty.call(C, x), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, x),
+  "Symbol x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, x),
+  "Symbol x doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, x, {
   value: undefined,
@@ -51,8 +63,14 @@ verifyProperty(c, x, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
-assert.sameValue(Object.hasOwnProperty.call(C, y), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, y),
+  "Symbol y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, y),
+  "Symbol y doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, y, {
   value: 42,
@@ -61,10 +79,28 @@ verifyProperty(c, y, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "y"),
+  "y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "y"),
+  "y doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "y"),
+  "y doesn't appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/after-same-line-static-gen-grammar-privatename-identifier-semantics-stringvalue.js b/test/language/statements/class/elements/after-same-line-static-gen-grammar-privatename-identifier-semantics-stringvalue.js
index de8b2f49b7..b3a44a0480 100644
--- a/test/language/statements/class/elements/after-same-line-static-gen-grammar-privatename-identifier-semantics-stringvalue.js
+++ b/test/language/statements/class/elements/after-same-line-static-gen-grammar-privatename-identifier-semantics-stringvalue.js
@@ -89,8 +89,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-gen-literal-names-asi.js b/test/language/statements/class/elements/after-same-line-static-gen-literal-names-asi.js
index d04d1bc138..e95b83bea1 100644
--- a/test/language/statements/class/elements/after-same-line-static-gen-literal-names-asi.js
+++ b/test/language/statements/class/elements/after-same-line-static-gen-literal-names-asi.js
@@ -30,8 +30,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -39,8 +45,14 @@ verifyProperty(C, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -49,8 +61,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
diff --git a/test/language/statements/class/elements/after-same-line-static-gen-literal-names.js b/test/language/statements/class/elements/after-same-line-static-gen-literal-names.js
index 9c83b00986..1c98d439e0 100644
--- a/test/language/statements/class/elements/after-same-line-static-gen-literal-names.js
+++ b/test/language/statements/class/elements/after-same-line-static-gen-literal-names.js
@@ -32,8 +32,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -41,8 +47,14 @@ verifyProperty(C, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -51,8 +63,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -61,8 +79,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: fn,
diff --git a/test/language/statements/class/elements/after-same-line-static-gen-private-field-usage.js b/test/language/statements/class/elements/after-same-line-static-gen-private-field-usage.js
index 09c77e0cec..c8543528ba 100644
--- a/test/language/statements/class/elements/after-same-line-static-gen-private-field-usage.js
+++ b/test/language/statements/class/elements/after-same-line-static-gen-private-field-usage.js
@@ -32,8 +32,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-gen-private-method-getter-usage.js b/test/language/statements/class/elements/after-same-line-static-gen-private-method-getter-usage.js
index 6b36c0acb0..ec1b563970 100644
--- a/test/language/statements/class/elements/after-same-line-static-gen-private-method-getter-usage.js
+++ b/test/language/statements/class/elements/after-same-line-static-gen-private-method-getter-usage.js
@@ -32,8 +32,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-gen-private-method-usage.js b/test/language/statements/class/elements/after-same-line-static-gen-private-method-usage.js
index be5f38c9d8..cc0283dc05 100644
--- a/test/language/statements/class/elements/after-same-line-static-gen-private-method-usage.js
+++ b/test/language/statements/class/elements/after-same-line-static-gen-private-method-usage.js
@@ -32,8 +32,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-gen-private-names.js b/test/language/statements/class/elements/after-same-line-static-gen-private-names.js
index 599337a1ed..3f60e10d80 100644
--- a/test/language/statements/class/elements/after-same-line-static-gen-private-names.js
+++ b/test/language/statements/class/elements/after-same-line-static-gen-private-names.js
@@ -39,8 +39,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -49,18 +55,18 @@ verifyProperty(C, "m", {
 });
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(c.x(), 42, "test 7");
 assert.sameValue(c.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 10");
diff --git a/test/language/statements/class/elements/after-same-line-static-gen-rs-field-identifier-initializer.js b/test/language/statements/class/elements/after-same-line-static-gen-rs-field-identifier-initializer.js
index b644cff2dd..f2f14a2b24 100644
--- a/test/language/statements/class/elements/after-same-line-static-gen-rs-field-identifier-initializer.js
+++ b/test/language/statements/class/elements/after-same-line-static-gen-rs-field-identifier-initializer.js
@@ -65,8 +65,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-gen-rs-field-identifier.js b/test/language/statements/class/elements/after-same-line-static-gen-rs-field-identifier.js
index dbf5bc565f..e39cbcd0d9 100644
--- a/test/language/statements/class/elements/after-same-line-static-gen-rs-field-identifier.js
+++ b/test/language/statements/class/elements/after-same-line-static-gen-rs-field-identifier.js
@@ -65,8 +65,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-gen-rs-private-getter-alt.js b/test/language/statements/class/elements/after-same-line-static-gen-rs-private-getter-alt.js
index 11c237eb3e..8ccc3f57cf 100644
--- a/test/language/statements/class/elements/after-same-line-static-gen-rs-private-getter-alt.js
+++ b/test/language/statements/class/elements/after-same-line-static-gen-rs-private-getter-alt.js
@@ -106,8 +106,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-gen-rs-private-getter.js b/test/language/statements/class/elements/after-same-line-static-gen-rs-private-getter.js
index 24687ef44c..0a304148fa 100644
--- a/test/language/statements/class/elements/after-same-line-static-gen-rs-private-getter.js
+++ b/test/language/statements/class/elements/after-same-line-static-gen-rs-private-getter.js
@@ -106,8 +106,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-gen-rs-private-method-alt.js b/test/language/statements/class/elements/after-same-line-static-gen-rs-private-method-alt.js
index 18d6914326..16b1e59863 100644
--- a/test/language/statements/class/elements/after-same-line-static-gen-rs-private-method-alt.js
+++ b/test/language/statements/class/elements/after-same-line-static-gen-rs-private-method-alt.js
@@ -105,8 +105,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-gen-rs-private-method.js b/test/language/statements/class/elements/after-same-line-static-gen-rs-private-method.js
index c052d6d14f..de92fdf39a 100644
--- a/test/language/statements/class/elements/after-same-line-static-gen-rs-private-method.js
+++ b/test/language/statements/class/elements/after-same-line-static-gen-rs-private-method.js
@@ -105,8 +105,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-gen-rs-private-setter-alt.js b/test/language/statements/class/elements/after-same-line-static-gen-rs-private-setter-alt.js
index 372937a36b..87a9fc13c2 100644
--- a/test/language/statements/class/elements/after-same-line-static-gen-rs-private-setter-alt.js
+++ b/test/language/statements/class/elements/after-same-line-static-gen-rs-private-setter-alt.js
@@ -105,8 +105,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-gen-rs-private-setter.js b/test/language/statements/class/elements/after-same-line-static-gen-rs-private-setter.js
index 6a50d7f6c9..d2b004a76e 100644
--- a/test/language/statements/class/elements/after-same-line-static-gen-rs-private-setter.js
+++ b/test/language/statements/class/elements/after-same-line-static-gen-rs-private-setter.js
@@ -105,8 +105,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-gen-rs-privatename-identifier-alt.js b/test/language/statements/class/elements/after-same-line-static-gen-rs-privatename-identifier-alt.js
index 0d02fc0c82..19cd98caaa 100644
--- a/test/language/statements/class/elements/after-same-line-static-gen-rs-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/after-same-line-static-gen-rs-privatename-identifier-alt.js
@@ -86,8 +86,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-gen-rs-privatename-identifier-initializer-alt.js b/test/language/statements/class/elements/after-same-line-static-gen-rs-privatename-identifier-initializer-alt.js
index 950b10ca6d..9e6650181b 100644
--- a/test/language/statements/class/elements/after-same-line-static-gen-rs-privatename-identifier-initializer-alt.js
+++ b/test/language/statements/class/elements/after-same-line-static-gen-rs-privatename-identifier-initializer-alt.js
@@ -80,8 +80,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-gen-rs-privatename-identifier-initializer.js b/test/language/statements/class/elements/after-same-line-static-gen-rs-privatename-identifier-initializer.js
index 9d06b8ed3b..c855d44ee7 100644
--- a/test/language/statements/class/elements/after-same-line-static-gen-rs-privatename-identifier-initializer.js
+++ b/test/language/statements/class/elements/after-same-line-static-gen-rs-privatename-identifier-initializer.js
@@ -80,8 +80,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-gen-rs-privatename-identifier.js b/test/language/statements/class/elements/after-same-line-static-gen-rs-privatename-identifier.js
index 2870ac7a59..578e0edf05 100644
--- a/test/language/statements/class/elements/after-same-line-static-gen-rs-privatename-identifier.js
+++ b/test/language/statements/class/elements/after-same-line-static-gen-rs-privatename-identifier.js
@@ -86,8 +86,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-gen-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/statements/class/elements/after-same-line-static-gen-rs-static-async-generator-method-privatename-identifier-alt.js
index e030eb762c..0895ff5598 100644
--- a/test/language/statements/class/elements/after-same-line-static-gen-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/after-same-line-static-gen-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -102,8 +102,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-gen-rs-static-async-generator-method-privatename-identifier.js b/test/language/statements/class/elements/after-same-line-static-gen-rs-static-async-generator-method-privatename-identifier.js
index 19a9664d78..fbb8690a07 100644
--- a/test/language/statements/class/elements/after-same-line-static-gen-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/after-same-line-static-gen-rs-static-async-generator-method-privatename-identifier.js
@@ -102,8 +102,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-gen-rs-static-async-method-privatename-identifier-alt.js b/test/language/statements/class/elements/after-same-line-static-gen-rs-static-async-method-privatename-identifier-alt.js
index f9645fb0fd..3a48e53484 100644
--- a/test/language/statements/class/elements/after-same-line-static-gen-rs-static-async-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/after-same-line-static-gen-rs-static-async-method-privatename-identifier-alt.js
@@ -102,8 +102,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-gen-rs-static-async-method-privatename-identifier.js b/test/language/statements/class/elements/after-same-line-static-gen-rs-static-async-method-privatename-identifier.js
index b7ec3e82ef..4cdebe9e0e 100644
--- a/test/language/statements/class/elements/after-same-line-static-gen-rs-static-async-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/after-same-line-static-gen-rs-static-async-method-privatename-identifier.js
@@ -102,8 +102,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-gen-rs-static-generator-method-privatename-identifier-alt.js b/test/language/statements/class/elements/after-same-line-static-gen-rs-static-generator-method-privatename-identifier-alt.js
index 8c6e6c059d..4bbc8e47d6 100644
--- a/test/language/statements/class/elements/after-same-line-static-gen-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/after-same-line-static-gen-rs-static-generator-method-privatename-identifier-alt.js
@@ -102,8 +102,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-gen-rs-static-generator-method-privatename-identifier.js b/test/language/statements/class/elements/after-same-line-static-gen-rs-static-generator-method-privatename-identifier.js
index 793d0417f0..033a300c24 100644
--- a/test/language/statements/class/elements/after-same-line-static-gen-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/after-same-line-static-gen-rs-static-generator-method-privatename-identifier.js
@@ -102,8 +102,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-gen-rs-static-method-privatename-identifier-alt.js b/test/language/statements/class/elements/after-same-line-static-gen-rs-static-method-privatename-identifier-alt.js
index ff70078fc6..6437e2783d 100644
--- a/test/language/statements/class/elements/after-same-line-static-gen-rs-static-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/after-same-line-static-gen-rs-static-method-privatename-identifier-alt.js
@@ -99,8 +99,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-gen-rs-static-method-privatename-identifier.js b/test/language/statements/class/elements/after-same-line-static-gen-rs-static-method-privatename-identifier.js
index bf05711d70..d013ab2522 100644
--- a/test/language/statements/class/elements/after-same-line-static-gen-rs-static-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/after-same-line-static-gen-rs-static-method-privatename-identifier.js
@@ -99,8 +99,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-alt-by-classname.js b/test/language/statements/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-alt-by-classname.js
index ab72b2838e..1228f360a1 100644
--- a/test/language/statements/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-alt-by-classname.js
+++ b/test/language/statements/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-alt-by-classname.js
@@ -87,8 +87,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-alt.js b/test/language/statements/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-alt.js
index 58e1992369..cc22185845 100644
--- a/test/language/statements/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-alt.js
@@ -87,8 +87,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-by-classname.js b/test/language/statements/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-by-classname.js
index 4fd39e411b..62e9d703c1 100644
--- a/test/language/statements/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-by-classname.js
+++ b/test/language/statements/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-by-classname.js
@@ -87,8 +87,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js b/test/language/statements/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
index a4bbb3bd4b..9db8722b41 100644
--- a/test/language/statements/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
+++ b/test/language/statements/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
@@ -81,8 +81,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-initializer-alt.js b/test/language/statements/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-initializer-alt.js
index d4a4ff1413..6383a52074 100644
--- a/test/language/statements/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-initializer-alt.js
+++ b/test/language/statements/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-initializer-alt.js
@@ -81,8 +81,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-initializer.js b/test/language/statements/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-initializer.js
index 0d53b73516..e923a54a01 100644
--- a/test/language/statements/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-initializer.js
+++ b/test/language/statements/class/elements/after-same-line-static-gen-rs-static-privatename-identifier-initializer.js
@@ -81,8 +81,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-gen-rs-static-privatename-identifier.js b/test/language/statements/class/elements/after-same-line-static-gen-rs-static-privatename-identifier.js
index 4777d68023..1060fc6dd9 100644
--- a/test/language/statements/class/elements/after-same-line-static-gen-rs-static-privatename-identifier.js
+++ b/test/language/statements/class/elements/after-same-line-static-gen-rs-static-privatename-identifier.js
@@ -87,8 +87,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-gen-static-private-fields.js b/test/language/statements/class/elements/after-same-line-static-gen-static-private-fields.js
index 54037bd39e..097fad6ab1 100644
--- a/test/language/statements/class/elements/after-same-line-static-gen-static-private-fields.js
+++ b/test/language/statements/class/elements/after-same-line-static-gen-static-private-fields.js
@@ -39,8 +39,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -49,18 +55,18 @@ verifyProperty(C, "m", {
 });
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/statements/class/elements/after-same-line-static-gen-static-private-methods-with-fields.js b/test/language/statements/class/elements/after-same-line-static-gen-static-private-methods-with-fields.js
index b44683eb82..dda01bbe8f 100644
--- a/test/language/statements/class/elements/after-same-line-static-gen-static-private-methods-with-fields.js
+++ b/test/language/statements/class/elements/after-same-line-static-gen-static-private-methods-with-fields.js
@@ -45,8 +45,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -55,29 +61,29 @@ verifyProperty(C, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#xVal"), "test 7");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 8");
+assert(!Object.prototype.hasOwnProperty.call(c, "#xVal"), "test 9");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#yVal"), "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 11");
+assert(!Object.prototype.hasOwnProperty.call(c, "#yVal"), "test 12");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 13");
 assert.sameValue(C.y(), 43, "test 14");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 15");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 16");
 
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 17");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 18");
diff --git a/test/language/statements/class/elements/after-same-line-static-gen-static-private-methods.js b/test/language/statements/class/elements/after-same-line-static-gen-static-private-methods.js
index 3c6de88016..fde72d2940 100644
--- a/test/language/statements/class/elements/after-same-line-static-gen-static-private-methods.js
+++ b/test/language/statements/class/elements/after-same-line-static-gen-static-private-methods.js
@@ -43,8 +43,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -53,18 +59,18 @@ verifyProperty(C, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/statements/class/elements/after-same-line-static-gen-string-literal-names.js b/test/language/statements/class/elements/after-same-line-static-gen-string-literal-names.js
index 8900d6079f..7347cc2c8f 100644
--- a/test/language/statements/class/elements/after-same-line-static-gen-string-literal-names.js
+++ b/test/language/statements/class/elements/after-same-line-static-gen-string-literal-names.js
@@ -30,8 +30,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m().next().value, 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -39,8 +45,14 @@ verifyProperty(C, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -49,8 +61,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: undefined,
@@ -59,8 +77,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: 39,
@@ -69,8 +93,14 @@ verifyProperty(c, "c", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "d"),
+  "d does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "d"),
+  "d does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "d", {
   value: 42,
diff --git a/test/language/statements/class/elements/after-same-line-static-method-computed-names.js b/test/language/statements/class/elements/after-same-line-static-method-computed-names.js
index 5fba2daa92..93a3ad8e34 100644
--- a/test/language/statements/class/elements/after-same-line-static-method-computed-names.js
+++ b/test/language/statements/class/elements/after-same-line-static-method-computed-names.js
@@ -31,8 +31,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -40,8 +46,14 @@ verifyProperty(C, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -50,12 +62,27 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "10"),
+  "10 doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "10"),
+  "10 doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "10", {
   value: "meep",
@@ -64,8 +91,14 @@ verifyProperty(c, "10", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "not initialized", {
   value: undefined,
diff --git a/test/language/statements/class/elements/after-same-line-static-method-computed-symbol-names.js b/test/language/statements/class/elements/after-same-line-static-method-computed-symbol-names.js
index 945cc507ac..2f527be75d 100644
--- a/test/language/statements/class/elements/after-same-line-static-method-computed-symbol-names.js
+++ b/test/language/statements/class/elements/after-same-line-static-method-computed-symbol-names.js
@@ -32,8 +32,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -41,8 +47,14 @@ verifyProperty(C, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, x), false);
-assert.sameValue(Object.hasOwnProperty.call(C, x), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, x),
+  "Symbol x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, x),
+  "Symbol x doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, x, {
   value: undefined,
@@ -51,8 +63,14 @@ verifyProperty(c, x, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
-assert.sameValue(Object.hasOwnProperty.call(C, y), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, y),
+  "Symbol y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, y),
+  "Symbol y doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, y, {
   value: 42,
@@ -61,10 +79,28 @@ verifyProperty(c, y, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "y"),
+  "y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "y"),
+  "y doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "y"),
+  "y doesn't appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/after-same-line-static-method-grammar-privatename-identifier-semantics-stringvalue.js b/test/language/statements/class/elements/after-same-line-static-method-grammar-privatename-identifier-semantics-stringvalue.js
index 8047b1253c..1404393e62 100644
--- a/test/language/statements/class/elements/after-same-line-static-method-grammar-privatename-identifier-semantics-stringvalue.js
+++ b/test/language/statements/class/elements/after-same-line-static-method-grammar-privatename-identifier-semantics-stringvalue.js
@@ -89,8 +89,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-method-literal-names-asi.js b/test/language/statements/class/elements/after-same-line-static-method-literal-names-asi.js
index ce7269c41d..02dc621e9e 100644
--- a/test/language/statements/class/elements/after-same-line-static-method-literal-names-asi.js
+++ b/test/language/statements/class/elements/after-same-line-static-method-literal-names-asi.js
@@ -30,8 +30,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -39,8 +45,14 @@ verifyProperty(C, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -49,8 +61,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
diff --git a/test/language/statements/class/elements/after-same-line-static-method-literal-names.js b/test/language/statements/class/elements/after-same-line-static-method-literal-names.js
index 36ded9bea5..edc025cc7c 100644
--- a/test/language/statements/class/elements/after-same-line-static-method-literal-names.js
+++ b/test/language/statements/class/elements/after-same-line-static-method-literal-names.js
@@ -32,8 +32,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -41,8 +47,14 @@ verifyProperty(C, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -51,8 +63,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -61,8 +79,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: fn,
diff --git a/test/language/statements/class/elements/after-same-line-static-method-private-field-usage.js b/test/language/statements/class/elements/after-same-line-static-method-private-field-usage.js
index 3b96332753..c1435414be 100644
--- a/test/language/statements/class/elements/after-same-line-static-method-private-field-usage.js
+++ b/test/language/statements/class/elements/after-same-line-static-method-private-field-usage.js
@@ -32,8 +32,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-method-private-method-getter-usage.js b/test/language/statements/class/elements/after-same-line-static-method-private-method-getter-usage.js
index dc7b878171..748d7936a6 100644
--- a/test/language/statements/class/elements/after-same-line-static-method-private-method-getter-usage.js
+++ b/test/language/statements/class/elements/after-same-line-static-method-private-method-getter-usage.js
@@ -32,8 +32,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-method-private-method-usage.js b/test/language/statements/class/elements/after-same-line-static-method-private-method-usage.js
index 77e87bc92e..a342a118a4 100644
--- a/test/language/statements/class/elements/after-same-line-static-method-private-method-usage.js
+++ b/test/language/statements/class/elements/after-same-line-static-method-private-method-usage.js
@@ -32,8 +32,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-method-private-names.js b/test/language/statements/class/elements/after-same-line-static-method-private-names.js
index 54e4d8c30b..74b9a4f6b6 100644
--- a/test/language/statements/class/elements/after-same-line-static-method-private-names.js
+++ b/test/language/statements/class/elements/after-same-line-static-method-private-names.js
@@ -39,8 +39,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -49,18 +55,18 @@ verifyProperty(C, "m", {
 });
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(c.x(), 42, "test 7");
 assert.sameValue(c.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 10");
diff --git a/test/language/statements/class/elements/after-same-line-static-method-rs-field-identifier-initializer.js b/test/language/statements/class/elements/after-same-line-static-method-rs-field-identifier-initializer.js
index cc41fe1c1d..7dac1e5fe2 100644
--- a/test/language/statements/class/elements/after-same-line-static-method-rs-field-identifier-initializer.js
+++ b/test/language/statements/class/elements/after-same-line-static-method-rs-field-identifier-initializer.js
@@ -65,8 +65,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-method-rs-field-identifier.js b/test/language/statements/class/elements/after-same-line-static-method-rs-field-identifier.js
index f23c903620..46b47e6e9f 100644
--- a/test/language/statements/class/elements/after-same-line-static-method-rs-field-identifier.js
+++ b/test/language/statements/class/elements/after-same-line-static-method-rs-field-identifier.js
@@ -65,8 +65,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-method-rs-private-getter-alt.js b/test/language/statements/class/elements/after-same-line-static-method-rs-private-getter-alt.js
index fc026ec56c..9a5ed627f8 100644
--- a/test/language/statements/class/elements/after-same-line-static-method-rs-private-getter-alt.js
+++ b/test/language/statements/class/elements/after-same-line-static-method-rs-private-getter-alt.js
@@ -106,8 +106,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-method-rs-private-getter.js b/test/language/statements/class/elements/after-same-line-static-method-rs-private-getter.js
index f30157a9e9..e6a6ddeed7 100644
--- a/test/language/statements/class/elements/after-same-line-static-method-rs-private-getter.js
+++ b/test/language/statements/class/elements/after-same-line-static-method-rs-private-getter.js
@@ -106,8 +106,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-method-rs-private-method-alt.js b/test/language/statements/class/elements/after-same-line-static-method-rs-private-method-alt.js
index e306732752..52b61ac206 100644
--- a/test/language/statements/class/elements/after-same-line-static-method-rs-private-method-alt.js
+++ b/test/language/statements/class/elements/after-same-line-static-method-rs-private-method-alt.js
@@ -105,8 +105,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-method-rs-private-method.js b/test/language/statements/class/elements/after-same-line-static-method-rs-private-method.js
index d70f368f7b..8ee25ac81f 100644
--- a/test/language/statements/class/elements/after-same-line-static-method-rs-private-method.js
+++ b/test/language/statements/class/elements/after-same-line-static-method-rs-private-method.js
@@ -105,8 +105,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-method-rs-private-setter-alt.js b/test/language/statements/class/elements/after-same-line-static-method-rs-private-setter-alt.js
index 1187a88348..5f2c5199ea 100644
--- a/test/language/statements/class/elements/after-same-line-static-method-rs-private-setter-alt.js
+++ b/test/language/statements/class/elements/after-same-line-static-method-rs-private-setter-alt.js
@@ -105,8 +105,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-method-rs-private-setter.js b/test/language/statements/class/elements/after-same-line-static-method-rs-private-setter.js
index 63f470d9b8..ae569333e2 100644
--- a/test/language/statements/class/elements/after-same-line-static-method-rs-private-setter.js
+++ b/test/language/statements/class/elements/after-same-line-static-method-rs-private-setter.js
@@ -105,8 +105,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-method-rs-privatename-identifier-alt.js b/test/language/statements/class/elements/after-same-line-static-method-rs-privatename-identifier-alt.js
index a0219f5e20..8dcbbd0184 100644
--- a/test/language/statements/class/elements/after-same-line-static-method-rs-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/after-same-line-static-method-rs-privatename-identifier-alt.js
@@ -86,8 +86,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-method-rs-privatename-identifier-initializer-alt.js b/test/language/statements/class/elements/after-same-line-static-method-rs-privatename-identifier-initializer-alt.js
index ef01c5187f..064062f30d 100644
--- a/test/language/statements/class/elements/after-same-line-static-method-rs-privatename-identifier-initializer-alt.js
+++ b/test/language/statements/class/elements/after-same-line-static-method-rs-privatename-identifier-initializer-alt.js
@@ -80,8 +80,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-method-rs-privatename-identifier-initializer.js b/test/language/statements/class/elements/after-same-line-static-method-rs-privatename-identifier-initializer.js
index 74a3395287..9a07cfc9ac 100644
--- a/test/language/statements/class/elements/after-same-line-static-method-rs-privatename-identifier-initializer.js
+++ b/test/language/statements/class/elements/after-same-line-static-method-rs-privatename-identifier-initializer.js
@@ -80,8 +80,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-method-rs-privatename-identifier.js b/test/language/statements/class/elements/after-same-line-static-method-rs-privatename-identifier.js
index 6d6b5ab564..da83227ba7 100644
--- a/test/language/statements/class/elements/after-same-line-static-method-rs-privatename-identifier.js
+++ b/test/language/statements/class/elements/after-same-line-static-method-rs-privatename-identifier.js
@@ -86,8 +86,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-method-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/statements/class/elements/after-same-line-static-method-rs-static-async-generator-method-privatename-identifier-alt.js
index 6f6b48e011..1e02d12478 100644
--- a/test/language/statements/class/elements/after-same-line-static-method-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/after-same-line-static-method-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -102,8 +102,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-method-rs-static-async-generator-method-privatename-identifier.js b/test/language/statements/class/elements/after-same-line-static-method-rs-static-async-generator-method-privatename-identifier.js
index 4df184cc0b..f80910da4a 100644
--- a/test/language/statements/class/elements/after-same-line-static-method-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/after-same-line-static-method-rs-static-async-generator-method-privatename-identifier.js
@@ -102,8 +102,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-method-rs-static-async-method-privatename-identifier-alt.js b/test/language/statements/class/elements/after-same-line-static-method-rs-static-async-method-privatename-identifier-alt.js
index 5ac4b93b6a..b39e48c3d3 100644
--- a/test/language/statements/class/elements/after-same-line-static-method-rs-static-async-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/after-same-line-static-method-rs-static-async-method-privatename-identifier-alt.js
@@ -102,8 +102,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-method-rs-static-async-method-privatename-identifier.js b/test/language/statements/class/elements/after-same-line-static-method-rs-static-async-method-privatename-identifier.js
index 80a0329cba..72af2ba8b6 100644
--- a/test/language/statements/class/elements/after-same-line-static-method-rs-static-async-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/after-same-line-static-method-rs-static-async-method-privatename-identifier.js
@@ -102,8 +102,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-method-rs-static-generator-method-privatename-identifier-alt.js b/test/language/statements/class/elements/after-same-line-static-method-rs-static-generator-method-privatename-identifier-alt.js
index 06fa6fc54d..0593fd2b7e 100644
--- a/test/language/statements/class/elements/after-same-line-static-method-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/after-same-line-static-method-rs-static-generator-method-privatename-identifier-alt.js
@@ -102,8 +102,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-method-rs-static-generator-method-privatename-identifier.js b/test/language/statements/class/elements/after-same-line-static-method-rs-static-generator-method-privatename-identifier.js
index a5755ebed0..71ac4b4dda 100644
--- a/test/language/statements/class/elements/after-same-line-static-method-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/after-same-line-static-method-rs-static-generator-method-privatename-identifier.js
@@ -102,8 +102,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-method-rs-static-method-privatename-identifier-alt.js b/test/language/statements/class/elements/after-same-line-static-method-rs-static-method-privatename-identifier-alt.js
index 811af78b8f..1a57e8526e 100644
--- a/test/language/statements/class/elements/after-same-line-static-method-rs-static-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/after-same-line-static-method-rs-static-method-privatename-identifier-alt.js
@@ -99,8 +99,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-method-rs-static-method-privatename-identifier.js b/test/language/statements/class/elements/after-same-line-static-method-rs-static-method-privatename-identifier.js
index b34dfb001d..cfb2475ebe 100644
--- a/test/language/statements/class/elements/after-same-line-static-method-rs-static-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/after-same-line-static-method-rs-static-method-privatename-identifier.js
@@ -99,8 +99,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-method-rs-static-privatename-identifier-alt-by-classname.js b/test/language/statements/class/elements/after-same-line-static-method-rs-static-privatename-identifier-alt-by-classname.js
index eea03771c9..65871b1b6e 100644
--- a/test/language/statements/class/elements/after-same-line-static-method-rs-static-privatename-identifier-alt-by-classname.js
+++ b/test/language/statements/class/elements/after-same-line-static-method-rs-static-privatename-identifier-alt-by-classname.js
@@ -87,8 +87,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-method-rs-static-privatename-identifier-alt.js b/test/language/statements/class/elements/after-same-line-static-method-rs-static-privatename-identifier-alt.js
index b57cdb87a5..324212204a 100644
--- a/test/language/statements/class/elements/after-same-line-static-method-rs-static-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/after-same-line-static-method-rs-static-privatename-identifier-alt.js
@@ -87,8 +87,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-method-rs-static-privatename-identifier-by-classname.js b/test/language/statements/class/elements/after-same-line-static-method-rs-static-privatename-identifier-by-classname.js
index 26a463f51e..18b494038f 100644
--- a/test/language/statements/class/elements/after-same-line-static-method-rs-static-privatename-identifier-by-classname.js
+++ b/test/language/statements/class/elements/after-same-line-static-method-rs-static-privatename-identifier-by-classname.js
@@ -87,8 +87,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-method-rs-static-privatename-identifier-initializer-alt-by-classname.js b/test/language/statements/class/elements/after-same-line-static-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
index 10bcba05a8..f7b5f0c54f 100644
--- a/test/language/statements/class/elements/after-same-line-static-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
+++ b/test/language/statements/class/elements/after-same-line-static-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
@@ -81,8 +81,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-method-rs-static-privatename-identifier-initializer-alt.js b/test/language/statements/class/elements/after-same-line-static-method-rs-static-privatename-identifier-initializer-alt.js
index 6cab2bfbc9..1ea6f9cc03 100644
--- a/test/language/statements/class/elements/after-same-line-static-method-rs-static-privatename-identifier-initializer-alt.js
+++ b/test/language/statements/class/elements/after-same-line-static-method-rs-static-privatename-identifier-initializer-alt.js
@@ -81,8 +81,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-method-rs-static-privatename-identifier-initializer.js b/test/language/statements/class/elements/after-same-line-static-method-rs-static-privatename-identifier-initializer.js
index 865aa2c318..f0621f0b5f 100644
--- a/test/language/statements/class/elements/after-same-line-static-method-rs-static-privatename-identifier-initializer.js
+++ b/test/language/statements/class/elements/after-same-line-static-method-rs-static-privatename-identifier-initializer.js
@@ -81,8 +81,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-method-rs-static-privatename-identifier.js b/test/language/statements/class/elements/after-same-line-static-method-rs-static-privatename-identifier.js
index b9293fe5b1..efe3e3d44d 100644
--- a/test/language/statements/class/elements/after-same-line-static-method-rs-static-privatename-identifier.js
+++ b/test/language/statements/class/elements/after-same-line-static-method-rs-static-privatename-identifier.js
@@ -87,8 +87,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/after-same-line-static-method-static-private-fields.js b/test/language/statements/class/elements/after-same-line-static-method-static-private-fields.js
index d75cba81be..a0bca6a86b 100644
--- a/test/language/statements/class/elements/after-same-line-static-method-static-private-fields.js
+++ b/test/language/statements/class/elements/after-same-line-static-method-static-private-fields.js
@@ -39,8 +39,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -49,18 +55,18 @@ verifyProperty(C, "m", {
 });
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/statements/class/elements/after-same-line-static-method-static-private-methods-with-fields.js b/test/language/statements/class/elements/after-same-line-static-method-static-private-methods-with-fields.js
index a34d4e05c1..c324071d64 100644
--- a/test/language/statements/class/elements/after-same-line-static-method-static-private-methods-with-fields.js
+++ b/test/language/statements/class/elements/after-same-line-static-method-static-private-methods-with-fields.js
@@ -45,8 +45,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -55,29 +61,29 @@ verifyProperty(C, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#xVal"), "test 7");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 8");
+assert(!Object.prototype.hasOwnProperty.call(c, "#xVal"), "test 9");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#yVal"), "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 11");
+assert(!Object.prototype.hasOwnProperty.call(c, "#yVal"), "test 12");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 13");
 assert.sameValue(C.y(), 43, "test 14");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 15");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 16");
 
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 17");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 18");
diff --git a/test/language/statements/class/elements/after-same-line-static-method-static-private-methods.js b/test/language/statements/class/elements/after-same-line-static-method-static-private-methods.js
index 3ae8ee01d8..c13eecebbc 100644
--- a/test/language/statements/class/elements/after-same-line-static-method-static-private-methods.js
+++ b/test/language/statements/class/elements/after-same-line-static-method-static-private-methods.js
@@ -43,8 +43,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -53,18 +59,18 @@ verifyProperty(C, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/statements/class/elements/after-same-line-static-method-string-literal-names.js b/test/language/statements/class/elements/after-same-line-static-method-string-literal-names.js
index e4aa80104c..1d6420ddbf 100644
--- a/test/language/statements/class/elements/after-same-line-static-method-string-literal-names.js
+++ b/test/language/statements/class/elements/after-same-line-static-method-string-literal-names.js
@@ -30,8 +30,14 @@ class C {
 var c = new C();
 
 assert.sameValue(C.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "m"),
+  "m doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(C, "m", {
   enumerable: false,
@@ -39,8 +45,14 @@ verifyProperty(C, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -49,8 +61,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: undefined,
@@ -59,8 +77,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: 39,
@@ -69,8 +93,14 @@ verifyProperty(c, "c", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "d"),
+  "d does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "d"),
+  "d does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "d", {
   value: 42,
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-identifier-spread-strict.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-identifier-spread-strict.js
index 6404349375..aeee653286 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-identifier-spread-strict.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-identifier-spread-strict.js
@@ -48,8 +48,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -58,5 +64,11 @@ var iter = C.gen();
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-identifier-strict.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-identifier-strict.js
index 243d5414f4..505504b5e3 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-identifier-strict.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-identifier-strict.js
@@ -39,8 +39,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -49,5 +55,11 @@ var iter = C.gen();
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-promise-reject-next-catch.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-promise-reject-next-catch.js
index e8a364cbd1..fafc1546b0 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-promise-reject-next-catch.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-promise-reject-next-catch.js
@@ -34,8 +34,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -55,5 +61,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-promise-reject-next-for-await-of-async-iterator.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-promise-reject-next-for-await-of-async-iterator.js
index 8bc57c6e15..f6700bc951 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-promise-reject-next-for-await-of-async-iterator.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-promise-reject-next-for-await-of-async-iterator.js
@@ -39,8 +39,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -61,5 +67,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-promise-reject-next-for-await-of-sync-iterator.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-promise-reject-next-for-await-of-sync-iterator.js
index ad11204f65..1eee573bad 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-promise-reject-next-for-await-of-sync-iterator.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-promise-reject-next-for-await-of-sync-iterator.js
@@ -39,8 +39,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -60,5 +66,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-promise-reject-next-yield-star-async-iterator.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-promise-reject-next-yield-star-async-iterator.js
index c23a7b7f0c..d51d2f9740 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-promise-reject-next-yield-star-async-iterator.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-promise-reject-next-yield-star-async-iterator.js
@@ -38,8 +38,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -59,5 +65,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-promise-reject-next-yield-star-sync-iterator.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-promise-reject-next-yield-star-sync-iterator.js
index 712569e48c..404aa56414 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-promise-reject-next-yield-star-sync-iterator.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-promise-reject-next-yield-star-sync-iterator.js
@@ -37,8 +37,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -58,5 +64,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-promise-reject-next.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-promise-reject-next.js
index 82e7173c80..d4c8fe4e1b 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-promise-reject-next.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-promise-reject-next.js
@@ -34,8 +34,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -55,5 +61,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-spread-arr-multiple.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-spread-arr-multiple.js
index cf8185e09b..87ccfcd0d5 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-spread-arr-multiple.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-spread-arr-multiple.js
@@ -41,8 +41,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -61,5 +67,11 @@ item.then(({ done, value }) => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-spread-arr-single.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-spread-arr-single.js
index 65b38368fc..8a44927738 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-spread-arr-single.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-spread-arr-single.js
@@ -39,8 +39,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -60,5 +66,11 @@ item.then(({ done, value }) => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-spread-obj.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-spread-obj.js
index 2967460995..81f5373ec1 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-spread-obj.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-spread-obj.js
@@ -43,8 +43,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -63,5 +69,11 @@ item.then(({ done, value }) => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-async-next.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-async-next.js
index 4bbfbf19cb..3f44781735 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-async-next.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-async-next.js
@@ -151,8 +151,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -230,5 +236,11 @@ iter.next("next-arg-1").then(v => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-async-return.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-async-return.js
index 40a6dbd162..af58f5a983 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-async-return.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-async-return.js
@@ -165,8 +165,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -246,5 +252,11 @@ iter.next().then(v => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-async-throw.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-async-throw.js
index 599b769a67..34fa786485 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-async-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-async-throw.js
@@ -170,8 +170,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -254,5 +260,11 @@ iter.next().then(v => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-expr-abrupt.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-expr-abrupt.js
index 010fc74aa9..401a2b7058 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-expr-abrupt.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-expr-abrupt.js
@@ -46,8 +46,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -65,5 +71,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-get-abrupt.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-get-abrupt.js
index 814a3dbe44..935a63c607 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-get-abrupt.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-get-abrupt.js
@@ -66,8 +66,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -85,5 +91,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-boolean-throw.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-boolean-throw.js
index 869f0dc7e2..95e19ef463 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-boolean-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-boolean-throw.js
@@ -65,8 +65,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -84,5 +90,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-number-throw.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-number-throw.js
index 14bcb7efd8..254cb546a8 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-number-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-number-throw.js
@@ -65,8 +65,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -84,5 +90,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-object-throw.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-object-throw.js
index 3f7abcc65b..ea4b4266cb 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-object-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-object-throw.js
@@ -65,8 +65,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -84,5 +90,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-string-throw.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-string-throw.js
index 6cfb8a4df7..ca68240ba8 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-string-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-string-throw.js
@@ -65,8 +65,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -84,5 +90,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-symbol-throw.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-symbol-throw.js
index 8bb318a930..ad3eacb4cc 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-symbol-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-not-callable-symbol-throw.js
@@ -65,8 +65,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -84,5 +90,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-null-sync-get-abrupt.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-null-sync-get-abrupt.js
index aa3675cc6c..477410181f 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-null-sync-get-abrupt.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-null-sync-get-abrupt.js
@@ -70,8 +70,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -90,5 +96,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-abrupt.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-abrupt.js
index 40d1767aa3..ccf5c03f83 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-abrupt.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-abrupt.js
@@ -62,8 +62,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -81,5 +87,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-boolean-throw.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-boolean-throw.js
index b894abee47..7483472d89 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-boolean-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-boolean-throw.js
@@ -62,8 +62,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -81,5 +87,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-null-throw.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-null-throw.js
index e1db3157f4..1c5754105a 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-null-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-null-throw.js
@@ -62,8 +62,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -81,5 +87,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-number-throw.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-number-throw.js
index 5bdbd206db..e651ee7999 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-number-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-number-throw.js
@@ -62,8 +62,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -81,5 +87,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-string-throw.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-string-throw.js
index fc5a242226..071b36a061 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-string-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-string-throw.js
@@ -62,8 +62,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -81,5 +87,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-symbol-throw.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-symbol-throw.js
index 5184d164af..4512c90372 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-symbol-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-symbol-throw.js
@@ -62,8 +62,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -81,5 +87,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-undefined-throw.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-undefined-throw.js
index cbd9051214..3ee582a3bf 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-undefined-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-returns-undefined-throw.js
@@ -62,8 +62,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -81,5 +87,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-undefined-sync-get-abrupt.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-undefined-sync-get-abrupt.js
index d5ae0228d6..2304de8a43 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-undefined-sync-get-abrupt.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-async-undefined-sync-get-abrupt.js
@@ -70,8 +70,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -90,5 +96,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-get-abrupt.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-get-abrupt.js
index 4a3b6833e2..d195d64b8d 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-get-abrupt.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-get-abrupt.js
@@ -65,8 +65,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -84,5 +90,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-boolean-throw.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-boolean-throw.js
index 586f102679..157f182162 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-boolean-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-boolean-throw.js
@@ -64,8 +64,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -83,5 +89,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-number-throw.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-number-throw.js
index afeb7d1bf1..bfc5ca18b2 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-number-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-number-throw.js
@@ -64,8 +64,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -83,5 +89,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-object-throw.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-object-throw.js
index 3469bde3d1..761efa21f8 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-object-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-object-throw.js
@@ -64,8 +64,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -83,5 +89,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-string-throw.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-string-throw.js
index 55e93371bb..3e94254827 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-string-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-string-throw.js
@@ -64,8 +64,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -83,5 +89,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-symbol-throw.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-symbol-throw.js
index 7be72a8781..d03424e7ab 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-symbol-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-not-callable-symbol-throw.js
@@ -64,8 +64,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -83,5 +89,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-abrupt.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-abrupt.js
index 6cea12d4f3..a89dbba113 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-abrupt.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-abrupt.js
@@ -59,8 +59,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -78,5 +84,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-boolean-throw.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-boolean-throw.js
index fb0db49602..ac23c682b7 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-boolean-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-boolean-throw.js
@@ -64,8 +64,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -83,5 +89,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-null-throw.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-null-throw.js
index 1dc68438c7..a79a16ae59 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-null-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-null-throw.js
@@ -64,8 +64,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -83,5 +89,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-number-throw.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-number-throw.js
index 8f56fcc635..508fc93a7a 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-number-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-number-throw.js
@@ -64,8 +64,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -83,5 +89,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-string-throw.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-string-throw.js
index 50b6c634ef..7b7abbc01a 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-string-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-string-throw.js
@@ -64,8 +64,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -83,5 +89,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-symbol-throw.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-symbol-throw.js
index bf9751618f..fca162ed9b 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-symbol-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-symbol-throw.js
@@ -64,8 +64,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -83,5 +89,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-undefined-throw.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-undefined-throw.js
index dd69e462fb..5647f7a5e1 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-undefined-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-getiter-sync-returns-undefined-throw.js
@@ -64,8 +64,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -83,5 +89,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-call-done-get-abrupt.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-call-done-get-abrupt.js
index 448b27f283..57a5bfc02b 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-call-done-get-abrupt.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-call-done-get-abrupt.js
@@ -65,8 +65,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -84,5 +90,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-call-returns-abrupt.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-call-returns-abrupt.js
index 3344319b33..9973f0599c 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-call-returns-abrupt.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-call-returns-abrupt.js
@@ -57,8 +57,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -76,5 +82,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-call-value-get-abrupt.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-call-value-get-abrupt.js
index 23a841463b..d8c2fbbe99 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-call-value-get-abrupt.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-call-value-get-abrupt.js
@@ -67,8 +67,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -86,5 +92,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-get-abrupt.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-get-abrupt.js
index adfa30012d..8c63e38691 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-get-abrupt.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-get-abrupt.js
@@ -57,8 +57,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -76,5 +82,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-non-object-ignores-then.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-non-object-ignores-then.js
index b7fbed1b81..34650269dd 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-non-object-ignores-then.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-non-object-ignores-then.js
@@ -77,8 +77,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -96,5 +102,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-not-callable-boolean-throw.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-not-callable-boolean-throw.js
index 0cc0d61c69..3fe8fdfcb6 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-not-callable-boolean-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-not-callable-boolean-throw.js
@@ -54,8 +54,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -73,5 +79,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-not-callable-null-throw.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-not-callable-null-throw.js
index bcd563916f..6cc5e7af7b 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-not-callable-null-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-not-callable-null-throw.js
@@ -54,8 +54,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -73,5 +79,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-not-callable-number-throw.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-not-callable-number-throw.js
index 8bd63d1434..b02ddf4d58 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-not-callable-number-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-not-callable-number-throw.js
@@ -54,8 +54,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -73,5 +79,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-not-callable-object-throw.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-not-callable-object-throw.js
index b9914dde4a..4dbb788e8d 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-not-callable-object-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-not-callable-object-throw.js
@@ -54,8 +54,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -73,5 +79,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-not-callable-string-throw.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-not-callable-string-throw.js
index d4ebf97b04..e3a9db3072 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-not-callable-string-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-not-callable-string-throw.js
@@ -54,8 +54,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -73,5 +79,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-not-callable-symbol-throw.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-not-callable-symbol-throw.js
index 4056be6d84..55dd515e5c 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-not-callable-symbol-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-not-callable-symbol-throw.js
@@ -54,8 +54,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -73,5 +79,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-not-callable-undefined-throw.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-not-callable-undefined-throw.js
index 34491a0131..7348f21901 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-not-callable-undefined-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-not-callable-undefined-throw.js
@@ -54,8 +54,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -73,5 +79,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-then-get-abrupt.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-then-get-abrupt.js
index f400b14753..0b9b3a104e 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-then-get-abrupt.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-then-get-abrupt.js
@@ -81,8 +81,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -100,5 +106,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-boolean-fulfillpromise.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-boolean-fulfillpromise.js
index fa7ff154c4..f8b1c7e70b 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-boolean-fulfillpromise.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-boolean-fulfillpromise.js
@@ -81,8 +81,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -94,5 +100,11 @@ iter.next().then(({ value, done }) => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-null-fulfillpromise.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-null-fulfillpromise.js
index 209664ebd3..59a567e9e3 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-null-fulfillpromise.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-null-fulfillpromise.js
@@ -81,8 +81,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -94,5 +100,11 @@ iter.next().then(({ value, done }) => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-number-fulfillpromise.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-number-fulfillpromise.js
index d19224cfb5..5c0b6cbb80 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-number-fulfillpromise.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-number-fulfillpromise.js
@@ -81,8 +81,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -94,5 +100,11 @@ iter.next().then(({ value, done }) => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-object-fulfillpromise.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-object-fulfillpromise.js
index e954d41755..83f880e6af 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-object-fulfillpromise.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-object-fulfillpromise.js
@@ -81,8 +81,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -94,5 +100,11 @@ iter.next().then(({ value, done }) => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-string-fulfillpromise.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-string-fulfillpromise.js
index 93397d9326..c739f51a7a 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-string-fulfillpromise.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-string-fulfillpromise.js
@@ -81,8 +81,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -94,5 +100,11 @@ iter.next().then(({ value, done }) => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-symbol-fulfillpromise.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-symbol-fulfillpromise.js
index 4bbf2789a4..611722e630 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-symbol-fulfillpromise.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-symbol-fulfillpromise.js
@@ -81,8 +81,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -94,5 +100,11 @@ iter.next().then(({ value, done }) => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-undefined-fulfillpromise.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-undefined-fulfillpromise.js
index d277cf12b9..be6e3f7e7b 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-undefined-fulfillpromise.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-then-non-callable-undefined-fulfillpromise.js
@@ -81,8 +81,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -94,5 +100,11 @@ iter.next().then(({ value, done }) => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-then-returns-abrupt.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-then-returns-abrupt.js
index 1a4fbb2685..f38e308b12 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-then-returns-abrupt.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-next-then-returns-abrupt.js
@@ -81,8 +81,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -100,5 +106,11 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-sync-next.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-sync-next.js
index db0fc1dd86..ec30768aad 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-sync-next.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-sync-next.js
@@ -170,8 +170,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -233,5 +239,11 @@ iter.next("next-arg-1").then(v => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-sync-return.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-sync-return.js
index 426a78ec06..fd8a49e4a2 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-sync-return.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-sync-return.js
@@ -145,8 +145,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -208,5 +214,11 @@ iter.next().then(v => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-sync-throw.js b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-sync-throw.js
index 3fac49cbf5..729ef5f1ec 100644
--- a/test/language/statements/class/elements/async-gen-private-method-static/yield-star-sync-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method-static/yield-star-sync-throw.js
@@ -148,8 +148,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -214,5 +220,11 @@ iter.next().then(v => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-identifier-spread-strict.js b/test/language/statements/class/elements/async-gen-private-method/yield-identifier-spread-strict.js
index 97613d2c26..12c4de2e86 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-identifier-spread-strict.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-identifier-spread-strict.js
@@ -50,9 +50,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -61,6 +70,15 @@ var iter = c.gen();
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-identifier-strict.js b/test/language/statements/class/elements/async-gen-private-method/yield-identifier-strict.js
index 22a4f66432..101df246db 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-identifier-strict.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-identifier-strict.js
@@ -41,9 +41,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -52,6 +61,15 @@ var iter = c.gen();
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-promise-reject-next-catch.js b/test/language/statements/class/elements/async-gen-private-method/yield-promise-reject-next-catch.js
index 0645b12531..63c24ce050 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-promise-reject-next-catch.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-promise-reject-next-catch.js
@@ -36,9 +36,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -58,6 +67,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-promise-reject-next-for-await-of-async-iterator.js b/test/language/statements/class/elements/async-gen-private-method/yield-promise-reject-next-for-await-of-async-iterator.js
index a54e16178f..9c4f546430 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-promise-reject-next-for-await-of-async-iterator.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-promise-reject-next-for-await-of-async-iterator.js
@@ -41,9 +41,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -64,6 +73,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-promise-reject-next-for-await-of-sync-iterator.js b/test/language/statements/class/elements/async-gen-private-method/yield-promise-reject-next-for-await-of-sync-iterator.js
index 330f52b535..5553904023 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-promise-reject-next-for-await-of-sync-iterator.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-promise-reject-next-for-await-of-sync-iterator.js
@@ -41,9 +41,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -63,6 +72,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-promise-reject-next-yield-star-async-iterator.js b/test/language/statements/class/elements/async-gen-private-method/yield-promise-reject-next-yield-star-async-iterator.js
index f084b8cc96..1f76e49a92 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-promise-reject-next-yield-star-async-iterator.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-promise-reject-next-yield-star-async-iterator.js
@@ -40,9 +40,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -62,6 +71,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-promise-reject-next-yield-star-sync-iterator.js b/test/language/statements/class/elements/async-gen-private-method/yield-promise-reject-next-yield-star-sync-iterator.js
index 4dad592f1a..a6ed03251f 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-promise-reject-next-yield-star-sync-iterator.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-promise-reject-next-yield-star-sync-iterator.js
@@ -39,9 +39,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -61,6 +70,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-promise-reject-next.js b/test/language/statements/class/elements/async-gen-private-method/yield-promise-reject-next.js
index 935f74824b..7cc4660355 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-promise-reject-next.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-promise-reject-next.js
@@ -36,9 +36,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -58,6 +67,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-spread-arr-multiple.js b/test/language/statements/class/elements/async-gen-private-method/yield-spread-arr-multiple.js
index 6430030664..0d540cde5e 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-spread-arr-multiple.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-spread-arr-multiple.js
@@ -43,9 +43,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -64,6 +73,15 @@ item.then(({ done, value }) => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-spread-arr-single.js b/test/language/statements/class/elements/async-gen-private-method/yield-spread-arr-single.js
index 9fa18d3ab1..572b89cda2 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-spread-arr-single.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-spread-arr-single.js
@@ -41,9 +41,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -63,6 +72,15 @@ item.then(({ done, value }) => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-spread-obj.js b/test/language/statements/class/elements/async-gen-private-method/yield-spread-obj.js
index 132c051bf4..915d81d646 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-spread-obj.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-spread-obj.js
@@ -45,9 +45,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -66,6 +75,15 @@ item.then(({ done, value }) => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-async-next.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-async-next.js
index 43967f080e..0c224ec7f4 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-async-next.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-async-next.js
@@ -153,9 +153,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -233,6 +242,15 @@ iter.next("next-arg-1").then(v => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-async-return.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-async-return.js
index 238c2c94b0..65dca7f641 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-async-return.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-async-return.js
@@ -167,9 +167,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -249,6 +258,15 @@ iter.next().then(v => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-async-throw.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-async-throw.js
index 04b10c0efb..50f7935987 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-async-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-async-throw.js
@@ -172,9 +172,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -257,6 +266,15 @@ iter.next().then(v => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-expr-abrupt.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-expr-abrupt.js
index c127cd49be..e3a5c46788 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-expr-abrupt.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-expr-abrupt.js
@@ -48,9 +48,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -68,6 +77,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-get-abrupt.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-get-abrupt.js
index 30377f1904..f35df58b5e 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-get-abrupt.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-get-abrupt.js
@@ -68,9 +68,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -88,6 +97,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-boolean-throw.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-boolean-throw.js
index c97e0a7c6a..b6a776b7b8 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-boolean-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-boolean-throw.js
@@ -67,9 +67,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -87,6 +96,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-number-throw.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-number-throw.js
index b20a4ec807..9b95829cc0 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-number-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-number-throw.js
@@ -67,9 +67,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -87,6 +96,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-object-throw.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-object-throw.js
index ec534bfa25..1965167eee 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-object-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-object-throw.js
@@ -67,9 +67,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -87,6 +96,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-string-throw.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-string-throw.js
index db0de0d8d8..bfcefdd571 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-string-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-string-throw.js
@@ -67,9 +67,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -87,6 +96,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-symbol-throw.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-symbol-throw.js
index 62a4e8a25a..5abb527779 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-symbol-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-not-callable-symbol-throw.js
@@ -67,9 +67,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -87,6 +96,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-null-sync-get-abrupt.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-null-sync-get-abrupt.js
index 11eaa74d75..5d5ef33a90 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-null-sync-get-abrupt.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-null-sync-get-abrupt.js
@@ -72,9 +72,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -93,6 +102,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-returns-abrupt.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-returns-abrupt.js
index 1601390cfb..4674399edd 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-returns-abrupt.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-returns-abrupt.js
@@ -64,9 +64,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -84,6 +93,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-returns-boolean-throw.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-returns-boolean-throw.js
index 6dd829922e..7f22ab0374 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-returns-boolean-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-returns-boolean-throw.js
@@ -64,9 +64,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -84,6 +93,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-returns-null-throw.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-returns-null-throw.js
index 949be2e3ed..21b95eb8a0 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-returns-null-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-returns-null-throw.js
@@ -64,9 +64,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -84,6 +93,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-returns-number-throw.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-returns-number-throw.js
index 088ba42b00..7930cc6a77 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-returns-number-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-returns-number-throw.js
@@ -64,9 +64,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -84,6 +93,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-returns-string-throw.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-returns-string-throw.js
index c28b7879e9..d1ed831dd7 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-returns-string-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-returns-string-throw.js
@@ -64,9 +64,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -84,6 +93,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-returns-symbol-throw.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-returns-symbol-throw.js
index 8e3b8ecdb4..c59cc75703 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-returns-symbol-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-returns-symbol-throw.js
@@ -64,9 +64,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -84,6 +93,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-returns-undefined-throw.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-returns-undefined-throw.js
index d8dbe61b85..32a97f0997 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-returns-undefined-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-returns-undefined-throw.js
@@ -64,9 +64,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -84,6 +93,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-undefined-sync-get-abrupt.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-undefined-sync-get-abrupt.js
index 6024371e55..869af7e0ed 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-undefined-sync-get-abrupt.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-async-undefined-sync-get-abrupt.js
@@ -72,9 +72,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -93,6 +102,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-get-abrupt.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-get-abrupt.js
index 3d9f03d6f6..b1c8365e2a 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-get-abrupt.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-get-abrupt.js
@@ -67,9 +67,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -87,6 +96,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-boolean-throw.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-boolean-throw.js
index 529b311723..c90a95a80b 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-boolean-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-boolean-throw.js
@@ -66,9 +66,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -86,6 +95,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-number-throw.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-number-throw.js
index 6223dac04a..fd67cb463a 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-number-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-number-throw.js
@@ -66,9 +66,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -86,6 +95,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-object-throw.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-object-throw.js
index 648a198d40..b3078cedce 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-object-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-object-throw.js
@@ -66,9 +66,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -86,6 +95,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-string-throw.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-string-throw.js
index 3c0259c76e..6d2d253714 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-string-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-string-throw.js
@@ -66,9 +66,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -86,6 +95,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-symbol-throw.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-symbol-throw.js
index f13a60e1ee..7c13e10397 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-symbol-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-not-callable-symbol-throw.js
@@ -66,9 +66,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -86,6 +95,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-abrupt.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-abrupt.js
index 02dcbbffcb..449b553f99 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-abrupt.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-abrupt.js
@@ -61,9 +61,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -81,6 +90,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-boolean-throw.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-boolean-throw.js
index 310d51984c..b7beae8ee1 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-boolean-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-boolean-throw.js
@@ -66,9 +66,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -86,6 +95,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-null-throw.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-null-throw.js
index 991fea247b..7263acb8e2 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-null-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-null-throw.js
@@ -66,9 +66,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -86,6 +95,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-number-throw.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-number-throw.js
index 8b2fec004e..3e435acfdb 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-number-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-number-throw.js
@@ -66,9 +66,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -86,6 +95,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-string-throw.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-string-throw.js
index 4c3dc320d4..d89e522080 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-string-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-string-throw.js
@@ -66,9 +66,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -86,6 +95,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-symbol-throw.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-symbol-throw.js
index e6b1f6823c..19cec261ca 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-symbol-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-symbol-throw.js
@@ -66,9 +66,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -86,6 +95,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-undefined-throw.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-undefined-throw.js
index 580d1a2f65..5272b8c761 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-undefined-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-getiter-sync-returns-undefined-throw.js
@@ -66,9 +66,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -86,6 +95,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-next-call-done-get-abrupt.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-next-call-done-get-abrupt.js
index 82addf0c25..b405943ed9 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-next-call-done-get-abrupt.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-next-call-done-get-abrupt.js
@@ -67,9 +67,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -87,6 +96,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-next-call-returns-abrupt.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-next-call-returns-abrupt.js
index 06bac4e1dd..09aa4afa51 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-next-call-returns-abrupt.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-next-call-returns-abrupt.js
@@ -59,9 +59,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -79,6 +88,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-next-call-value-get-abrupt.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-next-call-value-get-abrupt.js
index e37ab085d3..352ae714d3 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-next-call-value-get-abrupt.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-next-call-value-get-abrupt.js
@@ -69,9 +69,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -89,6 +98,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-next-get-abrupt.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-next-get-abrupt.js
index 16009cdf23..3d2d2c80d8 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-next-get-abrupt.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-next-get-abrupt.js
@@ -59,9 +59,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -79,6 +88,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-next-non-object-ignores-then.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-next-non-object-ignores-then.js
index 495150b0f3..53a8b219a8 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-next-non-object-ignores-then.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-next-non-object-ignores-then.js
@@ -79,9 +79,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -99,6 +108,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-next-not-callable-boolean-throw.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-next-not-callable-boolean-throw.js
index 0fd699817c..e41c43af78 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-next-not-callable-boolean-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-next-not-callable-boolean-throw.js
@@ -56,9 +56,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -76,6 +85,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-next-not-callable-null-throw.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-next-not-callable-null-throw.js
index 6c02881f70..f8fb6fdf0d 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-next-not-callable-null-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-next-not-callable-null-throw.js
@@ -56,9 +56,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -76,6 +85,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-next-not-callable-number-throw.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-next-not-callable-number-throw.js
index d4365fbc0a..73e32a20a0 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-next-not-callable-number-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-next-not-callable-number-throw.js
@@ -56,9 +56,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -76,6 +85,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-next-not-callable-object-throw.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-next-not-callable-object-throw.js
index 7f10b18a14..52c5454b09 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-next-not-callable-object-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-next-not-callable-object-throw.js
@@ -56,9 +56,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -76,6 +85,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-next-not-callable-string-throw.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-next-not-callable-string-throw.js
index a5c9a87aa4..4a1dfef5e2 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-next-not-callable-string-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-next-not-callable-string-throw.js
@@ -56,9 +56,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -76,6 +85,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-next-not-callable-symbol-throw.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-next-not-callable-symbol-throw.js
index 9cb1506bad..4c82622c2d 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-next-not-callable-symbol-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-next-not-callable-symbol-throw.js
@@ -56,9 +56,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -76,6 +85,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-next-not-callable-undefined-throw.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-next-not-callable-undefined-throw.js
index e942797ef5..85a896b7b3 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-next-not-callable-undefined-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-next-not-callable-undefined-throw.js
@@ -56,9 +56,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -76,6 +85,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-next-then-get-abrupt.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-next-then-get-abrupt.js
index 8fe629fe3b..94db0f3be3 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-next-then-get-abrupt.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-next-then-get-abrupt.js
@@ -83,9 +83,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -103,6 +112,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-next-then-non-callable-boolean-fulfillpromise.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-next-then-non-callable-boolean-fulfillpromise.js
index 7a9ebad34b..66f6d33022 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-next-then-non-callable-boolean-fulfillpromise.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-next-then-non-callable-boolean-fulfillpromise.js
@@ -83,9 +83,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -97,6 +106,15 @@ iter.next().then(({ value, done }) => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-next-then-non-callable-null-fulfillpromise.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-next-then-non-callable-null-fulfillpromise.js
index 3e7d5b6f83..1730f33ae7 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-next-then-non-callable-null-fulfillpromise.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-next-then-non-callable-null-fulfillpromise.js
@@ -83,9 +83,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -97,6 +106,15 @@ iter.next().then(({ value, done }) => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-next-then-non-callable-number-fulfillpromise.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-next-then-non-callable-number-fulfillpromise.js
index fda8feef39..2342b47ca3 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-next-then-non-callable-number-fulfillpromise.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-next-then-non-callable-number-fulfillpromise.js
@@ -83,9 +83,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -97,6 +106,15 @@ iter.next().then(({ value, done }) => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-next-then-non-callable-object-fulfillpromise.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-next-then-non-callable-object-fulfillpromise.js
index 2048f1f95f..a9eaaf0b8c 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-next-then-non-callable-object-fulfillpromise.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-next-then-non-callable-object-fulfillpromise.js
@@ -83,9 +83,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -97,6 +106,15 @@ iter.next().then(({ value, done }) => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-next-then-non-callable-string-fulfillpromise.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-next-then-non-callable-string-fulfillpromise.js
index 6a06b3bc7d..990580b5c2 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-next-then-non-callable-string-fulfillpromise.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-next-then-non-callable-string-fulfillpromise.js
@@ -83,9 +83,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -97,6 +106,15 @@ iter.next().then(({ value, done }) => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-next-then-non-callable-symbol-fulfillpromise.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-next-then-non-callable-symbol-fulfillpromise.js
index 17b7a22dcf..e20c9e9746 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-next-then-non-callable-symbol-fulfillpromise.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-next-then-non-callable-symbol-fulfillpromise.js
@@ -83,9 +83,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -97,6 +106,15 @@ iter.next().then(({ value, done }) => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-next-then-non-callable-undefined-fulfillpromise.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-next-then-non-callable-undefined-fulfillpromise.js
index fc7f9ca147..8dfe3f3980 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-next-then-non-callable-undefined-fulfillpromise.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-next-then-non-callable-undefined-fulfillpromise.js
@@ -83,9 +83,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -97,6 +106,15 @@ iter.next().then(({ value, done }) => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-next-then-returns-abrupt.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-next-then-returns-abrupt.js
index 9844b94a2d..62c03327c3 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-next-then-returns-abrupt.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-next-then-returns-abrupt.js
@@ -83,9 +83,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -103,6 +112,15 @@ iter.next().then(() => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-sync-next.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-sync-next.js
index 3b4d9817ce..8b18283750 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-sync-next.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-sync-next.js
@@ -172,9 +172,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -236,6 +245,15 @@ iter.next("next-arg-1").then(v => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-sync-return.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-sync-return.js
index 570a8d678b..fc4c49fc9f 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-sync-return.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-sync-return.js
@@ -147,9 +147,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -211,6 +220,15 @@ iter.next().then(v => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/async-gen-private-method/yield-star-sync-throw.js b/test/language/statements/class/elements/async-gen-private-method/yield-star-sync-throw.js
index 3ba0f30928..ae8f8d4659 100644
--- a/test/language/statements/class/elements/async-gen-private-method/yield-star-sync-throw.js
+++ b/test/language/statements/class/elements/async-gen-private-method/yield-star-sync-throw.js
@@ -150,9 +150,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -217,6 +226,15 @@ iter.next().then(v => {
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "#gen does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "#gen does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "#gen does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/computed-name-toprimitive-symbol.js b/test/language/statements/class/elements/computed-name-toprimitive-symbol.js
index b903bb2c0c..c1733f1546 100644
--- a/test/language/statements/class/elements/computed-name-toprimitive-symbol.js
+++ b/test/language/statements/class/elements/computed-name-toprimitive-symbol.js
@@ -72,8 +72,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, s1), false);
-assert.sameValue(Object.hasOwnProperty.call(C, s1), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, s1),
+  "s1 doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, s1),
+  "s1 doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, s1, {
   value: 42,
@@ -82,8 +88,14 @@ verifyProperty(c, s1, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, s2), false);
-assert.sameValue(Object.hasOwnProperty.call(C, s2), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, s2),
+  "s2 doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, s2),
+  "s2 doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, s2, {
   value: 43,
@@ -92,8 +104,14 @@ verifyProperty(c, s2, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, s3), false);
-assert.sameValue(Object.hasOwnProperty.call(C, s3), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, s3),
+  "s3 doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, s3),
+  "s3 doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, s3, {
   value: 44,
diff --git a/test/language/statements/class/elements/computed-name-toprimitive.js b/test/language/statements/class/elements/computed-name-toprimitive.js
index 19fca26931..5af903dcbc 100644
--- a/test/language/statements/class/elements/computed-name-toprimitive.js
+++ b/test/language/statements/class/elements/computed-name-toprimitive.js
@@ -69,8 +69,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "d"),
+  "d doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "d"),
+  "d doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "d", {
   value: 42,
@@ -79,8 +85,14 @@ verifyProperty(c, "d", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "e"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "e"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "e"),
+  "e doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "e"),
+  "e doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "e", {
   value: 43,
@@ -89,8 +101,14 @@ verifyProperty(c, "e", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "f"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "f"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "f"),
+  "f doesn't appear as an own property on C prototype"
+);
+assert(!
+  Object.prototype.hasOwnProperty.call(C, "f"),
+  "f doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "f", {
   value: 44,
diff --git a/test/language/statements/class/elements/field-declaration.js b/test/language/statements/class/elements/field-declaration.js
index d1227f50cb..8c08e810e6 100644
--- a/test/language/statements/class/elements/field-declaration.js
+++ b/test/language/statements/class/elements/field-declaration.js
@@ -63,10 +63,22 @@ assert.sameValue(C.g, undefined);
 assert.sameValue(C.h, undefined);
 assert.sameValue(C[0], undefined);
 
-assert.sameValue(Object.hasOwnProperty.call(C, 'f'), false);
-assert.sameValue(Object.hasOwnProperty.call(C, 'g'), false);
-assert.sameValue(Object.hasOwnProperty.call(C, 'h'), false);
-assert.sameValue(Object.hasOwnProperty.call(C, 0), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, 'f'),
+  "f does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, 'g'),
+  "g does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, 'h'),
+  "h does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, 0),
+  "0 does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, 'f', {
   value: 'test262',
diff --git a/test/language/statements/class/elements/field-definition-accessor-no-line-terminator.js b/test/language/statements/class/elements/field-definition-accessor-no-line-terminator.js
index 11c0d453b6..02cb0a52b9 100644
--- a/test/language/statements/class/elements/field-definition-accessor-no-line-terminator.js
+++ b/test/language/statements/class/elements/field-definition-accessor-no-line-terminator.js
@@ -23,9 +23,27 @@ class C {
 
 let c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, 'accessor'), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, '$'), false);
-assert.sameValue(Object.hasOwnProperty.call(C, 'accessor'), true);
-assert.sameValue(Object.hasOwnProperty.call(C, '$'), false);
-assert.sameValue(Object.hasOwnProperty.call(c, 'accessor'), true);
-assert.sameValue(Object.hasOwnProperty.call(c, '$'), true);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, 'accessor'),
+  "accessor doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, '$'),
+  "$ doesn't appear as an own property on C prototype"
+);
+assert(
+  Object.prototype.hasOwnProperty.call(C, 'accessor'),
+  "C constructor has an own property accessor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, '$'),
+  "$ doesn't appear as an own property on C constructor"
+);
+assert(
+  Object.prototype.hasOwnProperty.call(c, 'accessor'),
+  "C instance has an own property accessor"
+);
+assert(
+  Object.prototype.hasOwnProperty.call(c, '$'),
+  "C instance has an own property $"
+);
diff --git a/test/language/statements/class/elements/gen-private-method-static/yield-identifier-spread-strict.js b/test/language/statements/class/elements/gen-private-method-static/yield-identifier-spread-strict.js
index 6505041bd9..cac8b9f2b0 100644
--- a/test/language/statements/class/elements/gen-private-method-static/yield-identifier-spread-strict.js
+++ b/test/language/statements/class/elements/gen-private-method-static/yield-identifier-spread-strict.js
@@ -47,8 +47,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "Private field '#gen' does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "Private field '#gen' does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -57,5 +63,11 @@ var iter = C.gen();
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "Private field '#gen' does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "Private field '#gen' does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/gen-private-method-static/yield-identifier-strict.js b/test/language/statements/class/elements/gen-private-method-static/yield-identifier-strict.js
index 56982df2a5..b01dd326ef 100644
--- a/test/language/statements/class/elements/gen-private-method-static/yield-identifier-strict.js
+++ b/test/language/statements/class/elements/gen-private-method-static/yield-identifier-strict.js
@@ -38,8 +38,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "Private field '#gen' does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "Private field '#gen' does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -48,5 +54,11 @@ var iter = C.gen();
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "Private field '#gen' does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "Private field '#gen' does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/gen-private-method-static/yield-spread-arr-multiple.js b/test/language/statements/class/elements/gen-private-method-static/yield-spread-arr-multiple.js
index 9a097b5ba3..245bf66fb0 100644
--- a/test/language/statements/class/elements/gen-private-method-static/yield-spread-arr-multiple.js
+++ b/test/language/statements/class/elements/gen-private-method-static/yield-spread-arr-multiple.js
@@ -40,8 +40,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "Private field '#gen' does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "Private field '#gen' does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -55,5 +61,11 @@ assert.sameValue(item.done, false);
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "Private field '#gen' does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "Private field '#gen' does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/gen-private-method-static/yield-spread-arr-single.js b/test/language/statements/class/elements/gen-private-method-static/yield-spread-arr-single.js
index fc071f30ae..e3282e306c 100644
--- a/test/language/statements/class/elements/gen-private-method-static/yield-spread-arr-single.js
+++ b/test/language/statements/class/elements/gen-private-method-static/yield-spread-arr-single.js
@@ -37,8 +37,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "Private field '#gen' does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "Private field '#gen' does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -57,5 +63,11 @@ assert.sameValue(item.done, false);
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "Private field '#gen' does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "Private field '#gen' does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/gen-private-method-static/yield-spread-obj.js b/test/language/statements/class/elements/gen-private-method-static/yield-spread-obj.js
index e62db2acbf..87be13fae6 100644
--- a/test/language/statements/class/elements/gen-private-method-static/yield-spread-obj.js
+++ b/test/language/statements/class/elements/gen-private-method-static/yield-spread-obj.js
@@ -42,8 +42,14 @@ class C {
 }
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "Private field '#gen' does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "Private field '#gen' does not appear as an own property on C constructor"
+);
 
 var iter = C.gen();
 
@@ -60,5 +66,11 @@ assert.sameValue(item.done, false);
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "Private field '#gen' does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "Private field '#gen' does not appear as an own property on C constructor"
+);
diff --git a/test/language/statements/class/elements/gen-private-method/yield-identifier-spread-strict.js b/test/language/statements/class/elements/gen-private-method/yield-identifier-spread-strict.js
index 9e29ca671b..0af48ac9c2 100644
--- a/test/language/statements/class/elements/gen-private-method/yield-identifier-spread-strict.js
+++ b/test/language/statements/class/elements/gen-private-method/yield-identifier-spread-strict.js
@@ -49,9 +49,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "Private field '#gen' does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "Private field '#gen' does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "Private field '#gen' does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -60,6 +69,15 @@ var iter = c.gen();
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "Private field '#gen' does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "Private field '#gen' does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "Private field '#gen' does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/gen-private-method/yield-identifier-strict.js b/test/language/statements/class/elements/gen-private-method/yield-identifier-strict.js
index 06c84b9a7a..03eaf5e76a 100644
--- a/test/language/statements/class/elements/gen-private-method/yield-identifier-strict.js
+++ b/test/language/statements/class/elements/gen-private-method/yield-identifier-strict.js
@@ -40,9 +40,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "Private field '#gen' does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "Private field '#gen' does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "Private field '#gen' does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -51,6 +60,15 @@ var iter = c.gen();
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "Private field '#gen' does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "Private field '#gen' does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "Private field '#gen' does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/gen-private-method/yield-spread-arr-multiple.js b/test/language/statements/class/elements/gen-private-method/yield-spread-arr-multiple.js
index 9e49a38c0c..f1bbf76849 100644
--- a/test/language/statements/class/elements/gen-private-method/yield-spread-arr-multiple.js
+++ b/test/language/statements/class/elements/gen-private-method/yield-spread-arr-multiple.js
@@ -42,9 +42,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "Private field '#gen' does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "Private field '#gen' does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "Private field '#gen' does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -58,6 +67,15 @@ assert.sameValue(item.done, false);
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "Private field '#gen' does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "Private field '#gen' does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "Private field '#gen' does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/gen-private-method/yield-spread-arr-single.js b/test/language/statements/class/elements/gen-private-method/yield-spread-arr-single.js
index c1801eb476..097f52c863 100644
--- a/test/language/statements/class/elements/gen-private-method/yield-spread-arr-single.js
+++ b/test/language/statements/class/elements/gen-private-method/yield-spread-arr-single.js
@@ -39,9 +39,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "Private field '#gen' does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "Private field '#gen' does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "Private field '#gen' does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -60,6 +69,15 @@ assert.sameValue(item.done, false);
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "Private field '#gen' does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "Private field '#gen' does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "Private field '#gen' does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/gen-private-method/yield-spread-obj.js b/test/language/statements/class/elements/gen-private-method/yield-spread-obj.js
index beb712855a..d14ef8542f 100644
--- a/test/language/statements/class/elements/gen-private-method/yield-spread-obj.js
+++ b/test/language/statements/class/elements/gen-private-method/yield-spread-obj.js
@@ -44,9 +44,18 @@ class C {
 const c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "Private field '#gen' does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "Private field '#gen' does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "Private field '#gen' does not appear as an own property on C instance"
+);
 
 var iter = c.gen();
 
@@ -63,6 +72,15 @@ assert.sameValue(item.done, false);
 assert.sameValue(callCount, 1);
 
 // Test the private fields do not appear as properties after set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#gen"), false, 'Object.hasOwnProperty.call(C.prototype, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(C, "#gen"), false, 'Object.hasOwnProperty.call(C, "#gen")');
-assert.sameValue(Object.hasOwnProperty.call(c, "#gen"), false, 'Object.hasOwnProperty.call(c, "#gen")');
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "#gen"),
+  "Private field '#gen' does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "#gen"),
+  "Private field '#gen' does not appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "#gen"),
+  "Private field '#gen' does not appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/multiple-definitions-computed-names.js b/test/language/statements/class/elements/multiple-definitions-computed-names.js
index 1e147b85e4..4b987aa1c0 100644
--- a/test/language/statements/class/elements/multiple-definitions-computed-names.js
+++ b/test/language/statements/class/elements/multiple-definitions-computed-names.js
@@ -35,7 +35,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -45,7 +48,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(!
+  Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -55,8 +61,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -66,8 +78,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
@@ -76,8 +94,14 @@ verifyProperty(c, "bar", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -86,12 +110,27 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "10"),
+  "10 doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "10"),
+  "10 doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "10", {
   value: "meep",
@@ -100,8 +139,14 @@ verifyProperty(c, "10", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "not initialized", {
   value: undefined,
diff --git a/test/language/statements/class/elements/multiple-definitions-computed-symbol-names.js b/test/language/statements/class/elements/multiple-definitions-computed-symbol-names.js
index 1193f5fc73..c8e6ce8496 100644
--- a/test/language/statements/class/elements/multiple-definitions-computed-symbol-names.js
+++ b/test/language/statements/class/elements/multiple-definitions-computed-symbol-names.js
@@ -36,7 +36,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -46,7 +49,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(!
+  Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -56,8 +62,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -67,8 +79,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
@@ -77,8 +95,14 @@ verifyProperty(c, "bar", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, x), false);
-assert.sameValue(Object.hasOwnProperty.call(C, x), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, x),
+  "Symbol x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, x),
+  "Symbol x doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, x, {
   value: undefined,
@@ -87,8 +111,14 @@ verifyProperty(c, x, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
-assert.sameValue(Object.hasOwnProperty.call(C, y), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, y),
+  "Symbol y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, y),
+  "Symbol y doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, y, {
   value: 42,
@@ -97,10 +127,28 @@ verifyProperty(c, y, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "y"),
+  "y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "y"),
+  "y doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "y"),
+  "y doesn't appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/multiple-definitions-grammar-privatename-identifier-semantics-stringvalue.js b/test/language/statements/class/elements/multiple-definitions-grammar-privatename-identifier-semantics-stringvalue.js
index 6b74035d2b..8e5562547f 100644
--- a/test/language/statements/class/elements/multiple-definitions-grammar-privatename-identifier-semantics-stringvalue.js
+++ b/test/language/statements/class/elements/multiple-definitions-grammar-privatename-identifier-semantics-stringvalue.js
@@ -93,7 +93,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -103,7 +106,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(!
+  Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -113,8 +119,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -124,8 +136,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-definitions-literal-names-asi.js b/test/language/statements/class/elements/multiple-definitions-literal-names-asi.js
index a95cb67501..ffdcab088a 100644
--- a/test/language/statements/class/elements/multiple-definitions-literal-names-asi.js
+++ b/test/language/statements/class/elements/multiple-definitions-literal-names-asi.js
@@ -34,7 +34,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -44,7 +47,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(!
+  Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -54,8 +60,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -65,8 +77,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
@@ -75,8 +93,14 @@ verifyProperty(c, "bar", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -85,8 +109,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
diff --git a/test/language/statements/class/elements/multiple-definitions-literal-names.js b/test/language/statements/class/elements/multiple-definitions-literal-names.js
index 7b65f877db..4195bd563f 100644
--- a/test/language/statements/class/elements/multiple-definitions-literal-names.js
+++ b/test/language/statements/class/elements/multiple-definitions-literal-names.js
@@ -36,7 +36,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -46,7 +49,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(!
+  Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -56,8 +62,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -67,8 +79,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
@@ -77,8 +95,14 @@ verifyProperty(c, "bar", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -87,8 +111,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -97,8 +127,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: fn,
diff --git a/test/language/statements/class/elements/multiple-definitions-private-field-usage.js b/test/language/statements/class/elements/multiple-definitions-private-field-usage.js
index cc1f965e30..abef5d4e5d 100644
--- a/test/language/statements/class/elements/multiple-definitions-private-field-usage.js
+++ b/test/language/statements/class/elements/multiple-definitions-private-field-usage.js
@@ -36,7 +36,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -46,7 +49,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(!
+  Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -56,8 +62,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -67,8 +79,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-definitions-private-method-getter-usage.js b/test/language/statements/class/elements/multiple-definitions-private-method-getter-usage.js
index 5d54af16c9..2866c8315a 100644
--- a/test/language/statements/class/elements/multiple-definitions-private-method-getter-usage.js
+++ b/test/language/statements/class/elements/multiple-definitions-private-method-getter-usage.js
@@ -36,7 +36,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -46,7 +49,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(!
+  Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -56,8 +62,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -67,8 +79,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-definitions-private-method-usage.js b/test/language/statements/class/elements/multiple-definitions-private-method-usage.js
index 5a8d9b3c85..feabdc93ff 100644
--- a/test/language/statements/class/elements/multiple-definitions-private-method-usage.js
+++ b/test/language/statements/class/elements/multiple-definitions-private-method-usage.js
@@ -36,7 +36,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -46,7 +49,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(!
+  Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -56,8 +62,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -67,8 +79,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-definitions-private-names.js b/test/language/statements/class/elements/multiple-definitions-private-names.js
index f9038a3930..77880665b4 100644
--- a/test/language/statements/class/elements/multiple-definitions-private-names.js
+++ b/test/language/statements/class/elements/multiple-definitions-private-names.js
@@ -43,7 +43,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -53,7 +56,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(!
+  Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -63,8 +69,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -74,8 +86,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
@@ -85,18 +103,18 @@ verifyProperty(c, "bar", {
 });
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(c.x(), 42, "test 7");
 assert.sameValue(c.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 10");
diff --git a/test/language/statements/class/elements/multiple-definitions-rs-field-identifier-initializer.js b/test/language/statements/class/elements/multiple-definitions-rs-field-identifier-initializer.js
index 2e62d320b5..a6cbad4ae7 100644
--- a/test/language/statements/class/elements/multiple-definitions-rs-field-identifier-initializer.js
+++ b/test/language/statements/class/elements/multiple-definitions-rs-field-identifier-initializer.js
@@ -69,7 +69,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -79,7 +82,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(!
+  Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -89,8 +95,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -100,8 +112,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-definitions-rs-field-identifier.js b/test/language/statements/class/elements/multiple-definitions-rs-field-identifier.js
index b797157d39..8e98b30932 100644
--- a/test/language/statements/class/elements/multiple-definitions-rs-field-identifier.js
+++ b/test/language/statements/class/elements/multiple-definitions-rs-field-identifier.js
@@ -69,7 +69,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -79,7 +82,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(!
+  Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -89,8 +95,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -100,8 +112,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-definitions-rs-private-getter-alt.js b/test/language/statements/class/elements/multiple-definitions-rs-private-getter-alt.js
index 5458121120..a6d404b4d1 100644
--- a/test/language/statements/class/elements/multiple-definitions-rs-private-getter-alt.js
+++ b/test/language/statements/class/elements/multiple-definitions-rs-private-getter-alt.js
@@ -110,7 +110,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -120,7 +123,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(!
+  Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -130,8 +136,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -141,8 +153,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-definitions-rs-private-getter.js b/test/language/statements/class/elements/multiple-definitions-rs-private-getter.js
index 2267a25849..8efe02c96e 100644
--- a/test/language/statements/class/elements/multiple-definitions-rs-private-getter.js
+++ b/test/language/statements/class/elements/multiple-definitions-rs-private-getter.js
@@ -110,7 +110,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -120,7 +123,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(!
+  Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -130,8 +136,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -141,8 +153,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-definitions-rs-private-method-alt.js b/test/language/statements/class/elements/multiple-definitions-rs-private-method-alt.js
index f841b0348f..7db11cc5c1 100644
--- a/test/language/statements/class/elements/multiple-definitions-rs-private-method-alt.js
+++ b/test/language/statements/class/elements/multiple-definitions-rs-private-method-alt.js
@@ -109,7 +109,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -119,7 +122,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(!
+  Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -129,8 +135,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -140,8 +152,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-definitions-rs-private-method.js b/test/language/statements/class/elements/multiple-definitions-rs-private-method.js
index d48a492bb3..a59e289a26 100644
--- a/test/language/statements/class/elements/multiple-definitions-rs-private-method.js
+++ b/test/language/statements/class/elements/multiple-definitions-rs-private-method.js
@@ -109,7 +109,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -119,7 +122,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(!
+  Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -129,8 +135,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -140,8 +152,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-definitions-rs-private-setter-alt.js b/test/language/statements/class/elements/multiple-definitions-rs-private-setter-alt.js
index b0cf27838c..2167c18cb6 100644
--- a/test/language/statements/class/elements/multiple-definitions-rs-private-setter-alt.js
+++ b/test/language/statements/class/elements/multiple-definitions-rs-private-setter-alt.js
@@ -109,7 +109,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -119,7 +122,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(!
+  Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -129,8 +135,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -140,8 +152,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-definitions-rs-private-setter.js b/test/language/statements/class/elements/multiple-definitions-rs-private-setter.js
index 511dbc7c23..935d83ee01 100644
--- a/test/language/statements/class/elements/multiple-definitions-rs-private-setter.js
+++ b/test/language/statements/class/elements/multiple-definitions-rs-private-setter.js
@@ -109,7 +109,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -119,7 +122,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(!
+  Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -129,8 +135,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -140,8 +152,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-definitions-rs-privatename-identifier-alt.js b/test/language/statements/class/elements/multiple-definitions-rs-privatename-identifier-alt.js
index 7d2b5a3f0a..de874eafd2 100644
--- a/test/language/statements/class/elements/multiple-definitions-rs-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/multiple-definitions-rs-privatename-identifier-alt.js
@@ -90,7 +90,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -100,7 +103,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(!
+  Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -110,8 +116,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -121,8 +133,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-definitions-rs-privatename-identifier-initializer-alt.js b/test/language/statements/class/elements/multiple-definitions-rs-privatename-identifier-initializer-alt.js
index 96b48b366b..d5c55a9b4b 100644
--- a/test/language/statements/class/elements/multiple-definitions-rs-privatename-identifier-initializer-alt.js
+++ b/test/language/statements/class/elements/multiple-definitions-rs-privatename-identifier-initializer-alt.js
@@ -84,7 +84,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -94,7 +97,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(!
+  Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -104,8 +110,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -115,8 +127,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-definitions-rs-privatename-identifier-initializer.js b/test/language/statements/class/elements/multiple-definitions-rs-privatename-identifier-initializer.js
index d2c51cb212..b1651ee8f2 100644
--- a/test/language/statements/class/elements/multiple-definitions-rs-privatename-identifier-initializer.js
+++ b/test/language/statements/class/elements/multiple-definitions-rs-privatename-identifier-initializer.js
@@ -84,7 +84,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -94,7 +97,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(!
+  Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -104,8 +110,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -115,8 +127,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-definitions-rs-privatename-identifier.js b/test/language/statements/class/elements/multiple-definitions-rs-privatename-identifier.js
index a7838a229f..2f00d2320e 100644
--- a/test/language/statements/class/elements/multiple-definitions-rs-privatename-identifier.js
+++ b/test/language/statements/class/elements/multiple-definitions-rs-privatename-identifier.js
@@ -90,7 +90,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -100,7 +103,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(!
+  Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -110,8 +116,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -121,8 +133,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-definitions-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/statements/class/elements/multiple-definitions-rs-static-async-generator-method-privatename-identifier-alt.js
index ba5999e260..a5b9d79705 100644
--- a/test/language/statements/class/elements/multiple-definitions-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/multiple-definitions-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -106,7 +106,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -116,7 +119,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(!
+  Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -126,8 +132,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -137,8 +149,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-definitions-rs-static-async-generator-method-privatename-identifier.js b/test/language/statements/class/elements/multiple-definitions-rs-static-async-generator-method-privatename-identifier.js
index 06ec53a6c7..0821c25457 100644
--- a/test/language/statements/class/elements/multiple-definitions-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/multiple-definitions-rs-static-async-generator-method-privatename-identifier.js
@@ -106,7 +106,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -116,7 +119,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(!
+  Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -126,8 +132,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -137,8 +149,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-definitions-rs-static-async-method-privatename-identifier-alt.js b/test/language/statements/class/elements/multiple-definitions-rs-static-async-method-privatename-identifier-alt.js
index 44bf23e011..7bdbaa1285 100644
--- a/test/language/statements/class/elements/multiple-definitions-rs-static-async-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/multiple-definitions-rs-static-async-method-privatename-identifier-alt.js
@@ -106,7 +106,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -116,7 +119,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(!
+  Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -126,8 +132,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -137,8 +149,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-definitions-rs-static-async-method-privatename-identifier.js b/test/language/statements/class/elements/multiple-definitions-rs-static-async-method-privatename-identifier.js
index 267f5150b0..c191c885f0 100644
--- a/test/language/statements/class/elements/multiple-definitions-rs-static-async-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/multiple-definitions-rs-static-async-method-privatename-identifier.js
@@ -106,7 +106,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -116,7 +119,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(!
+  Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -126,8 +132,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -137,8 +149,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-definitions-rs-static-generator-method-privatename-identifier-alt.js b/test/language/statements/class/elements/multiple-definitions-rs-static-generator-method-privatename-identifier-alt.js
index 06b28454c8..cfb11a7226 100644
--- a/test/language/statements/class/elements/multiple-definitions-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/multiple-definitions-rs-static-generator-method-privatename-identifier-alt.js
@@ -106,7 +106,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -116,7 +119,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(!
+  Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -126,8 +132,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -137,8 +149,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-definitions-rs-static-generator-method-privatename-identifier.js b/test/language/statements/class/elements/multiple-definitions-rs-static-generator-method-privatename-identifier.js
index 2c02d1d2d0..41472cc387 100644
--- a/test/language/statements/class/elements/multiple-definitions-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/multiple-definitions-rs-static-generator-method-privatename-identifier.js
@@ -106,7 +106,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -116,7 +119,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(!
+  Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -126,8 +132,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -137,8 +149,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-definitions-rs-static-method-privatename-identifier-alt.js b/test/language/statements/class/elements/multiple-definitions-rs-static-method-privatename-identifier-alt.js
index 5c68f6779a..b8f63e3543 100644
--- a/test/language/statements/class/elements/multiple-definitions-rs-static-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/multiple-definitions-rs-static-method-privatename-identifier-alt.js
@@ -103,7 +103,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -113,7 +116,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(!
+  Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -123,8 +129,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -134,8 +146,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-definitions-rs-static-method-privatename-identifier.js b/test/language/statements/class/elements/multiple-definitions-rs-static-method-privatename-identifier.js
index d32b44a082..2a9d085393 100644
--- a/test/language/statements/class/elements/multiple-definitions-rs-static-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/multiple-definitions-rs-static-method-privatename-identifier.js
@@ -103,7 +103,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -113,7 +116,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(!
+  Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -123,8 +129,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -134,8 +146,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-definitions-rs-static-privatename-identifier-alt-by-classname.js b/test/language/statements/class/elements/multiple-definitions-rs-static-privatename-identifier-alt-by-classname.js
index eb9755ba03..0a59367c6d 100644
--- a/test/language/statements/class/elements/multiple-definitions-rs-static-privatename-identifier-alt-by-classname.js
+++ b/test/language/statements/class/elements/multiple-definitions-rs-static-privatename-identifier-alt-by-classname.js
@@ -91,7 +91,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -101,7 +104,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(!
+  Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -111,8 +117,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -122,8 +134,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-definitions-rs-static-privatename-identifier-alt.js b/test/language/statements/class/elements/multiple-definitions-rs-static-privatename-identifier-alt.js
index cb2eb4614c..696afeb419 100644
--- a/test/language/statements/class/elements/multiple-definitions-rs-static-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/multiple-definitions-rs-static-privatename-identifier-alt.js
@@ -91,7 +91,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -101,7 +104,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(!
+  Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -111,8 +117,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -122,8 +134,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-definitions-rs-static-privatename-identifier-by-classname.js b/test/language/statements/class/elements/multiple-definitions-rs-static-privatename-identifier-by-classname.js
index 822c726c9e..517ec7386a 100644
--- a/test/language/statements/class/elements/multiple-definitions-rs-static-privatename-identifier-by-classname.js
+++ b/test/language/statements/class/elements/multiple-definitions-rs-static-privatename-identifier-by-classname.js
@@ -91,7 +91,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -101,7 +104,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(!
+  Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -111,8 +117,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -122,8 +134,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-definitions-rs-static-privatename-identifier-initializer-alt-by-classname.js b/test/language/statements/class/elements/multiple-definitions-rs-static-privatename-identifier-initializer-alt-by-classname.js
index bce1b83cd8..656789b614 100644
--- a/test/language/statements/class/elements/multiple-definitions-rs-static-privatename-identifier-initializer-alt-by-classname.js
+++ b/test/language/statements/class/elements/multiple-definitions-rs-static-privatename-identifier-initializer-alt-by-classname.js
@@ -85,7 +85,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -95,7 +98,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(!
+  Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -105,8 +111,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -116,8 +128,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-definitions-rs-static-privatename-identifier-initializer-alt.js b/test/language/statements/class/elements/multiple-definitions-rs-static-privatename-identifier-initializer-alt.js
index bf5bf7a0f0..0cbacd991b 100644
--- a/test/language/statements/class/elements/multiple-definitions-rs-static-privatename-identifier-initializer-alt.js
+++ b/test/language/statements/class/elements/multiple-definitions-rs-static-privatename-identifier-initializer-alt.js
@@ -85,7 +85,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -95,7 +98,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(!
+  Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -105,8 +111,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -116,8 +128,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-definitions-rs-static-privatename-identifier-initializer.js b/test/language/statements/class/elements/multiple-definitions-rs-static-privatename-identifier-initializer.js
index 90377bb831..a9d86a7a5a 100644
--- a/test/language/statements/class/elements/multiple-definitions-rs-static-privatename-identifier-initializer.js
+++ b/test/language/statements/class/elements/multiple-definitions-rs-static-privatename-identifier-initializer.js
@@ -85,7 +85,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -95,7 +98,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(!
+  Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -105,8 +111,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -116,8 +128,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-definitions-rs-static-privatename-identifier.js b/test/language/statements/class/elements/multiple-definitions-rs-static-privatename-identifier.js
index b49d075685..a5eb835bb4 100644
--- a/test/language/statements/class/elements/multiple-definitions-rs-static-privatename-identifier.js
+++ b/test/language/statements/class/elements/multiple-definitions-rs-static-privatename-identifier.js
@@ -91,7 +91,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -101,7 +104,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(!
+  Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -111,8 +117,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -122,8 +134,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-definitions-static-private-fields.js b/test/language/statements/class/elements/multiple-definitions-static-private-fields.js
index aa6c5aa1c0..20353639a9 100644
--- a/test/language/statements/class/elements/multiple-definitions-static-private-fields.js
+++ b/test/language/statements/class/elements/multiple-definitions-static-private-fields.js
@@ -43,7 +43,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -53,7 +56,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(!
+  Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -63,8 +69,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -74,8 +86,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
@@ -85,18 +103,18 @@ verifyProperty(c, "bar", {
 });
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/statements/class/elements/multiple-definitions-static-private-methods-with-fields.js b/test/language/statements/class/elements/multiple-definitions-static-private-methods-with-fields.js
index 6b4af792e1..140a75a60f 100644
--- a/test/language/statements/class/elements/multiple-definitions-static-private-methods-with-fields.js
+++ b/test/language/statements/class/elements/multiple-definitions-static-private-methods-with-fields.js
@@ -49,7 +49,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -59,7 +62,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(!
+  Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -69,8 +75,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -80,8 +92,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
@@ -91,29 +109,29 @@ verifyProperty(c, "bar", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#xVal"), "test 7");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 8");
+assert(!Object.prototype.hasOwnProperty.call(c, "#xVal"), "test 9");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#yVal"), "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 11");
+assert(!Object.prototype.hasOwnProperty.call(c, "#yVal"), "test 12");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 13");
 assert.sameValue(C.y(), 43, "test 14");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 15");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 16");
 
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 17");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 18");
diff --git a/test/language/statements/class/elements/multiple-definitions-static-private-methods.js b/test/language/statements/class/elements/multiple-definitions-static-private-methods.js
index 13fa3ed783..635175c3c9 100644
--- a/test/language/statements/class/elements/multiple-definitions-static-private-methods.js
+++ b/test/language/statements/class/elements/multiple-definitions-static-private-methods.js
@@ -47,7 +47,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -57,7 +60,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(!
+  Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -67,8 +73,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -78,8 +90,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
@@ -89,18 +107,18 @@ verifyProperty(c, "bar", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/statements/class/elements/multiple-definitions-string-literal-names.js b/test/language/statements/class/elements/multiple-definitions-string-literal-names.js
index 677133e245..05d05cbd0a 100644
--- a/test/language/statements/class/elements/multiple-definitions-string-literal-names.js
+++ b/test/language/statements/class/elements/multiple-definitions-string-literal-names.js
@@ -34,7 +34,10 @@ class C {
 var c = new C();
 
 assert.sameValue(c.m(), 42);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -44,7 +47,10 @@ verifyProperty(C.prototype, "m", {
 });
 
 assert.sameValue(c.m2(), 39);
-assert.sameValue(Object.hasOwnProperty.call(c, "m2"), false);
+assert(!
+  Object.prototype.hasOwnProperty.call(c, "m2"),
+  "m2 doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m2, C.prototype.m2);
 
 verifyProperty(C.prototype, "m2", {
@@ -54,8 +60,14 @@ verifyProperty(C.prototype, "m2", {
 });
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -65,8 +77,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
@@ -75,8 +93,14 @@ verifyProperty(c, "bar", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -85,8 +109,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: undefined,
@@ -95,8 +125,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: 39,
@@ -105,8 +141,14 @@ verifyProperty(c, "c", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "d"),
+  "d does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "d"),
+  "d does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "d", {
   value: 42,
diff --git a/test/language/statements/class/elements/multiple-stacked-definitions-computed-names.js b/test/language/statements/class/elements/multiple-stacked-definitions-computed-names.js
index 6f9298a6c5..aa25b37c54 100644
--- a/test/language/statements/class/elements/multiple-stacked-definitions-computed-names.js
+++ b/test/language/statements/class/elements/multiple-stacked-definitions-computed-names.js
@@ -33,8 +33,14 @@ class C {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -44,8 +50,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
@@ -54,8 +66,14 @@ verifyProperty(c, "bar", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -64,12 +82,27 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "10"),
+  "10 doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "10"),
+  "10 doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "10", {
   value: "meep",
@@ -78,8 +111,14 @@ verifyProperty(c, "10", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "not initialized", {
   value: undefined,
diff --git a/test/language/statements/class/elements/multiple-stacked-definitions-computed-symbol-names.js b/test/language/statements/class/elements/multiple-stacked-definitions-computed-symbol-names.js
index af40f5b985..4ab23d9531 100644
--- a/test/language/statements/class/elements/multiple-stacked-definitions-computed-symbol-names.js
+++ b/test/language/statements/class/elements/multiple-stacked-definitions-computed-symbol-names.js
@@ -34,8 +34,14 @@ class C {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -45,8 +51,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
@@ -55,8 +67,14 @@ verifyProperty(c, "bar", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, x), false);
-assert.sameValue(Object.hasOwnProperty.call(C, x), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, x),
+  "Symbol x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, x),
+  "Symbol x doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, x, {
   value: undefined,
@@ -65,8 +83,14 @@ verifyProperty(c, x, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
-assert.sameValue(Object.hasOwnProperty.call(C, y), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, y),
+  "Symbol y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, y),
+  "Symbol y doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, y, {
   value: 42,
@@ -75,10 +99,28 @@ verifyProperty(c, y, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "y"),
+  "y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "y"),
+  "y doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "y"),
+  "y doesn't appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/multiple-stacked-definitions-grammar-privatename-identifier-semantics-stringvalue.js b/test/language/statements/class/elements/multiple-stacked-definitions-grammar-privatename-identifier-semantics-stringvalue.js
index 144baca5ba..7d87d7863d 100644
--- a/test/language/statements/class/elements/multiple-stacked-definitions-grammar-privatename-identifier-semantics-stringvalue.js
+++ b/test/language/statements/class/elements/multiple-stacked-definitions-grammar-privatename-identifier-semantics-stringvalue.js
@@ -91,8 +91,14 @@ class C {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -102,8 +108,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-stacked-definitions-literal-names-asi.js b/test/language/statements/class/elements/multiple-stacked-definitions-literal-names-asi.js
index 9cb5a7fa2d..8ee609c56a 100644
--- a/test/language/statements/class/elements/multiple-stacked-definitions-literal-names-asi.js
+++ b/test/language/statements/class/elements/multiple-stacked-definitions-literal-names-asi.js
@@ -32,8 +32,14 @@ class C {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -43,8 +49,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
@@ -53,8 +65,14 @@ verifyProperty(c, "bar", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -63,8 +81,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
diff --git a/test/language/statements/class/elements/multiple-stacked-definitions-literal-names.js b/test/language/statements/class/elements/multiple-stacked-definitions-literal-names.js
index d031a6b11a..daabc8f968 100644
--- a/test/language/statements/class/elements/multiple-stacked-definitions-literal-names.js
+++ b/test/language/statements/class/elements/multiple-stacked-definitions-literal-names.js
@@ -34,8 +34,14 @@ class C {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -45,8 +51,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
@@ -55,8 +67,14 @@ verifyProperty(c, "bar", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -65,8 +83,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -75,8 +99,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: fn,
diff --git a/test/language/statements/class/elements/multiple-stacked-definitions-private-field-usage.js b/test/language/statements/class/elements/multiple-stacked-definitions-private-field-usage.js
index 069eb034ee..733e4670c3 100644
--- a/test/language/statements/class/elements/multiple-stacked-definitions-private-field-usage.js
+++ b/test/language/statements/class/elements/multiple-stacked-definitions-private-field-usage.js
@@ -34,8 +34,14 @@ class C {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -45,8 +51,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-stacked-definitions-private-method-getter-usage.js b/test/language/statements/class/elements/multiple-stacked-definitions-private-method-getter-usage.js
index f28fbe327b..c9407b94b1 100644
--- a/test/language/statements/class/elements/multiple-stacked-definitions-private-method-getter-usage.js
+++ b/test/language/statements/class/elements/multiple-stacked-definitions-private-method-getter-usage.js
@@ -34,8 +34,14 @@ class C {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -45,8 +51,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-stacked-definitions-private-method-usage.js b/test/language/statements/class/elements/multiple-stacked-definitions-private-method-usage.js
index bb45bff6db..1cb1a499ad 100644
--- a/test/language/statements/class/elements/multiple-stacked-definitions-private-method-usage.js
+++ b/test/language/statements/class/elements/multiple-stacked-definitions-private-method-usage.js
@@ -34,8 +34,14 @@ class C {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -45,8 +51,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-stacked-definitions-private-names.js b/test/language/statements/class/elements/multiple-stacked-definitions-private-names.js
index 24a8606538..5d8b0a1ac7 100644
--- a/test/language/statements/class/elements/multiple-stacked-definitions-private-names.js
+++ b/test/language/statements/class/elements/multiple-stacked-definitions-private-names.js
@@ -41,8 +41,14 @@ class C {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -52,8 +58,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
@@ -63,18 +75,18 @@ verifyProperty(c, "bar", {
 });
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(c.x(), 42, "test 7");
 assert.sameValue(c.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 10");
diff --git a/test/language/statements/class/elements/multiple-stacked-definitions-rs-field-identifier-initializer.js b/test/language/statements/class/elements/multiple-stacked-definitions-rs-field-identifier-initializer.js
index 1ff0e76d79..f3802ec568 100644
--- a/test/language/statements/class/elements/multiple-stacked-definitions-rs-field-identifier-initializer.js
+++ b/test/language/statements/class/elements/multiple-stacked-definitions-rs-field-identifier-initializer.js
@@ -67,8 +67,14 @@ class C {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -78,8 +84,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-stacked-definitions-rs-field-identifier.js b/test/language/statements/class/elements/multiple-stacked-definitions-rs-field-identifier.js
index d369f799a3..19be308e37 100644
--- a/test/language/statements/class/elements/multiple-stacked-definitions-rs-field-identifier.js
+++ b/test/language/statements/class/elements/multiple-stacked-definitions-rs-field-identifier.js
@@ -67,8 +67,14 @@ class C {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -78,8 +84,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-stacked-definitions-rs-private-getter-alt.js b/test/language/statements/class/elements/multiple-stacked-definitions-rs-private-getter-alt.js
index 638b75562d..c854af2fab 100644
--- a/test/language/statements/class/elements/multiple-stacked-definitions-rs-private-getter-alt.js
+++ b/test/language/statements/class/elements/multiple-stacked-definitions-rs-private-getter-alt.js
@@ -108,8 +108,14 @@ class C {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -119,8 +125,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-stacked-definitions-rs-private-getter.js b/test/language/statements/class/elements/multiple-stacked-definitions-rs-private-getter.js
index 003e3b3332..ddfafea42d 100644
--- a/test/language/statements/class/elements/multiple-stacked-definitions-rs-private-getter.js
+++ b/test/language/statements/class/elements/multiple-stacked-definitions-rs-private-getter.js
@@ -108,8 +108,14 @@ class C {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -119,8 +125,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-stacked-definitions-rs-private-method-alt.js b/test/language/statements/class/elements/multiple-stacked-definitions-rs-private-method-alt.js
index 904cb6646a..fb9cf498df 100644
--- a/test/language/statements/class/elements/multiple-stacked-definitions-rs-private-method-alt.js
+++ b/test/language/statements/class/elements/multiple-stacked-definitions-rs-private-method-alt.js
@@ -107,8 +107,14 @@ class C {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -118,8 +124,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-stacked-definitions-rs-private-method.js b/test/language/statements/class/elements/multiple-stacked-definitions-rs-private-method.js
index de4cab2d46..923abff67c 100644
--- a/test/language/statements/class/elements/multiple-stacked-definitions-rs-private-method.js
+++ b/test/language/statements/class/elements/multiple-stacked-definitions-rs-private-method.js
@@ -107,8 +107,14 @@ class C {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -118,8 +124,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-stacked-definitions-rs-private-setter-alt.js b/test/language/statements/class/elements/multiple-stacked-definitions-rs-private-setter-alt.js
index db4dea470c..14711adb3a 100644
--- a/test/language/statements/class/elements/multiple-stacked-definitions-rs-private-setter-alt.js
+++ b/test/language/statements/class/elements/multiple-stacked-definitions-rs-private-setter-alt.js
@@ -107,8 +107,14 @@ class C {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -118,8 +124,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-stacked-definitions-rs-private-setter.js b/test/language/statements/class/elements/multiple-stacked-definitions-rs-private-setter.js
index ee0fd91abb..4ca7b72cfd 100644
--- a/test/language/statements/class/elements/multiple-stacked-definitions-rs-private-setter.js
+++ b/test/language/statements/class/elements/multiple-stacked-definitions-rs-private-setter.js
@@ -107,8 +107,14 @@ class C {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -118,8 +124,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-stacked-definitions-rs-privatename-identifier-alt.js b/test/language/statements/class/elements/multiple-stacked-definitions-rs-privatename-identifier-alt.js
index 871ddc150b..9038f62cc0 100644
--- a/test/language/statements/class/elements/multiple-stacked-definitions-rs-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/multiple-stacked-definitions-rs-privatename-identifier-alt.js
@@ -88,8 +88,14 @@ class C {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -99,8 +105,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-stacked-definitions-rs-privatename-identifier-initializer-alt.js b/test/language/statements/class/elements/multiple-stacked-definitions-rs-privatename-identifier-initializer-alt.js
index 50d8dd8f06..5990e62fe6 100644
--- a/test/language/statements/class/elements/multiple-stacked-definitions-rs-privatename-identifier-initializer-alt.js
+++ b/test/language/statements/class/elements/multiple-stacked-definitions-rs-privatename-identifier-initializer-alt.js
@@ -82,8 +82,14 @@ class C {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -93,8 +99,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-stacked-definitions-rs-privatename-identifier-initializer.js b/test/language/statements/class/elements/multiple-stacked-definitions-rs-privatename-identifier-initializer.js
index 2fbdcf235e..44020e2d4e 100644
--- a/test/language/statements/class/elements/multiple-stacked-definitions-rs-privatename-identifier-initializer.js
+++ b/test/language/statements/class/elements/multiple-stacked-definitions-rs-privatename-identifier-initializer.js
@@ -82,8 +82,14 @@ class C {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -93,8 +99,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-stacked-definitions-rs-privatename-identifier.js b/test/language/statements/class/elements/multiple-stacked-definitions-rs-privatename-identifier.js
index 43f84a8446..f7b9f87351 100644
--- a/test/language/statements/class/elements/multiple-stacked-definitions-rs-privatename-identifier.js
+++ b/test/language/statements/class/elements/multiple-stacked-definitions-rs-privatename-identifier.js
@@ -88,8 +88,14 @@ class C {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -99,8 +105,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-async-generator-method-privatename-identifier-alt.js
index 354dfaed11..d7236732fc 100644
--- a/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -104,8 +104,14 @@ class C {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -115,8 +121,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-async-generator-method-privatename-identifier.js b/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-async-generator-method-privatename-identifier.js
index 5b0bae44a8..30eb3f94bf 100644
--- a/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-async-generator-method-privatename-identifier.js
@@ -104,8 +104,14 @@ class C {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -115,8 +121,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-async-method-privatename-identifier-alt.js b/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-async-method-privatename-identifier-alt.js
index 4625038d7c..1030d1a8b9 100644
--- a/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-async-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-async-method-privatename-identifier-alt.js
@@ -104,8 +104,14 @@ class C {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -115,8 +121,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-async-method-privatename-identifier.js b/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-async-method-privatename-identifier.js
index cfb8228993..8c54bf9a49 100644
--- a/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-async-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-async-method-privatename-identifier.js
@@ -104,8 +104,14 @@ class C {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -115,8 +121,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-generator-method-privatename-identifier-alt.js b/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-generator-method-privatename-identifier-alt.js
index 80fe7c1ac4..9829a0a126 100644
--- a/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-generator-method-privatename-identifier-alt.js
@@ -104,8 +104,14 @@ class C {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -115,8 +121,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-generator-method-privatename-identifier.js b/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-generator-method-privatename-identifier.js
index bf758d5079..64d46382c5 100644
--- a/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-generator-method-privatename-identifier.js
@@ -104,8 +104,14 @@ class C {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -115,8 +121,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-method-privatename-identifier-alt.js b/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-method-privatename-identifier-alt.js
index fda7546901..a8478d396c 100644
--- a/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-method-privatename-identifier-alt.js
@@ -101,8 +101,14 @@ class C {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -112,8 +118,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-method-privatename-identifier.js b/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-method-privatename-identifier.js
index d27c710b70..fcb2ca3b18 100644
--- a/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-method-privatename-identifier.js
@@ -101,8 +101,14 @@ class C {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -112,8 +118,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-alt-by-classname.js b/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-alt-by-classname.js
index a48b0f0045..cc6444468e 100644
--- a/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-alt-by-classname.js
+++ b/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-alt-by-classname.js
@@ -89,8 +89,14 @@ class C {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -100,8 +106,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-alt.js b/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-alt.js
index d2e8f5b53c..f8070449ff 100644
--- a/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-alt.js
@@ -89,8 +89,14 @@ class C {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -100,8 +106,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-by-classname.js b/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-by-classname.js
index ead04ceeca..202cb3f3e3 100644
--- a/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-by-classname.js
+++ b/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-by-classname.js
@@ -89,8 +89,14 @@ class C {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -100,8 +106,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-initializer-alt-by-classname.js b/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-initializer-alt-by-classname.js
index 5e4d705eec..73e42b2e3f 100644
--- a/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-initializer-alt-by-classname.js
+++ b/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-initializer-alt-by-classname.js
@@ -83,8 +83,14 @@ class C {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -94,8 +100,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-initializer-alt.js b/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-initializer-alt.js
index 72c50fad37..8bb78a44e2 100644
--- a/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-initializer-alt.js
+++ b/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-initializer-alt.js
@@ -83,8 +83,14 @@ class C {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -94,8 +100,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-initializer.js b/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-initializer.js
index 62bf4299bf..6d83fc16b9 100644
--- a/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-initializer.js
+++ b/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier-initializer.js
@@ -83,8 +83,14 @@ class C {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -94,8 +100,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier.js b/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier.js
index b87bec7bf8..5f6c931c46 100644
--- a/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier.js
+++ b/test/language/statements/class/elements/multiple-stacked-definitions-rs-static-privatename-identifier.js
@@ -89,8 +89,14 @@ class C {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -100,8 +106,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
diff --git a/test/language/statements/class/elements/multiple-stacked-definitions-static-private-fields.js b/test/language/statements/class/elements/multiple-stacked-definitions-static-private-fields.js
index 4d4bc3a001..a0a5c8a7fa 100644
--- a/test/language/statements/class/elements/multiple-stacked-definitions-static-private-fields.js
+++ b/test/language/statements/class/elements/multiple-stacked-definitions-static-private-fields.js
@@ -41,8 +41,14 @@ class C {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -52,8 +58,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
@@ -63,18 +75,18 @@ verifyProperty(c, "bar", {
 });
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/statements/class/elements/multiple-stacked-definitions-static-private-methods-with-fields.js b/test/language/statements/class/elements/multiple-stacked-definitions-static-private-methods-with-fields.js
index d0904a0a67..55b851d0ca 100644
--- a/test/language/statements/class/elements/multiple-stacked-definitions-static-private-methods-with-fields.js
+++ b/test/language/statements/class/elements/multiple-stacked-definitions-static-private-methods-with-fields.js
@@ -47,8 +47,14 @@ class C {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -58,8 +64,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
@@ -69,29 +81,29 @@ verifyProperty(c, "bar", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#xVal"), "test 7");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 8");
+assert(!Object.prototype.hasOwnProperty.call(c, "#xVal"), "test 9");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#yVal"), "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 11");
+assert(!Object.prototype.hasOwnProperty.call(c, "#yVal"), "test 12");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 13");
 assert.sameValue(C.y(), 43, "test 14");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 15");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 16");
 
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 17");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 18");
diff --git a/test/language/statements/class/elements/multiple-stacked-definitions-static-private-methods.js b/test/language/statements/class/elements/multiple-stacked-definitions-static-private-methods.js
index f464e54701..0dbbb05873 100644
--- a/test/language/statements/class/elements/multiple-stacked-definitions-static-private-methods.js
+++ b/test/language/statements/class/elements/multiple-stacked-definitions-static-private-methods.js
@@ -45,8 +45,14 @@ class C {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -56,8 +62,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
@@ -67,18 +79,18 @@ verifyProperty(c, "bar", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/statements/class/elements/multiple-stacked-definitions-string-literal-names.js b/test/language/statements/class/elements/multiple-stacked-definitions-string-literal-names.js
index a8f56a2b4e..7ea48b0b65 100644
--- a/test/language/statements/class/elements/multiple-stacked-definitions-string-literal-names.js
+++ b/test/language/statements/class/elements/multiple-stacked-definitions-string-literal-names.js
@@ -32,8 +32,14 @@ class C {
 var c = new C();
 
 assert.sameValue(c.foo, "foobar");
-assert.sameValue(Object.hasOwnProperty.call(C, "foo"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "foo"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "foo"),
+  "foo doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "foo"),
+  "foo doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "foo", {
   value: "foobar",
@@ -43,8 +49,14 @@ verifyProperty(c, "foo", {
 });
 
 assert.sameValue(c.bar, "barbaz");
-assert.sameValue(Object.hasOwnProperty.call(C, "bar"), false);
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "bar"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "bar"),
+  "bar doesn't appear as an own property on the C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "bar"),
+  "bar doesn't appear as an own property on the C prototype"
+);
 
 verifyProperty(c, "bar", {
   value: "barbaz",
@@ -53,8 +65,14 @@ verifyProperty(c, "bar", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -63,8 +81,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: undefined,
@@ -73,8 +97,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: 39,
@@ -83,8 +113,14 @@ verifyProperty(c, "c", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "d"),
+  "d does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "d"),
+  "d does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "d", {
   value: 42,
diff --git a/test/language/statements/class/elements/new-no-sc-line-method-computed-names.js b/test/language/statements/class/elements/new-no-sc-line-method-computed-names.js
index 98dc4f774c..485cee9e71 100644
--- a/test/language/statements/class/elements/new-no-sc-line-method-computed-names.js
+++ b/test/language/statements/class/elements/new-no-sc-line-method-computed-names.js
@@ -33,7 +33,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -41,8 +44,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -51,12 +60,27 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "10"),
+  "10 doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "10"),
+  "10 doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "10", {
   value: "meep",
@@ -65,8 +89,14 @@ verifyProperty(c, "10", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "not initialized", {
   value: undefined,
diff --git a/test/language/statements/class/elements/new-no-sc-line-method-computed-symbol-names.js b/test/language/statements/class/elements/new-no-sc-line-method-computed-symbol-names.js
index a0bd1c1ac5..2bfb82f09d 100644
--- a/test/language/statements/class/elements/new-no-sc-line-method-computed-symbol-names.js
+++ b/test/language/statements/class/elements/new-no-sc-line-method-computed-symbol-names.js
@@ -34,7 +34,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -42,8 +45,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, x), false);
-assert.sameValue(Object.hasOwnProperty.call(C, x), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, x),
+  "Symbol x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, x),
+  "Symbol x doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, x, {
   value: undefined,
@@ -52,8 +61,14 @@ verifyProperty(c, x, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
-assert.sameValue(Object.hasOwnProperty.call(C, y), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, y),
+  "Symbol y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, y),
+  "Symbol y doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, y, {
   value: 42,
@@ -62,10 +77,28 @@ verifyProperty(c, y, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "y"),
+  "y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "y"),
+  "y doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "y"),
+  "y doesn't appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/new-no-sc-line-method-grammar-privatename-identifier-semantics-stringvalue.js b/test/language/statements/class/elements/new-no-sc-line-method-grammar-privatename-identifier-semantics-stringvalue.js
index 34ce12d739..311290abff 100644
--- a/test/language/statements/class/elements/new-no-sc-line-method-grammar-privatename-identifier-semantics-stringvalue.js
+++ b/test/language/statements/class/elements/new-no-sc-line-method-grammar-privatename-identifier-semantics-stringvalue.js
@@ -91,7 +91,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-no-sc-line-method-literal-names-asi.js b/test/language/statements/class/elements/new-no-sc-line-method-literal-names-asi.js
index 2d85e3a0e7..8e4c24bfc8 100644
--- a/test/language/statements/class/elements/new-no-sc-line-method-literal-names-asi.js
+++ b/test/language/statements/class/elements/new-no-sc-line-method-literal-names-asi.js
@@ -32,7 +32,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -40,8 +43,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -50,8 +59,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
diff --git a/test/language/statements/class/elements/new-no-sc-line-method-literal-names.js b/test/language/statements/class/elements/new-no-sc-line-method-literal-names.js
index 0d3046d78c..5a5067a237 100644
--- a/test/language/statements/class/elements/new-no-sc-line-method-literal-names.js
+++ b/test/language/statements/class/elements/new-no-sc-line-method-literal-names.js
@@ -34,7 +34,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -42,8 +45,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -52,8 +61,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -62,8 +77,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: fn,
diff --git a/test/language/statements/class/elements/new-no-sc-line-method-private-field-usage.js b/test/language/statements/class/elements/new-no-sc-line-method-private-field-usage.js
index fd02237085..ceb2923c77 100644
--- a/test/language/statements/class/elements/new-no-sc-line-method-private-field-usage.js
+++ b/test/language/statements/class/elements/new-no-sc-line-method-private-field-usage.js
@@ -34,7 +34,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-no-sc-line-method-private-method-getter-usage.js b/test/language/statements/class/elements/new-no-sc-line-method-private-method-getter-usage.js
index 06262bff41..5bef891787 100644
--- a/test/language/statements/class/elements/new-no-sc-line-method-private-method-getter-usage.js
+++ b/test/language/statements/class/elements/new-no-sc-line-method-private-method-getter-usage.js
@@ -34,7 +34,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-no-sc-line-method-private-method-usage.js b/test/language/statements/class/elements/new-no-sc-line-method-private-method-usage.js
index 4f0d61f109..275ada6430 100644
--- a/test/language/statements/class/elements/new-no-sc-line-method-private-method-usage.js
+++ b/test/language/statements/class/elements/new-no-sc-line-method-private-method-usage.js
@@ -34,7 +34,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-no-sc-line-method-private-names.js b/test/language/statements/class/elements/new-no-sc-line-method-private-names.js
index fe26d245c0..5da9fc15fc 100644
--- a/test/language/statements/class/elements/new-no-sc-line-method-private-names.js
+++ b/test/language/statements/class/elements/new-no-sc-line-method-private-names.js
@@ -41,7 +41,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -50,18 +53,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(c.x(), 42, "test 7");
 assert.sameValue(c.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 10");
diff --git a/test/language/statements/class/elements/new-no-sc-line-method-rs-field-identifier-initializer.js b/test/language/statements/class/elements/new-no-sc-line-method-rs-field-identifier-initializer.js
index eeff069695..fd7d145dc3 100644
--- a/test/language/statements/class/elements/new-no-sc-line-method-rs-field-identifier-initializer.js
+++ b/test/language/statements/class/elements/new-no-sc-line-method-rs-field-identifier-initializer.js
@@ -67,7 +67,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-no-sc-line-method-rs-field-identifier.js b/test/language/statements/class/elements/new-no-sc-line-method-rs-field-identifier.js
index 8705587a15..62f66cb232 100644
--- a/test/language/statements/class/elements/new-no-sc-line-method-rs-field-identifier.js
+++ b/test/language/statements/class/elements/new-no-sc-line-method-rs-field-identifier.js
@@ -67,7 +67,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-no-sc-line-method-rs-private-getter-alt.js b/test/language/statements/class/elements/new-no-sc-line-method-rs-private-getter-alt.js
index 99a113357c..b1817cad3d 100644
--- a/test/language/statements/class/elements/new-no-sc-line-method-rs-private-getter-alt.js
+++ b/test/language/statements/class/elements/new-no-sc-line-method-rs-private-getter-alt.js
@@ -108,7 +108,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-no-sc-line-method-rs-private-getter.js b/test/language/statements/class/elements/new-no-sc-line-method-rs-private-getter.js
index cc2948f350..09d193dbd4 100644
--- a/test/language/statements/class/elements/new-no-sc-line-method-rs-private-getter.js
+++ b/test/language/statements/class/elements/new-no-sc-line-method-rs-private-getter.js
@@ -108,7 +108,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-no-sc-line-method-rs-private-method-alt.js b/test/language/statements/class/elements/new-no-sc-line-method-rs-private-method-alt.js
index 005ed30427..8e2a5176f6 100644
--- a/test/language/statements/class/elements/new-no-sc-line-method-rs-private-method-alt.js
+++ b/test/language/statements/class/elements/new-no-sc-line-method-rs-private-method-alt.js
@@ -107,7 +107,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-no-sc-line-method-rs-private-method.js b/test/language/statements/class/elements/new-no-sc-line-method-rs-private-method.js
index c6c4f7fa02..bd97519ad9 100644
--- a/test/language/statements/class/elements/new-no-sc-line-method-rs-private-method.js
+++ b/test/language/statements/class/elements/new-no-sc-line-method-rs-private-method.js
@@ -107,7 +107,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-no-sc-line-method-rs-private-setter-alt.js b/test/language/statements/class/elements/new-no-sc-line-method-rs-private-setter-alt.js
index 6a2a8dec66..c3232a4cc7 100644
--- a/test/language/statements/class/elements/new-no-sc-line-method-rs-private-setter-alt.js
+++ b/test/language/statements/class/elements/new-no-sc-line-method-rs-private-setter-alt.js
@@ -107,7 +107,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-no-sc-line-method-rs-private-setter.js b/test/language/statements/class/elements/new-no-sc-line-method-rs-private-setter.js
index 49ac2488a4..1a73615016 100644
--- a/test/language/statements/class/elements/new-no-sc-line-method-rs-private-setter.js
+++ b/test/language/statements/class/elements/new-no-sc-line-method-rs-private-setter.js
@@ -107,7 +107,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-no-sc-line-method-rs-privatename-identifier-alt.js b/test/language/statements/class/elements/new-no-sc-line-method-rs-privatename-identifier-alt.js
index ac275031c8..376e869016 100644
--- a/test/language/statements/class/elements/new-no-sc-line-method-rs-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/new-no-sc-line-method-rs-privatename-identifier-alt.js
@@ -88,7 +88,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-no-sc-line-method-rs-privatename-identifier-initializer-alt.js b/test/language/statements/class/elements/new-no-sc-line-method-rs-privatename-identifier-initializer-alt.js
index 6aeeaca550..01560cfc6c 100644
--- a/test/language/statements/class/elements/new-no-sc-line-method-rs-privatename-identifier-initializer-alt.js
+++ b/test/language/statements/class/elements/new-no-sc-line-method-rs-privatename-identifier-initializer-alt.js
@@ -82,7 +82,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-no-sc-line-method-rs-privatename-identifier-initializer.js b/test/language/statements/class/elements/new-no-sc-line-method-rs-privatename-identifier-initializer.js
index 9d08cd1d53..875506cc61 100644
--- a/test/language/statements/class/elements/new-no-sc-line-method-rs-privatename-identifier-initializer.js
+++ b/test/language/statements/class/elements/new-no-sc-line-method-rs-privatename-identifier-initializer.js
@@ -82,7 +82,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-no-sc-line-method-rs-privatename-identifier.js b/test/language/statements/class/elements/new-no-sc-line-method-rs-privatename-identifier.js
index b18cb7e103..8fcf411f46 100644
--- a/test/language/statements/class/elements/new-no-sc-line-method-rs-privatename-identifier.js
+++ b/test/language/statements/class/elements/new-no-sc-line-method-rs-privatename-identifier.js
@@ -88,7 +88,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-no-sc-line-method-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/statements/class/elements/new-no-sc-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
index 6d137d1fe8..979d876a51 100644
--- a/test/language/statements/class/elements/new-no-sc-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/new-no-sc-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -104,7 +104,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-no-sc-line-method-rs-static-async-generator-method-privatename-identifier.js b/test/language/statements/class/elements/new-no-sc-line-method-rs-static-async-generator-method-privatename-identifier.js
index 915a1fb8cd..fc7ea5cf1d 100644
--- a/test/language/statements/class/elements/new-no-sc-line-method-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/new-no-sc-line-method-rs-static-async-generator-method-privatename-identifier.js
@@ -104,7 +104,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-no-sc-line-method-rs-static-async-method-privatename-identifier-alt.js b/test/language/statements/class/elements/new-no-sc-line-method-rs-static-async-method-privatename-identifier-alt.js
index 31bb7fb30b..120446884a 100644
--- a/test/language/statements/class/elements/new-no-sc-line-method-rs-static-async-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/new-no-sc-line-method-rs-static-async-method-privatename-identifier-alt.js
@@ -104,7 +104,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-no-sc-line-method-rs-static-async-method-privatename-identifier.js b/test/language/statements/class/elements/new-no-sc-line-method-rs-static-async-method-privatename-identifier.js
index 867491cae7..5ad2782956 100644
--- a/test/language/statements/class/elements/new-no-sc-line-method-rs-static-async-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/new-no-sc-line-method-rs-static-async-method-privatename-identifier.js
@@ -104,7 +104,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-no-sc-line-method-rs-static-generator-method-privatename-identifier-alt.js b/test/language/statements/class/elements/new-no-sc-line-method-rs-static-generator-method-privatename-identifier-alt.js
index b84c28ab5f..8cc9099ed1 100644
--- a/test/language/statements/class/elements/new-no-sc-line-method-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/new-no-sc-line-method-rs-static-generator-method-privatename-identifier-alt.js
@@ -104,7 +104,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-no-sc-line-method-rs-static-generator-method-privatename-identifier.js b/test/language/statements/class/elements/new-no-sc-line-method-rs-static-generator-method-privatename-identifier.js
index 02b478c4c8..62eb52cb92 100644
--- a/test/language/statements/class/elements/new-no-sc-line-method-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/new-no-sc-line-method-rs-static-generator-method-privatename-identifier.js
@@ -104,7 +104,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-no-sc-line-method-rs-static-method-privatename-identifier-alt.js b/test/language/statements/class/elements/new-no-sc-line-method-rs-static-method-privatename-identifier-alt.js
index 6738b1598f..8fbdd44736 100644
--- a/test/language/statements/class/elements/new-no-sc-line-method-rs-static-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/new-no-sc-line-method-rs-static-method-privatename-identifier-alt.js
@@ -101,7 +101,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-no-sc-line-method-rs-static-method-privatename-identifier.js b/test/language/statements/class/elements/new-no-sc-line-method-rs-static-method-privatename-identifier.js
index b5b6d7715c..b4aa3deb8c 100644
--- a/test/language/statements/class/elements/new-no-sc-line-method-rs-static-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/new-no-sc-line-method-rs-static-method-privatename-identifier.js
@@ -101,7 +101,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-alt-by-classname.js b/test/language/statements/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-alt-by-classname.js
index 66571a64d2..0898e4cf6f 100644
--- a/test/language/statements/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-alt-by-classname.js
+++ b/test/language/statements/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-alt-by-classname.js
@@ -89,7 +89,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-alt.js b/test/language/statements/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-alt.js
index 47f18bf99f..b749a4f71b 100644
--- a/test/language/statements/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-alt.js
@@ -89,7 +89,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-by-classname.js b/test/language/statements/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-by-classname.js
index 2ce450f3a8..bd157118aa 100644
--- a/test/language/statements/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-by-classname.js
+++ b/test/language/statements/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-by-classname.js
@@ -89,7 +89,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-initializer-alt-by-classname.js b/test/language/statements/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
index f31c3f8be1..53b3e41bce 100644
--- a/test/language/statements/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
+++ b/test/language/statements/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
@@ -83,7 +83,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-initializer-alt.js b/test/language/statements/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-initializer-alt.js
index 51d453b669..8eefdd5f1c 100644
--- a/test/language/statements/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-initializer-alt.js
+++ b/test/language/statements/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-initializer-alt.js
@@ -83,7 +83,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-initializer.js b/test/language/statements/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-initializer.js
index 54ed920419..0344b4272d 100644
--- a/test/language/statements/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-initializer.js
+++ b/test/language/statements/class/elements/new-no-sc-line-method-rs-static-privatename-identifier-initializer.js
@@ -83,7 +83,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-no-sc-line-method-rs-static-privatename-identifier.js b/test/language/statements/class/elements/new-no-sc-line-method-rs-static-privatename-identifier.js
index 2b2bacd4a9..840b93a9d5 100644
--- a/test/language/statements/class/elements/new-no-sc-line-method-rs-static-privatename-identifier.js
+++ b/test/language/statements/class/elements/new-no-sc-line-method-rs-static-privatename-identifier.js
@@ -89,7 +89,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-no-sc-line-method-static-private-fields.js b/test/language/statements/class/elements/new-no-sc-line-method-static-private-fields.js
index ed02a334c1..8e4f5532e4 100644
--- a/test/language/statements/class/elements/new-no-sc-line-method-static-private-fields.js
+++ b/test/language/statements/class/elements/new-no-sc-line-method-static-private-fields.js
@@ -41,7 +41,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -50,18 +53,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/statements/class/elements/new-no-sc-line-method-static-private-methods-with-fields.js b/test/language/statements/class/elements/new-no-sc-line-method-static-private-methods-with-fields.js
index 7489c96f86..1722590788 100644
--- a/test/language/statements/class/elements/new-no-sc-line-method-static-private-methods-with-fields.js
+++ b/test/language/statements/class/elements/new-no-sc-line-method-static-private-methods-with-fields.js
@@ -47,7 +47,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -56,29 +59,29 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#xVal"), "test 7");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 8");
+assert(!Object.prototype.hasOwnProperty.call(c, "#xVal"), "test 9");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#yVal"), "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 11");
+assert(!Object.prototype.hasOwnProperty.call(c, "#yVal"), "test 12");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 13");
 assert.sameValue(C.y(), 43, "test 14");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 15");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 16");
 
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 17");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 18");
diff --git a/test/language/statements/class/elements/new-no-sc-line-method-static-private-methods.js b/test/language/statements/class/elements/new-no-sc-line-method-static-private-methods.js
index b10d554947..59098410fd 100644
--- a/test/language/statements/class/elements/new-no-sc-line-method-static-private-methods.js
+++ b/test/language/statements/class/elements/new-no-sc-line-method-static-private-methods.js
@@ -45,7 +45,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -54,18 +57,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/statements/class/elements/new-no-sc-line-method-string-literal-names.js b/test/language/statements/class/elements/new-no-sc-line-method-string-literal-names.js
index a560cab6b3..5e4594c7f6 100644
--- a/test/language/statements/class/elements/new-no-sc-line-method-string-literal-names.js
+++ b/test/language/statements/class/elements/new-no-sc-line-method-string-literal-names.js
@@ -32,7 +32,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -40,8 +43,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -50,8 +59,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: undefined,
@@ -60,8 +75,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: 39,
@@ -70,8 +91,14 @@ verifyProperty(c, "c", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "d"),
+  "d does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "d"),
+  "d does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "d", {
   value: 42,
diff --git a/test/language/statements/class/elements/new-sc-line-gen-computed-names.js b/test/language/statements/class/elements/new-sc-line-gen-computed-names.js
index 33e877f038..17cca64f94 100644
--- a/test/language/statements/class/elements/new-sc-line-gen-computed-names.js
+++ b/test/language/statements/class/elements/new-sc-line-gen-computed-names.js
@@ -33,7 +33,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -41,8 +44,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -51,12 +60,27 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "10"),
+  "10 doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "10"),
+  "10 doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "10", {
   value: "meep",
@@ -65,8 +89,14 @@ verifyProperty(c, "10", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "not initialized", {
   value: undefined,
diff --git a/test/language/statements/class/elements/new-sc-line-gen-computed-symbol-names.js b/test/language/statements/class/elements/new-sc-line-gen-computed-symbol-names.js
index 7ffee05537..3f77e711ab 100644
--- a/test/language/statements/class/elements/new-sc-line-gen-computed-symbol-names.js
+++ b/test/language/statements/class/elements/new-sc-line-gen-computed-symbol-names.js
@@ -34,7 +34,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -42,8 +45,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, x), false);
-assert.sameValue(Object.hasOwnProperty.call(C, x), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, x),
+  "Symbol x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, x),
+  "Symbol x doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, x, {
   value: undefined,
@@ -52,8 +61,14 @@ verifyProperty(c, x, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
-assert.sameValue(Object.hasOwnProperty.call(C, y), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, y),
+  "Symbol y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, y),
+  "Symbol y doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, y, {
   value: 42,
@@ -62,10 +77,28 @@ verifyProperty(c, y, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "y"),
+  "y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "y"),
+  "y doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "y"),
+  "y doesn't appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/new-sc-line-gen-grammar-privatename-identifier-semantics-stringvalue.js b/test/language/statements/class/elements/new-sc-line-gen-grammar-privatename-identifier-semantics-stringvalue.js
index f6252b8dfd..fe81d85151 100644
--- a/test/language/statements/class/elements/new-sc-line-gen-grammar-privatename-identifier-semantics-stringvalue.js
+++ b/test/language/statements/class/elements/new-sc-line-gen-grammar-privatename-identifier-semantics-stringvalue.js
@@ -91,7 +91,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-gen-literal-names-asi.js b/test/language/statements/class/elements/new-sc-line-gen-literal-names-asi.js
index 5a840e86f8..1725cfbf01 100644
--- a/test/language/statements/class/elements/new-sc-line-gen-literal-names-asi.js
+++ b/test/language/statements/class/elements/new-sc-line-gen-literal-names-asi.js
@@ -32,7 +32,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -40,8 +43,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -50,8 +59,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
diff --git a/test/language/statements/class/elements/new-sc-line-gen-literal-names.js b/test/language/statements/class/elements/new-sc-line-gen-literal-names.js
index e44cf4643d..3961108faf 100644
--- a/test/language/statements/class/elements/new-sc-line-gen-literal-names.js
+++ b/test/language/statements/class/elements/new-sc-line-gen-literal-names.js
@@ -34,7 +34,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -42,8 +45,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -52,8 +61,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -62,8 +77,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: fn,
diff --git a/test/language/statements/class/elements/new-sc-line-gen-private-field-usage.js b/test/language/statements/class/elements/new-sc-line-gen-private-field-usage.js
index e4de195220..8b13b9389d 100644
--- a/test/language/statements/class/elements/new-sc-line-gen-private-field-usage.js
+++ b/test/language/statements/class/elements/new-sc-line-gen-private-field-usage.js
@@ -34,7 +34,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-gen-private-method-getter-usage.js b/test/language/statements/class/elements/new-sc-line-gen-private-method-getter-usage.js
index 298fedbbbb..cb65b57208 100644
--- a/test/language/statements/class/elements/new-sc-line-gen-private-method-getter-usage.js
+++ b/test/language/statements/class/elements/new-sc-line-gen-private-method-getter-usage.js
@@ -34,7 +34,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-gen-private-method-usage.js b/test/language/statements/class/elements/new-sc-line-gen-private-method-usage.js
index 113c872428..9da34eae3f 100644
--- a/test/language/statements/class/elements/new-sc-line-gen-private-method-usage.js
+++ b/test/language/statements/class/elements/new-sc-line-gen-private-method-usage.js
@@ -34,7 +34,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-gen-private-names.js b/test/language/statements/class/elements/new-sc-line-gen-private-names.js
index 883e8fc2e9..8795cf5e9d 100644
--- a/test/language/statements/class/elements/new-sc-line-gen-private-names.js
+++ b/test/language/statements/class/elements/new-sc-line-gen-private-names.js
@@ -41,7 +41,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -50,18 +53,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(c.x(), 42, "test 7");
 assert.sameValue(c.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 10");
diff --git a/test/language/statements/class/elements/new-sc-line-gen-rs-field-identifier-initializer.js b/test/language/statements/class/elements/new-sc-line-gen-rs-field-identifier-initializer.js
index 36dd1b7c58..df43422a60 100644
--- a/test/language/statements/class/elements/new-sc-line-gen-rs-field-identifier-initializer.js
+++ b/test/language/statements/class/elements/new-sc-line-gen-rs-field-identifier-initializer.js
@@ -67,7 +67,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-gen-rs-field-identifier.js b/test/language/statements/class/elements/new-sc-line-gen-rs-field-identifier.js
index c75e85d5a0..3914013a4e 100644
--- a/test/language/statements/class/elements/new-sc-line-gen-rs-field-identifier.js
+++ b/test/language/statements/class/elements/new-sc-line-gen-rs-field-identifier.js
@@ -67,7 +67,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-gen-rs-private-getter-alt.js b/test/language/statements/class/elements/new-sc-line-gen-rs-private-getter-alt.js
index 1a7780448c..cb06d042bb 100644
--- a/test/language/statements/class/elements/new-sc-line-gen-rs-private-getter-alt.js
+++ b/test/language/statements/class/elements/new-sc-line-gen-rs-private-getter-alt.js
@@ -108,7 +108,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-gen-rs-private-getter.js b/test/language/statements/class/elements/new-sc-line-gen-rs-private-getter.js
index a361fd5a93..b75b945474 100644
--- a/test/language/statements/class/elements/new-sc-line-gen-rs-private-getter.js
+++ b/test/language/statements/class/elements/new-sc-line-gen-rs-private-getter.js
@@ -108,7 +108,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-gen-rs-private-method-alt.js b/test/language/statements/class/elements/new-sc-line-gen-rs-private-method-alt.js
index 33553c99d2..60e84edf19 100644
--- a/test/language/statements/class/elements/new-sc-line-gen-rs-private-method-alt.js
+++ b/test/language/statements/class/elements/new-sc-line-gen-rs-private-method-alt.js
@@ -107,7 +107,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-gen-rs-private-method.js b/test/language/statements/class/elements/new-sc-line-gen-rs-private-method.js
index 1c477b54a5..6b3b6b89ee 100644
--- a/test/language/statements/class/elements/new-sc-line-gen-rs-private-method.js
+++ b/test/language/statements/class/elements/new-sc-line-gen-rs-private-method.js
@@ -107,7 +107,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-gen-rs-private-setter-alt.js b/test/language/statements/class/elements/new-sc-line-gen-rs-private-setter-alt.js
index f5cb18d74a..6fca0896de 100644
--- a/test/language/statements/class/elements/new-sc-line-gen-rs-private-setter-alt.js
+++ b/test/language/statements/class/elements/new-sc-line-gen-rs-private-setter-alt.js
@@ -107,7 +107,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-gen-rs-private-setter.js b/test/language/statements/class/elements/new-sc-line-gen-rs-private-setter.js
index 3b7a9decab..9749a87ae6 100644
--- a/test/language/statements/class/elements/new-sc-line-gen-rs-private-setter.js
+++ b/test/language/statements/class/elements/new-sc-line-gen-rs-private-setter.js
@@ -107,7 +107,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-gen-rs-privatename-identifier-alt.js b/test/language/statements/class/elements/new-sc-line-gen-rs-privatename-identifier-alt.js
index 1fe8a6c8e7..deca002f56 100644
--- a/test/language/statements/class/elements/new-sc-line-gen-rs-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/new-sc-line-gen-rs-privatename-identifier-alt.js
@@ -88,7 +88,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-gen-rs-privatename-identifier-initializer-alt.js b/test/language/statements/class/elements/new-sc-line-gen-rs-privatename-identifier-initializer-alt.js
index 244a7c81ad..3dcb6ca61f 100644
--- a/test/language/statements/class/elements/new-sc-line-gen-rs-privatename-identifier-initializer-alt.js
+++ b/test/language/statements/class/elements/new-sc-line-gen-rs-privatename-identifier-initializer-alt.js
@@ -82,7 +82,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-gen-rs-privatename-identifier-initializer.js b/test/language/statements/class/elements/new-sc-line-gen-rs-privatename-identifier-initializer.js
index ade006a32e..e0530cdba6 100644
--- a/test/language/statements/class/elements/new-sc-line-gen-rs-privatename-identifier-initializer.js
+++ b/test/language/statements/class/elements/new-sc-line-gen-rs-privatename-identifier-initializer.js
@@ -82,7 +82,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-gen-rs-privatename-identifier.js b/test/language/statements/class/elements/new-sc-line-gen-rs-privatename-identifier.js
index b60b2fbf5a..2a84ba7919 100644
--- a/test/language/statements/class/elements/new-sc-line-gen-rs-privatename-identifier.js
+++ b/test/language/statements/class/elements/new-sc-line-gen-rs-privatename-identifier.js
@@ -88,7 +88,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/statements/class/elements/new-sc-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js
index 4f41d8aaa0..3d84b8fc97 100644
--- a/test/language/statements/class/elements/new-sc-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/new-sc-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -104,7 +104,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-gen-rs-static-async-generator-method-privatename-identifier.js b/test/language/statements/class/elements/new-sc-line-gen-rs-static-async-generator-method-privatename-identifier.js
index 0e411292ce..ed0a11fb5b 100644
--- a/test/language/statements/class/elements/new-sc-line-gen-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/new-sc-line-gen-rs-static-async-generator-method-privatename-identifier.js
@@ -104,7 +104,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-gen-rs-static-async-method-privatename-identifier-alt.js b/test/language/statements/class/elements/new-sc-line-gen-rs-static-async-method-privatename-identifier-alt.js
index 0835308d20..a56e28f4a5 100644
--- a/test/language/statements/class/elements/new-sc-line-gen-rs-static-async-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/new-sc-line-gen-rs-static-async-method-privatename-identifier-alt.js
@@ -104,7 +104,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-gen-rs-static-async-method-privatename-identifier.js b/test/language/statements/class/elements/new-sc-line-gen-rs-static-async-method-privatename-identifier.js
index b70cf28963..cd1b64f18a 100644
--- a/test/language/statements/class/elements/new-sc-line-gen-rs-static-async-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/new-sc-line-gen-rs-static-async-method-privatename-identifier.js
@@ -104,7 +104,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-gen-rs-static-generator-method-privatename-identifier-alt.js b/test/language/statements/class/elements/new-sc-line-gen-rs-static-generator-method-privatename-identifier-alt.js
index 1fd06677dd..6dac540c63 100644
--- a/test/language/statements/class/elements/new-sc-line-gen-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/new-sc-line-gen-rs-static-generator-method-privatename-identifier-alt.js
@@ -104,7 +104,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-gen-rs-static-generator-method-privatename-identifier.js b/test/language/statements/class/elements/new-sc-line-gen-rs-static-generator-method-privatename-identifier.js
index 0560fa0c50..97c96a3ba8 100644
--- a/test/language/statements/class/elements/new-sc-line-gen-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/new-sc-line-gen-rs-static-generator-method-privatename-identifier.js
@@ -104,7 +104,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-gen-rs-static-method-privatename-identifier-alt.js b/test/language/statements/class/elements/new-sc-line-gen-rs-static-method-privatename-identifier-alt.js
index 890d573b1c..6bb19d6aa7 100644
--- a/test/language/statements/class/elements/new-sc-line-gen-rs-static-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/new-sc-line-gen-rs-static-method-privatename-identifier-alt.js
@@ -101,7 +101,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-gen-rs-static-method-privatename-identifier.js b/test/language/statements/class/elements/new-sc-line-gen-rs-static-method-privatename-identifier.js
index fb003bceac..f608b2d19c 100644
--- a/test/language/statements/class/elements/new-sc-line-gen-rs-static-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/new-sc-line-gen-rs-static-method-privatename-identifier.js
@@ -101,7 +101,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-gen-rs-static-privatename-identifier-alt-by-classname.js b/test/language/statements/class/elements/new-sc-line-gen-rs-static-privatename-identifier-alt-by-classname.js
index ce133f9e8f..40792f780a 100644
--- a/test/language/statements/class/elements/new-sc-line-gen-rs-static-privatename-identifier-alt-by-classname.js
+++ b/test/language/statements/class/elements/new-sc-line-gen-rs-static-privatename-identifier-alt-by-classname.js
@@ -89,7 +89,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-gen-rs-static-privatename-identifier-alt.js b/test/language/statements/class/elements/new-sc-line-gen-rs-static-privatename-identifier-alt.js
index f0890ca063..dfcda8f8d6 100644
--- a/test/language/statements/class/elements/new-sc-line-gen-rs-static-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/new-sc-line-gen-rs-static-privatename-identifier-alt.js
@@ -89,7 +89,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-gen-rs-static-privatename-identifier-by-classname.js b/test/language/statements/class/elements/new-sc-line-gen-rs-static-privatename-identifier-by-classname.js
index e94c6dd7c0..2fdb6938d1 100644
--- a/test/language/statements/class/elements/new-sc-line-gen-rs-static-privatename-identifier-by-classname.js
+++ b/test/language/statements/class/elements/new-sc-line-gen-rs-static-privatename-identifier-by-classname.js
@@ -89,7 +89,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js b/test/language/statements/class/elements/new-sc-line-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
index 680db87489..809f5ecc78 100644
--- a/test/language/statements/class/elements/new-sc-line-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
+++ b/test/language/statements/class/elements/new-sc-line-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
@@ -83,7 +83,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-gen-rs-static-privatename-identifier-initializer-alt.js b/test/language/statements/class/elements/new-sc-line-gen-rs-static-privatename-identifier-initializer-alt.js
index 5d0986bf27..2441ac6053 100644
--- a/test/language/statements/class/elements/new-sc-line-gen-rs-static-privatename-identifier-initializer-alt.js
+++ b/test/language/statements/class/elements/new-sc-line-gen-rs-static-privatename-identifier-initializer-alt.js
@@ -83,7 +83,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-gen-rs-static-privatename-identifier-initializer.js b/test/language/statements/class/elements/new-sc-line-gen-rs-static-privatename-identifier-initializer.js
index 385e8b965b..14ce30adbc 100644
--- a/test/language/statements/class/elements/new-sc-line-gen-rs-static-privatename-identifier-initializer.js
+++ b/test/language/statements/class/elements/new-sc-line-gen-rs-static-privatename-identifier-initializer.js
@@ -83,7 +83,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-gen-rs-static-privatename-identifier.js b/test/language/statements/class/elements/new-sc-line-gen-rs-static-privatename-identifier.js
index 80847e08b3..43623ee69d 100644
--- a/test/language/statements/class/elements/new-sc-line-gen-rs-static-privatename-identifier.js
+++ b/test/language/statements/class/elements/new-sc-line-gen-rs-static-privatename-identifier.js
@@ -89,7 +89,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-gen-static-private-fields.js b/test/language/statements/class/elements/new-sc-line-gen-static-private-fields.js
index cd08bbdd1c..5c6c999eda 100644
--- a/test/language/statements/class/elements/new-sc-line-gen-static-private-fields.js
+++ b/test/language/statements/class/elements/new-sc-line-gen-static-private-fields.js
@@ -41,7 +41,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -50,18 +53,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/statements/class/elements/new-sc-line-gen-static-private-methods-with-fields.js b/test/language/statements/class/elements/new-sc-line-gen-static-private-methods-with-fields.js
index 0ea5bd0cd4..8fdc1d3b8a 100644
--- a/test/language/statements/class/elements/new-sc-line-gen-static-private-methods-with-fields.js
+++ b/test/language/statements/class/elements/new-sc-line-gen-static-private-methods-with-fields.js
@@ -47,7 +47,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -56,29 +59,29 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#xVal"), "test 7");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 8");
+assert(!Object.prototype.hasOwnProperty.call(c, "#xVal"), "test 9");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#yVal"), "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 11");
+assert(!Object.prototype.hasOwnProperty.call(c, "#yVal"), "test 12");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 13");
 assert.sameValue(C.y(), 43, "test 14");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 15");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 16");
 
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 17");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 18");
diff --git a/test/language/statements/class/elements/new-sc-line-gen-static-private-methods.js b/test/language/statements/class/elements/new-sc-line-gen-static-private-methods.js
index e3ec231dc0..90223b6c4e 100644
--- a/test/language/statements/class/elements/new-sc-line-gen-static-private-methods.js
+++ b/test/language/statements/class/elements/new-sc-line-gen-static-private-methods.js
@@ -45,7 +45,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -54,18 +57,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/statements/class/elements/new-sc-line-gen-string-literal-names.js b/test/language/statements/class/elements/new-sc-line-gen-string-literal-names.js
index 02913c192d..56ab7cbf2c 100644
--- a/test/language/statements/class/elements/new-sc-line-gen-string-literal-names.js
+++ b/test/language/statements/class/elements/new-sc-line-gen-string-literal-names.js
@@ -32,7 +32,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -40,8 +43,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -50,8 +59,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: undefined,
@@ -60,8 +75,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: 39,
@@ -70,8 +91,14 @@ verifyProperty(c, "c", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "d"),
+  "d does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "d"),
+  "d does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "d", {
   value: 42,
diff --git a/test/language/statements/class/elements/new-sc-line-method-computed-names.js b/test/language/statements/class/elements/new-sc-line-method-computed-names.js
index 808e68c132..7c808c8b36 100644
--- a/test/language/statements/class/elements/new-sc-line-method-computed-names.js
+++ b/test/language/statements/class/elements/new-sc-line-method-computed-names.js
@@ -33,7 +33,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -41,8 +44,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -51,12 +60,27 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "10"),
+  "10 doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "10"),
+  "10 doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "10", {
   value: "meep",
@@ -65,8 +89,14 @@ verifyProperty(c, "10", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "not initialized", {
   value: undefined,
diff --git a/test/language/statements/class/elements/new-sc-line-method-computed-symbol-names.js b/test/language/statements/class/elements/new-sc-line-method-computed-symbol-names.js
index b33ec200cb..a9e1aa3664 100644
--- a/test/language/statements/class/elements/new-sc-line-method-computed-symbol-names.js
+++ b/test/language/statements/class/elements/new-sc-line-method-computed-symbol-names.js
@@ -34,7 +34,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -42,8 +45,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, x), false);
-assert.sameValue(Object.hasOwnProperty.call(C, x), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, x),
+  "Symbol x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, x),
+  "Symbol x doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, x, {
   value: undefined,
@@ -52,8 +61,14 @@ verifyProperty(c, x, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
-assert.sameValue(Object.hasOwnProperty.call(C, y), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, y),
+  "Symbol y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, y),
+  "Symbol y doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, y, {
   value: 42,
@@ -62,10 +77,28 @@ verifyProperty(c, y, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "y"),
+  "y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "y"),
+  "y doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "y"),
+  "y doesn't appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/new-sc-line-method-grammar-privatename-identifier-semantics-stringvalue.js b/test/language/statements/class/elements/new-sc-line-method-grammar-privatename-identifier-semantics-stringvalue.js
index 7d54f73113..9597fe63f0 100644
--- a/test/language/statements/class/elements/new-sc-line-method-grammar-privatename-identifier-semantics-stringvalue.js
+++ b/test/language/statements/class/elements/new-sc-line-method-grammar-privatename-identifier-semantics-stringvalue.js
@@ -91,7 +91,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-method-literal-names-asi.js b/test/language/statements/class/elements/new-sc-line-method-literal-names-asi.js
index 4d3e450ac1..baff9afbf4 100644
--- a/test/language/statements/class/elements/new-sc-line-method-literal-names-asi.js
+++ b/test/language/statements/class/elements/new-sc-line-method-literal-names-asi.js
@@ -32,7 +32,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -40,8 +43,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -50,8 +59,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
diff --git a/test/language/statements/class/elements/new-sc-line-method-literal-names.js b/test/language/statements/class/elements/new-sc-line-method-literal-names.js
index 1fb79f1719..78d99fc25f 100644
--- a/test/language/statements/class/elements/new-sc-line-method-literal-names.js
+++ b/test/language/statements/class/elements/new-sc-line-method-literal-names.js
@@ -34,7 +34,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -42,8 +45,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -52,8 +61,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -62,8 +77,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: fn,
diff --git a/test/language/statements/class/elements/new-sc-line-method-private-field-usage.js b/test/language/statements/class/elements/new-sc-line-method-private-field-usage.js
index 17c8532a02..4f64e374a1 100644
--- a/test/language/statements/class/elements/new-sc-line-method-private-field-usage.js
+++ b/test/language/statements/class/elements/new-sc-line-method-private-field-usage.js
@@ -34,7 +34,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-method-private-method-getter-usage.js b/test/language/statements/class/elements/new-sc-line-method-private-method-getter-usage.js
index 5205cb4884..94169c7f74 100644
--- a/test/language/statements/class/elements/new-sc-line-method-private-method-getter-usage.js
+++ b/test/language/statements/class/elements/new-sc-line-method-private-method-getter-usage.js
@@ -34,7 +34,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-method-private-method-usage.js b/test/language/statements/class/elements/new-sc-line-method-private-method-usage.js
index 3a81e315d6..4d9db2815e 100644
--- a/test/language/statements/class/elements/new-sc-line-method-private-method-usage.js
+++ b/test/language/statements/class/elements/new-sc-line-method-private-method-usage.js
@@ -34,7 +34,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-method-private-names.js b/test/language/statements/class/elements/new-sc-line-method-private-names.js
index bbbb1dd68e..dd3d102b64 100644
--- a/test/language/statements/class/elements/new-sc-line-method-private-names.js
+++ b/test/language/statements/class/elements/new-sc-line-method-private-names.js
@@ -41,7 +41,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -50,18 +53,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(c.x(), 42, "test 7");
 assert.sameValue(c.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 10");
diff --git a/test/language/statements/class/elements/new-sc-line-method-rs-field-identifier-initializer.js b/test/language/statements/class/elements/new-sc-line-method-rs-field-identifier-initializer.js
index f9291cd5e9..f8d520bb4d 100644
--- a/test/language/statements/class/elements/new-sc-line-method-rs-field-identifier-initializer.js
+++ b/test/language/statements/class/elements/new-sc-line-method-rs-field-identifier-initializer.js
@@ -67,7 +67,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-method-rs-field-identifier.js b/test/language/statements/class/elements/new-sc-line-method-rs-field-identifier.js
index fedc258ae1..09b73d97c3 100644
--- a/test/language/statements/class/elements/new-sc-line-method-rs-field-identifier.js
+++ b/test/language/statements/class/elements/new-sc-line-method-rs-field-identifier.js
@@ -67,7 +67,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-method-rs-private-getter-alt.js b/test/language/statements/class/elements/new-sc-line-method-rs-private-getter-alt.js
index 89d763ab95..e2d6e37a62 100644
--- a/test/language/statements/class/elements/new-sc-line-method-rs-private-getter-alt.js
+++ b/test/language/statements/class/elements/new-sc-line-method-rs-private-getter-alt.js
@@ -108,7 +108,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-method-rs-private-getter.js b/test/language/statements/class/elements/new-sc-line-method-rs-private-getter.js
index ff7c2aecf0..07f02d66f9 100644
--- a/test/language/statements/class/elements/new-sc-line-method-rs-private-getter.js
+++ b/test/language/statements/class/elements/new-sc-line-method-rs-private-getter.js
@@ -108,7 +108,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-method-rs-private-method-alt.js b/test/language/statements/class/elements/new-sc-line-method-rs-private-method-alt.js
index ddb220cc74..7627653f1d 100644
--- a/test/language/statements/class/elements/new-sc-line-method-rs-private-method-alt.js
+++ b/test/language/statements/class/elements/new-sc-line-method-rs-private-method-alt.js
@@ -107,7 +107,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-method-rs-private-method.js b/test/language/statements/class/elements/new-sc-line-method-rs-private-method.js
index d7edc34a5f..e12b13adf7 100644
--- a/test/language/statements/class/elements/new-sc-line-method-rs-private-method.js
+++ b/test/language/statements/class/elements/new-sc-line-method-rs-private-method.js
@@ -107,7 +107,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-method-rs-private-setter-alt.js b/test/language/statements/class/elements/new-sc-line-method-rs-private-setter-alt.js
index 3df0b79376..b9bd64d9a9 100644
--- a/test/language/statements/class/elements/new-sc-line-method-rs-private-setter-alt.js
+++ b/test/language/statements/class/elements/new-sc-line-method-rs-private-setter-alt.js
@@ -107,7 +107,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-method-rs-private-setter.js b/test/language/statements/class/elements/new-sc-line-method-rs-private-setter.js
index 0775caa13e..b745e7ac1c 100644
--- a/test/language/statements/class/elements/new-sc-line-method-rs-private-setter.js
+++ b/test/language/statements/class/elements/new-sc-line-method-rs-private-setter.js
@@ -107,7 +107,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-method-rs-privatename-identifier-alt.js b/test/language/statements/class/elements/new-sc-line-method-rs-privatename-identifier-alt.js
index 823ff68ae5..2238736b6a 100644
--- a/test/language/statements/class/elements/new-sc-line-method-rs-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/new-sc-line-method-rs-privatename-identifier-alt.js
@@ -88,7 +88,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-method-rs-privatename-identifier-initializer-alt.js b/test/language/statements/class/elements/new-sc-line-method-rs-privatename-identifier-initializer-alt.js
index 33d9d2415f..198d44a725 100644
--- a/test/language/statements/class/elements/new-sc-line-method-rs-privatename-identifier-initializer-alt.js
+++ b/test/language/statements/class/elements/new-sc-line-method-rs-privatename-identifier-initializer-alt.js
@@ -82,7 +82,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-method-rs-privatename-identifier-initializer.js b/test/language/statements/class/elements/new-sc-line-method-rs-privatename-identifier-initializer.js
index e32b5785b1..b5e41981fc 100644
--- a/test/language/statements/class/elements/new-sc-line-method-rs-privatename-identifier-initializer.js
+++ b/test/language/statements/class/elements/new-sc-line-method-rs-privatename-identifier-initializer.js
@@ -82,7 +82,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-method-rs-privatename-identifier.js b/test/language/statements/class/elements/new-sc-line-method-rs-privatename-identifier.js
index 649213a770..1fcf6a9398 100644
--- a/test/language/statements/class/elements/new-sc-line-method-rs-privatename-identifier.js
+++ b/test/language/statements/class/elements/new-sc-line-method-rs-privatename-identifier.js
@@ -88,7 +88,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-method-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/statements/class/elements/new-sc-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
index 0ce23d970d..f646bf5baf 100644
--- a/test/language/statements/class/elements/new-sc-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/new-sc-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -104,7 +104,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-method-rs-static-async-generator-method-privatename-identifier.js b/test/language/statements/class/elements/new-sc-line-method-rs-static-async-generator-method-privatename-identifier.js
index 517b6814a3..d62a6a753f 100644
--- a/test/language/statements/class/elements/new-sc-line-method-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/new-sc-line-method-rs-static-async-generator-method-privatename-identifier.js
@@ -104,7 +104,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-method-rs-static-async-method-privatename-identifier-alt.js b/test/language/statements/class/elements/new-sc-line-method-rs-static-async-method-privatename-identifier-alt.js
index aeb0167009..7c703e8f22 100644
--- a/test/language/statements/class/elements/new-sc-line-method-rs-static-async-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/new-sc-line-method-rs-static-async-method-privatename-identifier-alt.js
@@ -104,7 +104,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-method-rs-static-async-method-privatename-identifier.js b/test/language/statements/class/elements/new-sc-line-method-rs-static-async-method-privatename-identifier.js
index c98cdd655b..129b2293e7 100644
--- a/test/language/statements/class/elements/new-sc-line-method-rs-static-async-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/new-sc-line-method-rs-static-async-method-privatename-identifier.js
@@ -104,7 +104,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-method-rs-static-generator-method-privatename-identifier-alt.js b/test/language/statements/class/elements/new-sc-line-method-rs-static-generator-method-privatename-identifier-alt.js
index 59578ba270..27d8447d54 100644
--- a/test/language/statements/class/elements/new-sc-line-method-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/new-sc-line-method-rs-static-generator-method-privatename-identifier-alt.js
@@ -104,7 +104,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-method-rs-static-generator-method-privatename-identifier.js b/test/language/statements/class/elements/new-sc-line-method-rs-static-generator-method-privatename-identifier.js
index dda302ded1..ab7817a3df 100644
--- a/test/language/statements/class/elements/new-sc-line-method-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/new-sc-line-method-rs-static-generator-method-privatename-identifier.js
@@ -104,7 +104,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-method-rs-static-method-privatename-identifier-alt.js b/test/language/statements/class/elements/new-sc-line-method-rs-static-method-privatename-identifier-alt.js
index 5f5e15e907..9dc8a99879 100644
--- a/test/language/statements/class/elements/new-sc-line-method-rs-static-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/new-sc-line-method-rs-static-method-privatename-identifier-alt.js
@@ -101,7 +101,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-method-rs-static-method-privatename-identifier.js b/test/language/statements/class/elements/new-sc-line-method-rs-static-method-privatename-identifier.js
index 320fce677a..a6ff6f6ad9 100644
--- a/test/language/statements/class/elements/new-sc-line-method-rs-static-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/new-sc-line-method-rs-static-method-privatename-identifier.js
@@ -101,7 +101,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-method-rs-static-privatename-identifier-alt-by-classname.js b/test/language/statements/class/elements/new-sc-line-method-rs-static-privatename-identifier-alt-by-classname.js
index 6693886c8a..83c5ff75ae 100644
--- a/test/language/statements/class/elements/new-sc-line-method-rs-static-privatename-identifier-alt-by-classname.js
+++ b/test/language/statements/class/elements/new-sc-line-method-rs-static-privatename-identifier-alt-by-classname.js
@@ -89,7 +89,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-method-rs-static-privatename-identifier-alt.js b/test/language/statements/class/elements/new-sc-line-method-rs-static-privatename-identifier-alt.js
index fe1c11dd94..e44799a280 100644
--- a/test/language/statements/class/elements/new-sc-line-method-rs-static-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/new-sc-line-method-rs-static-privatename-identifier-alt.js
@@ -89,7 +89,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-method-rs-static-privatename-identifier-by-classname.js b/test/language/statements/class/elements/new-sc-line-method-rs-static-privatename-identifier-by-classname.js
index 11f1158d18..1f374e8979 100644
--- a/test/language/statements/class/elements/new-sc-line-method-rs-static-privatename-identifier-by-classname.js
+++ b/test/language/statements/class/elements/new-sc-line-method-rs-static-privatename-identifier-by-classname.js
@@ -89,7 +89,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-method-rs-static-privatename-identifier-initializer-alt-by-classname.js b/test/language/statements/class/elements/new-sc-line-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
index bc85546b99..c19983de7f 100644
--- a/test/language/statements/class/elements/new-sc-line-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
+++ b/test/language/statements/class/elements/new-sc-line-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
@@ -83,7 +83,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-method-rs-static-privatename-identifier-initializer-alt.js b/test/language/statements/class/elements/new-sc-line-method-rs-static-privatename-identifier-initializer-alt.js
index 29209a436f..45f21f78e4 100644
--- a/test/language/statements/class/elements/new-sc-line-method-rs-static-privatename-identifier-initializer-alt.js
+++ b/test/language/statements/class/elements/new-sc-line-method-rs-static-privatename-identifier-initializer-alt.js
@@ -83,7 +83,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-method-rs-static-privatename-identifier-initializer.js b/test/language/statements/class/elements/new-sc-line-method-rs-static-privatename-identifier-initializer.js
index 8c46f8c1c5..26b9565638 100644
--- a/test/language/statements/class/elements/new-sc-line-method-rs-static-privatename-identifier-initializer.js
+++ b/test/language/statements/class/elements/new-sc-line-method-rs-static-privatename-identifier-initializer.js
@@ -83,7 +83,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-method-rs-static-privatename-identifier.js b/test/language/statements/class/elements/new-sc-line-method-rs-static-privatename-identifier.js
index 81c47b6400..4ab59ed6c9 100644
--- a/test/language/statements/class/elements/new-sc-line-method-rs-static-privatename-identifier.js
+++ b/test/language/statements/class/elements/new-sc-line-method-rs-static-privatename-identifier.js
@@ -89,7 +89,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/new-sc-line-method-static-private-fields.js b/test/language/statements/class/elements/new-sc-line-method-static-private-fields.js
index cbec48dadf..cade9d7a8d 100644
--- a/test/language/statements/class/elements/new-sc-line-method-static-private-fields.js
+++ b/test/language/statements/class/elements/new-sc-line-method-static-private-fields.js
@@ -41,7 +41,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -50,18 +53,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/statements/class/elements/new-sc-line-method-static-private-methods-with-fields.js b/test/language/statements/class/elements/new-sc-line-method-static-private-methods-with-fields.js
index d30cf060a5..3bec867c6a 100644
--- a/test/language/statements/class/elements/new-sc-line-method-static-private-methods-with-fields.js
+++ b/test/language/statements/class/elements/new-sc-line-method-static-private-methods-with-fields.js
@@ -47,7 +47,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -56,29 +59,29 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#xVal"), "test 7");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 8");
+assert(!Object.prototype.hasOwnProperty.call(c, "#xVal"), "test 9");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#yVal"), "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 11");
+assert(!Object.prototype.hasOwnProperty.call(c, "#yVal"), "test 12");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 13");
 assert.sameValue(C.y(), 43, "test 14");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 15");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 16");
 
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 17");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 18");
diff --git a/test/language/statements/class/elements/new-sc-line-method-static-private-methods.js b/test/language/statements/class/elements/new-sc-line-method-static-private-methods.js
index dbd9543c14..89bf3e8f98 100644
--- a/test/language/statements/class/elements/new-sc-line-method-static-private-methods.js
+++ b/test/language/statements/class/elements/new-sc-line-method-static-private-methods.js
@@ -45,7 +45,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -54,18 +57,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/statements/class/elements/new-sc-line-method-string-literal-names.js b/test/language/statements/class/elements/new-sc-line-method-string-literal-names.js
index 5e344dae4e..4d81a139ef 100644
--- a/test/language/statements/class/elements/new-sc-line-method-string-literal-names.js
+++ b/test/language/statements/class/elements/new-sc-line-method-string-literal-names.js
@@ -32,7 +32,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -40,8 +43,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -50,8 +59,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: undefined,
@@ -60,8 +75,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: 39,
@@ -70,8 +91,14 @@ verifyProperty(c, "c", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "d"),
+  "d does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "d"),
+  "d does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "d", {
   value: 42,
diff --git a/test/language/statements/class/elements/redeclaration-symbol.js b/test/language/statements/class/elements/redeclaration-symbol.js
index 6726e9b49c..ea0d768bec 100644
--- a/test/language/statements/class/elements/redeclaration-symbol.js
+++ b/test/language/statements/class/elements/redeclaration-symbol.js
@@ -42,8 +42,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
-assert.sameValue(Object.hasOwnProperty.call(C, y), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, y),
+  "y does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, y),
+  "y does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, y, {
   value: "same_value",
diff --git a/test/language/statements/class/elements/redeclaration.js b/test/language/statements/class/elements/redeclaration.js
index c3fc519c3d..949f8bb045 100644
--- a/test/language/statements/class/elements/redeclaration.js
+++ b/test/language/statements/class/elements/redeclaration.js
@@ -42,8 +42,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "y"),
+  "y does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "y"),
+  "y does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "y", {
   value: "same_value",
diff --git a/test/language/statements/class/elements/regular-definitions-computed-names.js b/test/language/statements/class/elements/regular-definitions-computed-names.js
index 55b0502c8d..398c5f92f3 100644
--- a/test/language/statements/class/elements/regular-definitions-computed-names.js
+++ b/test/language/statements/class/elements/regular-definitions-computed-names.js
@@ -30,8 +30,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -40,12 +46,27 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "10"),
+  "10 doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "10"),
+  "10 doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "10", {
   value: "meep",
@@ -54,8 +75,14 @@ verifyProperty(c, "10", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "not initialized", {
   value: undefined,
diff --git a/test/language/statements/class/elements/regular-definitions-computed-symbol-names.js b/test/language/statements/class/elements/regular-definitions-computed-symbol-names.js
index 90fb8b78ab..9307600df8 100644
--- a/test/language/statements/class/elements/regular-definitions-computed-symbol-names.js
+++ b/test/language/statements/class/elements/regular-definitions-computed-symbol-names.js
@@ -31,8 +31,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, x), false);
-assert.sameValue(Object.hasOwnProperty.call(C, x), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, x),
+  "Symbol x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, x),
+  "Symbol x doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, x, {
   value: undefined,
@@ -41,8 +47,14 @@ verifyProperty(c, x, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
-assert.sameValue(Object.hasOwnProperty.call(C, y), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, y),
+  "Symbol y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, y),
+  "Symbol y doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, y, {
   value: 42,
@@ -51,10 +63,28 @@ verifyProperty(c, y, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "y"),
+  "y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "y"),
+  "y doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "y"),
+  "y doesn't appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/regular-definitions-literal-names-asi.js b/test/language/statements/class/elements/regular-definitions-literal-names-asi.js
index 516b9d2b7a..a28164f019 100644
--- a/test/language/statements/class/elements/regular-definitions-literal-names-asi.js
+++ b/test/language/statements/class/elements/regular-definitions-literal-names-asi.js
@@ -29,8 +29,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -39,8 +45,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
diff --git a/test/language/statements/class/elements/regular-definitions-literal-names.js b/test/language/statements/class/elements/regular-definitions-literal-names.js
index 7187ebc587..a24345a4d6 100644
--- a/test/language/statements/class/elements/regular-definitions-literal-names.js
+++ b/test/language/statements/class/elements/regular-definitions-literal-names.js
@@ -31,8 +31,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -41,8 +47,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -51,8 +63,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: fn,
diff --git a/test/language/statements/class/elements/regular-definitions-private-names.js b/test/language/statements/class/elements/regular-definitions-private-names.js
index b05b0b0408..9b581884ee 100644
--- a/test/language/statements/class/elements/regular-definitions-private-names.js
+++ b/test/language/statements/class/elements/regular-definitions-private-names.js
@@ -38,18 +38,18 @@ class C {
 var c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(c.x(), 42, "test 7");
 assert.sameValue(c.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 10");
diff --git a/test/language/statements/class/elements/regular-definitions-static-private-fields.js b/test/language/statements/class/elements/regular-definitions-static-private-fields.js
index d7e354aff3..1d0e31711d 100644
--- a/test/language/statements/class/elements/regular-definitions-static-private-fields.js
+++ b/test/language/statements/class/elements/regular-definitions-static-private-fields.js
@@ -38,18 +38,18 @@ class C {
 var c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/statements/class/elements/regular-definitions-static-private-methods-with-fields.js b/test/language/statements/class/elements/regular-definitions-static-private-methods-with-fields.js
index 7f688e6f05..82a8eb3e77 100644
--- a/test/language/statements/class/elements/regular-definitions-static-private-methods-with-fields.js
+++ b/test/language/statements/class/elements/regular-definitions-static-private-methods-with-fields.js
@@ -44,29 +44,29 @@ class C {
 var c = new C();
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#xVal"), "test 7");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 8");
+assert(!Object.prototype.hasOwnProperty.call(c, "#xVal"), "test 9");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#yVal"), "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 11");
+assert(!Object.prototype.hasOwnProperty.call(c, "#yVal"), "test 12");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 13");
 assert.sameValue(C.y(), 43, "test 14");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 15");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 16");
 
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 17");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 18");
diff --git a/test/language/statements/class/elements/regular-definitions-static-private-methods.js b/test/language/statements/class/elements/regular-definitions-static-private-methods.js
index a887bbd0f6..f3d2136da3 100644
--- a/test/language/statements/class/elements/regular-definitions-static-private-methods.js
+++ b/test/language/statements/class/elements/regular-definitions-static-private-methods.js
@@ -42,18 +42,18 @@ class C {
 var c = new C();
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/statements/class/elements/regular-definitions-string-literal-names.js b/test/language/statements/class/elements/regular-definitions-string-literal-names.js
index c9c9d04445..f69a0227ba 100644
--- a/test/language/statements/class/elements/regular-definitions-string-literal-names.js
+++ b/test/language/statements/class/elements/regular-definitions-string-literal-names.js
@@ -29,8 +29,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -39,8 +45,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: undefined,
@@ -49,8 +61,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: 39,
@@ -59,8 +77,14 @@ verifyProperty(c, "c", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "d"),
+  "d does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "d"),
+  "d does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "d", {
   value: 42,
diff --git a/test/language/statements/class/elements/same-line-async-gen-computed-names.js b/test/language/statements/class/elements/same-line-async-gen-computed-names.js
index 60a9218b6c..cb3e7e701d 100644
--- a/test/language/statements/class/elements/same-line-async-gen-computed-names.js
+++ b/test/language/statements/class/elements/same-line-async-gen-computed-names.js
@@ -30,7 +30,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -50,8 +53,14 @@ c.m().next().then(function(v) {
         throw new Test262Error('Test262:AsyncTestFailure')
       }
     }
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+      "b doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "b"),
+      "b doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "b", {
       value: 42,
@@ -60,12 +69,27 @@ c.m().next().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-    assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+      "x doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "x"),
+      "x doesn't appear as an own property on C constructor"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(c, "x"),
+      "x doesn't appear as an own property on C instance"
+    );
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "10"),
+      "10 doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "10"),
+      "10 doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "10", {
       value: "meep",
@@ -74,8 +98,14 @@ c.m().next().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "not initialized"),
+      "'not initialized' doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "not initialized"),
+      "'not initialized' doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "not initialized", {
       value: undefined,
diff --git a/test/language/statements/class/elements/same-line-async-gen-computed-symbol-names.js b/test/language/statements/class/elements/same-line-async-gen-computed-symbol-names.js
index ce357bf83a..ee6144a97f 100644
--- a/test/language/statements/class/elements/same-line-async-gen-computed-symbol-names.js
+++ b/test/language/statements/class/elements/same-line-async-gen-computed-symbol-names.js
@@ -31,7 +31,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -51,8 +54,14 @@ c.m().next().then(function(v) {
         throw new Test262Error('Test262:AsyncTestFailure')
       }
     }
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, x), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, x), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, x),
+      "Symbol x doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, x),
+      "Symbol x doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, x, {
       value: undefined,
@@ -61,8 +70,14 @@ c.m().next().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, y), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, y),
+      "Symbol y doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, y),
+      "Symbol y doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, y, {
       value: 42,
@@ -71,13 +86,31 @@ c.m().next().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-    assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+      "x doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "x"),
+      "x doesn't appear as an own property on C constructor"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(c, "x"),
+      "x doesn't appear as an own property on C instance"
+    );
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
-    assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "y"),
+      "y doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "y"),
+      "y doesn't appear as an own property on C constructor"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(c, "y"),
+      "y doesn't appear as an own property on C instance"
+    );
   }
 
   return Promise.resolve(assertions());
diff --git a/test/language/statements/class/elements/same-line-async-gen-grammar-privatename-identifier-semantics-stringvalue.js b/test/language/statements/class/elements/same-line-async-gen-grammar-privatename-identifier-semantics-stringvalue.js
index 56231f6a91..d4da5d881c 100644
--- a/test/language/statements/class/elements/same-line-async-gen-grammar-privatename-identifier-semantics-stringvalue.js
+++ b/test/language/statements/class/elements/same-line-async-gen-grammar-privatename-identifier-semantics-stringvalue.js
@@ -88,7 +88,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-gen-literal-names-asi.js b/test/language/statements/class/elements/same-line-async-gen-literal-names-asi.js
index a03a7ee61c..591316f2e7 100644
--- a/test/language/statements/class/elements/same-line-async-gen-literal-names-asi.js
+++ b/test/language/statements/class/elements/same-line-async-gen-literal-names-asi.js
@@ -29,7 +29,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -49,8 +52,14 @@ c.m().next().then(function(v) {
         throw new Test262Error('Test262:AsyncTestFailure')
       }
     }
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+      "a doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "a"),
+      "a doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "a", {
       value: undefined,
@@ -59,8 +68,14 @@ c.m().next().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+      "b doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "b"),
+      "b doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "b", {
       value: 42,
diff --git a/test/language/statements/class/elements/same-line-async-gen-literal-names.js b/test/language/statements/class/elements/same-line-async-gen-literal-names.js
index d81bff8029..64625b996e 100644
--- a/test/language/statements/class/elements/same-line-async-gen-literal-names.js
+++ b/test/language/statements/class/elements/same-line-async-gen-literal-names.js
@@ -31,7 +31,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -51,8 +54,14 @@ c.m().next().then(function(v) {
         throw new Test262Error('Test262:AsyncTestFailure')
       }
     }
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+      "a doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "a"),
+      "a doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "a", {
       value: undefined,
@@ -61,8 +70,14 @@ c.m().next().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+      "b doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "b"),
+      "b doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "b", {
       value: 42,
@@ -71,8 +86,14 @@ c.m().next().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+      "c doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "c"),
+      "c doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "c", {
       value: fn,
diff --git a/test/language/statements/class/elements/same-line-async-gen-private-field-usage.js b/test/language/statements/class/elements/same-line-async-gen-private-field-usage.js
index 9a4d1bbf5f..6e452a07bb 100644
--- a/test/language/statements/class/elements/same-line-async-gen-private-field-usage.js
+++ b/test/language/statements/class/elements/same-line-async-gen-private-field-usage.js
@@ -31,7 +31,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-gen-private-method-getter-usage.js b/test/language/statements/class/elements/same-line-async-gen-private-method-getter-usage.js
index 92221949a7..b928e2844d 100644
--- a/test/language/statements/class/elements/same-line-async-gen-private-method-getter-usage.js
+++ b/test/language/statements/class/elements/same-line-async-gen-private-method-getter-usage.js
@@ -31,7 +31,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-gen-private-method-usage.js b/test/language/statements/class/elements/same-line-async-gen-private-method-usage.js
index ef53929ec8..836c36da0e 100644
--- a/test/language/statements/class/elements/same-line-async-gen-private-method-usage.js
+++ b/test/language/statements/class/elements/same-line-async-gen-private-method-usage.js
@@ -31,7 +31,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-gen-private-names.js b/test/language/statements/class/elements/same-line-async-gen-private-names.js
index a02e095307..a70f7e3044 100644
--- a/test/language/statements/class/elements/same-line-async-gen-private-names.js
+++ b/test/language/statements/class/elements/same-line-async-gen-private-names.js
@@ -38,7 +38,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -59,21 +62,21 @@ c.m().next().then(function(v) {
       }
     }
     // Test the private fields do not appear as properties before set to value
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
     // Test if private fields can be sucessfully accessed and set to value
     assert.sameValue(c.x(), 42, "test 7");
     assert.sameValue(c.y(), 43, "test 8");
 
     // Test the private fields do not appear as properties before after set to value
-    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 9");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 10");
   }
 
   return Promise.resolve(assertions());
diff --git a/test/language/statements/class/elements/same-line-async-gen-rs-field-identifier-initializer.js b/test/language/statements/class/elements/same-line-async-gen-rs-field-identifier-initializer.js
index e396496a0e..bbf30ddfc2 100644
--- a/test/language/statements/class/elements/same-line-async-gen-rs-field-identifier-initializer.js
+++ b/test/language/statements/class/elements/same-line-async-gen-rs-field-identifier-initializer.js
@@ -64,7 +64,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-gen-rs-field-identifier.js b/test/language/statements/class/elements/same-line-async-gen-rs-field-identifier.js
index b0ba754f77..2a175c8c24 100644
--- a/test/language/statements/class/elements/same-line-async-gen-rs-field-identifier.js
+++ b/test/language/statements/class/elements/same-line-async-gen-rs-field-identifier.js
@@ -64,7 +64,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-gen-rs-private-getter-alt.js b/test/language/statements/class/elements/same-line-async-gen-rs-private-getter-alt.js
index 7c7cfedfd1..e4bb9ce5b0 100644
--- a/test/language/statements/class/elements/same-line-async-gen-rs-private-getter-alt.js
+++ b/test/language/statements/class/elements/same-line-async-gen-rs-private-getter-alt.js
@@ -105,7 +105,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-gen-rs-private-getter.js b/test/language/statements/class/elements/same-line-async-gen-rs-private-getter.js
index 766f97db1d..65fba0b95a 100644
--- a/test/language/statements/class/elements/same-line-async-gen-rs-private-getter.js
+++ b/test/language/statements/class/elements/same-line-async-gen-rs-private-getter.js
@@ -105,7 +105,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-gen-rs-private-method-alt.js b/test/language/statements/class/elements/same-line-async-gen-rs-private-method-alt.js
index b61767dce9..c738ec4fc1 100644
--- a/test/language/statements/class/elements/same-line-async-gen-rs-private-method-alt.js
+++ b/test/language/statements/class/elements/same-line-async-gen-rs-private-method-alt.js
@@ -104,7 +104,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-gen-rs-private-method.js b/test/language/statements/class/elements/same-line-async-gen-rs-private-method.js
index 802638488d..d47a391816 100644
--- a/test/language/statements/class/elements/same-line-async-gen-rs-private-method.js
+++ b/test/language/statements/class/elements/same-line-async-gen-rs-private-method.js
@@ -104,7 +104,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-gen-rs-private-setter-alt.js b/test/language/statements/class/elements/same-line-async-gen-rs-private-setter-alt.js
index d5e6edf9d8..eb985abc0c 100644
--- a/test/language/statements/class/elements/same-line-async-gen-rs-private-setter-alt.js
+++ b/test/language/statements/class/elements/same-line-async-gen-rs-private-setter-alt.js
@@ -104,7 +104,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-gen-rs-private-setter.js b/test/language/statements/class/elements/same-line-async-gen-rs-private-setter.js
index 47c2352643..284a58222a 100644
--- a/test/language/statements/class/elements/same-line-async-gen-rs-private-setter.js
+++ b/test/language/statements/class/elements/same-line-async-gen-rs-private-setter.js
@@ -104,7 +104,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-gen-rs-privatename-identifier-alt.js b/test/language/statements/class/elements/same-line-async-gen-rs-privatename-identifier-alt.js
index 24200c84f1..7ee0004476 100644
--- a/test/language/statements/class/elements/same-line-async-gen-rs-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/same-line-async-gen-rs-privatename-identifier-alt.js
@@ -85,7 +85,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-gen-rs-privatename-identifier-initializer-alt.js b/test/language/statements/class/elements/same-line-async-gen-rs-privatename-identifier-initializer-alt.js
index 139b0e225d..15df26c0de 100644
--- a/test/language/statements/class/elements/same-line-async-gen-rs-privatename-identifier-initializer-alt.js
+++ b/test/language/statements/class/elements/same-line-async-gen-rs-privatename-identifier-initializer-alt.js
@@ -79,7 +79,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-gen-rs-privatename-identifier-initializer.js b/test/language/statements/class/elements/same-line-async-gen-rs-privatename-identifier-initializer.js
index 88820b24d2..6c429aa071 100644
--- a/test/language/statements/class/elements/same-line-async-gen-rs-privatename-identifier-initializer.js
+++ b/test/language/statements/class/elements/same-line-async-gen-rs-privatename-identifier-initializer.js
@@ -79,7 +79,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-gen-rs-privatename-identifier.js b/test/language/statements/class/elements/same-line-async-gen-rs-privatename-identifier.js
index fc272cc205..888b24d157 100644
--- a/test/language/statements/class/elements/same-line-async-gen-rs-privatename-identifier.js
+++ b/test/language/statements/class/elements/same-line-async-gen-rs-privatename-identifier.js
@@ -85,7 +85,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-gen-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/statements/class/elements/same-line-async-gen-rs-static-async-generator-method-privatename-identifier-alt.js
index c8fbcef4b1..896fc982f4 100644
--- a/test/language/statements/class/elements/same-line-async-gen-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/same-line-async-gen-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -101,7 +101,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-gen-rs-static-async-generator-method-privatename-identifier.js b/test/language/statements/class/elements/same-line-async-gen-rs-static-async-generator-method-privatename-identifier.js
index 17765fb1df..716afc3285 100644
--- a/test/language/statements/class/elements/same-line-async-gen-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/same-line-async-gen-rs-static-async-generator-method-privatename-identifier.js
@@ -101,7 +101,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-gen-rs-static-async-method-privatename-identifier-alt.js b/test/language/statements/class/elements/same-line-async-gen-rs-static-async-method-privatename-identifier-alt.js
index 4826b03457..9d5c470545 100644
--- a/test/language/statements/class/elements/same-line-async-gen-rs-static-async-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/same-line-async-gen-rs-static-async-method-privatename-identifier-alt.js
@@ -101,7 +101,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-gen-rs-static-async-method-privatename-identifier.js b/test/language/statements/class/elements/same-line-async-gen-rs-static-async-method-privatename-identifier.js
index 9df9991c33..d770934709 100644
--- a/test/language/statements/class/elements/same-line-async-gen-rs-static-async-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/same-line-async-gen-rs-static-async-method-privatename-identifier.js
@@ -101,7 +101,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-gen-rs-static-generator-method-privatename-identifier-alt.js b/test/language/statements/class/elements/same-line-async-gen-rs-static-generator-method-privatename-identifier-alt.js
index 7b6031fcdc..61b2f820a5 100644
--- a/test/language/statements/class/elements/same-line-async-gen-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/same-line-async-gen-rs-static-generator-method-privatename-identifier-alt.js
@@ -101,7 +101,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-gen-rs-static-generator-method-privatename-identifier.js b/test/language/statements/class/elements/same-line-async-gen-rs-static-generator-method-privatename-identifier.js
index 61902b4fd8..3dcceae65c 100644
--- a/test/language/statements/class/elements/same-line-async-gen-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/same-line-async-gen-rs-static-generator-method-privatename-identifier.js
@@ -101,7 +101,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-gen-rs-static-method-privatename-identifier-alt.js b/test/language/statements/class/elements/same-line-async-gen-rs-static-method-privatename-identifier-alt.js
index 49fc544af0..c861c7293c 100644
--- a/test/language/statements/class/elements/same-line-async-gen-rs-static-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/same-line-async-gen-rs-static-method-privatename-identifier-alt.js
@@ -98,7 +98,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-gen-rs-static-method-privatename-identifier.js b/test/language/statements/class/elements/same-line-async-gen-rs-static-method-privatename-identifier.js
index 56d8f00c99..8d6237c683 100644
--- a/test/language/statements/class/elements/same-line-async-gen-rs-static-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/same-line-async-gen-rs-static-method-privatename-identifier.js
@@ -98,7 +98,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-gen-rs-static-privatename-identifier-alt-by-classname.js b/test/language/statements/class/elements/same-line-async-gen-rs-static-privatename-identifier-alt-by-classname.js
index 6a7beda254..1af7834be7 100644
--- a/test/language/statements/class/elements/same-line-async-gen-rs-static-privatename-identifier-alt-by-classname.js
+++ b/test/language/statements/class/elements/same-line-async-gen-rs-static-privatename-identifier-alt-by-classname.js
@@ -86,7 +86,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-gen-rs-static-privatename-identifier-alt.js b/test/language/statements/class/elements/same-line-async-gen-rs-static-privatename-identifier-alt.js
index f3367d6d4c..0ca91b685c 100644
--- a/test/language/statements/class/elements/same-line-async-gen-rs-static-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/same-line-async-gen-rs-static-privatename-identifier-alt.js
@@ -86,7 +86,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-gen-rs-static-privatename-identifier-by-classname.js b/test/language/statements/class/elements/same-line-async-gen-rs-static-privatename-identifier-by-classname.js
index 0ce3b7edd2..7e4d01ff6f 100644
--- a/test/language/statements/class/elements/same-line-async-gen-rs-static-privatename-identifier-by-classname.js
+++ b/test/language/statements/class/elements/same-line-async-gen-rs-static-privatename-identifier-by-classname.js
@@ -86,7 +86,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js b/test/language/statements/class/elements/same-line-async-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
index e6d09e5a04..5fad561b2e 100644
--- a/test/language/statements/class/elements/same-line-async-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
+++ b/test/language/statements/class/elements/same-line-async-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
@@ -80,7 +80,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-gen-rs-static-privatename-identifier-initializer-alt.js b/test/language/statements/class/elements/same-line-async-gen-rs-static-privatename-identifier-initializer-alt.js
index 956983b865..7400b04863 100644
--- a/test/language/statements/class/elements/same-line-async-gen-rs-static-privatename-identifier-initializer-alt.js
+++ b/test/language/statements/class/elements/same-line-async-gen-rs-static-privatename-identifier-initializer-alt.js
@@ -80,7 +80,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-gen-rs-static-privatename-identifier-initializer.js b/test/language/statements/class/elements/same-line-async-gen-rs-static-privatename-identifier-initializer.js
index 30dc88d772..d78ec82440 100644
--- a/test/language/statements/class/elements/same-line-async-gen-rs-static-privatename-identifier-initializer.js
+++ b/test/language/statements/class/elements/same-line-async-gen-rs-static-privatename-identifier-initializer.js
@@ -80,7 +80,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-gen-rs-static-privatename-identifier.js b/test/language/statements/class/elements/same-line-async-gen-rs-static-privatename-identifier.js
index 521bc491c8..6129f60ec0 100644
--- a/test/language/statements/class/elements/same-line-async-gen-rs-static-privatename-identifier.js
+++ b/test/language/statements/class/elements/same-line-async-gen-rs-static-privatename-identifier.js
@@ -86,7 +86,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-gen-static-private-fields.js b/test/language/statements/class/elements/same-line-async-gen-static-private-fields.js
index 4874217627..3ccd35f746 100644
--- a/test/language/statements/class/elements/same-line-async-gen-static-private-fields.js
+++ b/test/language/statements/class/elements/same-line-async-gen-static-private-fields.js
@@ -38,7 +38,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -59,21 +62,21 @@ c.m().next().then(function(v) {
       }
     }
     // Test the private fields do not appear as properties before set to value
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
     // Test if private fields can be sucessfully accessed and set to value
     assert.sameValue(C.x(), 42, "test 7");
     assert.sameValue(C.y(), 43, "test 8");
 
     // Test the private fields do not appear as properties before after set to value
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
   }
 
   return Promise.resolve(assertions());
diff --git a/test/language/statements/class/elements/same-line-async-gen-static-private-methods-with-fields.js b/test/language/statements/class/elements/same-line-async-gen-static-private-methods-with-fields.js
index 27f24dc34a..8ba6190b78 100644
--- a/test/language/statements/class/elements/same-line-async-gen-static-private-methods-with-fields.js
+++ b/test/language/statements/class/elements/same-line-async-gen-static-private-methods-with-fields.js
@@ -44,7 +44,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -65,32 +68,32 @@ c.m().next().then(function(v) {
       }
     }
     // Test the private methods do not appear as properties before set to value
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#xVal"), "test 7");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 8");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#xVal"), "test 9");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#yVal"), "test 10");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 11");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#yVal"), "test 12");
 
     // Test if private fields can be sucessfully accessed and set to value
     assert.sameValue(C.x(), 42, "test 13");
     assert.sameValue(C.y(), 43, "test 14");
 
     // Test the private fields do not appear as properties before after set to value
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 15");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 16");
 
-    assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 17");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 18");
   }
 
   return Promise.resolve(assertions());
diff --git a/test/language/statements/class/elements/same-line-async-gen-static-private-methods.js b/test/language/statements/class/elements/same-line-async-gen-static-private-methods.js
index ab2df8540e..e0deabe55c 100644
--- a/test/language/statements/class/elements/same-line-async-gen-static-private-methods.js
+++ b/test/language/statements/class/elements/same-line-async-gen-static-private-methods.js
@@ -42,7 +42,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -63,21 +66,21 @@ c.m().next().then(function(v) {
       }
     }
     // Test the private methods do not appear as properties before set to value
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
     // Test if private fields can be sucessfully accessed and set to value
     assert.sameValue(C.x(), 42, "test 7");
     assert.sameValue(C.y(), 86, "test 8");
 
     // Test the private fields do not appear as properties before after set to value
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
   }
 
   return Promise.resolve(assertions());
diff --git a/test/language/statements/class/elements/same-line-async-gen-string-literal-names.js b/test/language/statements/class/elements/same-line-async-gen-string-literal-names.js
index 13d014206b..fe1f8eec05 100644
--- a/test/language/statements/class/elements/same-line-async-gen-string-literal-names.js
+++ b/test/language/statements/class/elements/same-line-async-gen-string-literal-names.js
@@ -29,7 +29,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -49,8 +52,14 @@ c.m().next().then(function(v) {
         throw new Test262Error('Test262:AsyncTestFailure')
       }
     }
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+      "a does not appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "a"),
+      "a does not appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "a", {
       value: undefined,
@@ -59,8 +68,14 @@ c.m().next().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+      "b does not appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "b"),
+      "b does not appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "b", {
       value: undefined,
@@ -69,8 +84,14 @@ c.m().next().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+      "c does not appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "c"),
+      "c does not appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "c", {
       value: 39,
@@ -79,8 +100,14 @@ c.m().next().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "d"),
+      "d does not appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "d"),
+      "d does not appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "d", {
       value: 42,
diff --git a/test/language/statements/class/elements/same-line-async-method-computed-names.js b/test/language/statements/class/elements/same-line-async-method-computed-names.js
index 6a9411721d..43f449f5ac 100644
--- a/test/language/statements/class/elements/same-line-async-method-computed-names.js
+++ b/test/language/statements/class/elements/same-line-async-method-computed-names.js
@@ -30,7 +30,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -49,8 +52,14 @@ c.m().then(function(v) {
         throw new Test262Error('Test262:AsyncTestFailure')
       }
     }
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+      "b doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "b"),
+      "b doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "b", {
       value: 42,
@@ -59,12 +68,27 @@ c.m().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-    assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+      "x doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "x"),
+      "x doesn't appear as an own property on C constructor"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(c, "x"),
+      "x doesn't appear as an own property on C instance"
+    );
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "10"),
+      "10 doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "10"),
+      "10 doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "10", {
       value: "meep",
@@ -73,8 +97,14 @@ c.m().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "not initialized"),
+      "'not initialized' doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "not initialized"),
+      "'not initialized' doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "not initialized", {
       value: undefined,
diff --git a/test/language/statements/class/elements/same-line-async-method-computed-symbol-names.js b/test/language/statements/class/elements/same-line-async-method-computed-symbol-names.js
index 6454eb219c..75f9cc7ee6 100644
--- a/test/language/statements/class/elements/same-line-async-method-computed-symbol-names.js
+++ b/test/language/statements/class/elements/same-line-async-method-computed-symbol-names.js
@@ -31,7 +31,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -50,8 +53,14 @@ c.m().then(function(v) {
         throw new Test262Error('Test262:AsyncTestFailure')
       }
     }
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, x), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, x), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, x),
+      "Symbol x doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, x),
+      "Symbol x doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, x, {
       value: undefined,
@@ -60,8 +69,14 @@ c.m().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, y), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, y),
+      "Symbol y doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, y),
+      "Symbol y doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, y, {
       value: 42,
@@ -70,13 +85,31 @@ c.m().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-    assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+      "x doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "x"),
+      "x doesn't appear as an own property on C constructor"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(c, "x"),
+      "x doesn't appear as an own property on C instance"
+    );
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
-    assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "y"),
+      "y doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "y"),
+      "y doesn't appear as an own property on C constructor"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(c, "y"),
+      "y doesn't appear as an own property on C instance"
+    );
   }
 
   return Promise.resolve(assertions());
diff --git a/test/language/statements/class/elements/same-line-async-method-grammar-privatename-identifier-semantics-stringvalue.js b/test/language/statements/class/elements/same-line-async-method-grammar-privatename-identifier-semantics-stringvalue.js
index 64bc414421..c6df69b076 100644
--- a/test/language/statements/class/elements/same-line-async-method-grammar-privatename-identifier-semantics-stringvalue.js
+++ b/test/language/statements/class/elements/same-line-async-method-grammar-privatename-identifier-semantics-stringvalue.js
@@ -88,7 +88,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-method-literal-names-asi.js b/test/language/statements/class/elements/same-line-async-method-literal-names-asi.js
index 195f221547..436d42ae99 100644
--- a/test/language/statements/class/elements/same-line-async-method-literal-names-asi.js
+++ b/test/language/statements/class/elements/same-line-async-method-literal-names-asi.js
@@ -29,7 +29,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -48,8 +51,14 @@ c.m().then(function(v) {
         throw new Test262Error('Test262:AsyncTestFailure')
       }
     }
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+      "a doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "a"),
+      "a doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "a", {
       value: undefined,
@@ -58,8 +67,14 @@ c.m().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+      "b doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "b"),
+      "b doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "b", {
       value: 42,
diff --git a/test/language/statements/class/elements/same-line-async-method-literal-names.js b/test/language/statements/class/elements/same-line-async-method-literal-names.js
index eb5d225349..dc13e88959 100644
--- a/test/language/statements/class/elements/same-line-async-method-literal-names.js
+++ b/test/language/statements/class/elements/same-line-async-method-literal-names.js
@@ -31,7 +31,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -50,8 +53,14 @@ c.m().then(function(v) {
         throw new Test262Error('Test262:AsyncTestFailure')
       }
     }
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+      "a doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "a"),
+      "a doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "a", {
       value: undefined,
@@ -60,8 +69,14 @@ c.m().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+      "b doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "b"),
+      "b doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "b", {
       value: 42,
@@ -70,8 +85,14 @@ c.m().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+      "c doesn't appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "c"),
+      "c doesn't appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "c", {
       value: fn,
diff --git a/test/language/statements/class/elements/same-line-async-method-private-field-usage.js b/test/language/statements/class/elements/same-line-async-method-private-field-usage.js
index 933dae3f28..79c1f4c4b4 100644
--- a/test/language/statements/class/elements/same-line-async-method-private-field-usage.js
+++ b/test/language/statements/class/elements/same-line-async-method-private-field-usage.js
@@ -31,7 +31,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-method-private-method-getter-usage.js b/test/language/statements/class/elements/same-line-async-method-private-method-getter-usage.js
index 3d2fe7679c..5f67ea88b9 100644
--- a/test/language/statements/class/elements/same-line-async-method-private-method-getter-usage.js
+++ b/test/language/statements/class/elements/same-line-async-method-private-method-getter-usage.js
@@ -31,7 +31,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-method-private-method-usage.js b/test/language/statements/class/elements/same-line-async-method-private-method-usage.js
index 9ae4181af6..19daa14a82 100644
--- a/test/language/statements/class/elements/same-line-async-method-private-method-usage.js
+++ b/test/language/statements/class/elements/same-line-async-method-private-method-usage.js
@@ -31,7 +31,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-method-private-names.js b/test/language/statements/class/elements/same-line-async-method-private-names.js
index c59d9d1783..abc197d421 100644
--- a/test/language/statements/class/elements/same-line-async-method-private-names.js
+++ b/test/language/statements/class/elements/same-line-async-method-private-names.js
@@ -38,7 +38,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -58,21 +61,21 @@ c.m().then(function(v) {
       }
     }
     // Test the private fields do not appear as properties before set to value
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
     // Test if private fields can be sucessfully accessed and set to value
     assert.sameValue(c.x(), 42, "test 7");
     assert.sameValue(c.y(), 43, "test 8");
 
     // Test the private fields do not appear as properties before after set to value
-    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 9");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 10");
   }
 
   return Promise.resolve(assertions());
diff --git a/test/language/statements/class/elements/same-line-async-method-rs-field-identifier-initializer.js b/test/language/statements/class/elements/same-line-async-method-rs-field-identifier-initializer.js
index 17499257a3..cad5ff61fb 100644
--- a/test/language/statements/class/elements/same-line-async-method-rs-field-identifier-initializer.js
+++ b/test/language/statements/class/elements/same-line-async-method-rs-field-identifier-initializer.js
@@ -64,7 +64,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-method-rs-field-identifier.js b/test/language/statements/class/elements/same-line-async-method-rs-field-identifier.js
index 28800c9b12..80497651aa 100644
--- a/test/language/statements/class/elements/same-line-async-method-rs-field-identifier.js
+++ b/test/language/statements/class/elements/same-line-async-method-rs-field-identifier.js
@@ -64,7 +64,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-method-rs-private-getter-alt.js b/test/language/statements/class/elements/same-line-async-method-rs-private-getter-alt.js
index 190a213e13..a9c10953c1 100644
--- a/test/language/statements/class/elements/same-line-async-method-rs-private-getter-alt.js
+++ b/test/language/statements/class/elements/same-line-async-method-rs-private-getter-alt.js
@@ -105,7 +105,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-method-rs-private-getter.js b/test/language/statements/class/elements/same-line-async-method-rs-private-getter.js
index 2c784c669c..e73f5a19db 100644
--- a/test/language/statements/class/elements/same-line-async-method-rs-private-getter.js
+++ b/test/language/statements/class/elements/same-line-async-method-rs-private-getter.js
@@ -105,7 +105,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-method-rs-private-method-alt.js b/test/language/statements/class/elements/same-line-async-method-rs-private-method-alt.js
index 4add8a1032..b751a7f5ac 100644
--- a/test/language/statements/class/elements/same-line-async-method-rs-private-method-alt.js
+++ b/test/language/statements/class/elements/same-line-async-method-rs-private-method-alt.js
@@ -104,7 +104,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-method-rs-private-method.js b/test/language/statements/class/elements/same-line-async-method-rs-private-method.js
index fe9abcaa35..6b20383150 100644
--- a/test/language/statements/class/elements/same-line-async-method-rs-private-method.js
+++ b/test/language/statements/class/elements/same-line-async-method-rs-private-method.js
@@ -104,7 +104,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-method-rs-private-setter-alt.js b/test/language/statements/class/elements/same-line-async-method-rs-private-setter-alt.js
index 6da0371c02..ed3a748ea4 100644
--- a/test/language/statements/class/elements/same-line-async-method-rs-private-setter-alt.js
+++ b/test/language/statements/class/elements/same-line-async-method-rs-private-setter-alt.js
@@ -104,7 +104,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-method-rs-private-setter.js b/test/language/statements/class/elements/same-line-async-method-rs-private-setter.js
index 0c44c8ae4f..d60888cc56 100644
--- a/test/language/statements/class/elements/same-line-async-method-rs-private-setter.js
+++ b/test/language/statements/class/elements/same-line-async-method-rs-private-setter.js
@@ -104,7 +104,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-method-rs-privatename-identifier-alt.js b/test/language/statements/class/elements/same-line-async-method-rs-privatename-identifier-alt.js
index 301cb279f7..a6178c7e0f 100644
--- a/test/language/statements/class/elements/same-line-async-method-rs-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/same-line-async-method-rs-privatename-identifier-alt.js
@@ -85,7 +85,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-method-rs-privatename-identifier-initializer-alt.js b/test/language/statements/class/elements/same-line-async-method-rs-privatename-identifier-initializer-alt.js
index f343ccb31b..b7fc817fc2 100644
--- a/test/language/statements/class/elements/same-line-async-method-rs-privatename-identifier-initializer-alt.js
+++ b/test/language/statements/class/elements/same-line-async-method-rs-privatename-identifier-initializer-alt.js
@@ -79,7 +79,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-method-rs-privatename-identifier-initializer.js b/test/language/statements/class/elements/same-line-async-method-rs-privatename-identifier-initializer.js
index 83686eb298..3b1e39295e 100644
--- a/test/language/statements/class/elements/same-line-async-method-rs-privatename-identifier-initializer.js
+++ b/test/language/statements/class/elements/same-line-async-method-rs-privatename-identifier-initializer.js
@@ -79,7 +79,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-method-rs-privatename-identifier.js b/test/language/statements/class/elements/same-line-async-method-rs-privatename-identifier.js
index b2df9c62f9..f4caf0152c 100644
--- a/test/language/statements/class/elements/same-line-async-method-rs-privatename-identifier.js
+++ b/test/language/statements/class/elements/same-line-async-method-rs-privatename-identifier.js
@@ -85,7 +85,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-method-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/statements/class/elements/same-line-async-method-rs-static-async-generator-method-privatename-identifier-alt.js
index 9b5ed96c43..75d3d0852a 100644
--- a/test/language/statements/class/elements/same-line-async-method-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/same-line-async-method-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -101,7 +101,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-method-rs-static-async-generator-method-privatename-identifier.js b/test/language/statements/class/elements/same-line-async-method-rs-static-async-generator-method-privatename-identifier.js
index 4a7f98dfd2..0e68518db6 100644
--- a/test/language/statements/class/elements/same-line-async-method-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/same-line-async-method-rs-static-async-generator-method-privatename-identifier.js
@@ -101,7 +101,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-method-rs-static-async-method-privatename-identifier-alt.js b/test/language/statements/class/elements/same-line-async-method-rs-static-async-method-privatename-identifier-alt.js
index abc84a9a23..664425757a 100644
--- a/test/language/statements/class/elements/same-line-async-method-rs-static-async-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/same-line-async-method-rs-static-async-method-privatename-identifier-alt.js
@@ -101,7 +101,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-method-rs-static-async-method-privatename-identifier.js b/test/language/statements/class/elements/same-line-async-method-rs-static-async-method-privatename-identifier.js
index c37b21c6bd..adcfa7c3f6 100644
--- a/test/language/statements/class/elements/same-line-async-method-rs-static-async-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/same-line-async-method-rs-static-async-method-privatename-identifier.js
@@ -101,7 +101,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-method-rs-static-generator-method-privatename-identifier-alt.js b/test/language/statements/class/elements/same-line-async-method-rs-static-generator-method-privatename-identifier-alt.js
index aa1a5f95de..62319caf68 100644
--- a/test/language/statements/class/elements/same-line-async-method-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/same-line-async-method-rs-static-generator-method-privatename-identifier-alt.js
@@ -101,7 +101,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-method-rs-static-generator-method-privatename-identifier.js b/test/language/statements/class/elements/same-line-async-method-rs-static-generator-method-privatename-identifier.js
index 08f9acd59c..9ac6ffc2a0 100644
--- a/test/language/statements/class/elements/same-line-async-method-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/same-line-async-method-rs-static-generator-method-privatename-identifier.js
@@ -101,7 +101,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-method-rs-static-method-privatename-identifier-alt.js b/test/language/statements/class/elements/same-line-async-method-rs-static-method-privatename-identifier-alt.js
index 2be42d45cb..7dd21a1f91 100644
--- a/test/language/statements/class/elements/same-line-async-method-rs-static-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/same-line-async-method-rs-static-method-privatename-identifier-alt.js
@@ -98,7 +98,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-method-rs-static-method-privatename-identifier.js b/test/language/statements/class/elements/same-line-async-method-rs-static-method-privatename-identifier.js
index 9e9a647d0b..b18b651875 100644
--- a/test/language/statements/class/elements/same-line-async-method-rs-static-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/same-line-async-method-rs-static-method-privatename-identifier.js
@@ -98,7 +98,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-method-rs-static-privatename-identifier-alt-by-classname.js b/test/language/statements/class/elements/same-line-async-method-rs-static-privatename-identifier-alt-by-classname.js
index 2b0e1d9940..29f12f8032 100644
--- a/test/language/statements/class/elements/same-line-async-method-rs-static-privatename-identifier-alt-by-classname.js
+++ b/test/language/statements/class/elements/same-line-async-method-rs-static-privatename-identifier-alt-by-classname.js
@@ -86,7 +86,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-method-rs-static-privatename-identifier-alt.js b/test/language/statements/class/elements/same-line-async-method-rs-static-privatename-identifier-alt.js
index e46281dab6..67e29c3308 100644
--- a/test/language/statements/class/elements/same-line-async-method-rs-static-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/same-line-async-method-rs-static-privatename-identifier-alt.js
@@ -86,7 +86,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-method-rs-static-privatename-identifier-by-classname.js b/test/language/statements/class/elements/same-line-async-method-rs-static-privatename-identifier-by-classname.js
index 942615c564..19bc207c3c 100644
--- a/test/language/statements/class/elements/same-line-async-method-rs-static-privatename-identifier-by-classname.js
+++ b/test/language/statements/class/elements/same-line-async-method-rs-static-privatename-identifier-by-classname.js
@@ -86,7 +86,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-method-rs-static-privatename-identifier-initializer-alt-by-classname.js b/test/language/statements/class/elements/same-line-async-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
index f645c052ea..2a0ae41a61 100644
--- a/test/language/statements/class/elements/same-line-async-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
+++ b/test/language/statements/class/elements/same-line-async-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
@@ -80,7 +80,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-method-rs-static-privatename-identifier-initializer-alt.js b/test/language/statements/class/elements/same-line-async-method-rs-static-privatename-identifier-initializer-alt.js
index 912e3d1db5..38c6793252 100644
--- a/test/language/statements/class/elements/same-line-async-method-rs-static-privatename-identifier-initializer-alt.js
+++ b/test/language/statements/class/elements/same-line-async-method-rs-static-privatename-identifier-initializer-alt.js
@@ -80,7 +80,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-method-rs-static-privatename-identifier-initializer.js b/test/language/statements/class/elements/same-line-async-method-rs-static-privatename-identifier-initializer.js
index 17b745e7e8..3d04940ae9 100644
--- a/test/language/statements/class/elements/same-line-async-method-rs-static-privatename-identifier-initializer.js
+++ b/test/language/statements/class/elements/same-line-async-method-rs-static-privatename-identifier-initializer.js
@@ -80,7 +80,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-method-rs-static-privatename-identifier.js b/test/language/statements/class/elements/same-line-async-method-rs-static-privatename-identifier.js
index 140c62137d..a0933e1d78 100644
--- a/test/language/statements/class/elements/same-line-async-method-rs-static-privatename-identifier.js
+++ b/test/language/statements/class/elements/same-line-async-method-rs-static-privatename-identifier.js
@@ -86,7 +86,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
diff --git a/test/language/statements/class/elements/same-line-async-method-static-private-fields.js b/test/language/statements/class/elements/same-line-async-method-static-private-fields.js
index e4080aea95..7ff5967420 100644
--- a/test/language/statements/class/elements/same-line-async-method-static-private-fields.js
+++ b/test/language/statements/class/elements/same-line-async-method-static-private-fields.js
@@ -38,7 +38,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -58,21 +61,21 @@ c.m().then(function(v) {
       }
     }
     // Test the private fields do not appear as properties before set to value
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
     // Test if private fields can be sucessfully accessed and set to value
     assert.sameValue(C.x(), 42, "test 7");
     assert.sameValue(C.y(), 43, "test 8");
 
     // Test the private fields do not appear as properties before after set to value
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
   }
 
   return Promise.resolve(assertions());
diff --git a/test/language/statements/class/elements/same-line-async-method-static-private-methods-with-fields.js b/test/language/statements/class/elements/same-line-async-method-static-private-methods-with-fields.js
index 12443dd97d..e60d6ce771 100644
--- a/test/language/statements/class/elements/same-line-async-method-static-private-methods-with-fields.js
+++ b/test/language/statements/class/elements/same-line-async-method-static-private-methods-with-fields.js
@@ -44,7 +44,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -64,32 +67,32 @@ c.m().then(function(v) {
       }
     }
     // Test the private methods do not appear as properties before set to value
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#xVal"), "test 7");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 8");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#xVal"), "test 9");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#yVal"), "test 10");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 11");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#yVal"), "test 12");
 
     // Test if private fields can be sucessfully accessed and set to value
     assert.sameValue(C.x(), 42, "test 13");
     assert.sameValue(C.y(), 43, "test 14");
 
     // Test the private fields do not appear as properties before after set to value
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 15");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 16");
 
-    assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 17");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 18");
   }
 
   return Promise.resolve(assertions());
diff --git a/test/language/statements/class/elements/same-line-async-method-static-private-methods.js b/test/language/statements/class/elements/same-line-async-method-static-private-methods.js
index 5839993af3..854681bd48 100644
--- a/test/language/statements/class/elements/same-line-async-method-static-private-methods.js
+++ b/test/language/statements/class/elements/same-line-async-method-static-private-methods.js
@@ -42,7 +42,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -62,21 +65,21 @@ c.m().then(function(v) {
       }
     }
     // Test the private methods do not appear as properties before set to value
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-    assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+    assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+    assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
     // Test if private fields can be sucessfully accessed and set to value
     assert.sameValue(C.x(), 42, "test 7");
     assert.sameValue(C.y(), 86, "test 8");
 
     // Test the private fields do not appear as properties before after set to value
-    assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-    assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+    assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
   }
 
   return Promise.resolve(assertions());
diff --git a/test/language/statements/class/elements/same-line-async-method-string-literal-names.js b/test/language/statements/class/elements/same-line-async-method-string-literal-names.js
index f7bf971681..9b1613c08e 100644
--- a/test/language/statements/class/elements/same-line-async-method-string-literal-names.js
+++ b/test/language/statements/class/elements/same-line-async-method-string-literal-names.js
@@ -29,7 +29,10 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 assert.sameValue(c.m, C.prototype.m);
 
 verifyProperty(C.prototype, "m", {
@@ -48,8 +51,14 @@ c.m().then(function(v) {
         throw new Test262Error('Test262:AsyncTestFailure')
       }
     }
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+      "a does not appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "a"),
+      "a does not appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "a", {
       value: undefined,
@@ -58,8 +67,14 @@ c.m().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+      "b does not appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "b"),
+      "b does not appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "b", {
       value: undefined,
@@ -68,8 +83,14 @@ c.m().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+      "c does not appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "c"),
+      "c does not appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "c", {
       value: 39,
@@ -78,8 +99,14 @@ c.m().then(function(v) {
       configurable: true
     });
 
-    assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
-    assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
+    assert(
+      !Object.prototype.hasOwnProperty.call(C.prototype, "d"),
+      "d does not appear as an own property on C prototype"
+    );
+    assert(
+      !Object.prototype.hasOwnProperty.call(C, "d"),
+      "d does not appear as an own property on C constructor"
+    );
 
     verifyProperty(c, "d", {
       value: 42,
diff --git a/test/language/statements/class/elements/same-line-gen-computed-names.js b/test/language/statements/class/elements/same-line-gen-computed-names.js
index 93ad26fbf8..2ee3dee236 100644
--- a/test/language/statements/class/elements/same-line-gen-computed-names.js
+++ b/test/language/statements/class/elements/same-line-gen-computed-names.js
@@ -32,7 +32,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -40,8 +43,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -50,12 +59,27 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "10"),
+  "10 doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "10"),
+  "10 doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "10", {
   value: "meep",
@@ -64,8 +88,14 @@ verifyProperty(c, "10", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "not initialized", {
   value: undefined,
diff --git a/test/language/statements/class/elements/same-line-gen-computed-symbol-names.js b/test/language/statements/class/elements/same-line-gen-computed-symbol-names.js
index 1823c26fc2..d4592e96d4 100644
--- a/test/language/statements/class/elements/same-line-gen-computed-symbol-names.js
+++ b/test/language/statements/class/elements/same-line-gen-computed-symbol-names.js
@@ -33,7 +33,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -41,8 +44,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, x), false);
-assert.sameValue(Object.hasOwnProperty.call(C, x), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, x),
+  "Symbol x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, x),
+  "Symbol x doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, x, {
   value: undefined,
@@ -51,8 +60,14 @@ verifyProperty(c, x, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
-assert.sameValue(Object.hasOwnProperty.call(C, y), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, y),
+  "Symbol y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, y),
+  "Symbol y doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, y, {
   value: 42,
@@ -61,10 +76,28 @@ verifyProperty(c, y, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "y"),
+  "y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "y"),
+  "y doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "y"),
+  "y doesn't appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/same-line-gen-grammar-privatename-identifier-semantics-stringvalue.js b/test/language/statements/class/elements/same-line-gen-grammar-privatename-identifier-semantics-stringvalue.js
index 91730d6780..75748417c9 100644
--- a/test/language/statements/class/elements/same-line-gen-grammar-privatename-identifier-semantics-stringvalue.js
+++ b/test/language/statements/class/elements/same-line-gen-grammar-privatename-identifier-semantics-stringvalue.js
@@ -90,7 +90,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-gen-literal-names-asi.js b/test/language/statements/class/elements/same-line-gen-literal-names-asi.js
index 3590160ce1..939f1c9ba2 100644
--- a/test/language/statements/class/elements/same-line-gen-literal-names-asi.js
+++ b/test/language/statements/class/elements/same-line-gen-literal-names-asi.js
@@ -31,7 +31,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -39,8 +42,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -49,8 +58,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
diff --git a/test/language/statements/class/elements/same-line-gen-literal-names.js b/test/language/statements/class/elements/same-line-gen-literal-names.js
index 8676b1622b..a4b56a0baf 100644
--- a/test/language/statements/class/elements/same-line-gen-literal-names.js
+++ b/test/language/statements/class/elements/same-line-gen-literal-names.js
@@ -33,7 +33,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -41,8 +44,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -51,8 +60,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -61,8 +76,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: fn,
diff --git a/test/language/statements/class/elements/same-line-gen-private-field-usage.js b/test/language/statements/class/elements/same-line-gen-private-field-usage.js
index a0bd0046dd..4ac2943088 100644
--- a/test/language/statements/class/elements/same-line-gen-private-field-usage.js
+++ b/test/language/statements/class/elements/same-line-gen-private-field-usage.js
@@ -33,7 +33,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-gen-private-method-getter-usage.js b/test/language/statements/class/elements/same-line-gen-private-method-getter-usage.js
index e9c8ccbe39..4b8f143ee4 100644
--- a/test/language/statements/class/elements/same-line-gen-private-method-getter-usage.js
+++ b/test/language/statements/class/elements/same-line-gen-private-method-getter-usage.js
@@ -33,7 +33,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-gen-private-method-usage.js b/test/language/statements/class/elements/same-line-gen-private-method-usage.js
index 4d8429cbf2..4bc6531330 100644
--- a/test/language/statements/class/elements/same-line-gen-private-method-usage.js
+++ b/test/language/statements/class/elements/same-line-gen-private-method-usage.js
@@ -33,7 +33,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-gen-private-names.js b/test/language/statements/class/elements/same-line-gen-private-names.js
index 3ff1d51828..5b76348ec4 100644
--- a/test/language/statements/class/elements/same-line-gen-private-names.js
+++ b/test/language/statements/class/elements/same-line-gen-private-names.js
@@ -40,7 +40,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -49,18 +52,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(c.x(), 42, "test 7");
 assert.sameValue(c.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 10");
diff --git a/test/language/statements/class/elements/same-line-gen-rs-field-identifier-initializer.js b/test/language/statements/class/elements/same-line-gen-rs-field-identifier-initializer.js
index e63e31dd7d..dc39460d09 100644
--- a/test/language/statements/class/elements/same-line-gen-rs-field-identifier-initializer.js
+++ b/test/language/statements/class/elements/same-line-gen-rs-field-identifier-initializer.js
@@ -66,7 +66,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-gen-rs-field-identifier.js b/test/language/statements/class/elements/same-line-gen-rs-field-identifier.js
index 2f874fcdd4..b568e375a4 100644
--- a/test/language/statements/class/elements/same-line-gen-rs-field-identifier.js
+++ b/test/language/statements/class/elements/same-line-gen-rs-field-identifier.js
@@ -66,7 +66,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-gen-rs-private-getter-alt.js b/test/language/statements/class/elements/same-line-gen-rs-private-getter-alt.js
index 860e77169c..7d3d240706 100644
--- a/test/language/statements/class/elements/same-line-gen-rs-private-getter-alt.js
+++ b/test/language/statements/class/elements/same-line-gen-rs-private-getter-alt.js
@@ -107,7 +107,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-gen-rs-private-getter.js b/test/language/statements/class/elements/same-line-gen-rs-private-getter.js
index 5f361cf7f1..fd1d469d70 100644
--- a/test/language/statements/class/elements/same-line-gen-rs-private-getter.js
+++ b/test/language/statements/class/elements/same-line-gen-rs-private-getter.js
@@ -107,7 +107,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-gen-rs-private-method-alt.js b/test/language/statements/class/elements/same-line-gen-rs-private-method-alt.js
index 87bb069cf1..221d49c305 100644
--- a/test/language/statements/class/elements/same-line-gen-rs-private-method-alt.js
+++ b/test/language/statements/class/elements/same-line-gen-rs-private-method-alt.js
@@ -106,7 +106,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-gen-rs-private-method.js b/test/language/statements/class/elements/same-line-gen-rs-private-method.js
index f9607129ce..25d4c3e77c 100644
--- a/test/language/statements/class/elements/same-line-gen-rs-private-method.js
+++ b/test/language/statements/class/elements/same-line-gen-rs-private-method.js
@@ -106,7 +106,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-gen-rs-private-setter-alt.js b/test/language/statements/class/elements/same-line-gen-rs-private-setter-alt.js
index 69264a7cad..ef4b47da9c 100644
--- a/test/language/statements/class/elements/same-line-gen-rs-private-setter-alt.js
+++ b/test/language/statements/class/elements/same-line-gen-rs-private-setter-alt.js
@@ -106,7 +106,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-gen-rs-private-setter.js b/test/language/statements/class/elements/same-line-gen-rs-private-setter.js
index dc04e90d89..f6410f0afd 100644
--- a/test/language/statements/class/elements/same-line-gen-rs-private-setter.js
+++ b/test/language/statements/class/elements/same-line-gen-rs-private-setter.js
@@ -106,7 +106,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-gen-rs-privatename-identifier-alt.js b/test/language/statements/class/elements/same-line-gen-rs-privatename-identifier-alt.js
index 9ae993ed0b..4bf28ee0ca 100644
--- a/test/language/statements/class/elements/same-line-gen-rs-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/same-line-gen-rs-privatename-identifier-alt.js
@@ -87,7 +87,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-gen-rs-privatename-identifier-initializer-alt.js b/test/language/statements/class/elements/same-line-gen-rs-privatename-identifier-initializer-alt.js
index 955a5a7015..987ae793b9 100644
--- a/test/language/statements/class/elements/same-line-gen-rs-privatename-identifier-initializer-alt.js
+++ b/test/language/statements/class/elements/same-line-gen-rs-privatename-identifier-initializer-alt.js
@@ -81,7 +81,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-gen-rs-privatename-identifier-initializer.js b/test/language/statements/class/elements/same-line-gen-rs-privatename-identifier-initializer.js
index a4718468ff..fc5b706ff1 100644
--- a/test/language/statements/class/elements/same-line-gen-rs-privatename-identifier-initializer.js
+++ b/test/language/statements/class/elements/same-line-gen-rs-privatename-identifier-initializer.js
@@ -81,7 +81,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-gen-rs-privatename-identifier.js b/test/language/statements/class/elements/same-line-gen-rs-privatename-identifier.js
index 901ee0ae09..83ac30c3b5 100644
--- a/test/language/statements/class/elements/same-line-gen-rs-privatename-identifier.js
+++ b/test/language/statements/class/elements/same-line-gen-rs-privatename-identifier.js
@@ -87,7 +87,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/statements/class/elements/same-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js
index 4a785bc099..82463b8c27 100644
--- a/test/language/statements/class/elements/same-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/same-line-gen-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -103,7 +103,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-gen-rs-static-async-generator-method-privatename-identifier.js b/test/language/statements/class/elements/same-line-gen-rs-static-async-generator-method-privatename-identifier.js
index 7b5374fa87..3ef4be77eb 100644
--- a/test/language/statements/class/elements/same-line-gen-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/same-line-gen-rs-static-async-generator-method-privatename-identifier.js
@@ -103,7 +103,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-gen-rs-static-async-method-privatename-identifier-alt.js b/test/language/statements/class/elements/same-line-gen-rs-static-async-method-privatename-identifier-alt.js
index 83171ed535..dfeb508050 100644
--- a/test/language/statements/class/elements/same-line-gen-rs-static-async-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/same-line-gen-rs-static-async-method-privatename-identifier-alt.js
@@ -103,7 +103,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-gen-rs-static-async-method-privatename-identifier.js b/test/language/statements/class/elements/same-line-gen-rs-static-async-method-privatename-identifier.js
index 1f21fca789..d92e299548 100644
--- a/test/language/statements/class/elements/same-line-gen-rs-static-async-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/same-line-gen-rs-static-async-method-privatename-identifier.js
@@ -103,7 +103,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-gen-rs-static-generator-method-privatename-identifier-alt.js b/test/language/statements/class/elements/same-line-gen-rs-static-generator-method-privatename-identifier-alt.js
index 2238d046b8..e6ec12ee88 100644
--- a/test/language/statements/class/elements/same-line-gen-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/same-line-gen-rs-static-generator-method-privatename-identifier-alt.js
@@ -103,7 +103,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-gen-rs-static-generator-method-privatename-identifier.js b/test/language/statements/class/elements/same-line-gen-rs-static-generator-method-privatename-identifier.js
index a5c8de77ea..fb41a838de 100644
--- a/test/language/statements/class/elements/same-line-gen-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/same-line-gen-rs-static-generator-method-privatename-identifier.js
@@ -103,7 +103,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-gen-rs-static-method-privatename-identifier-alt.js b/test/language/statements/class/elements/same-line-gen-rs-static-method-privatename-identifier-alt.js
index 624cf12aa0..2511e75017 100644
--- a/test/language/statements/class/elements/same-line-gen-rs-static-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/same-line-gen-rs-static-method-privatename-identifier-alt.js
@@ -100,7 +100,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-gen-rs-static-method-privatename-identifier.js b/test/language/statements/class/elements/same-line-gen-rs-static-method-privatename-identifier.js
index 88767441e8..56c06d8acd 100644
--- a/test/language/statements/class/elements/same-line-gen-rs-static-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/same-line-gen-rs-static-method-privatename-identifier.js
@@ -100,7 +100,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-gen-rs-static-privatename-identifier-alt-by-classname.js b/test/language/statements/class/elements/same-line-gen-rs-static-privatename-identifier-alt-by-classname.js
index f66601eb76..5a67899f4e 100644
--- a/test/language/statements/class/elements/same-line-gen-rs-static-privatename-identifier-alt-by-classname.js
+++ b/test/language/statements/class/elements/same-line-gen-rs-static-privatename-identifier-alt-by-classname.js
@@ -88,7 +88,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-gen-rs-static-privatename-identifier-alt.js b/test/language/statements/class/elements/same-line-gen-rs-static-privatename-identifier-alt.js
index 511b550bba..c2a2b04ca8 100644
--- a/test/language/statements/class/elements/same-line-gen-rs-static-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/same-line-gen-rs-static-privatename-identifier-alt.js
@@ -88,7 +88,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-gen-rs-static-privatename-identifier-by-classname.js b/test/language/statements/class/elements/same-line-gen-rs-static-privatename-identifier-by-classname.js
index af011ec91f..5b214a196e 100644
--- a/test/language/statements/class/elements/same-line-gen-rs-static-privatename-identifier-by-classname.js
+++ b/test/language/statements/class/elements/same-line-gen-rs-static-privatename-identifier-by-classname.js
@@ -88,7 +88,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js b/test/language/statements/class/elements/same-line-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
index 7384574475..99b35dadce 100644
--- a/test/language/statements/class/elements/same-line-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
+++ b/test/language/statements/class/elements/same-line-gen-rs-static-privatename-identifier-initializer-alt-by-classname.js
@@ -82,7 +82,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-gen-rs-static-privatename-identifier-initializer-alt.js b/test/language/statements/class/elements/same-line-gen-rs-static-privatename-identifier-initializer-alt.js
index 6113697f5a..f36b1b34cb 100644
--- a/test/language/statements/class/elements/same-line-gen-rs-static-privatename-identifier-initializer-alt.js
+++ b/test/language/statements/class/elements/same-line-gen-rs-static-privatename-identifier-initializer-alt.js
@@ -82,7 +82,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-gen-rs-static-privatename-identifier-initializer.js b/test/language/statements/class/elements/same-line-gen-rs-static-privatename-identifier-initializer.js
index a3ac475fbf..b7f3f27086 100644
--- a/test/language/statements/class/elements/same-line-gen-rs-static-privatename-identifier-initializer.js
+++ b/test/language/statements/class/elements/same-line-gen-rs-static-privatename-identifier-initializer.js
@@ -82,7 +82,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-gen-rs-static-privatename-identifier.js b/test/language/statements/class/elements/same-line-gen-rs-static-privatename-identifier.js
index ce0ec793a7..6cf0a48db5 100644
--- a/test/language/statements/class/elements/same-line-gen-rs-static-privatename-identifier.js
+++ b/test/language/statements/class/elements/same-line-gen-rs-static-privatename-identifier.js
@@ -88,7 +88,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-gen-static-private-fields.js b/test/language/statements/class/elements/same-line-gen-static-private-fields.js
index ab281b6aab..559097de95 100644
--- a/test/language/statements/class/elements/same-line-gen-static-private-fields.js
+++ b/test/language/statements/class/elements/same-line-gen-static-private-fields.js
@@ -40,7 +40,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -49,18 +52,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/statements/class/elements/same-line-gen-static-private-methods-with-fields.js b/test/language/statements/class/elements/same-line-gen-static-private-methods-with-fields.js
index e9fb853c21..6a02a7109a 100644
--- a/test/language/statements/class/elements/same-line-gen-static-private-methods-with-fields.js
+++ b/test/language/statements/class/elements/same-line-gen-static-private-methods-with-fields.js
@@ -46,7 +46,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -55,29 +58,29 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#xVal"), "test 7");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 8");
+assert(!Object.prototype.hasOwnProperty.call(c, "#xVal"), "test 9");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#yVal"), "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 11");
+assert(!Object.prototype.hasOwnProperty.call(c, "#yVal"), "test 12");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 13");
 assert.sameValue(C.y(), 43, "test 14");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 15");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 16");
 
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 17");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 18");
diff --git a/test/language/statements/class/elements/same-line-gen-static-private-methods.js b/test/language/statements/class/elements/same-line-gen-static-private-methods.js
index 192bf90577..f0e482abfb 100644
--- a/test/language/statements/class/elements/same-line-gen-static-private-methods.js
+++ b/test/language/statements/class/elements/same-line-gen-static-private-methods.js
@@ -44,7 +44,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -53,18 +56,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/statements/class/elements/same-line-gen-string-literal-names.js b/test/language/statements/class/elements/same-line-gen-string-literal-names.js
index 7c6313a8b8..090b798be9 100644
--- a/test/language/statements/class/elements/same-line-gen-string-literal-names.js
+++ b/test/language/statements/class/elements/same-line-gen-string-literal-names.js
@@ -31,7 +31,10 @@ var c = new C();
 
 assert.sameValue(c.m().next().value, 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -39,8 +42,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -49,8 +58,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: undefined,
@@ -59,8 +74,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: 39,
@@ -69,8 +90,14 @@ verifyProperty(c, "c", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "d"),
+  "d does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "d"),
+  "d does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "d", {
   value: 42,
diff --git a/test/language/statements/class/elements/same-line-method-computed-names.js b/test/language/statements/class/elements/same-line-method-computed-names.js
index 28dca30f7f..fde4d89e71 100644
--- a/test/language/statements/class/elements/same-line-method-computed-names.js
+++ b/test/language/statements/class/elements/same-line-method-computed-names.js
@@ -32,7 +32,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -40,8 +43,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -50,12 +59,27 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "10"),
+  "10 doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "10"),
+  "10 doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "10", {
   value: "meep",
@@ -64,8 +88,14 @@ verifyProperty(c, "10", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "not initialized", {
   value: undefined,
diff --git a/test/language/statements/class/elements/same-line-method-computed-symbol-names.js b/test/language/statements/class/elements/same-line-method-computed-symbol-names.js
index 73256b4467..13d88a3dd2 100644
--- a/test/language/statements/class/elements/same-line-method-computed-symbol-names.js
+++ b/test/language/statements/class/elements/same-line-method-computed-symbol-names.js
@@ -33,7 +33,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -41,8 +44,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, x), false);
-assert.sameValue(Object.hasOwnProperty.call(C, x), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, x),
+  "Symbol x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, x),
+  "Symbol x doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, x, {
   value: undefined,
@@ -51,8 +60,14 @@ verifyProperty(c, x, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
-assert.sameValue(Object.hasOwnProperty.call(C, y), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, y),
+  "Symbol y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, y),
+  "Symbol y doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, y, {
   value: 42,
@@ -61,10 +76,28 @@ verifyProperty(c, y, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "y"),
+  "y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "y"),
+  "y doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "y"),
+  "y doesn't appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/same-line-method-grammar-privatename-identifier-semantics-stringvalue.js b/test/language/statements/class/elements/same-line-method-grammar-privatename-identifier-semantics-stringvalue.js
index 8e2768592b..6fe826a381 100644
--- a/test/language/statements/class/elements/same-line-method-grammar-privatename-identifier-semantics-stringvalue.js
+++ b/test/language/statements/class/elements/same-line-method-grammar-privatename-identifier-semantics-stringvalue.js
@@ -90,7 +90,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-method-literal-names-asi.js b/test/language/statements/class/elements/same-line-method-literal-names-asi.js
index abcc297249..c770af2661 100644
--- a/test/language/statements/class/elements/same-line-method-literal-names-asi.js
+++ b/test/language/statements/class/elements/same-line-method-literal-names-asi.js
@@ -31,7 +31,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -39,8 +42,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -49,8 +58,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
diff --git a/test/language/statements/class/elements/same-line-method-literal-names.js b/test/language/statements/class/elements/same-line-method-literal-names.js
index d699cef61f..0bf03cb923 100644
--- a/test/language/statements/class/elements/same-line-method-literal-names.js
+++ b/test/language/statements/class/elements/same-line-method-literal-names.js
@@ -33,7 +33,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -41,8 +44,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -51,8 +60,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -61,8 +76,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: fn,
diff --git a/test/language/statements/class/elements/same-line-method-private-field-usage.js b/test/language/statements/class/elements/same-line-method-private-field-usage.js
index 74b8408453..490f50f986 100644
--- a/test/language/statements/class/elements/same-line-method-private-field-usage.js
+++ b/test/language/statements/class/elements/same-line-method-private-field-usage.js
@@ -33,7 +33,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-method-private-method-getter-usage.js b/test/language/statements/class/elements/same-line-method-private-method-getter-usage.js
index fbf8eb4063..41d0bdfb74 100644
--- a/test/language/statements/class/elements/same-line-method-private-method-getter-usage.js
+++ b/test/language/statements/class/elements/same-line-method-private-method-getter-usage.js
@@ -33,7 +33,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-method-private-method-usage.js b/test/language/statements/class/elements/same-line-method-private-method-usage.js
index 2eb883d8d3..9f6de47d92 100644
--- a/test/language/statements/class/elements/same-line-method-private-method-usage.js
+++ b/test/language/statements/class/elements/same-line-method-private-method-usage.js
@@ -33,7 +33,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-method-private-names.js b/test/language/statements/class/elements/same-line-method-private-names.js
index 3236136096..08ad4c4b18 100644
--- a/test/language/statements/class/elements/same-line-method-private-names.js
+++ b/test/language/statements/class/elements/same-line-method-private-names.js
@@ -40,7 +40,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -49,18 +52,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(c.x(), 42, "test 7");
 assert.sameValue(c.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 10");
diff --git a/test/language/statements/class/elements/same-line-method-rs-field-identifier-initializer.js b/test/language/statements/class/elements/same-line-method-rs-field-identifier-initializer.js
index c1035acdec..98fea76d5d 100644
--- a/test/language/statements/class/elements/same-line-method-rs-field-identifier-initializer.js
+++ b/test/language/statements/class/elements/same-line-method-rs-field-identifier-initializer.js
@@ -66,7 +66,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-method-rs-field-identifier.js b/test/language/statements/class/elements/same-line-method-rs-field-identifier.js
index 56084ee1f1..7b7e0d0ece 100644
--- a/test/language/statements/class/elements/same-line-method-rs-field-identifier.js
+++ b/test/language/statements/class/elements/same-line-method-rs-field-identifier.js
@@ -66,7 +66,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-method-rs-private-getter-alt.js b/test/language/statements/class/elements/same-line-method-rs-private-getter-alt.js
index 05c73a4ebf..fa79a8f4d6 100644
--- a/test/language/statements/class/elements/same-line-method-rs-private-getter-alt.js
+++ b/test/language/statements/class/elements/same-line-method-rs-private-getter-alt.js
@@ -107,7 +107,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-method-rs-private-getter.js b/test/language/statements/class/elements/same-line-method-rs-private-getter.js
index 8dec7ecdc3..79f21c03db 100644
--- a/test/language/statements/class/elements/same-line-method-rs-private-getter.js
+++ b/test/language/statements/class/elements/same-line-method-rs-private-getter.js
@@ -107,7 +107,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-method-rs-private-method-alt.js b/test/language/statements/class/elements/same-line-method-rs-private-method-alt.js
index 0bdffdbca6..ed587a732a 100644
--- a/test/language/statements/class/elements/same-line-method-rs-private-method-alt.js
+++ b/test/language/statements/class/elements/same-line-method-rs-private-method-alt.js
@@ -106,7 +106,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-method-rs-private-method.js b/test/language/statements/class/elements/same-line-method-rs-private-method.js
index b2577354a4..ca5912f71c 100644
--- a/test/language/statements/class/elements/same-line-method-rs-private-method.js
+++ b/test/language/statements/class/elements/same-line-method-rs-private-method.js
@@ -106,7 +106,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-method-rs-private-setter-alt.js b/test/language/statements/class/elements/same-line-method-rs-private-setter-alt.js
index 6ee06ab9b4..b963bdaee2 100644
--- a/test/language/statements/class/elements/same-line-method-rs-private-setter-alt.js
+++ b/test/language/statements/class/elements/same-line-method-rs-private-setter-alt.js
@@ -106,7 +106,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-method-rs-private-setter.js b/test/language/statements/class/elements/same-line-method-rs-private-setter.js
index df1951952a..234f71e83b 100644
--- a/test/language/statements/class/elements/same-line-method-rs-private-setter.js
+++ b/test/language/statements/class/elements/same-line-method-rs-private-setter.js
@@ -106,7 +106,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-method-rs-privatename-identifier-alt.js b/test/language/statements/class/elements/same-line-method-rs-privatename-identifier-alt.js
index 27e705be79..3dd2eaece4 100644
--- a/test/language/statements/class/elements/same-line-method-rs-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/same-line-method-rs-privatename-identifier-alt.js
@@ -87,7 +87,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-method-rs-privatename-identifier-initializer-alt.js b/test/language/statements/class/elements/same-line-method-rs-privatename-identifier-initializer-alt.js
index 91e9fa0ad2..7813e76682 100644
--- a/test/language/statements/class/elements/same-line-method-rs-privatename-identifier-initializer-alt.js
+++ b/test/language/statements/class/elements/same-line-method-rs-privatename-identifier-initializer-alt.js
@@ -81,7 +81,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-method-rs-privatename-identifier-initializer.js b/test/language/statements/class/elements/same-line-method-rs-privatename-identifier-initializer.js
index 0b1701a304..63b24635f1 100644
--- a/test/language/statements/class/elements/same-line-method-rs-privatename-identifier-initializer.js
+++ b/test/language/statements/class/elements/same-line-method-rs-privatename-identifier-initializer.js
@@ -81,7 +81,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-method-rs-privatename-identifier.js b/test/language/statements/class/elements/same-line-method-rs-privatename-identifier.js
index 27ce9159b1..a4e21ca3ab 100644
--- a/test/language/statements/class/elements/same-line-method-rs-privatename-identifier.js
+++ b/test/language/statements/class/elements/same-line-method-rs-privatename-identifier.js
@@ -87,7 +87,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-method-rs-static-async-generator-method-privatename-identifier-alt.js b/test/language/statements/class/elements/same-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
index 9d637ba591..359e956e3b 100644
--- a/test/language/statements/class/elements/same-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/same-line-method-rs-static-async-generator-method-privatename-identifier-alt.js
@@ -103,7 +103,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-method-rs-static-async-generator-method-privatename-identifier.js b/test/language/statements/class/elements/same-line-method-rs-static-async-generator-method-privatename-identifier.js
index 94d3e836b0..dbcf48048f 100644
--- a/test/language/statements/class/elements/same-line-method-rs-static-async-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/same-line-method-rs-static-async-generator-method-privatename-identifier.js
@@ -103,7 +103,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-method-rs-static-async-method-privatename-identifier-alt.js b/test/language/statements/class/elements/same-line-method-rs-static-async-method-privatename-identifier-alt.js
index de0c83c6bd..1424d63cd3 100644
--- a/test/language/statements/class/elements/same-line-method-rs-static-async-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/same-line-method-rs-static-async-method-privatename-identifier-alt.js
@@ -103,7 +103,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-method-rs-static-async-method-privatename-identifier.js b/test/language/statements/class/elements/same-line-method-rs-static-async-method-privatename-identifier.js
index 838d679486..a086247724 100644
--- a/test/language/statements/class/elements/same-line-method-rs-static-async-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/same-line-method-rs-static-async-method-privatename-identifier.js
@@ -103,7 +103,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-method-rs-static-generator-method-privatename-identifier-alt.js b/test/language/statements/class/elements/same-line-method-rs-static-generator-method-privatename-identifier-alt.js
index 765102d0e5..0a480361dd 100644
--- a/test/language/statements/class/elements/same-line-method-rs-static-generator-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/same-line-method-rs-static-generator-method-privatename-identifier-alt.js
@@ -103,7 +103,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-method-rs-static-generator-method-privatename-identifier.js b/test/language/statements/class/elements/same-line-method-rs-static-generator-method-privatename-identifier.js
index cb57018c9c..6a87a5cab5 100644
--- a/test/language/statements/class/elements/same-line-method-rs-static-generator-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/same-line-method-rs-static-generator-method-privatename-identifier.js
@@ -103,7 +103,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-method-rs-static-method-privatename-identifier-alt.js b/test/language/statements/class/elements/same-line-method-rs-static-method-privatename-identifier-alt.js
index 5aa62623f5..7733221788 100644
--- a/test/language/statements/class/elements/same-line-method-rs-static-method-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/same-line-method-rs-static-method-privatename-identifier-alt.js
@@ -100,7 +100,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-method-rs-static-method-privatename-identifier.js b/test/language/statements/class/elements/same-line-method-rs-static-method-privatename-identifier.js
index f4c665047f..404644dc67 100644
--- a/test/language/statements/class/elements/same-line-method-rs-static-method-privatename-identifier.js
+++ b/test/language/statements/class/elements/same-line-method-rs-static-method-privatename-identifier.js
@@ -100,7 +100,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-method-rs-static-privatename-identifier-alt-by-classname.js b/test/language/statements/class/elements/same-line-method-rs-static-privatename-identifier-alt-by-classname.js
index 61b793d3bc..1650e4fbcf 100644
--- a/test/language/statements/class/elements/same-line-method-rs-static-privatename-identifier-alt-by-classname.js
+++ b/test/language/statements/class/elements/same-line-method-rs-static-privatename-identifier-alt-by-classname.js
@@ -88,7 +88,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-method-rs-static-privatename-identifier-alt.js b/test/language/statements/class/elements/same-line-method-rs-static-privatename-identifier-alt.js
index 21fc1f4d54..e9159ea2f4 100644
--- a/test/language/statements/class/elements/same-line-method-rs-static-privatename-identifier-alt.js
+++ b/test/language/statements/class/elements/same-line-method-rs-static-privatename-identifier-alt.js
@@ -88,7 +88,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-method-rs-static-privatename-identifier-by-classname.js b/test/language/statements/class/elements/same-line-method-rs-static-privatename-identifier-by-classname.js
index 2c2970dce3..e27d3d758b 100644
--- a/test/language/statements/class/elements/same-line-method-rs-static-privatename-identifier-by-classname.js
+++ b/test/language/statements/class/elements/same-line-method-rs-static-privatename-identifier-by-classname.js
@@ -88,7 +88,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-method-rs-static-privatename-identifier-initializer-alt-by-classname.js b/test/language/statements/class/elements/same-line-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
index a88ff633a5..d7510e2d0b 100644
--- a/test/language/statements/class/elements/same-line-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
+++ b/test/language/statements/class/elements/same-line-method-rs-static-privatename-identifier-initializer-alt-by-classname.js
@@ -82,7 +82,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-method-rs-static-privatename-identifier-initializer-alt.js b/test/language/statements/class/elements/same-line-method-rs-static-privatename-identifier-initializer-alt.js
index d515609a18..81604efcb7 100644
--- a/test/language/statements/class/elements/same-line-method-rs-static-privatename-identifier-initializer-alt.js
+++ b/test/language/statements/class/elements/same-line-method-rs-static-privatename-identifier-initializer-alt.js
@@ -82,7 +82,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-method-rs-static-privatename-identifier-initializer.js b/test/language/statements/class/elements/same-line-method-rs-static-privatename-identifier-initializer.js
index a6a5a0401e..5815ad9402 100644
--- a/test/language/statements/class/elements/same-line-method-rs-static-privatename-identifier-initializer.js
+++ b/test/language/statements/class/elements/same-line-method-rs-static-privatename-identifier-initializer.js
@@ -82,7 +82,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-method-rs-static-privatename-identifier.js b/test/language/statements/class/elements/same-line-method-rs-static-privatename-identifier.js
index 23c2ea4293..b3bd4442d9 100644
--- a/test/language/statements/class/elements/same-line-method-rs-static-privatename-identifier.js
+++ b/test/language/statements/class/elements/same-line-method-rs-static-privatename-identifier.js
@@ -88,7 +88,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
diff --git a/test/language/statements/class/elements/same-line-method-static-private-fields.js b/test/language/statements/class/elements/same-line-method-static-private-fields.js
index 62e9fe3a5c..bb28fb764b 100644
--- a/test/language/statements/class/elements/same-line-method-static-private-fields.js
+++ b/test/language/statements/class/elements/same-line-method-static-private-fields.js
@@ -40,7 +40,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -49,18 +52,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/statements/class/elements/same-line-method-static-private-methods-with-fields.js b/test/language/statements/class/elements/same-line-method-static-private-methods-with-fields.js
index 79076f7eed..77a4f3886f 100644
--- a/test/language/statements/class/elements/same-line-method-static-private-methods-with-fields.js
+++ b/test/language/statements/class/elements/same-line-method-static-private-methods-with-fields.js
@@ -46,7 +46,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -55,29 +58,29 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#xVal"), "test 7");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 8");
+assert(!Object.prototype.hasOwnProperty.call(c, "#xVal"), "test 9");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#yVal"), "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 11");
+assert(!Object.prototype.hasOwnProperty.call(c, "#yVal"), "test 12");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 13");
 assert.sameValue(C.y(), 43, "test 14");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 15");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 16");
 
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 17");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 18");
diff --git a/test/language/statements/class/elements/same-line-method-static-private-methods.js b/test/language/statements/class/elements/same-line-method-static-private-methods.js
index f3fa850d04..f4e267a944 100644
--- a/test/language/statements/class/elements/same-line-method-static-private-methods.js
+++ b/test/language/statements/class/elements/same-line-method-static-private-methods.js
@@ -44,7 +44,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -53,18 +56,18 @@ verifyProperty(C.prototype, "m", {
 });
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/statements/class/elements/same-line-method-string-literal-names.js b/test/language/statements/class/elements/same-line-method-string-literal-names.js
index 3ab9a413f4..9010ff803f 100644
--- a/test/language/statements/class/elements/same-line-method-string-literal-names.js
+++ b/test/language/statements/class/elements/same-line-method-string-literal-names.js
@@ -31,7 +31,10 @@ var c = new C();
 
 assert.sameValue(c.m(), 42);
 assert.sameValue(c.m, C.prototype.m);
-assert.sameValue(Object.hasOwnProperty.call(c, "m"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "m"),
+  "m doesn't appear as an own property on the C instance"
+);
 
 verifyProperty(C.prototype, "m", {
   enumerable: false,
@@ -39,8 +42,14 @@ verifyProperty(C.prototype, "m", {
   writable: true,
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -49,8 +58,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: undefined,
@@ -59,8 +74,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: 39,
@@ -69,8 +90,14 @@ verifyProperty(c, "c", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "d"),
+  "d does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "d"),
+  "d does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "d", {
   value: 42,
diff --git a/test/language/statements/class/elements/static-field-declaration.js b/test/language/statements/class/elements/static-field-declaration.js
index 9a333996ee..a0a78a7cc6 100644
--- a/test/language/statements/class/elements/static-field-declaration.js
+++ b/test/language/statements/class/elements/static-field-declaration.js
@@ -84,10 +84,22 @@ assert.sameValue(c.g, undefined);
 assert.sameValue(c.h, undefined);
 assert.sameValue(c[0], undefined);
 
-assert.sameValue(Object.hasOwnProperty.call(c, 'f'), false);
-assert.sameValue(Object.hasOwnProperty.call(c, 'g'), false);
-assert.sameValue(Object.hasOwnProperty.call(c, 'h'), false);
-assert.sameValue(Object.hasOwnProperty.call(c, 0), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, 'f'),
+  "f does not appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, 'g'),
+  "g does not appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, 'h'),
+  "h does not appear as an own property on the C instance"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, 0),
+  "0 does not appear as an own property on the C instance"
+);
 
 verifyProperty(C, 'f', {
   value: 'test262',
diff --git a/test/language/statements/class/elements/wrapped-in-sc-computed-names.js b/test/language/statements/class/elements/wrapped-in-sc-computed-names.js
index ecaa6c05d0..769bcf6a05 100644
--- a/test/language/statements/class/elements/wrapped-in-sc-computed-names.js
+++ b/test/language/statements/class/elements/wrapped-in-sc-computed-names.js
@@ -32,8 +32,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -42,12 +48,27 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "10"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "10"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "10"),
+  "10 doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "10"),
+  "10 doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "10", {
   value: "meep",
@@ -56,8 +77,14 @@ verifyProperty(c, "10", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "not initialized"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "not initialized"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "not initialized"),
+  "'not initialized' doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "not initialized", {
   value: undefined,
diff --git a/test/language/statements/class/elements/wrapped-in-sc-computed-symbol-names.js b/test/language/statements/class/elements/wrapped-in-sc-computed-symbol-names.js
index 5e00cae237..83981f5e2f 100644
--- a/test/language/statements/class/elements/wrapped-in-sc-computed-symbol-names.js
+++ b/test/language/statements/class/elements/wrapped-in-sc-computed-symbol-names.js
@@ -33,8 +33,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, x), false);
-assert.sameValue(Object.hasOwnProperty.call(C, x), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, x),
+  "Symbol x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, x),
+  "Symbol x doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, x, {
   value: undefined,
@@ -43,8 +49,14 @@ verifyProperty(c, x, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, y), false);
-assert.sameValue(Object.hasOwnProperty.call(C, y), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, y),
+  "Symbol y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, y),
+  "Symbol y doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, y, {
   value: 42,
@@ -53,10 +65,28 @@ verifyProperty(c, y, {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "x"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "x"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "x"),
+  "x doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "x"),
+  "x doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "x"),
+  "x doesn't appear as an own property on C instance"
+);
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "y"), false);
-assert.sameValue(Object.hasOwnProperty.call(c, "y"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "y"),
+  "y doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "y"),
+  "y doesn't appear as an own property on C constructor"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(c, "y"),
+  "y doesn't appear as an own property on C instance"
+);
diff --git a/test/language/statements/class/elements/wrapped-in-sc-literal-names-asi.js b/test/language/statements/class/elements/wrapped-in-sc-literal-names-asi.js
index 61719da04d..9aaa6f1560 100644
--- a/test/language/statements/class/elements/wrapped-in-sc-literal-names-asi.js
+++ b/test/language/statements/class/elements/wrapped-in-sc-literal-names-asi.js
@@ -31,8 +31,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -41,8 +47,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
diff --git a/test/language/statements/class/elements/wrapped-in-sc-literal-names.js b/test/language/statements/class/elements/wrapped-in-sc-literal-names.js
index 42c3b09d13..2d406ea82c 100644
--- a/test/language/statements/class/elements/wrapped-in-sc-literal-names.js
+++ b/test/language/statements/class/elements/wrapped-in-sc-literal-names.js
@@ -33,8 +33,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -43,8 +49,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: 42,
@@ -53,8 +65,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c doesn't appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c doesn't appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: fn,
diff --git a/test/language/statements/class/elements/wrapped-in-sc-private-names.js b/test/language/statements/class/elements/wrapped-in-sc-private-names.js
index dd7e80c768..99c631c1db 100644
--- a/test/language/statements/class/elements/wrapped-in-sc-private-names.js
+++ b/test/language/statements/class/elements/wrapped-in-sc-private-names.js
@@ -40,18 +40,18 @@ class C {
 var c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(c.x(), 42, "test 7");
 assert.sameValue(c.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 10");
diff --git a/test/language/statements/class/elements/wrapped-in-sc-static-private-fields.js b/test/language/statements/class/elements/wrapped-in-sc-static-private-fields.js
index ed5d9a328e..8ade0a8fce 100644
--- a/test/language/statements/class/elements/wrapped-in-sc-static-private-fields.js
+++ b/test/language/statements/class/elements/wrapped-in-sc-static-private-fields.js
@@ -40,18 +40,18 @@ class C {
 var c = new C();
 
 // Test the private fields do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 43, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/statements/class/elements/wrapped-in-sc-static-private-methods-with-fields.js b/test/language/statements/class/elements/wrapped-in-sc-static-private-methods-with-fields.js
index b651813f84..2ef824f600 100644
--- a/test/language/statements/class/elements/wrapped-in-sc-static-private-methods-with-fields.js
+++ b/test/language/statements/class/elements/wrapped-in-sc-static-private-methods-with-fields.js
@@ -46,29 +46,29 @@ class C {
 var c = new C();
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#xVal"), false, "test 7");
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 8");
-assert.sameValue(Object.hasOwnProperty.call(c, "#xVal"), false, "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#xVal"), "test 7");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 8");
+assert(!Object.prototype.hasOwnProperty.call(c, "#xVal"), "test 9");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#yVal"), false, "test 10");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 11");
-assert.sameValue(Object.hasOwnProperty.call(c, "#yVal"), false, "test 12");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#yVal"), "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 11");
+assert(!Object.prototype.hasOwnProperty.call(c, "#yVal"), "test 12");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 13");
 assert.sameValue(C.y(), 43, "test 14");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 15");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 16");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 15");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 16");
 
-assert.sameValue(Object.hasOwnProperty.call(C, "#xVal"), false, "test 17");
-assert.sameValue(Object.hasOwnProperty.call(C, "#yVal"), false, "test 18");
+assert(!Object.prototype.hasOwnProperty.call(C, "#xVal"), "test 17");
+assert(!Object.prototype.hasOwnProperty.call(C, "#yVal"), "test 18");
diff --git a/test/language/statements/class/elements/wrapped-in-sc-static-private-methods.js b/test/language/statements/class/elements/wrapped-in-sc-static-private-methods.js
index e093c6b438..91bc8c0e46 100644
--- a/test/language/statements/class/elements/wrapped-in-sc-static-private-methods.js
+++ b/test/language/statements/class/elements/wrapped-in-sc-static-private-methods.js
@@ -44,18 +44,18 @@ class C {
 var c = new C();
 
 // Test the private methods do not appear as properties before set to value
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#x"), false, "test 1");
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 2");
-assert.sameValue(Object.hasOwnProperty.call(c, "#x"), false, "test 3");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#x"), "test 1");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 2");
+assert(!Object.prototype.hasOwnProperty.call(c, "#x"), "test 3");
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "#y"), false, "test 4");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 5");
-assert.sameValue(Object.hasOwnProperty.call(c, "#y"), false, "test 6");
+assert(!Object.prototype.hasOwnProperty.call(C.prototype, "#y"), "test 4");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 5");
+assert(!Object.prototype.hasOwnProperty.call(c, "#y"), "test 6");
 
 // Test if private fields can be sucessfully accessed and set to value
 assert.sameValue(C.x(), 42, "test 7");
 assert.sameValue(C.y(), 86, "test 8");
 
 // Test the private fields do not appear as properties before after set to value
-assert.sameValue(Object.hasOwnProperty.call(C, "#x"), false, "test 9");
-assert.sameValue(Object.hasOwnProperty.call(C, "#y"), false, "test 10");
+assert(!Object.prototype.hasOwnProperty.call(C, "#x"), "test 9");
+assert(!Object.prototype.hasOwnProperty.call(C, "#y"), "test 10");
diff --git a/test/language/statements/class/elements/wrapped-in-sc-string-literal-names.js b/test/language/statements/class/elements/wrapped-in-sc-string-literal-names.js
index c53bcb6652..cb68e2714d 100644
--- a/test/language/statements/class/elements/wrapped-in-sc-string-literal-names.js
+++ b/test/language/statements/class/elements/wrapped-in-sc-string-literal-names.js
@@ -31,8 +31,14 @@ class C {
 
 var c = new C();
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "a"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "a"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "a"),
+  "a does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "a"),
+  "a does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "a", {
   value: undefined,
@@ -41,8 +47,14 @@ verifyProperty(c, "a", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "b"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "b"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "b"),
+  "b does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "b"),
+  "b does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "b", {
   value: undefined,
@@ -51,8 +63,14 @@ verifyProperty(c, "b", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "c"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "c"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "c"),
+  "c does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "c"),
+  "c does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "c", {
   value: 39,
@@ -61,8 +79,14 @@ verifyProperty(c, "c", {
   configurable: true
 });
 
-assert.sameValue(Object.hasOwnProperty.call(C.prototype, "d"), false);
-assert.sameValue(Object.hasOwnProperty.call(C, "d"), false);
+assert(
+  !Object.prototype.hasOwnProperty.call(C.prototype, "d"),
+  "d does not appear as an own property on C prototype"
+);
+assert(
+  !Object.prototype.hasOwnProperty.call(C, "d"),
+  "d does not appear as an own property on C constructor"
+);
 
 verifyProperty(c, "d", {
   value: 42,
diff --git a/test/language/statements/generators/yield-identifier-spread-non-strict.js b/test/language/statements/generators/yield-identifier-spread-non-strict.js
index 4c7858bdec..ad56eb1b66 100644
--- a/test/language/statements/generators/yield-identifier-spread-non-strict.js
+++ b/test/language/statements/generators/yield-identifier-spread-non-strict.js
@@ -55,7 +55,7 @@ assert.sameValue(value.z, 30);
 assert.sameValue(value.a, 1);
 assert.sameValue(value.b, 2);
 assert.sameValue(value[s], 42);
-assert(Object.hasOwnProperty.call(value, s));
+assert(Object.prototype.hasOwnProperty.call(value, s), "s is an own property");
 assert.sameValue(Object.keys(value).length, 5);
 
 assert.sameValue(callCount, 1);