From 26a029d407be480d791972afb5975cf62c9360a6 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 02:47:55 +0200 Subject: Adding upstream version 124.0.1. Signed-off-by: Daniel Baumann --- .../built-ins/FinalizationRegistry/browser.js | 0 .../built-ins/FinalizationRegistry/constructor.js | 18 ++++ ...ne-chance-to-call-cleanupCallback-for-object.js | 97 ++++++++++++++++++++++ .../FinalizationRegistry/instance-extensible.js | 33 ++++++++ .../FinalizationRegistry/is-a-constructor.js | 27 ++++++ .../built-ins/FinalizationRegistry/length.js | 35 ++++++++ .../test262/built-ins/FinalizationRegistry/name.js | 34 ++++++++ .../newtarget-prototype-is-not-object.js | 61 ++++++++++++++ .../built-ins/FinalizationRegistry/prop-desc.js | 25 ++++++ .../FinalizationRegistry/proto-from-ctor-realm.js | 62 ++++++++++++++ .../built-ins/FinalizationRegistry/proto.js | 21 +++++ .../prototype-from-newtarget-abrupt.js | 44 ++++++++++ .../prototype-from-newtarget-custom.js | 47 +++++++++++ .../prototype-from-newtarget.js | 36 ++++++++ .../prototype/Symbol.toStringTag.js | 26 ++++++ .../FinalizationRegistry/prototype/browser.js | 0 .../prototype/cleanupSome/browser.js | 0 .../cleanupSome/callback-not-callable-throws.js | 56 +++++++++++++ .../cleanup-prevented-with-reference.js | 48 +++++++++++ .../cleanup-prevented-with-unregister.js | 55 ++++++++++++ .../prototype/cleanupSome/custom-this.js | 29 +++++++ .../cleanupSome/holdings-multiple-values.js | 70 ++++++++++++++++ .../prototype/cleanupSome/length.js | 35 ++++++++ .../prototype/cleanupSome/name.js | 34 ++++++++ .../prototype/cleanupSome/not-a-constructor.js | 36 ++++++++ .../prototype/cleanupSome/prop-desc.js | 27 ++++++ .../prototype/cleanupSome/reentrancy.js | 52 ++++++++++++ .../cleanupSome/return-undefined-with-gc.js | 67 +++++++++++++++ .../prototype/cleanupSome/return-undefined.js | 44 ++++++++++ .../prototype/cleanupSome/shell.js | 0 .../this-does-not-have-internal-cells-throws.js | 51 ++++++++++++ .../cleanupSome/this-not-object-throws.js | 53 ++++++++++++ .../FinalizationRegistry/prototype/constructor.js | 26 ++++++ .../FinalizationRegistry/prototype/prop-desc.js | 21 +++++ .../FinalizationRegistry/prototype/proto.js | 17 ++++ .../prototype/register/browser.js | 0 .../prototype/register/custom-this.js | 31 +++++++ .../prototype/register/heldValue-same-as-target.js | 38 +++++++++ .../prototype/register/holdings-any-value-type.js | 38 +++++++++ .../prototype/register/length.js | 35 ++++++++ .../prototype/register/name.js | 34 ++++++++ .../prototype/register/not-a-constructor.js | 36 ++++++++ .../prototype/register/prop-desc.js | 27 ++++++ .../register/return-undefined-register-itself.js | 33 ++++++++ .../register/return-undefined-register-object.js | 46 ++++++++++ .../register/return-undefined-register-symbol.js | 76 +++++++++++++++++ .../prototype/register/shell.js | 0 .../this-does-not-have-internal-target-throws.js | 51 ++++++++++++ .../prototype/register/this-not-object-throws.js | 54 ++++++++++++ .../throws-when-target-cannot-be-held-weakly.js | 47 +++++++++++ ...oken-not-undefined-and-cannot-be-held-weakly.js | 47 +++++++++++ .../unregisterToken-same-as-holdings-and-target.js | 30 +++++++ .../register/unregisterToken-same-as-holdings.js | 30 +++++++ .../register/unregisterToken-same-as-target.js | 29 +++++++ .../FinalizationRegistry/prototype/shell.js | 0 .../prototype/unregister/browser.js | 0 .../prototype/unregister/custom-this.js | 50 +++++++++++ .../prototype/unregister/length.js | 35 ++++++++ .../prototype/unregister/name.js | 34 ++++++++ .../prototype/unregister/not-a-constructor.js | 36 ++++++++ .../prototype/unregister/prop-desc.js | 27 ++++++ .../prototype/unregister/shell.js | 0 .../this-does-not-have-internal-cells-throws.js | 51 ++++++++++++ .../prototype/unregister/this-not-object-throws.js | 52 ++++++++++++ ...s-when-unregisterToken-cannot-be-held-weakly.js | 47 +++++++++++ .../unregister-cleaned-up-object-cell.js | 64 ++++++++++++++ .../unregister/unregister-object-token.js | 57 +++++++++++++ .../unregister/unregister-symbol-token.js | 64 ++++++++++++++ .../returns-new-object-from-constructor.js | 42 ++++++++++ .../built-ins/FinalizationRegistry/shell.js | 83 ++++++++++++++++++ .../target-not-callable-throws.js | 72 ++++++++++++++++ .../undefined-newtarget-throws.js | 31 +++++++ .../unnaffected-by-poisoned-cleanupCallback.js | 36 ++++++++ 73 files changed, 2750 insertions(+) create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/browser.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/constructor.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/gc-has-one-chance-to-call-cleanupCallback-for-object.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/instance-extensible.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/is-a-constructor.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/length.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/name.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/newtarget-prototype-is-not-object.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prop-desc.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/proto-from-ctor-realm.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/proto.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype-from-newtarget-abrupt.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype-from-newtarget-custom.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype-from-newtarget.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/Symbol.toStringTag.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/browser.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/browser.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/callback-not-callable-throws.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/cleanup-prevented-with-reference.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/cleanup-prevented-with-unregister.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/custom-this.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/holdings-multiple-values.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/length.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/name.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/not-a-constructor.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/prop-desc.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/reentrancy.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/return-undefined-with-gc.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/return-undefined.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/shell.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/this-does-not-have-internal-cells-throws.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/this-not-object-throws.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/constructor.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/prop-desc.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/proto.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/browser.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/custom-this.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/heldValue-same-as-target.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/holdings-any-value-type.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/length.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/name.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/not-a-constructor.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/prop-desc.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/return-undefined-register-itself.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/return-undefined-register-object.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/return-undefined-register-symbol.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/shell.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/this-does-not-have-internal-target-throws.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/this-not-object-throws.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/throws-when-target-cannot-be-held-weakly.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/throws-when-unregisterToken-not-undefined-and-cannot-be-held-weakly.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/unregisterToken-same-as-holdings-and-target.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/unregisterToken-same-as-holdings.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/unregisterToken-same-as-target.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/shell.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/browser.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/custom-this.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/length.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/name.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/not-a-constructor.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/prop-desc.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/shell.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/this-does-not-have-internal-cells-throws.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/this-not-object-throws.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/throws-when-unregisterToken-cannot-be-held-weakly.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/unregister-cleaned-up-object-cell.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/unregister-object-token.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/unregister-symbol-token.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/returns-new-object-from-constructor.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/shell.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/target-not-callable-throws.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/undefined-newtarget-throws.js create mode 100644 js/src/tests/test262/built-ins/FinalizationRegistry/unnaffected-by-poisoned-cleanupCallback.js (limited to 'js/src/tests/test262/built-ins/FinalizationRegistry') diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/browser.js b/js/src/tests/test262/built-ins/FinalizationRegistry/browser.js new file mode 100644 index 0000000000..e69de29bb2 diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/constructor.js b/js/src/tests/test262/built-ins/FinalizationRegistry/constructor.js new file mode 100644 index 0000000000..56ba61b07a --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/constructor.js @@ -0,0 +1,18 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry-constructor +description: > + The FinalizationRegistry constructor is the %FinalizationRegistry% intrinsic object and the initial + value of the FinalizationRegistry property of the global object. +features: [FinalizationRegistry] +---*/ + +assert.sameValue( + typeof FinalizationRegistry, 'function', + 'typeof FinalizationRegistry is function' +); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/gc-has-one-chance-to-call-cleanupCallback-for-object.js b/js/src/tests/test262/built-ins/FinalizationRegistry/gc-has-one-chance-to-call-cleanupCallback-for-object.js new file mode 100644 index 0000000000..276574af63 --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/gc-has-one-chance-to-call-cleanupCallback-for-object.js @@ -0,0 +1,97 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) async -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry-target +description: > + cleanupCallback has only one optional chance to be called for a GC that cleans + up a registered Object target. +info: | + FinalizationRegistry.prototype.cleanupSome ( [ _callback_ ] ) + 3. If _callback_ is present and IsCallable(_callback_) is *false*, throw a + *TypeError* exception. + 4. Perform ? CleanupFinalizationRegistry(_finalizationRegistry_, _callback_). + 5. Return *undefined*. + + Execution + + At any time, if a set of objects and/or symbols _S_ is not live, an ECMAScript + implementation may perform the following steps atomically: + + 1. For each element _value_ of _S_, do + ... + b. For each FinalizationRegistry _fg_ such that _fg_.[[Cells]] contains a + Record _cell_ such that _cell_.[[WeakRefTarget]] is _value_, + i. Set _cell_.[[WeakRefTarget]] to ~empty~. + ii. Optionally, perform HostEnqueueFinalizationRegistryCleanupJob(_fg_). +features: [FinalizationRegistry.prototype.cleanupSome, FinalizationRegistry, async-functions, host-gc-required] +flags: [async, non-deterministic] +includes: [async-gc.js, compareArray.js] +---*/ + +let cleanupCallback = 0; +let holdings = []; +function cb(holding) { + holdings.push(holding); +} + +let finalizationRegistry = new FinalizationRegistry(function() { + cleanupCallback += 1; +}); + +function emptyCells() { + let target = {}; + finalizationRegistry.register(target, 'a'); + + let prom = asyncGC(target); + target = null; + + return prom; +} + +emptyCells().then(async function() { + await Promise.resolve(1); + + finalizationRegistry.cleanupSome(cb); + + // cleanupSome will be invoked if there are empty cells left. If the + // cleanupCallback already ran, then cb won't be called. + let expectedCalled = cleanupCallback === 1 ? 0 : 1; + // This asserts the registered object was emptied in the previous GC. + assert.sameValue(holdings.length, expectedCalled, 'cleanupSome callback for the first time'); + + // At this point, we can't assert if cleanupCallback was called, because it's + // optional. Although, we can finally assert it's not gonna be called anymore + // for the other executions of the Garbage Collector. + // The chance of having it called only happens right after the + // cell.[[WeakRefTarget]] is set to empty. + assert(cleanupCallback >= 0, 'cleanupCallback might be 0'); + assert(cleanupCallback <= 1, 'cleanupCallback might be 1'); + + // Restoring the cleanupCallback variable to 0 will help us asserting the + // finalizationRegistry callback is not called again. + cleanupCallback = 0; + + await $262.gc(); + await Promise.resolve(2); // tick + + finalizationRegistry.cleanupSome(cb); + + assert.sameValue(holdings.length, expectedCalled, 'cleanupSome callback is not called anymore, no empty cells'); + assert.sameValue(cleanupCallback, 0, 'cleanupCallback is not called again #1'); + + await $262.gc(); + await Promise.resolve(3); // tick + + finalizationRegistry.cleanupSome(cb); + + assert.sameValue(holdings.length, expectedCalled, 'cleanupSome callback is not called again #2'); + assert.sameValue(cleanupCallback, 0, 'cleanupCallback is not called again #2'); + + if (holdings.length) { + assert.compareArray(holdings, ['a']); + } + + await $262.gc(); +}).then($DONE, resolveAsyncGC); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/instance-extensible.js b/js/src/tests/test262/built-ins/FinalizationRegistry/instance-extensible.js new file mode 100644 index 0000000000..b8e9fb09ce --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/instance-extensible.js @@ -0,0 +1,33 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry-target +description: Instances of FinalizationRegistry are extensible +info: | + FinalizationRegistry ( cleanupCallback ) + + ... + 3. Let finalizationRegistry be ? OrdinaryCreateFromConstructor(NewTarget, "%FinalizationRegistryPrototype%", « [[Realm]], [[CleanupCallback]], [[Cells]], [[IsFinalizationRegistryCleanupJobActive]] »). + ... + 9. Return finalizationRegistry. + + OrdinaryCreateFromConstructor ( constructor, intrinsicDefaultProto [ , internalSlotsList ] ) + + ... + 2. Let proto be ? GetPrototypeFromConstructor(constructor, intrinsicDefaultProto). + 3. Return ObjectCreate(proto, internalSlotsList). + + ObjectCreate ( proto [ , internalSlotsList ] ) + + 4. Set obj.[[Prototype]] to proto. + 5. Set obj.[[Extensible]] to true. + 6. Return obj. +features: [FinalizationRegistry] +---*/ + +var finalizationRegistry = new FinalizationRegistry(function() {}); +assert.sameValue(Object.isExtensible(finalizationRegistry), true); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/is-a-constructor.js b/js/src/tests/test262/built-ins/FinalizationRegistry/is-a-constructor.js new file mode 100644 index 0000000000..bcd6332ff8 --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/is-a-constructor.js @@ -0,0 +1,27 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2020 Rick Waldron. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-ecmascript-standard-built-in-objects +description: > + The FinalizationRegistry constructor implements [[Construct]] +info: | + IsConstructor ( argument ) + + The abstract operation IsConstructor takes argument argument (an ECMAScript language value). + It determines if argument is a function object with a [[Construct]] internal method. + It performs the following steps when called: + + If Type(argument) is not Object, return false. + If argument has a [[Construct]] internal method, return true. + Return false. +includes: [isConstructor.js] +features: [Reflect.construct, FinalizationRegistry, arrow-function] +---*/ + +assert.sameValue(isConstructor(FinalizationRegistry), true, 'isConstructor(FinalizationRegistry) must return true'); +new FinalizationRegistry(() => {}); + + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/length.js b/js/src/tests/test262/built-ins/FinalizationRegistry/length.js new file mode 100644 index 0000000000..5ac6d2f0d8 --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/length.js @@ -0,0 +1,35 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry-target +description: FinalizationRegistry.length property descriptor +info: | + FinalizationRegistry ( cleanupCallback ) + + 17 ECMAScript Standard Built-in Objects + + Every built-in function object, including constructors, has a length + property whose value is an integer. Unless otherwise specified, this + value is equal to the largest number of named arguments shown in the + subclause headings for the function description. Optional parameters + (which are indicated with brackets: [ ]) or rest parameters (which + are shown using the form «...name») are not included in the default + argument count. + + Unless otherwise specified, the length property of a built-in + function object has the attributes { [[Writable]]: false, + [[Enumerable]]: false, [[Configurable]]: true }. +includes: [propertyHelper.js] +features: [FinalizationRegistry] +---*/ + +verifyProperty(FinalizationRegistry, 'length', { + value: 1, + writable: false, + enumerable: false, + configurable: true +}); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/name.js b/js/src/tests/test262/built-ins/FinalizationRegistry/name.js new file mode 100644 index 0000000000..4b0655b261 --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/name.js @@ -0,0 +1,34 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry-target +description: FinalizationRegistry.name property descriptor +info: | + FinalizationRegistry ( value ) + + 17 ECMAScript Standard Built-in Objects + + Every built-in function object, including constructors, that is not + identified as an anonymous function has a name property whose value + is a String. Unless otherwise specified, this value is the name that + is given to the function in this specification. For functions that + are specified as properties of objects, the name value is the + property name string used to access the function. [...] + + Unless otherwise specified, the name property of a built-in function + object, if it exists, has the attributes { [[Writable]]: false, + [[Enumerable]]: false, [[Configurable]]: true }. +includes: [propertyHelper.js] +features: [FinalizationRegistry] +---*/ + +verifyProperty(FinalizationRegistry, 'name', { + value: 'FinalizationRegistry', + writable: false, + enumerable: false, + configurable: true +}); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/newtarget-prototype-is-not-object.js b/js/src/tests/test262/built-ins/FinalizationRegistry/newtarget-prototype-is-not-object.js new file mode 100644 index 0000000000..26b0e91221 --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/newtarget-prototype-is-not-object.js @@ -0,0 +1,61 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry-target +description: > + [[Prototype]] defaults to %FinalizationRegistryPrototype% if NewTarget.prototype is not an object. +info: | + FinalizationRegistry ( cleanupCallback ) + + ... + 3. Let finalizationRegistry be ? OrdinaryCreateFromConstructor(NewTarget, "%FinalizationRegistryPrototype%", « [[Realm]], [[CleanupCallback]], [[Cells]], [[IsFinalizationRegistryCleanupJobActive]] »). + ... + 9. Return finalizationRegistry. + + OrdinaryCreateFromConstructor ( constructor, intrinsicDefaultProto [ , internalSlotsList ] ) + + ... + 2. Let proto be ? GetPrototypeFromConstructor(constructor, intrinsicDefaultProto). + 3. Return ObjectCreate(proto, internalSlotsList). + + GetPrototypeFromConstructor ( constructor, intrinsicDefaultProto ) + + 3. Let proto be ? Get(constructor, 'prototype'). + 4. If Type(proto) is not Object, then + a. Let realm be ? GetFunctionRealm(constructor). + b. Set proto to realm's intrinsic object named intrinsicDefaultProto. + 5. Return proto. +features: [FinalizationRegistry, Reflect.construct, Symbol] +---*/ + +var finalizationRegistry; +function newTarget() {} +function fn() {} + +newTarget.prototype = undefined; +finalizationRegistry = Reflect.construct(FinalizationRegistry, [fn], newTarget); +assert.sameValue(Object.getPrototypeOf(finalizationRegistry), FinalizationRegistry.prototype, 'newTarget.prototype is undefined'); + +newTarget.prototype = null; +finalizationRegistry = Reflect.construct(FinalizationRegistry, [fn], newTarget); +assert.sameValue(Object.getPrototypeOf(finalizationRegistry), FinalizationRegistry.prototype, 'newTarget.prototype is null'); + +newTarget.prototype = true; +finalizationRegistry = Reflect.construct(FinalizationRegistry, [fn], newTarget); +assert.sameValue(Object.getPrototypeOf(finalizationRegistry), FinalizationRegistry.prototype, 'newTarget.prototype is a Boolean'); + +newTarget.prototype = ''; +finalizationRegistry = Reflect.construct(FinalizationRegistry, [fn], newTarget); +assert.sameValue(Object.getPrototypeOf(finalizationRegistry), FinalizationRegistry.prototype, 'newTarget.prototype is a String'); + +newTarget.prototype = Symbol(); +finalizationRegistry = Reflect.construct(FinalizationRegistry, [fn], newTarget); +assert.sameValue(Object.getPrototypeOf(finalizationRegistry), FinalizationRegistry.prototype, 'newTarget.prototype is a Symbol'); + +newTarget.prototype = 1; +finalizationRegistry = Reflect.construct(FinalizationRegistry, [fn], newTarget); +assert.sameValue(Object.getPrototypeOf(finalizationRegistry), FinalizationRegistry.prototype, 'newTarget.prototype is a Number'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prop-desc.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prop-desc.js new file mode 100644 index 0000000000..20510998d7 --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prop-desc.js @@ -0,0 +1,25 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry-constructor +description: > + Property descriptor of FinalizationRegistry +info: | + 17 ECMAScript Standard Built-in Objects: + + Every other data property described in clauses 18 through 26 and in Annex B.2 + has the attributes { [[Writable]]: true, [[Enumerable]]: false, + [[Configurable]]: true } unless otherwise specified. +includes: [propertyHelper.js] +features: [FinalizationRegistry] +---*/ + +verifyProperty(this, 'FinalizationRegistry', { + enumerable: false, + writable: true, + configurable: true +}); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/proto-from-ctor-realm.js b/js/src/tests/test262/built-ins/FinalizationRegistry/proto-from-ctor-realm.js new file mode 100644 index 0000000000..f2807a5cd2 --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/proto-from-ctor-realm.js @@ -0,0 +1,62 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry-target +description: Default [[Prototype]] value derived from realm of the newTarget +info: | + FinalizationRegistry ( cleanupCallback ) + + ... + 3. Let finalizationRegistry be ? OrdinaryCreateFromConstructor(NewTarget, "%FinalizationRegistryPrototype%", « [[Realm]], [[CleanupCallback]], [[Cells]], [[IsFinalizationRegistryCleanupJobActive]] »). + ... + 9. Return finalizationRegistry. + + OrdinaryCreateFromConstructor ( constructor, intrinsicDefaultProto [ , internalSlotsList ] ) + + ... + 2. Let proto be ? GetPrototypeFromConstructor(constructor, intrinsicDefaultProto). + 3. Return ObjectCreate(proto, internalSlotsList). + + GetPrototypeFromConstructor ( constructor, intrinsicDefaultProto ) + + 3. Let proto be ? Get(constructor, 'prototype'). + 4. If Type(proto) is not Object, then + a. Let realm be ? GetFunctionRealm(constructor). + b. Set proto to realm's intrinsic object named intrinsicDefaultProto. + 5. Return proto. +features: [FinalizationRegistry, cross-realm, Reflect, Symbol] +---*/ + +var other = $262.createRealm().global; +var newTarget = new other.Function(); +function fn() {} +var finalizationRegistry; + +newTarget.prototype = undefined; +finalizationRegistry = Reflect.construct(FinalizationRegistry, [fn], newTarget); +assert.sameValue(Object.getPrototypeOf(finalizationRegistry), other.FinalizationRegistry.prototype, 'newTarget.prototype is undefined'); + +newTarget.prototype = null; +finalizationRegistry = Reflect.construct(FinalizationRegistry, [fn], newTarget); +assert.sameValue(Object.getPrototypeOf(finalizationRegistry), other.FinalizationRegistry.prototype, 'newTarget.prototype is null'); + +newTarget.prototype = true; +finalizationRegistry = Reflect.construct(FinalizationRegistry, [fn], newTarget); +assert.sameValue(Object.getPrototypeOf(finalizationRegistry), other.FinalizationRegistry.prototype, 'newTarget.prototype is a Boolean'); + +newTarget.prototype = ''; +finalizationRegistry = Reflect.construct(FinalizationRegistry, [fn], newTarget); +assert.sameValue(Object.getPrototypeOf(finalizationRegistry), other.FinalizationRegistry.prototype, 'newTarget.prototype is a String'); + +newTarget.prototype = Symbol(); +finalizationRegistry = Reflect.construct(FinalizationRegistry, [fn], newTarget); +assert.sameValue(Object.getPrototypeOf(finalizationRegistry), other.FinalizationRegistry.prototype, 'newTarget.prototype is a Symbol'); + +newTarget.prototype = 1; +finalizationRegistry = Reflect.construct(FinalizationRegistry, [fn], newTarget); +assert.sameValue(Object.getPrototypeOf(finalizationRegistry), other.FinalizationRegistry.prototype, 'newTarget.prototype is a Number'); + + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/proto.js b/js/src/tests/test262/built-ins/FinalizationRegistry/proto.js new file mode 100644 index 0000000000..f9bf522ede --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/proto.js @@ -0,0 +1,21 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-properties-of-the-finalization-registry-constructor +description: > + The prototype of FinalizationRegistry is Object.prototype +info: | + The value of the [[Prototype]] internal slot of the FinalizationRegistry object is the + intrinsic object %FunctionPrototype%. +features: [FinalizationRegistry] +---*/ + +assert.sameValue( + Object.getPrototypeOf(FinalizationRegistry), + Function.prototype, + 'Object.getPrototypeOf(FinalizationRegistry) returns the value of `Function.prototype`' +); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype-from-newtarget-abrupt.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype-from-newtarget-abrupt.js new file mode 100644 index 0000000000..c945b62544 --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype-from-newtarget-abrupt.js @@ -0,0 +1,44 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry-target +description: > + Return abrupt from getting the NewTarget prototype +info: | + FinalizationRegistry ( cleanupCallback ) + + ... + 3. Let finalizationRegistry be ? OrdinaryCreateFromConstructor(NewTarget, "%FinalizationRegistryPrototype%", « [[Realm]], [[CleanupCallback]], [[Cells]], [[IsFinalizationRegistryCleanupJobActive]] »). + ... + 9. Return finalizationRegistry. + + OrdinaryCreateFromConstructor ( constructor, intrinsicDefaultProto [ , internalSlotsList ] ) + + ... + 2. Let proto be ? GetPrototypeFromConstructor(constructor, intrinsicDefaultProto). + 3. Return ObjectCreate(proto, internalSlotsList). + + GetPrototypeFromConstructor ( constructor, intrinsicDefaultProto ) + + 3. Let proto be ? Get(constructor, 'prototype'). +features: [FinalizationRegistry, Reflect.construct] +---*/ + +var calls = 0; +var newTarget = function() {}.bind(null); +Object.defineProperty(newTarget, 'prototype', { + get: function() { + calls += 1; + throw new Test262Error(); + } +}); + +assert.throws(Test262Error, function() { + Reflect.construct(FinalizationRegistry, [function() {}], newTarget); +}); + +assert.sameValue(calls, 1); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype-from-newtarget-custom.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype-from-newtarget-custom.js new file mode 100644 index 0000000000..b31b87972e --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype-from-newtarget-custom.js @@ -0,0 +1,47 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry-target +description: > + The [[Prototype]] internal slot is computed from NewTarget. +info: | + FinalizationRegistry ( cleanupCallback ) + + ... + 3. Let finalizationRegistry be ? OrdinaryCreateFromConstructor(NewTarget, "%FinalizationRegistryPrototype%", « [[Realm]], [[CleanupCallback]], [[Cells]], [[IsFinalizationRegistryCleanupJobActive]] »). + ... + 9. Return finalizationRegistry. + + OrdinaryCreateFromConstructor ( constructor, intrinsicDefaultProto [ , internalSlotsList ] ) + + ... + 2. Let proto be ? GetPrototypeFromConstructor(constructor, intrinsicDefaultProto). + 3. Return ObjectCreate(proto, internalSlotsList). + + GetPrototypeFromConstructor ( constructor, intrinsicDefaultProto ) + + 3. Let proto be ? Get(constructor, 'prototype'). + 4. If Type(proto) is not Object, then + a. Let realm be ? GetFunctionRealm(constructor). + b. Set proto to realm's intrinsic object named intrinsicDefaultProto. + 5. Return proto. +features: [FinalizationRegistry, Reflect.construct] +---*/ + +var finalizationRegistry; + +finalizationRegistry = Reflect.construct(FinalizationRegistry, [function() {}], Object); +assert.sameValue(Object.getPrototypeOf(finalizationRegistry), Object.prototype, 'NewTarget is built-in Object constructor'); + +var newTarget = function() {}.bind(null); +Object.defineProperty(newTarget, 'prototype', { + get: function() { + return Array.prototype; + } +}); +finalizationRegistry = Reflect.construct(FinalizationRegistry, [function() {}], newTarget); +assert.sameValue(Object.getPrototypeOf(finalizationRegistry), Array.prototype, 'NewTarget is BoundFunction with accessor'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype-from-newtarget.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype-from-newtarget.js new file mode 100644 index 0000000000..75b44ab7f4 --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype-from-newtarget.js @@ -0,0 +1,36 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry-target +description: > + The [[Prototype]] internal slot is computed from NewTarget. +info: | + FinalizationRegistry ( cleanupCallback ) + + ... + 3. Let finalizationRegistry be ? OrdinaryCreateFromConstructor(NewTarget, "%FinalizationRegistryPrototype%", « [[Realm]], [[CleanupCallback]], [[Cells]], [[IsFinalizationRegistryCleanupJobActive]] »). + ... + 9. Return finalizationRegistry. + + OrdinaryCreateFromConstructor ( constructor, intrinsicDefaultProto [ , internalSlotsList ] ) + + ... + 2. Let proto be ? GetPrototypeFromConstructor(constructor, intrinsicDefaultProto). + 3. Return ObjectCreate(proto, internalSlotsList). + + GetPrototypeFromConstructor ( constructor, intrinsicDefaultProto ) + + 3. Let proto be ? Get(constructor, 'prototype'). + 4. If Type(proto) is not Object, then + a. Let realm be ? GetFunctionRealm(constructor). + b. Set proto to realm's intrinsic object named intrinsicDefaultProto. + 5. Return proto. +features: [FinalizationRegistry] +---*/ + +var finalizationRegistry = new FinalizationRegistry(function() {}); +assert.sameValue(Object.getPrototypeOf(finalizationRegistry), FinalizationRegistry.prototype); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/Symbol.toStringTag.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/Symbol.toStringTag.js new file mode 100644 index 0000000000..e687cd8771 --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/Symbol.toStringTag.js @@ -0,0 +1,26 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry-@@tostringtag +description: > + `Symbol.toStringTag` property descriptor +info: | + The initial value of the @@toStringTag property is the String value + 'FinalizationRegistry'. + + This property has the attributes { [[Writable]]: false, [[Enumerable]]: + false, [[Configurable]]: true }. +includes: [propertyHelper.js] +features: [FinalizationRegistry, Symbol, Symbol.toStringTag] +---*/ + +verifyProperty(FinalizationRegistry.prototype, Symbol.toStringTag, { + value: 'FinalizationRegistry', + writable: false, + enumerable: false, + configurable: true +}); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/browser.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/browser.js new file mode 100644 index 0000000000..e69de29bb2 diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/browser.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/browser.js new file mode 100644 index 0000000000..e69de29bb2 diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/callback-not-callable-throws.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/callback-not-callable-throws.js new file mode 100644 index 0000000000..2e8450b19e --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/callback-not-callable-throws.js @@ -0,0 +1,56 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry.prototype.cleanupSome +description: Throws a TypeError if callback is not callable +info: | + FinalizationRegistry.prototype.cleanupSome ( [ callback ] ) + + 1. Let finalizationRegistry be the this value. + 2. If Type(finalizationRegistry) is not Object, throw a TypeError exception. + 3. If finalizationRegistry does not have a [[Cells]] internal slot, throw a TypeError exception. + 4. If callback is not undefined and IsCallable(callback) is false, throw a TypeError exception. + ... +features: [FinalizationRegistry.prototype.cleanupSome, FinalizationRegistry] +---*/ + +assert.sameValue(typeof FinalizationRegistry.prototype.cleanupSome, 'function'); + +var finalizationRegistry = new FinalizationRegistry(function() {}); + +assert.throws(TypeError, function() { + finalizationRegistry.cleanupSome(null); +}, 'null'); + +assert.throws(TypeError, function() { + finalizationRegistry.cleanupSome(true); +}, 'true'); + +assert.throws(TypeError, function() { + finalizationRegistry.cleanupSome(false); +}, 'false'); + +assert.throws(TypeError, function() { + finalizationRegistry.cleanupSome(1); +}, 'number'); + +assert.throws(TypeError, function() { + finalizationRegistry.cleanupSome('object'); +}, 'string'); + +var s = Symbol(); +assert.throws(TypeError, function() { + finalizationRegistry.cleanupSome(s); +}, 'symbol'); + +assert.throws(TypeError, function() { + finalizationRegistry.cleanupSome({}); +}, 'object'); + +assert.throws(TypeError, function() { + finalizationRegistry.cleanupSome(FinalizationRegistry.prototype); +}, 'FinalizationRegistry.prototype'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/cleanup-prevented-with-reference.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/cleanup-prevented-with-reference.js new file mode 100644 index 0000000000..d8c23a7d1e --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/cleanup-prevented-with-reference.js @@ -0,0 +1,48 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) async -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry.prototype.cleanupSome +description: Cleanup might be prevented with a reference usage; +info: | + FinalizationRegistry.prototype.cleanupSome ( [ callback ] ) + + 1. Let finalizationRegistry be the this value. + 2. If Type(finalizationRegistry) is not Object, throw a TypeError exception. + 3. If finalizationRegistry does not have a [[Cells]] internal slot, throw a TypeError exception. + 4. If callback is not undefined and IsCallable(callback) is false, throw a TypeError exception. + 5. Perform ? CleanupFinalizationRegistry(finalizationRegistry, callback). + 6. Return undefined. +features: [FinalizationRegistry.prototype.cleanupSome, FinalizationRegistry, host-gc-required] +includes: [async-gc.js] +flags: [async, non-deterministic] +---*/ + +var holdingsList = []; +function cb(holding) { + holdingsList.push(holding); +}; +var finalizationRegistry = new FinalizationRegistry(function() {}); + +var referenced = {}; + +function emptyCells() { + var target = {}; + finalizationRegistry.register(target, 'target!'); + finalizationRegistry.register(referenced, 'referenced'); + + var prom = asyncGC(target); + target = null; + + return prom; +} + +emptyCells().then(function() { + finalizationRegistry.cleanupSome(cb); + + assert.sameValue(holdingsList.length, 1); + assert.sameValue(holdingsList[0], 'target!'); + + assert.sameValue(typeof referenced, 'object', 'referenced preserved'); +}).then($DONE, resolveAsyncGC); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/cleanup-prevented-with-unregister.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/cleanup-prevented-with-unregister.js new file mode 100644 index 0000000000..6669be38b2 --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/cleanup-prevented-with-unregister.js @@ -0,0 +1,55 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) async -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry.prototype.cleanupSome +description: Cleanup might be prevented with an unregister usage +info: | + FinalizationRegistry.prototype.cleanupSome ( [ callback ] ) + + 1. Let finalizationRegistry be the this value. + 2. If Type(finalizationRegistry) is not Object, throw a TypeError exception. + 3. If finalizationRegistry does not have a [[Cells]] internal slot, throw a TypeError exception. + 4. If callback is not undefined and IsCallable(callback) is false, throw a TypeError exception. + 5. Perform ? CleanupFinalizationRegistry(finalizationRegistry, callback). + 6. Return undefined. + + FinalizationRegistry.prototype.unregister ( unregisterToken ) + + 1. Let removed be false. + 2. For each Record { [[Target]], [[Holdings]], [[UnregisterToken]] } cell that is an element of finalizationRegistry.[[Cells]], do + a. If SameValue(cell.[[UnregisterToken]], unregisterToken) is true, then + i. Remove cell from finalizationRegistry.[[Cells]]. + ii. Set removed to true. + 3. Return removed. +features: [FinalizationRegistry.prototype.cleanupSome, FinalizationRegistry, host-gc-required] +includes: [async-gc.js] +flags: [async, non-deterministic] +---*/ + +var token = {}; +var finalizationRegistry = new FinalizationRegistry(function() {}); + +function emptyCells() { + var target = {}; + finalizationRegistry.register(target, 'target!', token); + + var prom = asyncGC(target); + target = null; + + return prom; +} + +emptyCells().then(function() { + var called = 0; + + var res = finalizationRegistry.unregister(token); + assert.sameValue(res, true, 'unregister target before iterating over it in cleanup'); + + finalizationRegistry.cleanupSome(function cb(holding) { + called += 1; + }); + + assert.sameValue(called, 0, 'callback was not called'); +}).then($DONE, resolveAsyncGC); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/custom-this.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/custom-this.js new file mode 100644 index 0000000000..1b99dc1917 --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/custom-this.js @@ -0,0 +1,29 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry.prototype.cleanupSome +description: Return values applying custom this +info: | + FinalizationRegistry.prototype.cleanupSome ( [ callback ] ) + + 1. Let finalizationRegistry be the this value. + 2. If Type(finalizationRegistry) is not Object, throw a TypeError exception. + 3. If finalizationRegistry does not have a [[Cells]] internal slot, throw a TypeError exception. + 4. If callback is not undefined and IsCallable(callback) is false, throw a TypeError exception. + 5. Perform ! CleanupFinalizationRegistry(finalizationRegistry, callback). + 6. Return undefined. +features: [FinalizationRegistry.prototype.cleanupSome, FinalizationRegistry] +---*/ + +var fn = function() {}; +var cleanupSome = FinalizationRegistry.prototype.cleanupSome; +var finalizationRegistry = new FinalizationRegistry(fn); + +var cb = function() {}; + +assert.sameValue(cleanupSome.call(finalizationRegistry, cb), undefined); +assert.sameValue(cleanupSome.call(finalizationRegistry, fn), undefined), 'reuse the same cleanup callback fn'; + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/holdings-multiple-values.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/holdings-multiple-values.js new file mode 100644 index 0000000000..4c8d99b11a --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/holdings-multiple-values.js @@ -0,0 +1,70 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) async -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-properties-of-the-finalization-registry-constructor +description: > + Iterates over different type values in holdings +info: | + FinalizationRegistry.prototype.cleanupSome ( [ callback ] ) + + 1. Let finalizationRegistry be the this value. + ... + 5. Perform ! CleanupFinalizationRegistry(finalizationRegistry, callback). + ... + + CleanupFinalizationRegistry ( finalizationRegistry [ , callback ] ) + + ... + 3. While finalizationRegistry.[[Cells]] contains a Record cell such that cell.[[WeakRefTarget]] is ~empty~, then an implementation may perform the following steps, + a. Choose any such cell. + b. Remove cell from finalizationRegistry.[[Cells]]. + c. Perform ? Call(callback, undefined, << cell.[[HeldValue]] >>). + ... + + +features: [FinalizationRegistry.prototype.cleanupSome, FinalizationRegistry, Symbol, host-gc-required] +includes: [async-gc.js] +flags: [async, non-deterministic] +---*/ + +function check(value, expectedName) { + var holdings = []; + var called = 0; + var finalizationRegistry = new FinalizationRegistry(function() {}); + + function callback(holding) { + called += 1; + holdings.push(holding); + } + + // This is internal to avoid conflicts + function emptyCells(value) { + var target = {}; + finalizationRegistry.register(target, value); + + var prom = asyncGC(target); + target = null; + + return prom; + } + + return emptyCells(value).then(function() { + finalizationRegistry.cleanupSome(callback); + assert.sameValue(called, 1, expectedName); + assert.sameValue(holdings.length, 1, expectedName); + assert.sameValue(holdings[0], value, expectedName); + }); +} + +Promise.all([ + check(undefined, 'undefined'), + check(null, 'null'), + check('', 'the empty string'), + check({}, 'object'), + check(42, 'number'), + check(true, 'true'), + check(false, 'false'), + check(Symbol(1), 'symbol'), +]).then(() => $DONE(), resolveAsyncGC); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/length.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/length.js new file mode 100644 index 0000000000..797ecd5694 --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/length.js @@ -0,0 +1,35 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry.prototype.cleanupSome +description: FinalizationRegistry.prototype.cleanupSome.length property descriptor +info: | + FinalizationRegistry.prototype.cleanupSome ( [ callback ] ) + + 17 ECMAScript Standard Built-in Objects + + Every built-in function object, including constructors, has a length + property whose value is an integer. Unless otherwise specified, this + value is equal to the largest number of named arguments shown in the + subclause headings for the function description. Optional parameters + (which are indicated with brackets: [ ]) or rest parameters (which + are shown using the form «...name») are not included in the default + argument count. + + Unless otherwise specified, the length property of a built-in + function object has the attributes { [[Writable]]: false, + [[Enumerable]]: false, [[Configurable]]: true }. +includes: [propertyHelper.js] +features: [FinalizationRegistry.prototype.cleanupSome, FinalizationRegistry] +---*/ + +verifyProperty(FinalizationRegistry.prototype.cleanupSome, 'length', { + value: 0, + writable: false, + enumerable: false, + configurable: true +}); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/name.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/name.js new file mode 100644 index 0000000000..e71415a2c2 --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/name.js @@ -0,0 +1,34 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry.prototype.cleanupSome +description: FinalizationRegistry.prototype.cleanupSome.name property descriptor +info: | + FinalizationRegistry.prototype.cleanupSome.name value and property descriptor + + 17 ECMAScript Standard Built-in Objects + + Every built-in function object, including constructors, that is not + identified as an anonymous function has a name property whose value + is a String. Unless otherwise specified, this value is the name that + is given to the function in this specification. For functions that + are specified as properties of objects, the name value is the + property name string used to access the function. [...] + + Unless otherwise specified, the name property of a built-in function + object, if it exists, has the attributes { [[Writable]]: false, + [[Enumerable]]: false, [[Configurable]]: true }. +includes: [propertyHelper.js] +features: [FinalizationRegistry.prototype.cleanupSome, FinalizationRegistry] +---*/ + +verifyProperty(FinalizationRegistry.prototype.cleanupSome, 'name', { + value: 'cleanupSome', + writable: false, + enumerable: false, + configurable: true +}); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/not-a-constructor.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/not-a-constructor.js new file mode 100644 index 0000000000..12c979cc12 --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/not-a-constructor.js @@ -0,0 +1,36 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2020 Rick Waldron. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-ecmascript-standard-built-in-objects +description: > + FinalizationRegistry.prototype.cleanupSome does not implement [[Construct]], is not new-able +info: | + ECMAScript Function Objects + + Built-in function objects that are not identified as constructors do not + implement the [[Construct]] internal method unless otherwise specified in + the description of a particular function. + + sec-evaluatenew + + ... + 7. If IsConstructor(constructor) is false, throw a TypeError exception. + ... +includes: [isConstructor.js] +features: [Reflect.construct, FinalizationRegistry, FinalizationRegistry.prototype.cleanupSome, arrow-function] +---*/ + +assert.sameValue( + isConstructor(FinalizationRegistry.prototype.cleanupSome), + false, + 'isConstructor(FinalizationRegistry.prototype.cleanupSome) must return false' +); + +assert.throws(TypeError, () => { + let fr = new FinalizationRegistry(() => {}); new fr.cleanupSome(() => {}); +}, '`let fr = new FinalizationRegistry(() => {}); new fr.cleanupSome(() => {})` throws TypeError'); + + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/prop-desc.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/prop-desc.js new file mode 100644 index 0000000000..f942e2c1a4 --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/prop-desc.js @@ -0,0 +1,27 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry.prototype.cleanupSome +description: > + Property descriptor of FinalizationRegistry.prototype.cleanupSome +info: | + 17 ECMAScript Standard Built-in Objects: + + Every other data property described in clauses 18 through 26 and in Annex B.2 + has the attributes { [[Writable]]: true, [[Enumerable]]: false, + [[Configurable]]: true } unless otherwise specified. +includes: [propertyHelper.js] +features: [FinalizationRegistry.prototype.cleanupSome, FinalizationRegistry] +---*/ + +assert.sameValue(typeof FinalizationRegistry.prototype.cleanupSome, 'function'); + +verifyProperty(FinalizationRegistry.prototype, 'cleanupSome', { + enumerable: false, + writable: true, + configurable: true +}); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/reentrancy.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/reentrancy.js new file mode 100644 index 0000000000..ebecca0725 --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/reentrancy.js @@ -0,0 +1,52 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) async -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-properties-of-the-finalization-registry-constructor +description: > + The cleanupSome() method can be reentered +info: | + FinalizationRegistry.prototype.cleanupSome ( [ callback ] ) + +features: [FinalizationRegistry.prototype.cleanupSome, FinalizationRegistry, host-gc-required] +includes: [async-gc.js] +flags: [async, non-deterministic] +---*/ + +var called = 0; +var endOfCall = 0; +var finalizationRegistry = new FinalizationRegistry(function() {}); + +function callback(holding) { + called += 1; + + if (called === 1) { + // Atempt to re-enter the callback. + var nestedCallbackRan = false; + finalizationRegistry.cleanupSome(() => { nestedCallbackRan = true }); + assert.sameValue(nestedCallbackRan, true); + } + + endOfCall += 1; +} + +function emptyCells() { + var o1 = {}; + var o2 = {}; + // Register more than one objects to test reentrancy. + finalizationRegistry.register(o1, 'holdings 1'); + finalizationRegistry.register(o2, 'holdings 2'); + + var prom = asyncGC(o1); + o1 = null; + + return prom; +} + +emptyCells().then(function() { + finalizationRegistry.cleanupSome(callback); + + assert.sameValue(called, 1, 'callback was called'); + assert.sameValue(endOfCall, 1, 'callback finished'); +}).then($DONE, resolveAsyncGC); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/return-undefined-with-gc.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/return-undefined-with-gc.js new file mode 100644 index 0000000000..ef1f04b0e7 --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/return-undefined-with-gc.js @@ -0,0 +1,67 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) async -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry.prototype.cleanupSome +description: Return undefined regardless the result of CleanupFinalizationRegistry +info: | + FinalizationRegistry.prototype.cleanupSome ( [ callback ] ) + + 1. Let finalizationRegistry be the this value. + 2. If Type(finalizationRegistry) is not Object, throw a TypeError exception. + 3. If finalizationRegistry does not have a [[Cells]] internal slot, throw a TypeError exception. + 4. If callback is not undefined and IsCallable(callback) is false, throw a TypeError exception. + 5. Perform ? CleanupFinalizationRegistry(finalizationRegistry, callback). + 6. Return undefined. +features: [FinalizationRegistry.prototype.cleanupSome, FinalizationRegistry, arrow-function, async-functions, async-iteration, class, host-gc-required] +includes: [async-gc.js] +flags: [async, non-deterministic] +---*/ + +var called; +var fn = function() { + called += 1; + return 39; +}; +var cb = function() { + called += 1; + return 42; +}; +var finalizationRegistry = new FinalizationRegistry(fn); + +function emptyCells() { + var target = {}; + finalizationRegistry.register(target); + + var prom = asyncGC(target); + target = null; + + return prom; +} + +emptyCells().then(function() { + called = 0; + assert.sameValue(finalizationRegistry.cleanupSome(cb), undefined, 'regular callback'); + assert.sameValue(called, 1); +}).then(emptyCells).then(function() { + called = 0; + assert.sameValue(finalizationRegistry.cleanupSome(fn), undefined, 'regular callback, same FG cleanup function'); + assert.sameValue(called, 1); +}).then(emptyCells).then(function() { + called = 0; + assert.sameValue(finalizationRegistry.cleanupSome(), undefined, 'undefined (implicit) callback, defer to FB callback'); + assert.sameValue(called, 1); +}).then(emptyCells).then(function() { + called = 0; + assert.sameValue(finalizationRegistry.cleanupSome(undefined), undefined, 'undefined (explicit) callback, defer to FB callback'); + assert.sameValue(called, 1); +}).then(emptyCells).then(function() { + assert.sameValue(finalizationRegistry.cleanupSome(() => 1), undefined, 'arrow function'); +}).then(emptyCells).then(function() { + assert.sameValue(finalizationRegistry.cleanupSome(async function() {}), undefined, 'async function'); +}).then(emptyCells).then(function() { + assert.sameValue(finalizationRegistry.cleanupSome(function *() {}), undefined, 'generator'); +}).then(emptyCells).then(function() { + assert.sameValue(finalizationRegistry.cleanupSome(async function *() {}), undefined, 'async generator'); +}).then($DONE, resolveAsyncGC); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/return-undefined.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/return-undefined.js new file mode 100644 index 0000000000..6a5ff5a6e5 --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/return-undefined.js @@ -0,0 +1,44 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry.prototype.cleanupSome +description: Return undefined regardless the result of CleanupFinalizationRegistry +info: | + FinalizationRegistry.prototype.cleanupSome ( [ callback ] ) + + 1. Let finalizationRegistry be the this value. + 2. If Type(finalizationRegistry) is not Object, throw a TypeError exception. + 3. If finalizationRegistry does not have a [[Cells]] internal slot, throw a TypeError exception. + 4. If callback is not undefined and IsCallable(callback) is false, throw a TypeError exception. + 5. Perform ? CleanupFinalizationRegistry(finalizationRegistry, callback). + 6. Return undefined. +features: [FinalizationRegistry.prototype.cleanupSome, FinalizationRegistry, arrow-function, async-functions, async-iteration, class] +---*/ + +var fn = function() {}; +var cb = function() {}; +var poisoned = function() { throw new Test262Error(); }; +var finalizationRegistry = new FinalizationRegistry(fn); + +assert.sameValue(finalizationRegistry.cleanupSome(cb), undefined, 'regular callback'); +assert.sameValue(finalizationRegistry.cleanupSome(fn), undefined, 'regular callback, same FG cleanup function'); + +assert.sameValue(finalizationRegistry.cleanupSome(() => {}), undefined, 'arrow function'); +assert.sameValue(finalizationRegistry.cleanupSome(finalizationRegistry.cleanupSome), undefined, 'cleanupSome itself'); +assert.sameValue(finalizationRegistry.cleanupSome(poisoned), undefined, 'poisoned'); +assert.sameValue(finalizationRegistry.cleanupSome(class {}), undefined, 'class expression'); +assert.sameValue(finalizationRegistry.cleanupSome(async function() {}), undefined, 'async function'); +assert.sameValue(finalizationRegistry.cleanupSome(function *() {}), undefined, 'generator'); +assert.sameValue(finalizationRegistry.cleanupSome(async function *() {}), undefined, 'async generator'); + +assert.sameValue(finalizationRegistry.cleanupSome(), undefined, 'undefined, implicit'); +assert.sameValue(finalizationRegistry.cleanupSome(undefined), undefined, 'undefined, explicit'); + +var poisonedFg = new FinalizationRegistry(poisoned); + +assert.sameValue(poisonedFg.cleanupSome(cb), undefined, 'regular callback on poisoned FG cleanup callback'); +assert.sameValue(poisonedFg.cleanupSome(poisoned), undefined, 'poisoned callback on poisoned FG cleanup callback'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/shell.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/shell.js new file mode 100644 index 0000000000..e69de29bb2 diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/this-does-not-have-internal-cells-throws.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/this-does-not-have-internal-cells-throws.js new file mode 100644 index 0000000000..267e6d3163 --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/this-does-not-have-internal-cells-throws.js @@ -0,0 +1,51 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')||!this.hasOwnProperty('WeakRef')) -- FinalizationRegistry,WeakRef is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry.prototype.cleanupSome +description: Throws a TypeError if this does not have a [[Cells]] internal slot +info: | + FinalizationRegistry.prototype.cleanupSome ( [ callback ] ) + + 1. Let finalizationRegistry be the this value. + 2. If Type(finalizationRegistry) is not Object, throw a TypeError exception. + 3. If finalizationRegistry does not have a [[Cells]] internal slot, throw a TypeError exception. + 4. If callback is not undefined and IsCallable(callback) is false, throw a TypeError exception. + ... +features: [FinalizationRegistry.prototype.cleanupSome, WeakSet, WeakMap, FinalizationRegistry, WeakRef] +---*/ + +assert.sameValue(typeof FinalizationRegistry.prototype.cleanupSome, 'function'); + +var cleanupSome = FinalizationRegistry.prototype.cleanupSome; +var cb = function() {}; + +assert.throws(TypeError, function() { + cleanupSome.call({ ['[[Cells]]']: {} }, cb); +}, 'Ordinary object without [[Cells]]'); + +assert.throws(TypeError, function() { + cleanupSome.call(WeakRef.prototype, cb); +}, 'WeakRef.prototype does not have a [[Cells]] internal slot'); + +assert.throws(TypeError, function() { + cleanupSome.call(WeakRef, cb); +}, 'WeakRef does not have a [[Cells]] internal slot'); + +var wr = new WeakRef({}); +assert.throws(TypeError, function() { + cleanupSome.call(wr, cb); +}, 'WeakRef instance'); + +var wm = new WeakMap(); +assert.throws(TypeError, function() { + cleanupSome.call(wm, cb); +}, 'WeakMap instance'); + +var ws = new WeakSet(); +assert.throws(TypeError, function() { + cleanupSome.call(ws, cb); +}, 'WeakSet instance'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/this-not-object-throws.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/this-not-object-throws.js new file mode 100644 index 0000000000..0be9066201 --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/cleanupSome/this-not-object-throws.js @@ -0,0 +1,53 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry.prototype.cleanupSome +description: Throws a TypeError if this is not an Object +info: | + FinalizationRegistry.prototype.cleanupSome ( [ callback ] ) + + 1. Let finalizationRegistry be the this value. + 2. If Type(finalizationRegistry) is not Object, throw a TypeError exception. + 3. If finalizationRegistry does not have a [[Cells]] internal slot, throw a TypeError exception. + 4. If callback is not undefined and IsCallable(callback) is false, throw a TypeError exception. + ... +features: [FinalizationRegistry.prototype.cleanupSome, FinalizationRegistry] +---*/ + +assert.sameValue(typeof FinalizationRegistry.prototype.cleanupSome, 'function'); + +var cleanupSome = FinalizationRegistry.prototype.cleanupSome; +var cb = function() {}; + +assert.throws(TypeError, function() { + cleanupSome.call(undefined, cb); +}, 'undefined'); + +assert.throws(TypeError, function() { + cleanupSome.call(null, cb); +}, 'null'); + +assert.throws(TypeError, function() { + cleanupSome.call(true, cb); +}, 'true'); + +assert.throws(TypeError, function() { + cleanupSome.call(false, cb); +}, 'false'); + +assert.throws(TypeError, function() { + cleanupSome.call(1, cb); +}, 'number'); + +assert.throws(TypeError, function() { + cleanupSome.call('object', cb); +}, 'string'); + +var s = Symbol(); +assert.throws(TypeError, function() { + cleanupSome.call(s, cb); +}, 'symbol'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/constructor.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/constructor.js new file mode 100644 index 0000000000..3f83b2e752 --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/constructor.js @@ -0,0 +1,26 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry.prototype.constructor +description: FinalizationRegistry.prototype.constructor property descriptor +info: | + FinalizationRegistry.prototype.constructor + + The initial value of FinalizationRegistry.prototype.constructor is the intrinsic + object %FinalizationRegistry%. + + 17 ECMAScript Standard Built-in Objects +includes: [propertyHelper.js] +features: [FinalizationRegistry] +---*/ + +verifyProperty(FinalizationRegistry.prototype, 'constructor', { + value: FinalizationRegistry, + writable: true, + enumerable: false, + configurable: true +}); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/prop-desc.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/prop-desc.js new file mode 100644 index 0000000000..9694e2d296 --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/prop-desc.js @@ -0,0 +1,21 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: The property descriptor FinalizationRegistry.prototype +esid: sec-finalization-registry.prototype +info: | + This property has the attributes { [[Writable]]: false, [[Enumerable]]: false, + [[Configurable]]: false }. +features: [FinalizationRegistry] +includes: [propertyHelper.js] +---*/ + +verifyProperty(FinalizationRegistry, 'prototype', { + writable: false, + enumerable: false, + configurable: false +}); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/proto.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/proto.js new file mode 100644 index 0000000000..9a6c7fa310 --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/proto.js @@ -0,0 +1,17 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: The prototype of FinalizationRegistry.prototype is Object.prototype +esid: sec-properties-of-the-finalization-registry-prototype-object +info: | + The value of the [[Prototype]] internal slot of the FinalizationRegistry prototype object + is the intrinsic object %ObjectPrototype%. +features: [FinalizationRegistry] +---*/ + +var proto = Object.getPrototypeOf(FinalizationRegistry.prototype); +assert.sameValue(proto, Object.prototype); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/browser.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/browser.js new file mode 100644 index 0000000000..e69de29bb2 diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/custom-this.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/custom-this.js new file mode 100644 index 0000000000..fa1df025da --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/custom-this.js @@ -0,0 +1,31 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry.prototype.register +description: Return undefined (applying custom this) +info: | + FinalizationRegistry.prototype.register ( target , holdings [, unregisterToken ] ) + + 1. Let finalizationRegistry be the this value. + 2. If Type(finalizationRegistry) is not Object, throw a TypeError exception. + 3. If Type(target) is not Object, throw a TypeError exception. + 4. If finalizationRegistry does not have a [[Cells]] internal slot, throw a TypeError exception. + 5. If Type(unregisterToken) is not Object, + a. If unregisterToken is not undefined, throw a TypeError exception. + b. Set unregisterToken to empty. + 6. Let cell be the Record { [[Target]] : target, [[Holdings]]: holdings, [[UnregisterToken]]: unregisterToken }. + 7. Append cell to finalizationRegistry.[[Cells]]. + 8. Return undefined. +features: [FinalizationRegistry] +---*/ + +var fn = function() {}; +var register = FinalizationRegistry.prototype.register; +var finalizationRegistry = new FinalizationRegistry(fn); + +var target = {}; +assert.sameValue(register.call(finalizationRegistry, target), undefined); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/heldValue-same-as-target.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/heldValue-same-as-target.js new file mode 100644 index 0000000000..11c8142074 --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/heldValue-same-as-target.js @@ -0,0 +1,38 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry.prototype.register +description: heldValue may be the same as target +info: | + FinalizationRegistry.prototype.register ( _target_ , _heldValue_ [, _unregisterToken_ ] ) + 1. Let _finalizationRegistry_ be the *this* value. + 2. Perform ? RequireInternalSlot(_finalizationRegistry_, [[Cells]]). + 3. If CanBeHeldWeakly(_target_) is *false*, throw a *TypeError* exception. + 4. If SameValue(_target_, _heldValue_) is *true*, throw a *TypeError* exception. +features: [FinalizationRegistry, Symbol] +---*/ + +var finalizationRegistry = new FinalizationRegistry(function() {}); + +var target = {}; +assert.throws(TypeError, () => finalizationRegistry.register(target, target)); + +// The following will throw regardless of whether the implementation supports +// Symbols as weak values. Step 3 if no, Step 4 if yes. + +var symbolTarget = Symbol('a description'); +assert.throws( + TypeError, + () => finalizationRegistry.register(symbolTarget, symbolTarget), + 'target and heldValue are the same regular symbol' +); + +assert.throws( + TypeError, + () => finalizationRegistry.register(Symbol.hasInstance, Symbol.hasInstance), + 'target and heldValue are the same well-known symbol' +); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/holdings-any-value-type.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/holdings-any-value-type.js new file mode 100644 index 0000000000..87dacdbb34 --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/holdings-any-value-type.js @@ -0,0 +1,38 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry.prototype.register +description: No restriction for the value or type of holdings +info: | + FinalizationRegistry.prototype.register ( target , holdings [, unregisterToken ] ) + + 1. Let finalizationRegistry be the this value. + 2. If Type(finalizationRegistry) is not Object, throw a TypeError exception. + 3. If Type(target) is not Object, throw a TypeError exception. + 4. If finalizationRegistry does not have a [[Cells]] internal slot, throw a TypeError exception. + 5. If Type(unregisterToken) is not Object, + a. If unregisterToken is not undefined, throw a TypeError exception. + b. Set unregisterToken to empty. + 6. Let cell be the Record { [[Target]] : target, [[Holdings]]: holdings, [[UnregisterToken]]: unregisterToken }. + 7. Append cell to finalizationRegistry.[[Cells]]. + 8. Return undefined. +features: [FinalizationRegistry] +---*/ + +var fn = function() {}; +var finalizationRegistry = new FinalizationRegistry(fn); + +var target = {}; +assert.sameValue(finalizationRegistry.register(target, undefined), undefined, 'undefined'); +assert.sameValue(finalizationRegistry.register(target, null), undefined, 'null'); +assert.sameValue(finalizationRegistry.register(target, false), undefined, 'false'); +assert.sameValue(finalizationRegistry.register(target, true), undefined, 'true'); +assert.sameValue(finalizationRegistry.register(target, Symbol()), undefined, 'symbol'); +assert.sameValue(finalizationRegistry.register(target, {}), undefined, 'object'); +assert.sameValue(finalizationRegistry.register(target, finalizationRegistry), undefined, 'same as finalizationRegistry instance'); +assert.sameValue(finalizationRegistry.register(target, 1), undefined, 'number'); +assert.sameValue(finalizationRegistry.register(target, 'holdings'), undefined, 'string'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/length.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/length.js new file mode 100644 index 0000000000..6b33da1d3c --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/length.js @@ -0,0 +1,35 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry.prototype.register +description: FinalizationRegistry.prototype.register.length property descriptor +info: | + FinalizationRegistry.prototype.register ( target , holdings [, unregisterToken ] ) + + 17 ECMAScript Standard Built-in Objects + + Every built-in function object, including constructors, has a length + property whose value is an integer. Unless otherwise specified, this + value is equal to the largest number of named arguments shown in the + subclause headings for the function description. Optional parameters + (which are indicated with brackets: [ ]) or rest parameters (which + are shown using the form «...name») are not included in the default + argument count. + + Unless otherwise specified, the length property of a built-in + function object has the attributes { [[Writable]]: false, + [[Enumerable]]: false, [[Configurable]]: true }. +includes: [propertyHelper.js] +features: [FinalizationRegistry] +---*/ + +verifyProperty(FinalizationRegistry.prototype.register, 'length', { + value: 2, + enumerable: false, + writable: false, + configurable: true +}); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/name.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/name.js new file mode 100644 index 0000000000..7296b1a76f --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/name.js @@ -0,0 +1,34 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry.prototype.register +description: FinalizationRegistry.prototype.register.name property descriptor +info: | + FinalizationRegistry.prototype.register.name value and property descriptor + + 17 ECMAScript Standard Built-in Objects + + Every built-in function object, including constructors, that is not + identified as an anonymous function has a name property whose value + is a String. Unless otherwise specified, this value is the name that + is given to the function in this specification. For functions that + are specified as properties of objects, the name value is the + property name string used to access the function. [...] + + Unless otherwise specified, the name property of a built-in function + object, if it exists, has the attributes { [[Writable]]: false, + [[Enumerable]]: false, [[Configurable]]: true }. +includes: [propertyHelper.js] +features: [FinalizationRegistry] +---*/ + +verifyProperty(FinalizationRegistry.prototype.register, 'name', { + value: 'register', + enumerable: false, + writable: false, + configurable: true +}); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/not-a-constructor.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/not-a-constructor.js new file mode 100644 index 0000000000..f2471782ab --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/not-a-constructor.js @@ -0,0 +1,36 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2020 Rick Waldron. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-ecmascript-standard-built-in-objects +description: > + FinalizationRegistry.prototype.register does not implement [[Construct]], is not new-able +info: | + ECMAScript Function Objects + + Built-in function objects that are not identified as constructors do not + implement the [[Construct]] internal method unless otherwise specified in + the description of a particular function. + + sec-evaluatenew + + ... + 7. If IsConstructor(constructor) is false, throw a TypeError exception. + ... +includes: [isConstructor.js] +features: [Reflect.construct, FinalizationRegistry, arrow-function] +---*/ + +assert.sameValue( + isConstructor(FinalizationRegistry.prototype.register), + false, + 'isConstructor(FinalizationRegistry.prototype.register) must return false' +); + +assert.throws(TypeError, () => { + let fr = new FinalizationRegistry(() => {}); new fr.register({}); +}, '`let fr = new FinalizationRegistry(() => {}); new fr.register({})` throws TypeError'); + + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/prop-desc.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/prop-desc.js new file mode 100644 index 0000000000..22bb9a3298 --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/prop-desc.js @@ -0,0 +1,27 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry.prototype.register +description: > + Property descriptor of FinalizationRegistry.prototype.register +info: | + 17 ECMAScript Standard Built-in Objects: + + Every other data property described in clauses 18 through 26 and in Annex B.2 + has the attributes { [[Writable]]: true, [[Enumerable]]: false, + [[Configurable]]: true } unless otherwise specified. +includes: [propertyHelper.js] +features: [FinalizationRegistry] +---*/ + +assert.sameValue(typeof FinalizationRegistry.prototype.register, 'function'); + +verifyProperty(FinalizationRegistry.prototype, 'register', { + enumerable: false, + writable: true, + configurable: true +}); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/return-undefined-register-itself.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/return-undefined-register-itself.js new file mode 100644 index 0000000000..00efa55a0a --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/return-undefined-register-itself.js @@ -0,0 +1,33 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry.prototype.register +description: Return undefined after registering itself +info: | + FinalizationRegistry.prototype.register ( target , holdings [, unregisterToken ] ) + + 1. Let finalizationRegistry be the this value. + 2. If Type(finalizationRegistry) is not Object, throw a TypeError exception. + 3. If finalizationRegistry does not have a [[Cells]] internal slot, throw a TypeError exception. + 4. If Type(target) is not Object, throw a TypeError exception. + 5. If SameValue(target, holdings), throw a TypeError exception. + 6. If Type(unregisterToken) is not Object, + a. If unregisterToken is not undefined, throw a TypeError exception. + b. Set unregisterToken to empty. + 7. Let cell be the Record { [[Target]] : target, [[Holdings]]: holdings, [[UnregisterToken]]: unregisterToken }. + 8. Append cell to finalizationRegistry.[[Cells]]. + 9. Return undefined. +features: [FinalizationRegistry] +---*/ + +var fn = function() {}; +var finalizationRegistry = new FinalizationRegistry(fn); +var holdings = {}; + +assert.sameValue(finalizationRegistry.register(finalizationRegistry), undefined, 'Register itself'); +assert.sameValue(finalizationRegistry.register(finalizationRegistry, holdings), undefined, 'Register itself with holdings'); +assert.sameValue(finalizationRegistry.register(finalizationRegistry, holdings, finalizationRegistry), undefined, 'Register itself with holdings and unregisterToken'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/return-undefined-register-object.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/return-undefined-register-object.js new file mode 100644 index 0000000000..b185a37113 --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/return-undefined-register-object.js @@ -0,0 +1,46 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry.prototype.register +description: Return undefined after registering an Object +info: | + FinalizationRegistry.prototype.register ( _target_ , _heldValue_ [, _unregisterToken_ ] ) + 1. Let _finalizationRegistry_ be the *this* value. + 2. Perform ? RequireInternalSlot(_finalizationRegistry_, [[Cells]]). + 3. If CanBeHeldWeakly(_target_) is *false*, throw a *TypeError* exception. + 4. If SameValue(_target_, _heldValue_) is *true*, throw a *TypeError* + exception. + 5. If CanBeHeldWeakly(_unregisterToken_) is *false*, + a. If _unregisterToken_ is not *undefined*, throw a *TypeError* exception. + b. Set _unregisterToken_ to ~empty~. + 6. Let _cell_ be the Record { [[WeakRefTarget]]: _target_, [[HeldValue]]: + _heldValue_, [[UnregisterToken]]: _unregisterToken_ }. + 7. Append _cell_ to _finalizationRegistry_.[[Cells]]. + 8. Return *undefined*. +features: [FinalizationRegistry] +---*/ + +var fn = function() {}; +var finalizationRegistry = new FinalizationRegistry(fn); + +var target = {}; +assert.sameValue(finalizationRegistry.register(target), undefined, 'Register a target'); +assert.sameValue(finalizationRegistry.register(target), undefined, 'Register the same target again'); +assert.sameValue(finalizationRegistry.register(target), undefined, 'Register the same target again and again'); + +assert.sameValue(finalizationRegistry.register({}), undefined, 'Register other targets'); + +assert.sameValue(finalizationRegistry.register(target, undefined, {}), undefined, 'Register target with unregisterToken'); +assert.sameValue( + finalizationRegistry.register(target, undefined, target), + undefined, + 'Register target with unregisterToken being the registered target' +); + +assert.sameValue(finalizationRegistry.register(target, undefined, undefined), undefined, 'Register target with explicit undefined unregisterToken'); + +assert.sameValue(finalizationRegistry.register(fn), undefined, 'register the cleanup callback fn'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/return-undefined-register-symbol.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/return-undefined-register-symbol.js new file mode 100644 index 0000000000..8c8a944429 --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/return-undefined-register-symbol.js @@ -0,0 +1,76 @@ +// |reftest| shell-option(--enable-symbols-as-weakmap-keys) skip-if(release_or_beta||!this.hasOwnProperty('FinalizationRegistry')||!xulRuntime.shell) -- symbols-as-weakmap-keys is not released yet, FinalizationRegistry is not enabled unconditionally, requires shell-options +// Copyright (C) 2022 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry.prototype.register +description: Return undefined after registering a Symbol +info: | + FinalizationRegistry.prototype.register ( _target_ , _heldValue_ [, _unregisterToken_ ] ) + 8. Return *undefined*. +features: [FinalizationRegistry, Symbol, symbols-as-weakmap-keys] +---*/ + +var fn = function() {}; +var reg = new FinalizationRegistry(fn); + +var target = Symbol('a description'); +assert.sameValue(reg.register(target), undefined, 'Register a regular symbol'); +assert.sameValue(reg.register(target), undefined, 'Register the same symbol again'); +assert.sameValue(reg.register(target), undefined, 'Register the same symbol a third time'); + +assert.sameValue( + reg.register(Symbol('a description')), + undefined, + 'Register another symbol with the same description' +); +assert.sameValue( + reg.register(Symbol('a different description')), + undefined, + 'Register another symbol with another description' +); + +assert.sameValue( + reg.register(target, undefined, Symbol('unregister token')), + undefined, + 'Register a regular symbol with a symbol unregister token' +); +assert.sameValue( + reg.register(target, undefined, target), + undefined, + 'Register a regular symbol with itself as the unregister token' +); + +assert.sameValue( + reg.register(target, undefined, undefined), + undefined, + 'Register a regular symbol with explicit undefined unregister token' +); + +assert.sameValue(reg.register(Symbol.hasInstance), undefined, 'Register a well-known symbol'); +assert.sameValue(reg.register(Symbol.hasInstance), undefined, 'Register the same well-known symbol again'); +assert.sameValue(reg.register(Symbol.hasInstance), undefined, 'Register the same well-known symbol a third time'); + +assert.sameValue( + reg.register(target, undefined, Symbol.hasInstance), + undefined, + 'Register a regular symbol with a well-known symbol unregister token' +); +assert.sameValue( + reg.register(Symbol.hasInstance, undefined, Symbol.iterator), + undefined, + 'Register a well-known symbol with a different well-known symbol as unregister token' +); +assert.sameValue( + reg.register(Symbol.hasInstance, undefined, Symbol.hasInstance), + undefined, + 'Register a well-known symbol with itself as the unregister token' +); + +assert.sameValue( + reg.register(Symbol.hasInstance, undefined, undefined), + undefined, + 'Register a well-known symbol with explicit undefined unregister token' +); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/shell.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/shell.js new file mode 100644 index 0000000000..e69de29bb2 diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/this-does-not-have-internal-target-throws.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/this-does-not-have-internal-target-throws.js new file mode 100644 index 0000000000..f7044833ba --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/this-does-not-have-internal-target-throws.js @@ -0,0 +1,51 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')||!this.hasOwnProperty('WeakRef')) -- FinalizationRegistry,WeakRef is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry.prototype.register +description: Throws a TypeError if this does not have a [[Cells]] internal slot +info: | + FinalizationRegistry.prototype.register ( target , holdings [, unregisterToken ] ) + + 1. Let finalizationRegistry be the this value. + 2. If Type(finalizationRegistry) is not Object, throw a TypeError exception. + 3. If Type(target) is not Object, throw a TypeError exception. + 4. If finalizationRegistry does not have a [[Cells]] internal slot, throw a TypeError exception. + ... +features: [WeakSet, WeakMap, FinalizationRegistry, WeakRef] +---*/ + +assert.sameValue(typeof FinalizationRegistry.prototype.register, 'function'); + +var register = FinalizationRegistry.prototype.register; +var target = {}; + +assert.throws(TypeError, function() { + register.call({ ['[[Cells]]']: {} }, target); +}, 'Ordinary object without [[Cells]]'); + +assert.throws(TypeError, function() { + register.call(WeakRef.prototype, target); +}, 'WeakRef.prototype does not have a [[Cells]] internal slot'); + +assert.throws(TypeError, function() { + register.call(WeakRef, target); +}, 'WeakRef does not have a [[Cells]] internal slot'); + +var wr = new WeakRef({}); +assert.throws(TypeError, function() { + register.call(wr, target); +}, 'WeakRef instance'); + +var wm = new WeakMap(); +assert.throws(TypeError, function() { + register.call(wm, target); +}, 'WeakMap instance'); + +var ws = new WeakSet(); +assert.throws(TypeError, function() { + register.call(ws, target); +}, 'WeakSet instance'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/this-not-object-throws.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/this-not-object-throws.js new file mode 100644 index 0000000000..933a905e35 --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/this-not-object-throws.js @@ -0,0 +1,54 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry.prototype.register +description: Throws a TypeError if this is not an Object +info: | + FinalizationRegistry.prototype.register ( target , holdings [, unregisterToken ] ) + + 1. Let finalizationRegistry be the this value. + 2. If Type(finalizationRegistry) is not Object, throw a TypeError exception. + 3. If Type(target) is not Object, throw a TypeError exception. + 4. If finalizationRegistry does not have a [[Cells]] internal slot, throw a TypeError exception. + 5. If Type(unregisterToken) is not Object, + a. If unregisterToken is not undefined, throw a TypeError exception. + ... +features: [FinalizationRegistry] +---*/ + +assert.sameValue(typeof FinalizationRegistry.prototype.register, 'function'); + +var register = FinalizationRegistry.prototype.register; + +assert.throws(TypeError, function() { + register.call(undefined, {}); +}, 'undefined'); + +assert.throws(TypeError, function() { + register.call(null, {}); +}, 'null'); + +assert.throws(TypeError, function() { + register.call(true, {}); +}, 'true'); + +assert.throws(TypeError, function() { + register.call(false, {}); +}, 'false'); + +assert.throws(TypeError, function() { + register.call(1, {}); +}, 'number'); + +assert.throws(TypeError, function() { + register.call('object', {}); +}, 'string'); + +var s = Symbol(); +assert.throws(TypeError, function() { + register.call(s, {}); +}, 'symbol'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/throws-when-target-cannot-be-held-weakly.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/throws-when-target-cannot-be-held-weakly.js new file mode 100644 index 0000000000..fa2fe3e021 --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/throws-when-target-cannot-be-held-weakly.js @@ -0,0 +1,47 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry.prototype.register +description: Throws a TypeError if target cannot be held weakly +info: | + FinalizationRegistry.prototype.register ( _target_ , _heldValue_ [, _unregisterToken_ ] ) + 3. If CanBeHeldWeakly(_target_) is *false*, throw a *TypeError* exception. +features: [FinalizationRegistry] +---*/ + +assert.sameValue(typeof FinalizationRegistry.prototype.register, 'function'); + +var finalizationRegistry = new FinalizationRegistry(function() {}); + +assert.throws(TypeError, function() { + finalizationRegistry.register(undefined); +}, 'undefined'); + +assert.throws(TypeError, function() { + finalizationRegistry.register(null); +}, 'null'); + +assert.throws(TypeError, function() { + finalizationRegistry.register(true); +}, 'true'); + +assert.throws(TypeError, function() { + finalizationRegistry.register(false); +}, 'false'); + +assert.throws(TypeError, function() { + finalizationRegistry.register(1); +}, 'number'); + +assert.throws(TypeError, function() { + finalizationRegistry.register('object'); +}, 'string'); + +var s = Symbol.for('registered symbol'); +assert.throws(TypeError, function() { + finalizationRegistry.register(s); +}, 'registered symbol'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/throws-when-unregisterToken-not-undefined-and-cannot-be-held-weakly.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/throws-when-unregisterToken-not-undefined-and-cannot-be-held-weakly.js new file mode 100644 index 0000000000..6f7853a439 --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/throws-when-unregisterToken-not-undefined-and-cannot-be-held-weakly.js @@ -0,0 +1,47 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry.prototype.register +description: > + Throws a TypeError if unregisterToken is not undefined and cannot be held + weakly +info: | + FinalizationRegistry.prototype.register ( _target_ , _heldValue_ [, _unregisterToken_ ] ) + 5. If CanBeHeldWeakly(_unregisterToken_) is *false*, then + a. If _unregisterToken_ is not *undefined*, throw a *TypeError* exception. +features: [FinalizationRegistry] +---*/ + +assert.sameValue(typeof FinalizationRegistry.prototype.register, 'function'); + +var finalizationRegistry = new FinalizationRegistry(function() {}); +var target = {}; + +assert.throws(TypeError, function() { + finalizationRegistry.register(target, undefined, null); +}, 'null'); + +assert.throws(TypeError, function() { + finalizationRegistry.register(target, undefined, true); +}, 'true'); + +assert.throws(TypeError, function() { + finalizationRegistry.register(target, undefined, false); +}, 'false'); + +assert.throws(TypeError, function() { + finalizationRegistry.register(target, undefined, 1); +}, 'number'); + +assert.throws(TypeError, function() { + finalizationRegistry.register(target, undefined, 'object'); +}, 'string'); + +var s = Symbol.for('registered symbol'); +assert.throws(TypeError, function() { + finalizationRegistry.register(target, undefined, s); +}, 'registered symbol'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/unregisterToken-same-as-holdings-and-target.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/unregisterToken-same-as-holdings-and-target.js new file mode 100644 index 0000000000..a3ed546406 --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/unregisterToken-same-as-holdings-and-target.js @@ -0,0 +1,30 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry.prototype.register +description: unregisterToken may be the same as holdings and target +info: | + FinalizationRegistry.prototype.register ( target , holdings [, unregisterToken ] ) + + 1. Let finalizationRegistry be the this value. + 2. If Type(finalizationRegistry) is not Object, throw a TypeError exception. + 3. If finalizationRegistry does not have a [[Cells]] internal slot, throw a TypeError exception. + 4. If Type(target) is not Object, throw a TypeError exception. + 5. If SameValue(target, holdings), throw a TypeError exception. + 6. If Type(unregisterToken) is not Object, + a. If unregisterToken is not undefined, throw a TypeError exception. + b. Set unregisterToken to empty. + 7. Let cell be the Record { [[Target]] : target, [[Holdings]]: holdings, [[UnregisterToken]]: unregisterToken }. + 8. Append cell to finalizationRegistry.[[Cells]]. + 9. Return undefined. +features: [FinalizationRegistry] +---*/ + +var finalizationRegistry = new FinalizationRegistry(function() {}); + +var target = {}; +assert.throws(TypeError, () => finalizationRegistry.register(target, target, target)); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/unregisterToken-same-as-holdings.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/unregisterToken-same-as-holdings.js new file mode 100644 index 0000000000..befc50ec10 --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/unregisterToken-same-as-holdings.js @@ -0,0 +1,30 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry.prototype.register +description: unregisterToken may be the same as holdings +info: | + FinalizationRegistry.prototype.register ( target , holdings [, unregisterToken ] ) + + 1. Let finalizationRegistry be the this value. + 2. If Type(finalizationRegistry) is not Object, throw a TypeError exception. + 3. If Type(target) is not Object, throw a TypeError exception. + 4. If finalizationRegistry does not have a [[Cells]] internal slot, throw a TypeError exception. + 5. If Type(unregisterToken) is not Object, + a. If unregisterToken is not undefined, throw a TypeError exception. + b. Set unregisterToken to empty. + 6. Let cell be the Record { [[Target]] : target, [[Holdings]]: holdings, [[UnregisterToken]]: unregisterToken }. + 7. Append cell to finalizationRegistry.[[Cells]]. + 8. Return undefined. +features: [FinalizationRegistry] +---*/ + +var finalizationRegistry = new FinalizationRegistry(function() {}); + +var target = {}; +var holdings = {}; +assert.sameValue(finalizationRegistry.register(target, holdings, holdings), undefined); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/unregisterToken-same-as-target.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/unregisterToken-same-as-target.js new file mode 100644 index 0000000000..bfe567cf50 --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/register/unregisterToken-same-as-target.js @@ -0,0 +1,29 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry.prototype.register +description: unregisterToken may be the same as target +info: | + FinalizationRegistry.prototype.register ( target , holdings [, unregisterToken ] ) + + 1. Let finalizationRegistry be the this value. + 2. If Type(finalizationRegistry) is not Object, throw a TypeError exception. + 3. If Type(target) is not Object, throw a TypeError exception. + 4. If finalizationRegistry does not have a [[Cells]] internal slot, throw a TypeError exception. + 5. If Type(unregisterToken) is not Object, + a. If unregisterToken is not undefined, throw a TypeError exception. + b. Set unregisterToken to empty. + 6. Let cell be the Record { [[Target]] : target, [[Holdings]]: holdings, [[UnregisterToken]]: unregisterToken }. + 7. Append cell to finalizationRegistry.[[Cells]]. + 8. Return undefined. +features: [FinalizationRegistry] +---*/ + +var finalizationRegistry = new FinalizationRegistry(function() {}); + +var target = {}; +assert.sameValue(finalizationRegistry.register(target, '1', target), undefined); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/shell.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/shell.js new file mode 100644 index 0000000000..e69de29bb2 diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/browser.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/browser.js new file mode 100644 index 0000000000..e69de29bb2 diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/custom-this.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/custom-this.js new file mode 100644 index 0000000000..ac7157940e --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/custom-this.js @@ -0,0 +1,50 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry.prototype.unregister +description: Return values applying custom this +info: | + FinalizationRegistry.prototype.unregister ( unregisterToken ) + + 1. Let finalizationRegistry be the this value. + 2. If Type(finalizationRegistry) is not Object, throw a TypeError exception. + 3. If finalizationRegistry does not have a [[Cells]] internal slot, throw a TypeError exception. + 4. If Type(unregisterToken) is not Object, throw a TypeError exception. + 5. Let removed be false. + 6. For each Record { [[Target]], [[Holdings]], [[UnregisterToken]] } cell that is an element of finalizationRegistry.[[Cells]], do + a. If SameValue(cell.[[UnregisterToken]], unregisterToken) is true, then + i. Remove cell from finalizationRegistry.[[Cells]]. + ii. Set removed to true. + 7. Return removed. +features: [FinalizationRegistry] +---*/ + +var fn = function() {}; +var unregister = FinalizationRegistry.prototype.unregister; +var finalizationRegistry = new FinalizationRegistry(fn); + +var target1 = {}; +var target2 = {}; +var target3 = {}; +var token1 = {}; +var token2 = {}; + +assert.sameValue(unregister.call(finalizationRegistry, token1), false, 'unregistering token1 from empty finalizationRegistry'); +assert.sameValue(unregister.call(finalizationRegistry, token2), false, 'unregistering token2 from empty finalizationRegistry'); + +finalizationRegistry.register(target1, undefined, token1); +finalizationRegistry.register(target2, undefined, token2); +finalizationRegistry.register(target3, undefined, token2); + +assert.sameValue(unregister.call(finalizationRegistry, target1), false, 'own target does not work on unregister, #1'); +assert.sameValue(unregister.call(finalizationRegistry, target2), false, 'own target does not work on unregister, #2'); +assert.sameValue(unregister.call(finalizationRegistry, target3), false, 'own target does not work on unregister, #3'); + +assert.sameValue(unregister.call(finalizationRegistry, token1), true, 'unregistering token1 from finalizationRegistry'); +assert.sameValue(unregister.call(finalizationRegistry, token1), false, 'unregistering token1 again from finalizationRegistry'); +assert.sameValue(unregister.call(finalizationRegistry, token2), true, 'unregistering token2 to remove target2 and target3'); +assert.sameValue(unregister.call(finalizationRegistry, token2), false, 'unregistering token2 from empty finalizationRegistry'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/length.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/length.js new file mode 100644 index 0000000000..72d6570581 --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/length.js @@ -0,0 +1,35 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry.prototype.unregister +description: FinalizationRegistry.prototype.unregister.length property descriptor +info: | + FinalizationRegistry.prototype.unregister ( unregisterToken ) + + 17 ECMAScript Standard Built-in Objects + + Every built-in function object, including constructors, has a length + property whose value is an integer. Unless otherwise specified, this + value is equal to the largest number of named arguments shown in the + subclause headings for the function description. Optional parameters + (which are indicated with brackets: [ ]) or rest parameters (which + are shown using the form «...name») are not included in the default + argument count. + + Unless otherwise specified, the length property of a built-in + function object has the attributes { [[Writable]]: false, + [[Enumerable]]: false, [[Configurable]]: true }. +includes: [propertyHelper.js] +features: [FinalizationRegistry] +---*/ + +verifyProperty(FinalizationRegistry.prototype.unregister, 'length', { + value: 1, + writable: false, + enumerable: false, + configurable: true +}); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/name.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/name.js new file mode 100644 index 0000000000..3b92b98d58 --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/name.js @@ -0,0 +1,34 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry.prototype.unregister +description: FinalizationRegistry.prototype.unregister.name property descriptor +info: | + FinalizationRegistry.prototype.unregister.name value and property descriptor + + 17 ECMAScript Standard Built-in Objects + + Every built-in function object, including constructors, that is not + identified as an anonymous function has a name property whose value + is a String. Unless otherwise specified, this value is the name that + is given to the function in this specification. For functions that + are specified as properties of objects, the name value is the + property name string used to access the function. [...] + + Unless otherwise specified, the name property of a built-in function + object, if it exists, has the attributes { [[Writable]]: false, + [[Enumerable]]: false, [[Configurable]]: true }. +includes: [propertyHelper.js] +features: [FinalizationRegistry] +---*/ + +verifyProperty(FinalizationRegistry.prototype.unregister, 'name', { + value: 'unregister', + writable: false, + enumerable: false, + configurable: true +}); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/not-a-constructor.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/not-a-constructor.js new file mode 100644 index 0000000000..ea51595556 --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/not-a-constructor.js @@ -0,0 +1,36 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2020 Rick Waldron. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-ecmascript-standard-built-in-objects +description: > + FinalizationRegistry.prototype.unregister does not implement [[Construct]], is not new-able +info: | + ECMAScript Function Objects + + Built-in function objects that are not identified as constructors do not + implement the [[Construct]] internal method unless otherwise specified in + the description of a particular function. + + sec-evaluatenew + + ... + 7. If IsConstructor(constructor) is false, throw a TypeError exception. + ... +includes: [isConstructor.js] +features: [Reflect.construct, FinalizationRegistry, arrow-function] +---*/ + +assert.sameValue( + isConstructor(FinalizationRegistry.prototype.unregister), + false, + 'isConstructor(FinalizationRegistry.prototype.unregister) must return false' +); + +assert.throws(TypeError, () => { + let fr = new FinalizationRegistry(() => {}); let token = {}; fr.register(token); new fr.unregister(token); +}, '`let fr = new FinalizationRegistry(() => {}); let token = {}; fr.register(token); new fr.unregister(token)` throws TypeError'); + + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/prop-desc.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/prop-desc.js new file mode 100644 index 0000000000..0e4aa0564c --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/prop-desc.js @@ -0,0 +1,27 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry.prototype.unregister +description: > + Property descriptor of FinalizationRegistry.prototype.unregister +info: | + 17 ECMAScript Standard Built-in Objects: + + Every other data property described in clauses 18 through 26 and in Annex B.2 + has the attributes { [[Writable]]: true, [[Enumerable]]: false, + [[Configurable]]: true } unless otherwise specified. +includes: [propertyHelper.js] +features: [FinalizationRegistry] +---*/ + +assert.sameValue(typeof FinalizationRegistry.prototype.unregister, 'function'); + +verifyProperty(FinalizationRegistry.prototype, 'unregister', { + enumerable: false, + writable: true, + configurable: true +}); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/shell.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/shell.js new file mode 100644 index 0000000000..e69de29bb2 diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/this-does-not-have-internal-cells-throws.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/this-does-not-have-internal-cells-throws.js new file mode 100644 index 0000000000..a10e58c01d --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/this-does-not-have-internal-cells-throws.js @@ -0,0 +1,51 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')||!this.hasOwnProperty('WeakRef')) -- FinalizationRegistry,WeakRef is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry.prototype.unregister +description: Throws a TypeError if this does not have a [[Cells]] internal slot +info: | + FinalizationRegistry.prototype.unregister ( unregisterToken ) + + 1. Let finalizationRegistry be the this value. + 2. If Type(finalizationRegistry) is not Object, throw a TypeError exception. + 3. If finalizationRegistry does not have a [[Cells]] internal slot, throw a TypeError exception. + 4. If Type(unregisterToken) is not Object, throw a TypeError exception. + ... +features: [WeakSet, WeakMap, FinalizationRegistry, WeakRef] +---*/ + +assert.sameValue(typeof FinalizationRegistry.prototype.unregister, 'function'); + +var unregister = FinalizationRegistry.prototype.unregister; +var token = {}; + +assert.throws(TypeError, function() { + unregister.call({ ['[[Cells]]']: {} }, token); +}, 'Ordinary object without [[Cells]]'); + +assert.throws(TypeError, function() { + unregister.call(WeakRef.prototype, token); +}, 'WeakRef.prototype does not have a [[Cells]] internal slot'); + +assert.throws(TypeError, function() { + unregister.call(WeakRef, token); +}, 'WeakRef does not have a [[Cells]] internal slot'); + +var wr = new WeakRef({}); +assert.throws(TypeError, function() { + unregister.call(wr, token); +}, 'WeakRef instance'); + +var wm = new WeakMap(); +assert.throws(TypeError, function() { + unregister.call(wm, token); +}, 'WeakMap instance'); + +var ws = new WeakSet(); +assert.throws(TypeError, function() { + unregister.call(ws, token); +}, 'WeakSet instance'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/this-not-object-throws.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/this-not-object-throws.js new file mode 100644 index 0000000000..7cb536cb9c --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/this-not-object-throws.js @@ -0,0 +1,52 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry.prototype.unregister +description: Throws a TypeError if this is not an Object +info: | + FinalizationRegistry.prototype.unregister ( unregisterToken ) + + 1. Let finalizationRegistry be the this value. + 2. If Type(finalizationRegistry) is not Object, throw a TypeError exception. + 3. If finalizationRegistry does not have a [[Cells]] internal slot, throw a TypeError exception. + 4. If Type(unregisterToken) is not Object, throw a TypeError exception. + ... +features: [FinalizationRegistry] +---*/ + +assert.sameValue(typeof FinalizationRegistry.prototype.unregister, 'function'); + +var unregister = FinalizationRegistry.prototype.unregister; + +assert.throws(TypeError, function() { + unregister.call(undefined, {}); +}, 'undefined'); + +assert.throws(TypeError, function() { + unregister.call(null, {}); +}, 'null'); + +assert.throws(TypeError, function() { + unregister.call(true, {}); +}, 'true'); + +assert.throws(TypeError, function() { + unregister.call(false, {}); +}, 'false'); + +assert.throws(TypeError, function() { + unregister.call(1, {}); +}, 'number'); + +assert.throws(TypeError, function() { + unregister.call('object', {}); +}, 'string'); + +var s = Symbol(); +assert.throws(TypeError, function() { + unregister.call(s, {}); +}, 'symbol'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/throws-when-unregisterToken-cannot-be-held-weakly.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/throws-when-unregisterToken-cannot-be-held-weakly.js new file mode 100644 index 0000000000..403b569d5a --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/throws-when-unregisterToken-cannot-be-held-weakly.js @@ -0,0 +1,47 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry.prototype.unregister +description: Throws a TypeError if unregisterToken cannot be held weakly +info: | + FinalizationRegistry.prototype.unregister ( _unregisterToken_ ) + 3. If CanBeHeldWeakly(_unregisterToken_) is *false*, throw a *TypeError* exception. +features: [FinalizationRegistry] +---*/ + +assert.sameValue(typeof FinalizationRegistry.prototype.unregister, 'function'); + +var finalizationRegistry = new FinalizationRegistry(function() {}); + +assert.throws(TypeError, function() { + finalizationRegistry.unregister(undefined); +}, 'undefined'); + +assert.throws(TypeError, function() { + finalizationRegistry.unregister(null); +}, 'null'); + +assert.throws(TypeError, function() { + finalizationRegistry.unregister(true); +}, 'true'); + +assert.throws(TypeError, function() { + finalizationRegistry.unregister(false); +}, 'false'); + +assert.throws(TypeError, function() { + finalizationRegistry.unregister(1); +}, 'number'); + +assert.throws(TypeError, function() { + finalizationRegistry.unregister('object'); +}, 'string'); + +var s = Symbol.for('registered symbol'); +assert.throws(TypeError, function() { + finalizationRegistry.unregister(s); +}, 'registered symbol'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/unregister-cleaned-up-object-cell.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/unregister-cleaned-up-object-cell.js new file mode 100644 index 0000000000..da74a59287 --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/unregister-cleaned-up-object-cell.js @@ -0,0 +1,64 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) async -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Mathieu Hofman. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry.prototype.unregister +description: > + Cannot unregister a cell referring to an Object that has been cleaned up +info: | + FinalizationRegistry.prototype.cleanupSome ( [ _callback_ ] ) + 4. Perform ? CleanupFinalizationRegistry(_finalizationRegistry_, _callback_). + + CleanupFinalizationRegistry ( _finalizationRegistry_ ): + 3. While _finalizationRegistry_.[[Cells]] contains a Record _cell_ such that + _cell_.[[WeakRefTarget]] is ~empty~, then an implementation may perform the + following steps: + a. Choose any such _cell_. + b. Remove _cell_ from _finalizationRegistry_.[[Cells]]. + c. Perform ? HostCallJobCallback(_callback_, *undefined*, + « _cell_.[[HeldValue]] »). + + FinalizationRegistry.prototype.unregister ( _unregisterToken_ ) + 4. Let _removed_ be *false*. + 5. For each Record { [[WeakRefTarget]], [[HeldValue]], [[UnregisterToken]] } + _cell_ of _finalizationRegistry_.[[Cells]], do + a. If _cell_.[[UnregisterToken]] is not ~empty~ and + SameValue(_cell_.[[UnregisterToken]], _unregisterToken_) is *true*, then + i. Remove _cell_ from _finalizationRegistry_.[[Cells]]. + ii. Set _removed_ to *true*. + 6. Return _removed_. +features: [FinalizationRegistry.prototype.cleanupSome, FinalizationRegistry, host-gc-required] +includes: [async-gc.js] +flags: [async, non-deterministic] +---*/ + +var value = 'target!'; +var token = {}; +var finalizationRegistry = new FinalizationRegistry(function() {}); + +function emptyCells() { + var target = {}; + finalizationRegistry.register(target, value, token); + + var prom = asyncGC(target); + target = null; + + return prom; +} + +emptyCells().then(function() { + var called = 0; + var holdings = []; + finalizationRegistry.cleanupSome(function cb(holding) { + called += 1; + holdings.push(holding); + }); + + assert.sameValue(called, 1); + assert.sameValue(holdings.length, 1); + assert.sameValue(holdings[0], value); + + var res = finalizationRegistry.unregister(token); + assert.sameValue(res, false, 'unregister after iterating over it in cleanup'); +}).then($DONE, resolveAsyncGC); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/unregister-object-token.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/unregister-object-token.js new file mode 100644 index 0000000000..0dd685e4b8 --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/unregister-object-token.js @@ -0,0 +1,57 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry.prototype.unregister +description: > + Return boolean values indicating unregistering of values with Object token +info: | + FinalizationRegistry.prototype.unregister ( _unregisterToken_ ) + 4. Let _removed_ be *false*. + 5. For each Record { [[WeakRefTarget]], [[HeldValue]], [[UnregisterToken]] } + _cell_ of _finalizationRegistry_.[[Cells]], do + a. If _cell_.[[UnregisterToken]] is not ~empty~ and + SameValue(_cell_.[[UnregisterToken]], _unregisterToken_) is *true*, then + i. Remove _cell_ from _finalizationRegistry_.[[Cells]]. + ii. Set _removed_ to *true*. + 6. Return _removed_. +features: [FinalizationRegistry] +---*/ + +var fn = function() {}; +var finalizationRegistry = new FinalizationRegistry(fn); + +var target1 = {}; +var target2 = {}; +var target3 = {}; +var token1 = {}; +var token2 = {}; + +assert.sameValue(finalizationRegistry.unregister(token1), false, 'unregistering token1 from empty finalizationRegistry'); +assert.sameValue(finalizationRegistry.unregister(token2), false, 'unregistering token2 from empty finalizationRegistry'); + +finalizationRegistry.register(target1, undefined, token1); +finalizationRegistry.register(target1, undefined, token1); // Repeat registering un purpose +finalizationRegistry.register(target2, undefined, token2); +finalizationRegistry.register(target3, undefined, token2); + +assert.sameValue(finalizationRegistry.unregister(target1), false, 'own target does not work on unregister, #1'); +assert.sameValue(finalizationRegistry.unregister(target2), false, 'own target does not work on unregister, #2'); +assert.sameValue(finalizationRegistry.unregister(target3), false, 'own target does not work on unregister, #3'); + +assert.sameValue(finalizationRegistry.unregister(token1), true, 'unregistering token1 from finalizationRegistry'); +assert.sameValue(finalizationRegistry.unregister(token1), false, 'unregistering token1 again from finalizationRegistry'); +assert.sameValue(finalizationRegistry.unregister(token2), true, 'unregistering token2 to remove target2 and target3'); +assert.sameValue(finalizationRegistry.unregister(token2), false, 'unregistering token2 from empty finalizationRegistry'); + +// Notice these assertions take advantage of adding targets previously added with a token, +// but now they got no token so it won't be used to remove them. +finalizationRegistry.register(target1, token1); // holdings, not unregisterToken +finalizationRegistry.register(target2, token2); // holdings, not unregisterToken +finalizationRegistry.register(target3); + +assert.sameValue(finalizationRegistry.unregister(token1), false, 'nothing to remove without a set unregisterToken #1'); +assert.sameValue(finalizationRegistry.unregister(token2), false, 'nothing to remove without a set unregisterToken #2'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/unregister-symbol-token.js b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/unregister-symbol-token.js new file mode 100644 index 0000000000..f343ff3712 --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/prototype/unregister/unregister-symbol-token.js @@ -0,0 +1,64 @@ +// |reftest| shell-option(--enable-symbols-as-weakmap-keys) skip-if(release_or_beta||!this.hasOwnProperty('FinalizationRegistry')||!xulRuntime.shell) -- symbols-as-weakmap-keys is not released yet, FinalizationRegistry is not enabled unconditionally, requires shell-options +// Copyright (C) 2022 Igalia, S.L. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry.prototype.unregister +description: > + Return boolean values indicating unregistering of values with Symbol token +info: | + FinalizationRegistry.prototype.unregister ( _unregisterToken_ ) + 4. Let _removed_ be *false*. + 5. For each Record { [[WeakRefTarget]], [[HeldValue]], [[UnregisterToken]] } + _cell_ of _finalizationRegistry_.[[Cells]], do + a. If _cell_.[[UnregisterToken]] is not ~empty~ and + SameValue(_cell_.[[UnregisterToken]], _unregisterToken_) is *true*, then + i. Remove _cell_ from _finalizationRegistry_.[[Cells]]. + ii. Set _removed_ to *true*. + 6. Return _removed_. +features: [FinalizationRegistry, Symbol, symbols-as-weakmap-keys] +---*/ + +var fn = function() {}; +var reg = new FinalizationRegistry(fn); + +var target1 = {}; +var target2 = {}; +var target3 = {}; +var token = Symbol('unregister'); + +assert.sameValue(reg.unregister(token), false, 'unregistering regular symbol from empty registry'); +assert.sameValue(reg.unregister(Symbol.hasInstance), false, 'unregistering well-known symbol from empty registry'); + +reg.register(target1, undefined, token); +reg.register(target1, undefined, token); // Repeat registering on purpose +reg.register(target2, undefined, Symbol.hasInstance); +reg.register(target3, undefined, Symbol.hasInstance); + +assert.sameValue(reg.unregister(token), true, 'unregistering regular symbol from finalization registry'); +assert.sameValue(reg.unregister(token), false, 'unregistering regular symbol again from finalization registry'); +assert.sameValue( + reg.unregister(Symbol.hasInstance), + true, + 'unregistering well-known symbol to remove target2 and target3' +); +assert.sameValue( + reg.unregister(Symbol.hasInstance), + false, + 'unregistering well-known again from finalization registry' +); + +// Notice these assertions take advantage of adding targets previously added +// with a token, but now they have no token so it won't be used to remove them. +reg.register(target1, token); // heldValue, not unregisterToken +reg.register(target2, Symbol.hasInstance); // heldValue, not unregisterToken +reg.register(target3); + +assert.sameValue(reg.unregister(token), false, 'nothing to remove with regular symbol unregister token'); +assert.sameValue( + reg.unregister(Symbol.hasInstance), + false, + 'nothing to remove with well-known symbol unregister token' +); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/returns-new-object-from-constructor.js b/js/src/tests/test262/built-ins/FinalizationRegistry/returns-new-object-from-constructor.js new file mode 100644 index 0000000000..86cb020b36 --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/returns-new-object-from-constructor.js @@ -0,0 +1,42 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry-target +description: > + Returns a new ordinary object from the FinalizationRegistry constructor +info: | + FinalizationRegistry ( cleanupCallback ) + + ... + 3. Let finalizationRegistry be ? OrdinaryCreateFromConstructor(NewTarget, "%FinalizationRegistryPrototype%", « [[Realm]], [[CleanupCallback]], [[Cells]], [[IsFinalizationRegistryCleanupJobActive]] »). + ... + 9. Return finalizationRegistry. + + OrdinaryCreateFromConstructor ( constructor, intrinsicDefaultProto [ , internalSlotsList ] ) + + ... + 2. Let proto be ? GetPrototypeFromConstructor(constructor, intrinsicDefaultProto). + 3. Return ObjectCreate(proto, internalSlotsList). +features: [FinalizationRegistry, for-of] +---*/ + +var cleanupCallback = function() {}; +var finalizationRegistry = new FinalizationRegistry(cleanupCallback); + +assert.sameValue(Object.getPrototypeOf(finalizationRegistry), FinalizationRegistry.prototype); +assert.notSameValue(finalizationRegistry, cleanupCallback, 'does not return the same function'); +assert.sameValue(finalizationRegistry instanceof FinalizationRegistry, true, 'instanceof'); + +for (let key of Object.getOwnPropertyNames(finalizationRegistry)) { + assert(false, `should not set any own named properties: ${key}`); +} + +for (let key of Object.getOwnPropertySymbols(finalizationRegistry)) { + assert(false, `should not set any own symbol properties: ${String(key)}`); +} + +assert.sameValue(Object.getPrototypeOf(finalizationRegistry), FinalizationRegistry.prototype); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/shell.js b/js/src/tests/test262/built-ins/FinalizationRegistry/shell.js new file mode 100644 index 0000000000..b4d29ea4e9 --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/shell.js @@ -0,0 +1,83 @@ +// GENERATED, DO NOT EDIT +// file: async-gc.js +// Copyright (C) 2019 Ecma International. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. +/*--- +description: > + Collection of functions used to capture references cleanup from garbage collectors +features: [FinalizationRegistry.prototype.cleanupSome, FinalizationRegistry, Symbol, async-functions] +flags: [non-deterministic] +defines: [asyncGC, asyncGCDeref, resolveAsyncGC] +---*/ + +function asyncGC(...targets) { + var finalizationRegistry = new FinalizationRegistry(() => {}); + var length = targets.length; + + for (let target of targets) { + finalizationRegistry.register(target, 'target'); + target = null; + } + + targets = null; + + return Promise.resolve('tick').then(() => asyncGCDeref()).then(() => { + var names = []; + + // consume iterator to capture names + finalizationRegistry.cleanupSome(name => { names.push(name); }); + + if (!names || names.length != length) { + throw asyncGC.notCollected; + } + }); +} + +asyncGC.notCollected = Symbol('Object was not collected'); + +async function asyncGCDeref() { + var trigger; + + // TODO: Remove this when $262.clearKeptObject becomes documented and required + if ($262.clearKeptObjects) { + trigger = $262.clearKeptObjects(); + } + + await $262.gc(); + + return Promise.resolve(trigger); +} + +function resolveAsyncGC(err) { + if (err === asyncGC.notCollected) { + // Do not fail as GC can't provide necessary resources. + $DONE(); + return; + } + + $DONE(err); +} + +// file: isConstructor.js +// Copyright (C) 2017 André Bargull. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +description: | + Test if a given function is a constructor function. +defines: [isConstructor] +features: [Reflect.construct] +---*/ + +function isConstructor(f) { + if (typeof f !== "function") { + throw new Test262Error("isConstructor invoked with a non-function value"); + } + + try { + Reflect.construct(function(){}, [], f); + } catch (e) { + return false; + } + return true; +} diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/target-not-callable-throws.js b/js/src/tests/test262/built-ins/FinalizationRegistry/target-not-callable-throws.js new file mode 100644 index 0000000000..e68fecc72e --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/target-not-callable-throws.js @@ -0,0 +1,72 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')||!this.hasOwnProperty('WeakRef')) -- FinalizationRegistry,WeakRef is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry-target +description: > + Throws a TypeError if target is not callable +info: | + FinalizationRegistry ( cleanupCallback ) + + 1. If NewTarget is undefined, throw a TypeError exception. + 2. If IsCallable(cleanupCallback) is false, throw a TypeError exception. + ... +features: [FinalizationRegistry, WeakRef] +---*/ + +assert.sameValue( + typeof FinalizationRegistry, 'function', + 'typeof FinalizationRegistry is function' +); + +assert.throws(TypeError, function() { + new FinalizationRegistry({}); +}, 'ordinary object'); + +assert.throws(TypeError, function() { + new FinalizationRegistry(WeakRef.prototype); +}, 'WeakRef.prototype'); + +assert.throws(TypeError, function() { + new FinalizationRegistry(FinalizationRegistry.prototype); +}, 'FinalizationRegistry.prototype'); + +assert.throws(TypeError, function() { + new FinalizationRegistry([]); +}, 'Array'); + +assert.throws(TypeError, function() { + new FinalizationRegistry(); +}, 'implicit undefined'); + +assert.throws(TypeError, function() { + new FinalizationRegistry(undefined); +}, 'explicit undefined'); + +assert.throws(TypeError, function() { + new FinalizationRegistry(null); +}, 'null'); + +assert.throws(TypeError, function() { + new FinalizationRegistry(1); +}, 'number'); + +assert.throws(TypeError, function() { + new FinalizationRegistry('Object'); +}, 'string'); + +var s = Symbol(); +assert.throws(TypeError, function() { + new FinalizationRegistry(s); +}, 'symbol'); + +assert.throws(TypeError, function() { + new FinalizationRegistry(true); +}, 'Boolean, true'); + +assert.throws(TypeError, function() { + new FinalizationRegistry(false); +}, 'Boolean, false'); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/undefined-newtarget-throws.js b/js/src/tests/test262/built-ins/FinalizationRegistry/undefined-newtarget-throws.js new file mode 100644 index 0000000000..ebdef99c37 --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/undefined-newtarget-throws.js @@ -0,0 +1,31 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry-target +description: > + Throws a TypeError if NewTarget is undefined. +info: | + FinalizationRegistry ( cleanupCallback ) + + 1. If NewTarget is undefined, throw a TypeError exception. + 2. If IsCallable(cleanupCallback) is false, throw a TypeError exception. + ... +features: [FinalizationRegistry] +---*/ + +assert.sameValue( + typeof FinalizationRegistry, 'function', + 'typeof FinalizationRegistry is function' +); + +assert.throws(TypeError, function() { + FinalizationRegistry(); +}); + +assert.throws(TypeError, function() { + FinalizationRegistry(function() {}); +}); + +reportCompare(0, 0); diff --git a/js/src/tests/test262/built-ins/FinalizationRegistry/unnaffected-by-poisoned-cleanupCallback.js b/js/src/tests/test262/built-ins/FinalizationRegistry/unnaffected-by-poisoned-cleanupCallback.js new file mode 100644 index 0000000000..a28a89ed91 --- /dev/null +++ b/js/src/tests/test262/built-ins/FinalizationRegistry/unnaffected-by-poisoned-cleanupCallback.js @@ -0,0 +1,36 @@ +// |reftest| skip-if(!this.hasOwnProperty('FinalizationRegistry')) -- FinalizationRegistry is not enabled unconditionally +// Copyright (C) 2019 Leo Balter. All rights reserved. +// This code is governed by the BSD license found in the LICENSE file. + +/*--- +esid: sec-finalization-registry-target +description: > + Normal completion even if the cleanupCallback fn is poisoned +info: | + FinalizationRegistry ( cleanupCallback ) + + ... + 3. Let finalizationRegistry be ? OrdinaryCreateFromConstructor(NewTarget, "%FinalizationRegistryPrototype%", « [[Realm]], [[CleanupCallback]], [[Cells]], [[IsFinalizationRegistryCleanupJobActive]] »). + ... + 9. Return finalizationRegistry. +features: [FinalizationRegistry] +---*/ + +var cleanupCallback = function() { throw new Test262Error('should not throw yet'); }; +var finalizationRegistry = new FinalizationRegistry(cleanupCallback); + +assert.sameValue(Object.getPrototypeOf(finalizationRegistry), FinalizationRegistry.prototype); +assert.notSameValue(finalizationRegistry, cleanupCallback, 'does not return the same function'); +assert.sameValue(finalizationRegistry instanceof FinalizationRegistry, true, 'instanceof'); + +for (let key of Object.getOwnPropertyNames(finalizationRegistry)) { + assert(false, `should not set any own named properties: ${key}`); +} + +for (let key of Object.getOwnPropertySymbols(finalizationRegistry)) { + assert(false, `should not set any own symbol properties: ${String(key)}`); +} + +assert.sameValue(Object.getPrototypeOf(finalizationRegistry), FinalizationRegistry.prototype); + +reportCompare(0, 0); -- cgit v1.2.3