| //------------------------------------------------------------------------------------------------------- |
| // Copyright (C) Microsoft. All rights reserved. |
| // Licensed under the MIT license. See LICENSE.txt file in the project root for full license information. |
| //------------------------------------------------------------------------------------------------------- |
| |
| // Functional WeakMap tests -- verifies the APIs work correctly |
| // Note however this does not verify the GC semantics of WeakMap |
| |
| WScript.LoadScriptFile("..\\UnitTestFramework\\UnitTestFramework.js"); |
| |
| var tests = [ |
| { |
| name: "WeakMap constructor called on undefined or WeakMap.prototype returns new WeakMap object (and throws on null, non-extensible object)", |
| body: function () { |
| // WeakMap is no longer allowed to be called as a function unless the object it is given |
| // for its this argument already has the [[WeakMapData]] property on it. |
| // |
| // For IE11 we simply throw if WeakMap() is called as a function instead of in a new expression |
| assert.throws(function () { WeakMap.call(undefined); }, TypeError, "WeakMap.call() throws TypeError given undefined"); |
| assert.throws(function () { WeakMap.call(null); }, TypeError, "WeakMap.call() throws TypeError given null"); |
| assert.throws(function () { WeakMap.call(WeakMap.prototype); }, TypeError, "WeakMap.call() throws TypeError given WeakMap.prototype"); |
| /* |
| var weakmap1 = WeakMap.call(undefined); |
| assert.isTrue(weakmap1 !== null && weakmap1 !== undefined && weakmap1 !== WeakMap.prototype, "WeakMap constructor creates new WeakMap object when this is undefined"); |
| |
| var weakmap2 = WeakMap.call(WeakMap.prototype); |
| assert.isTrue(weakmap2 !== null && weakmap2 !== undefined && weakmap2 !== WeakMap.prototype, "WeakMap constructor creates new WeakMap object when this is equal to WeakMap.prototype"); |
| |
| var o = { }; |
| Object.preventExtensions(o); |
| |
| assert.throws(function () { WeakMap.call(null); }, TypeError, "WeakMap constructor throws on null"); |
| assert.throws(function () { WeakMap.call(o); }, TypeError, "WeakMap constructor throws on non-extensible object"); |
| */ |
| } |
| }, |
| |
| { |
| name: "WeakMap constructor throws when called on already initialized WeakMap object", |
| body: function () { |
| var weakmap = new WeakMap(); |
| assert.throws(function () { WeakMap.call(weakmap); }, TypeError); |
| |
| // WeakMap is no longer allowed to be called as a function unless the object it is given |
| // for its this argument already has the [[WeakMapData]] property on it. |
| /* |
| var obj = {}; |
| WeakMap.call(obj); |
| assert.throws(function () { WeakMap.call(obj); }, TypeError); |
| |
| function MyWeakMap() { |
| WeakMap.call(this); |
| } |
| MyWeakMap.prototype = new WeakMap(); |
| MyWeakMap.prototype.constructor = MyWeakMap; |
| |
| var myweakmap = new MyWeakMap(); |
| assert.throws(function () { WeakMap.call(myweakmap); }, TypeError); |
| assert.throws(function () { MyWeakMap.call(myweakmap); }, TypeError); |
| */ |
| } |
| }, |
| |
| { |
| name: "WeakMap constructor populates the weakmap with key-values pairs from given optional iterable argument", |
| body: function () { |
| var keys = [ { }, { }, { }, { } ]; |
| var wm = new WeakMap([ [keys[0], 1], [keys[1], 2], [keys[2], 3] ]); |
| |
| assert.areEqual(1, wm.get(keys[0]), "wm has key keys[0] mapping to value 1"); |
| assert.areEqual(2, wm.get(keys[1]), "wm has key keys[1] mapping to value 2"); |
| assert.areEqual(3, wm.get(keys[2]), "wm has key keys[2] mapping to value 3"); |
| |
| var customIterable = { |
| [Symbol.iterator]: function () { |
| var i = 0; |
| return { |
| next: function () { |
| return { |
| done: i > 3, |
| value: [ keys[i], ++i * 2 ] |
| }; |
| } |
| }; |
| } |
| }; |
| |
| wm = new WeakMap(customIterable); |
| |
| assert.areEqual(2, wm.get(keys[0]), "wm has key keys[0] mapping to value 2"); |
| assert.areEqual(4, wm.get(keys[1]), "wm has key keys[1] mapping to value 4"); |
| assert.areEqual(6, wm.get(keys[2]), "wm has key keys[2] mapping to value 6"); |
| assert.areEqual(8, wm.get(keys[3]), "wm has key keys[3] mapping to value 8"); |
| } |
| }, |
| |
| { |
| name: "WeakMap constructor throws exceptions for non- and malformed iterable arguments", |
| body: function () { |
| var iterableNoIteratorMethod = { [Symbol.iterator]: 123 }; |
| var iterableBadIteratorMethod = { [Symbol.iterator]: function () { } }; |
| var iterableNoIteratorNextMethod = { [Symbol.iterator]: function () { return { }; } }; |
| var iterableBadIteratorNextMethod = { [Symbol.iterator]: function () { return { next: 123 }; } }; |
| var iterableNoIteratorResultObject = { [Symbol.iterator]: function () { return { next: function () { } }; } }; |
| |
| assert.throws(function () { new WeakMap(123); }, TypeError, "new WeakMap() throws on non-object", "Function expected"); |
| assert.throws(function () { new WeakMap({ }); }, TypeError, "new WeakMap() throws on non-iterable object", "Function expected"); |
| assert.throws(function () { new WeakMap(iterableNoIteratorMethod); }, TypeError, "new WeakMap() throws on non-iterable object where @@iterator property is not a function", "Function expected"); |
| assert.throws(function () { new WeakMap(iterableBadIteratorMethod); }, TypeError, "new WeakMap() throws on non-iterable object where @@iterator function doesn't return an iterator", "Object expected"); |
| assert.throws(function () { new WeakMap(iterableNoIteratorNextMethod); }, TypeError, "new WeakMap() throws on iterable object where iterator object does not have next property", "Function expected"); |
| assert.throws(function () { new WeakMap(iterableBadIteratorNextMethod); }, TypeError, "new WeakMap() throws on iterable object where iterator object's next property is not a function", "Function expected"); |
| assert.throws(function () { new WeakMap(iterableNoIteratorResultObject); }, TypeError, "new WeakMap() throws on iterable object where iterator object's next method doesn't return an iterator result", "Object expected"); |
| } |
| }, |
| |
| { |
| name: "APIs throw TypeError where specified", |
| body: function () { |
| function MyWeakMapImposter() { } |
| MyWeakMapImposter.prototype = new WeakMap(); |
| MyWeakMapImposter.prototype.constructor = MyWeakMapImposter; |
| |
| var o = new MyWeakMapImposter(); |
| |
| assert.throws(function () { o.delete(o); }, TypeError, "delete should throw if this doesn't have WeakMapData property"); |
| assert.throws(function () { o.get(o); }, TypeError, "get should throw if this doesn't have WeakMapData property"); |
| assert.throws(function () { o.has(o); }, TypeError, "has should throw if this doesn't have WeakMapData property"); |
| assert.throws(function () { o.set(o, o); }, TypeError, "set should throw if this doesn't have WeakMapData property"); |
| |
| assert.throws(function () { WeakMap.prototype.delete.call(); }, TypeError, "delete should throw if called with no arguments"); |
| assert.throws(function () { WeakMap.prototype.get.call(); }, TypeError, "get should throw if called with no arguments"); |
| assert.throws(function () { WeakMap.prototype.has.call(); }, TypeError, "has should throw if called with no arguments"); |
| assert.throws(function () { WeakMap.prototype.set.call(); }, TypeError, "set should throw if called with no arguments"); |
| |
| assert.throws(function () { WeakMap.prototype.delete.call(null, o); }, TypeError, "delete should throw if this is null"); |
| assert.throws(function () { WeakMap.prototype.get.call(null, o); }, TypeError, "get should throw if this is null"); |
| assert.throws(function () { WeakMap.prototype.has.call(null, o); }, TypeError, "has should throw if this is null"); |
| assert.throws(function () { WeakMap.prototype.set.call(null, o, o); }, TypeError, "set should throw if this is null"); |
| |
| assert.throws(function () { WeakMap.prototype.delete.call(undefined, o); }, TypeError, "delete should throw if this is undefined"); |
| assert.throws(function () { WeakMap.prototype.get.call(undefined, o); }, TypeError, "get should throw if this is undefined"); |
| assert.throws(function () { WeakMap.prototype.has.call(undefined, o); }, TypeError, "has should throw if this is undefined"); |
| assert.throws(function () { WeakMap.prototype.set.call(undefined, o, o); }, TypeError, "set should throw if this is undefined"); |
| |
| var weakmap = new WeakMap(); |
| |
| assert.throws(function () { weakmap.set(null, o); }, TypeError, "set should throw if key is not an object, e.g. null"); |
| assert.throws(function () { weakmap.set(undefined, o); }, TypeError, "set should throw if key is not an object, e.g. undefined"); |
| assert.throws(function () { weakmap.set(true, o); }, TypeError, "set should throw if key is not an object, e.g. a boolean"); |
| assert.throws(function () { weakmap.set(10, o); }, TypeError, "set should throw if key is not an object, e.g. a number"); |
| assert.throws(function () { weakmap.set("hello", o); }, TypeError, "set should throw if key is not an object, e.g. a string"); |
| } |
| }, |
| |
| { |
| name: "Non-object key argument silent fails delete, get, and has", |
| body: function () { |
| var weakmap = new WeakMap(); |
| |
| assert.isTrue(weakmap.get(null) === undefined, "null is not an object and cannot be a key in a WeakMap; get returns undefined"); |
| assert.isTrue(weakmap.get(undefined) === undefined, "undefined is not an object and cannot be a key in a WeakMap; get returns undefined"); |
| assert.isTrue(weakmap.get(true) === undefined, "boolean is not an object and cannot be a key in a WeakMap; get returns undefined"); |
| assert.isTrue(weakmap.get(10) === undefined, "number is not an object and cannot be a key in a WeakMap; get returns undefined"); |
| assert.isTrue(weakmap.get("hello") === undefined, "string is not an object and cannot be a key in a WeakMap; get returns undefined"); |
| |
| assert.isFalse(weakmap.has(null), "null is not an object and cannot be a key in a WeakMap; has returns false"); |
| assert.isFalse(weakmap.has(undefined), "undefined is not an object and cannot be a key in a WeakMap; has returns false"); |
| assert.isFalse(weakmap.has(true), "boolean is not an object and cannot be a key in a WeakMap; has returns false"); |
| assert.isFalse(weakmap.has(10), "number is not an object and cannot be a key in a WeakMap; has returns false"); |
| assert.isFalse(weakmap.has("hello"), "string is not an object and cannot be a key in a WeakMap; has returns false"); |
| |
| assert.isFalse(weakmap.delete(null), "null is not an object and cannot be a key in a WeakMap; delete returns false"); |
| assert.isFalse(weakmap.delete(undefined), "undefined is not an object and cannot be a key in a WeakMap; delete returns false"); |
| assert.isFalse(weakmap.delete(true), "boolean is not an object and cannot be a key in a WeakMap; delete returns false"); |
| assert.isFalse(weakmap.delete(10), "number is not an object and cannot be a key in a WeakMap; delete returns false"); |
| assert.isFalse(weakmap.delete("hello"), "string is not an object and cannot be a key in a WeakMap; delete returns false"); |
| |
| var booleanObject = new Boolean(true); |
| var numberObject = new Number(10); |
| var stringObject = new String("hello"); |
| |
| weakmap.set(booleanObject, null); |
| weakmap.set(numberObject, null); |
| weakmap.set(stringObject, null); |
| |
| assert.isTrue(weakmap.get(true) === undefined, "boolean is not an object and cannot be a key in a WeakMap; get returns undefined"); |
| assert.isTrue(weakmap.get(10) === undefined, "number is not an object and cannot be a key in a WeakMap; get returns undefined"); |
| assert.isTrue(weakmap.get("hello") === undefined, "string is not an object and cannot be a key in a WeakMap; get returns undefined"); |
| |
| assert.isFalse(weakmap.has(true), "boolean is not an object and cannot be a key in a WeakMap; has returns false"); |
| assert.isFalse(weakmap.has(10), "number is not an object and cannot be a key in a WeakMap; has returns false"); |
| assert.isFalse(weakmap.has("hello"), "string is not an object and cannot be a key in a WeakMap; has returns false"); |
| |
| assert.isFalse(weakmap.delete(true), "boolean is not an object and cannot be a key in a WeakMap; delete returns false"); |
| assert.isFalse(weakmap.delete(10), "number is not an object and cannot be a key in a WeakMap; delete returns false"); |
| assert.isFalse(weakmap.delete("hello"), "string is not an object and cannot be a key in a WeakMap; delete returns false"); |
| } |
| }, |
| |
| { |
| name: "Basic usage, delete, get, has, set", |
| body: function () { |
| var weakmap = new WeakMap(); |
| |
| var o = { }; |
| var p = { }; |
| var q = { }; |
| |
| weakmap.set(o, 10); |
| weakmap.set(p, o); |
| weakmap.set(q, q); |
| |
| assert.isTrue(weakmap.has(o), "Should contain key o"); |
| assert.isTrue(weakmap.has(p), "Should contain key p"); |
| assert.isTrue(weakmap.has(q), "Should contain key q"); |
| assert.isFalse(weakmap.has(weakmap), "Should not contain other keys, 'weakmap'"); |
| assert.isFalse(weakmap.has({ }), "Should not contain other keys, '{ }'"); |
| |
| assert.isTrue(weakmap.get(o) === 10, "Should weakmap o to 10"); |
| assert.isTrue(weakmap.get(p) === o, "Should weakmap p to o"); |
| assert.isTrue(weakmap.get(q) === q, "Should weakmap q to q"); |
| assert.isTrue(weakmap.get(weakmap) === undefined, "Should return undefined for non-existant key, 'weakmap'"); |
| assert.isTrue(weakmap.get({ }) === undefined, "Should return undefined for non-existant key, '{ }'"); |
| |
| assert.isTrue(weakmap.delete(p), "Should return true after deleting key p"); |
| |
| assert.isTrue(weakmap.has(o), "Should still contain key o"); |
| assert.isFalse(weakmap.has(p), "Should no longer contain key p"); |
| assert.isTrue(weakmap.has(q), "Should still contain key q"); |
| |
| assert.isFalse(weakmap.delete(p), "Should return false, p is no longer a key"); |
| |
| assert.isTrue(weakmap.delete(o), "Should return true after deleting key o"); |
| assert.isTrue(weakmap.delete(q), "Should return true after deleting key q"); |
| |
| assert.isFalse(weakmap.has(o), "Should no longer contain key o"); |
| assert.isFalse(weakmap.has(p), "Should still not contain key p"); |
| assert.isFalse(weakmap.has(q), "Should no longer contain key q"); |
| } |
| }, |
| |
| { |
| name: "Not specifying arguments should default them to undefined", |
| body: function () { |
| var weakmap = new WeakMap(); |
| |
| assert.isFalse(weakmap.has(), "Should return false for implicit undefined; has"); |
| assert.isTrue(weakmap.get() === undefined, "Should return undefined for implicit undefined; get"); |
| assert.isFalse(weakmap.delete(), "Should return false for implicit undefined; delete"); |
| |
| assert.throws(function () { weakmap.set(); }, TypeError, "Should throw TypeError for implicit undefined; set"); |
| } |
| }, |
| |
| { |
| name: "Extra arguments should be ignored", |
| body: function () { |
| var weakmap = new WeakMap(); |
| var o = { }; |
| var p = { }; |
| var q = { }; |
| |
| assert.isFalse(weakmap.has(o, p, q), "Looks for o, ignores p and q, weak weakmap is empty and has should return false"); |
| assert.isTrue(weakmap.get(o, p, q) === undefined, "Looks for o, ignores p and q, weak weakmap is empty and get should return false"); |
| assert.isFalse(weakmap.delete(o, p, q), "Looks for o, ignores p and q, weak weakmap is empty and delete should return false"); |
| |
| weakmap.set(o, p, q); |
| |
| assert.isTrue(weakmap.has(o), "Should contain o"); |
| assert.isFalse(weakmap.has(p), "Should not contain p"); |
| assert.isFalse(weakmap.has(q), "Should not contain q"); |
| assert.isTrue(weakmap.has(o, p, q), "Ignores p and q, does have o"); |
| assert.isTrue(weakmap.has(o, q, p), "Order of extra arguments has no affect, still has o"); |
| assert.isFalse(weakmap.has(p, o), "Ignores o, does not have p"); |
| |
| assert.isTrue(weakmap.get(o) === p, "Should contain o and return p"); |
| assert.isTrue(weakmap.get(p) === undefined, "Should not contain p and return undefined"); |
| assert.isTrue(weakmap.get(q) === undefined, "Should not contain q and return undefined"); |
| assert.isTrue(weakmap.get(o, p, q) === p, "Ignores p and q, does have o, returns p"); |
| assert.isTrue(weakmap.get(o, q, p) === p, "Order of extra arguments has no affect, still has o, still returns p"); |
| assert.isTrue(weakmap.get(p, o) === undefined, "Ignores o, does not have p and returns undefined"); |
| |
| assert.isFalse(weakmap.delete(p, o, q), "p is not found so should return false, ignores o and q"); |
| assert.isFalse(weakmap.delete(q, o), "q is not found so should return false, ignores o"); |
| assert.isTrue(weakmap.delete(o, p, q), "o is found and deleted, so should return true, ignores p and q"); |
| } |
| }, |
| |
| { |
| name: "Delete should return true if item was in the WeakMap, false if not", |
| body: function () { |
| var weakmap = new WeakMap(); |
| var o = { }; |
| var p = { }; |
| |
| weakmap.set(o, p); |
| |
| assert.isFalse(weakmap.delete(p), "p is not a key in the weakmap, delete should return false"); |
| assert.isTrue(weakmap.delete(o), "o is a key in the weakmap, delete should remove it and return true"); |
| assert.isFalse(weakmap.delete(o), "o is no longer a key in the weakmap, delete should now return false"); |
| } |
| }, |
| |
| { |
| name: "Setting the same key twice is valid, and should modify the value", |
| body: function () { |
| var weakmap = new WeakMap(); |
| |
| var o = { }; |
| var p = { }; |
| |
| weakmap.set(o); |
| weakmap.set(o); |
| weakmap.set(p); |
| weakmap.delete(o); |
| weakmap.set(p); |
| weakmap.set(o); |
| weakmap.set(o); |
| |
| weakmap.delete(o); |
| weakmap.delete(p); |
| |
| weakmap.set(o, 3); |
| assert.isTrue(weakmap.get(o) === 3, "o maps to 3"); |
| weakmap.set(o, 4); |
| assert.isTrue(weakmap.get(o) === 4, "o maps to 4"); |
| weakmap.set(p, 5); |
| assert.isTrue(weakmap.get(o) === 4, "o still maps to 4"); |
| assert.isTrue(weakmap.get(p) === 5, "p maps to 5"); |
| weakmap.delete(o); |
| assert.isTrue(weakmap.get(o) === undefined, "o is no longer in the weakmap"); |
| assert.isTrue(weakmap.get(p) === 5, "p still maps to 5"); |
| weakmap.set(p, 6); |
| assert.isTrue(weakmap.get(p) === 6, "p maps to 6"); |
| } |
| }, |
| |
| { |
| name: "set returns the weakmap instance itself", |
| body: function () { |
| var weakmap = new WeakMap(); |
| var o = { }; |
| |
| assert.areEqual(weakmap, weakmap.set(o, o), "Setting new key should return WeakMap instance"); |
| assert.areEqual(weakmap, weakmap.set(o, o), "Setting existing key should return WeakMap instance"); |
| } |
| }, |
| |
| { |
| name: "Adding and removing keys from one WeakMap shouldn't affect other WeakMaps", |
| body: function () { |
| var wm1 = new WeakMap(); |
| var wm2 = new WeakMap(); |
| var wm3 = new WeakMap(); |
| |
| var o = { }; |
| var p = { }; |
| var q = { }; |
| |
| wm1.set(o, o); |
| wm1.set(p, q); |
| wm2.set(q, o); |
| |
| assert.isTrue(wm1.has(o), "wm1 has o"); |
| assert.isFalse(wm2.has(o), "wm2 does not have o"); |
| assert.isFalse(wm3.has(o), "wm3 does not have o"); |
| |
| assert.isTrue(wm1.get(o) === o, "wm1 has o map to o"); |
| assert.isTrue(wm2.get(o) === undefined, "wm2 does not have o and get returns undefined"); |
| assert.isTrue(wm3.get(o) === undefined, "wm3 does not have o and get returns undefined"); |
| |
| assert.isTrue(wm1.has(p), "wm1 has p"); |
| assert.isTrue(wm2.has(q), "wm2 has q"); |
| assert.isFalse(wm1.has(q), "wm1 does not have q"); |
| assert.isFalse(wm2.has(p), "wm2 does not have p"); |
| assert.isFalse(wm3.has(p), "wm3 does not have p"); |
| assert.isFalse(wm3.has(q), "wm3 does not have q"); |
| |
| assert.isTrue(wm1.get(p) === q, "wm1 has p map to q"); |
| assert.isTrue(wm2.get(q) === o, "wm2 has q map to o"); |
| assert.isTrue(wm1.get(q) === undefined, "wm1 does not have q and get returns undefined"); |
| assert.isTrue(wm2.get(p) === undefined, "wm2 does not have p and get returns undefined"); |
| assert.isTrue(wm3.get(p) === undefined, "wm3 does not have p and get returns undefined"); |
| assert.isTrue(wm3.get(q) === undefined, "wm3 does not have q and get returns undefined"); |
| |
| wm3.set(p, o); |
| wm3.set(q, p); |
| |
| assert.isTrue(wm3.has(p), "wm3 now has p"); |
| assert.isTrue(wm3.has(q), "wm3 now has q"); |
| assert.isTrue(wm1.has(p), "wm1 still has p"); |
| assert.isFalse(wm2.has(p), "wm2 still does not have p"); |
| assert.isFalse(wm1.has(q), "wm1 still does not have q"); |
| assert.isTrue(wm2.has(q), "wm2 still has q"); |
| |
| assert.isTrue(wm1.delete(p), "p is removed from wm1"); |
| |
| assert.isFalse(wm1.has(p), "wm1 no longer has p"); |
| assert.isTrue(wm3.has(p), "wm3 still has p"); |
| |
| wm3.delete(p); |
| wm3.delete(q); |
| |
| assert.isFalse(wm3.has(p), "wm3 no longer has p"); |
| assert.isFalse(wm3.has(q), "wm3 no longer has q"); |
| assert.isTrue(wm1.has(o), "wm1 still has o"); |
| assert.isTrue(wm2.has(q), "wm2 still has q"); |
| } |
| }, |
| |
| { |
| name: "Number, Boolean, and String and other special objects should all as keys", |
| body: function () { |
| var weakmap = new WeakMap(); |
| |
| var n = new Number(1); |
| var b = new Boolean(2); |
| var s = new String("Hi"); |
| |
| /* |
| Fast DOM and HostDispatch objects are tested in the mshtml test weakmap_DOMkey.html |
| WinRT objects are still an open issue; they are CustomExternalObjects so they work, |
| but they are proxied and the proxies are not kept alive by the outside object, only |
| by internal JS references. Further, allowing objects to be linked to the lifetime |
| of a WinJS object can cause cycles between JS GC objects and WinRT COM ref counted |
| objects, which are not deducible by the GC. Therefore using WinRT objects with |
| WeakMap is prone to subtle easy to make memory leak bugs. |
| var fd = new FastDOM(); |
| var hd = new HostDispatch(); |
| var wrt = new WinRT(); |
| */ |
| |
| var ab = new ArrayBuffer(32); |
| |
| weakmap.set(n, 1); |
| weakmap.set(b, 2); |
| weakmap.set(s, 3); |
| weakmap.set(ab, 4); |
| |
| assert.isTrue(weakmap.has(n), "weakmap has key n which is a Number instance"); |
| assert.isTrue(weakmap.has(b), "weakmap has key b which is a Boolean instance"); |
| assert.isTrue(weakmap.has(s), "weakmap has key s which is a String instance"); |
| assert.isTrue(weakmap.has(ab), "weakmap has key ab which is an ArrayBuffer instance"); |
| |
| assert.isTrue(weakmap.get(n) === 1, "weakmap has key n which is a Number instance and maps it to 1"); |
| assert.isTrue(weakmap.get(b) === 2, "weakmap has key b which is a Boolean instance and maps it to 2"); |
| assert.isTrue(weakmap.get(s) === 3, "weakmap has key s which is a String instance and maps it to 3"); |
| assert.isTrue(weakmap.get(ab) === 4, "weakmap has key ab which is an ArrayBuffer instance and maps it to 4"); |
| |
| assert.isTrue(weakmap.delete(n), "Successfully delete key n which is a Number instance from weakmap"); |
| assert.isTrue(weakmap.delete(b), "Successfully delete key b which is a Boolean instance from weakmap"); |
| assert.isTrue(weakmap.delete(s), "Successfully delete key s which is a String instance from weakmap"); |
| assert.isTrue(weakmap.delete(ab), "Successfully delete key ab which is an ArrayBuffer instance from weakmap"); |
| |
| assert.isFalse(weakmap.has(n), "weakmap no longer has key n"); |
| assert.isFalse(weakmap.has(b), "weakmap no longer has key b"); |
| assert.isFalse(weakmap.has(s), "weakmap no longer has key s"); |
| assert.isFalse(weakmap.has(ab), "weakmap no longer has key ab"); |
| } |
| }, |
| |
| { |
| name: "WeakMap can add keys that are sealed and frozen (testworthy because WeakMap implementation sets internal property on key objects)", |
| body: function () { |
| var wm = new WeakMap(); |
| |
| var sealedObj = Object.seal({ }); |
| var frozenObj = Object.freeze({ }); |
| |
| wm.set(sealedObj, 1248); |
| wm.set(frozenObj, 3927); |
| |
| assert.isTrue(wm.has(sealedObj), "WeakMap has sealed object as key"); |
| assert.isTrue(wm.has(frozenObj), "WeakMap has frozen object as key"); |
| |
| assert.areEqual(1248, wm.get(sealedObj), "WeakMap maps sealed object key to corresponding mapped value"); |
| assert.areEqual(3927, wm.get(frozenObj), "WeakMap maps frozen object key to corresponding mapped value"); |
| |
| var wm2 = new WeakMap(); |
| |
| assert.isFalse(wm2.has(sealedObj), "Second WeakMap does not have sealed object key"); |
| assert.isFalse(wm2.has(frozenObj), "Second WeakMap does not have frozen object key"); |
| |
| wm2.set(sealedObj, 42); |
| wm2.set(frozenObj, 68); |
| |
| assert.isTrue(wm2.has(sealedObj), "Second WeakMap now has sealed object key"); |
| assert.isTrue(wm2.has(frozenObj), "Second WeakMap now has frozen object key"); |
| |
| assert.isTrue(wm.has(sealedObj), "First WeakMap still has sealed object as key"); |
| assert.isTrue(wm.has(frozenObj), "First WeakMap still has frozen object as key"); |
| |
| wm.delete(sealedObj); |
| wm2.delete(frozenObj); |
| |
| assert.isTrue(wm2.has(sealedObj), "Second WeakMap still has sealed object key"); |
| assert.isFalse(wm2.has(frozenObj), "Second WeakMap no longer has frozen object key"); |
| |
| assert.isFalse(wm.has(sealedObj), "First WeakMap no longer has sealed object as key"); |
| assert.isTrue(wm.has(frozenObj), "First WeakMap still has frozen object as key"); |
| } |
| }, |
| |
| ]; |
| |
| testRunner.runTests(tests, { verbose: WScript.Arguments[0] != "summary" }); |
