ES6: Implement WeakSet

test/mjsunit/harmony/collections.js

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 17 matching lines @@
 // Flags: --harmony-collections --expose-gc --allow-natives-syntax
 
 
 // Test valid getter and setter calls on Sets.
 function TestValidSetCalls(m) {
   assertDoesNotThrow(function () { m.add(new Object) });
   assertDoesNotThrow(function () { m.has(new Object) });
   assertDoesNotThrow(function () { m.delete(new Object) });
 }
 TestValidSetCalls(new Set);
+TestValidSetCalls(new WeakSet);
 
 
 // Test valid getter and setter calls on Maps and WeakMaps
 function TestValidMapCalls(m) {
   assertDoesNotThrow(function () { m.get(new Object) });
   assertDoesNotThrow(function () { m.set(new Object) });
   assertDoesNotThrow(function () { m.has(new Object) });
   assertDoesNotThrow(function () { m.delete(new Object) });
 }
 TestValidMapCalls(new Map);
@@ skipping 30 matching lines @@
     TestSet(set, i);
     TestSet(set, i / 100);
     TestSet(set, 'key-' + i);
   }
   var keys = [ +0, -0, +Infinity, -Infinity, true, false, null, undefined ];
   for (var i = 0; i < keys.length; i++) {
     TestSet(set, keys[i]);
   }
 }
 TestSetBehavior(new Set);
+TestSet(new WeakSet, new Object);
 
 
 // Test expected mapping behavior for Maps and WeakMaps
 function TestMapping(map, key, value) {
   assertSame(undefined, map.set(key, value));
   assertSame(value, map.get(key));
 }
 function TestMapBehavior1(m) {
   TestMapping(m, new Object, 23);
   TestMapping(m, new Object, 'the-value');
@@ skipping 80 matching lines @@
     for (var p in x) array.push(p);
     return array.sort();
   }
   assertArrayEquals([], props(func));
   assertArrayEquals([], props(func.prototype));
   assertArrayEquals([], props(new func()));
 }
 TestEnumerable(Set);
 TestEnumerable(Map);
 TestEnumerable(WeakMap);
+TestEnumerable(WeakSet);
 
 
 // Test arbitrary properties on Maps and WeakMaps
 function TestArbitrary(m) {
   function TestProperty(map, property, value) {
     map[property] = value;
     assertEquals(value, map[property]);
   }
   for (var i = 0; i < 20; i++) {
     TestProperty(m, i, 'val' + i);
     TestProperty(m, 'foo' + i, 'bar' + i);
   }
   TestMapping(m, new Object, 'foobar');
 }
 TestArbitrary(new Map);
 TestArbitrary(new WeakMap);
 
 
 // Test direct constructor call
 assertTrue(Set() instanceof Set);
 assertTrue(Map() instanceof Map);
 assertTrue(WeakMap() instanceof WeakMap);
+assertTrue(WeakSet() instanceof WeakSet);
 
 
 // Test whether NaN values as keys are treated correctly.
 var s = new Set;
 assertFalse(s.has(NaN));
 assertFalse(s.has(NaN + 1));
 assertFalse(s.has(23));
 s.add(NaN);
 assertTrue(s.has(NaN));
 assertTrue(s.has(NaN + 1));
 assertFalse(s.has(23));
 var m = new Map;
 assertFalse(m.has(NaN));
 assertFalse(m.has(NaN + 1));
 assertFalse(m.has(23));
 m.set(NaN, 'a-value');
 assertTrue(m.has(NaN));
 assertTrue(m.has(NaN + 1));
 assertFalse(m.has(23));
 
 
 // Test some common JavaScript idioms for Sets
 var s = new Set;
 assertTrue(s instanceof Set);
 assertTrue(Set.prototype.add instanceof Function)
 assertTrue(Set.prototype.has instanceof Function)
 assertTrue(Set.prototype.delete instanceof Function)
+assertTrue(Set.prototype.clear instanceof Function)
 
 
 // Test some common JavaScript idioms for Maps
 var m = new Map;
 assertTrue(m instanceof Map);
 assertTrue(Map.prototype.set instanceof Function)
 assertTrue(Map.prototype.get instanceof Function)
 assertTrue(Map.prototype.has instanceof Function)
 assertTrue(Map.prototype.delete instanceof Function)
+assertTrue(Map.prototype.clear instanceof Function)
 
 
 // Test some common JavaScript idioms for WeakMaps
 var m = new WeakMap;
 assertTrue(m instanceof WeakMap);
 assertTrue(WeakMap.prototype.set instanceof Function)
 assertTrue(WeakMap.prototype.get instanceof Function)
 assertTrue(WeakMap.prototype.has instanceof Function)
 assertTrue(WeakMap.prototype.delete instanceof Function)
+assertTrue(WeakMap.prototype.clear instanceof Function)
 
 
-// Test class of the Set, Map and WeakMap instance and prototype.
+// Test some common JavaScript idioms for WeakSets
+var s = new WeakSet;
+assertTrue(s instanceof WeakSet);
+assertTrue(WeakSet.prototype.add instanceof Function)
+assertTrue(WeakSet.prototype.has instanceof Function)
+assertTrue(WeakSet.prototype.delete instanceof Function)
+assertTrue(WeakSet.prototype.clear instanceof Function)
+
+
+// Test class of instance and prototype.
 assertEquals("Set", %_ClassOf(new Set))
 assertEquals("Object", %_ClassOf(Set.prototype))
 assertEquals("Map", %_ClassOf(new Map))
 assertEquals("Object", %_ClassOf(Map.prototype))
 assertEquals("WeakMap", %_ClassOf(new WeakMap))
 assertEquals("Object", %_ClassOf(WeakMap.prototype))
+assertEquals("WeakSet", %_ClassOf(new WeakSet))
+assertEquals("Object", %_ClassOf(WeakMap.prototype))
 
 
-// Test constructor property of the Set, Map and WeakMap prototype.
+// Test name of constructor.
+assertEquals("Set", Set.name);
+assertEquals("Map", Map.name);
+assertEquals("WeakMap", WeakMap.name);
+assertEquals("WeakSet", WeakSet.name);
+
+
+// Test constructor property of the Set, Map, WeakMap and WeakSet prototype.
 function TestConstructor(C) {
   assertFalse(C === Object.prototype.constructor);
   assertSame(C, C.prototype.constructor);
   assertSame(C, C().__proto__.constructor);
   assertSame(C, (new C).__proto__.constructor);
 }
 TestConstructor(Set);
 TestConstructor(Map);
 TestConstructor(WeakMap);
+TestConstructor(WeakSet);
+
+
+function TestDescriptor(global, C) {
+  assertEquals({
+    value: C,
+    writable: true,
+    enumerable: false,
+    configurable: true
+  }, Object.getOwnPropertyDescriptor(global, C.name));
+}
+TestDescriptor(this, Set);
+TestDescriptor(this, Map);
+TestDescriptor(this, WeakMap);
+TestDescriptor(this, WeakSet);
 
 
 // Regression test for WeakMap prototype.
 assertTrue(WeakMap.prototype.constructor === WeakMap)
 assertTrue(Object.getPrototypeOf(WeakMap.prototype) === Object.prototype)
 
 
 // Regression test for issue 1617: The prototype of the WeakMap constructor
 // needs to be unique (i.e. different from the one of the Object constructor).
 assertFalse(WeakMap.prototype === Object.prototype);
@@ skipping 11 matching lines @@
 assertEquals(10, o.myValue);
 
 
 // Regression test for issue 1884: Invoking any of the methods for Harmony
 // maps, sets, or weak maps, with a wrong type of receiver should be throwing
 // a proper TypeError.
 var alwaysBogus = [ undefined, null, true, "x", 23, {} ];
 var bogusReceiversTestSet = [
   { proto: Set.prototype,
     funcs: [ 'add', 'has', 'delete' ],
-    receivers: alwaysBogus.concat([ new Map, new WeakMap ]),
+    receivers: alwaysBogus.concat([ new Map, new WeakMap, new WeakSet ]),
   },
   { proto: Map.prototype,
     funcs: [ 'get', 'set', 'has', 'delete' ],
-    receivers: alwaysBogus.concat([ new Set, new WeakMap ]),
+    receivers: alwaysBogus.concat([ new Set, new WeakMap, new WeakSet ]),
   },
   { proto: WeakMap.prototype,
     funcs: [ 'get', 'set', 'has', 'delete' ],
-    receivers: alwaysBogus.concat([ new Set, new Map ]),
+    receivers: alwaysBogus.concat([ new Set, new Map, new WeakSet ]),
+  },
+  { proto: WeakSet.prototype,
+    funcs: [ 'add', 'has', 'delete' ],
+    receivers: alwaysBogus.concat([ new Set, new Map, new WeakMap ]),
   },
 ];
 function TestBogusReceivers(testSet) {
   for (var i = 0; i < testSet.length; i++) {
     var proto = testSet[i].proto;
     var funcs = testSet[i].funcs;
     var receivers = testSet[i].receivers;
     for (var j = 0; j < funcs.length; j++) {
       var func = proto[funcs[j]];
       for (var k = 0; k < receivers.length; k++) {
@@ skipping 80 matching lines @@
 (function() {
   var k = new Object();
   var w = new WeakMap();
   w.set(k, 23);
   assertTrue(w.has(k));
   assertEquals(23, w.get(k));
   w.clear();
   assertFalse(w.has(k));
   assertEquals(undefined, w.get(k));
 })();
+
+
+// Test WeakSet clear
+(function() {
+  var k = new Object();
+  var w = new WeakSet();
+  w.add(k);
+  assertTrue(w.has(k));
+  w.clear();
+  assertFalse(w.has(k));
+})();