Revision: 22889
Author: [email protected]
Date: Tue Aug 5 19:37:32 2014 UTC
Log: Enable ES6 Map and Set by default
In doing so also remove all references to the --harmony-collections flag.
Due to the way context snapshotting works, it's not possible to simply
enable the flag by default.
Depends on ES6 Symbols: https://codereview.chromium.org/421313004
BUG=v8:1622
LOG=Y
[email protected], [email protected]
Review URL: https://codereview.chromium.org/427723002
http://code.google.com/p/v8/source/detail?r=22889
Added:
/branches/bleeding_edge/test/mjsunit/es6/collection-iterator.js
/branches/bleeding_edge/test/mjsunit/es6/collections.js
/branches/bleeding_edge/test/mjsunit/es6/debug-stepin-collections-foreach.js
/branches/bleeding_edge/test/mjsunit/es6/mirror-collections.js
/branches/bleeding_edge/test/mjsunit/es6/regress/regress-2186.js
Deleted:
/branches/bleeding_edge/test/mjsunit/es6/weak_collections.js
/branches/bleeding_edge/test/mjsunit/harmony/collection-iterator.js
/branches/bleeding_edge/test/mjsunit/harmony/collections.js
/branches/bleeding_edge/test/mjsunit/harmony/debug-stepin-collections-foreach.js
/branches/bleeding_edge/test/mjsunit/harmony/mirror-collections.js
/branches/bleeding_edge/test/mjsunit/harmony/regress/regress-2186.js
Modified:
/branches/bleeding_edge/BUILD.gn
/branches/bleeding_edge/src/bootstrapper.cc
/branches/bleeding_edge/src/flag-definitions.h
/branches/bleeding_edge/test/cctest/test-api.cc
/branches/bleeding_edge/test/cctest/test-heap-profiler.cc
/branches/bleeding_edge/test/cctest/test-heap.cc
/branches/bleeding_edge/test/cctest/test-ordered-hash-table.cc
/branches/bleeding_edge/test/mjsunit/builtins.js
/branches/bleeding_edge/test/mjsunit/debug-script.js
/branches/bleeding_edge/test/mjsunit/es6/symbols.js
/branches/bleeding_edge/test/mjsunit/es7/object-observe.js
/branches/bleeding_edge/test/mjsunit/harmony/private.js
/branches/bleeding_edge/test/mjsunit/harmony/proxies-hash.js
/branches/bleeding_edge/test/mjsunit/regress/regress-3281.js
/branches/bleeding_edge/tools/gyp/v8.gyp
=======================================
--- /dev/null
+++ /branches/bleeding_edge/test/mjsunit/es6/collection-iterator.js Tue
Aug 5 19:37:32 2014 UTC
@@ -0,0 +1,200 @@
+// Copyright 2014 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --allow-natives-syntax
+
+
+(function TestSetIterator() {
+ var s = new Set;
+ var iter = s.values();
+ assertEquals('Set Iterator', %_ClassOf(iter));
+
+ var SetIteratorPrototype = iter.__proto__;
+ assertFalse(SetIteratorPrototype.hasOwnProperty('constructor'));
+ assertEquals(SetIteratorPrototype.__proto__, Object.prototype);
+
+ var propertyNames = Object.getOwnPropertyNames(SetIteratorPrototype);
+ assertArrayEquals(['next'], propertyNames);
+
+ assertEquals(new Set().values().__proto__, SetIteratorPrototype);
+ assertEquals(new Set().entries().__proto__, SetIteratorPrototype);
+})();
+
+
+(function TestSetIteratorValues() {
+ var s = new Set;
+ s.add(1);
+ s.add(2);
+ s.add(3);
+ var iter = s.values();
+
+ assertEquals({value: 1, done: false}, iter.next());
+ assertEquals({value: 2, done: false}, iter.next());
+ assertEquals({value: 3, done: false}, iter.next());
+ assertEquals({value: undefined, done: true}, iter.next());
+ assertEquals({value: undefined, done: true}, iter.next());
+})();
+
+
+(function TestSetIteratorKeys() {
+ assertEquals(Set.prototype.keys, Set.prototype.values);
+})();
+
+
+(function TestSetIteratorEntries() {
+ var s = new Set;
+ s.add(1);
+ s.add(2);
+ s.add(3);
+ var iter = s.entries();
+
+ assertEquals({value: [1, 1], done: false}, iter.next());
+ assertEquals({value: [2, 2], done: false}, iter.next());
+ assertEquals({value: [3, 3], done: false}, iter.next());
+ assertEquals({value: undefined, done: true}, iter.next());
+ assertEquals({value: undefined, done: true}, iter.next());
+})();
+
+
+(function TestSetIteratorMutations() {
+ var s = new Set;
+ s.add(1);
+ var iter = s.values();
+ assertEquals({value: 1, done: false}, iter.next());
+ s.add(2);
+ s.add(3);
+ s.add(4);
+ s.add(5);
+ assertEquals({value: 2, done: false}, iter.next());
+ s.delete(3);
+ assertEquals({value: 4, done: false}, iter.next());
+ s.delete(5);
+ assertEquals({value: undefined, done: true}, iter.next());
+ s.add(4);
+ assertEquals({value: undefined, done: true}, iter.next());
+})();
+
+
+(function TestSetInvalidReceiver() {
+ assertThrows(function() {
+ Set.prototype.values.call({});
+ }, TypeError);
+ assertThrows(function() {
+ Set.prototype.entries.call({});
+ }, TypeError);
+})();
+
+
+(function TestSetIteratorInvalidReceiver() {
+ var iter = new Set().values();
+ assertThrows(function() {
+ iter.next.call({});
+ });
+})();
+
+
+(function TestSetIteratorSymbol() {
+ assertEquals(Set.prototype[Symbol.iterator], Set.prototype.values);
+ assertTrue(Set.prototype.hasOwnProperty(Symbol.iterator));
+ assertFalse(Set.prototype.propertyIsEnumerable(Symbol.iterator));
+
+ var iter = new Set().values();
+ assertEquals(iter, iter[Symbol.iterator]());
+ assertEquals(iter[Symbol.iterator].name, '[Symbol.iterator]');
+})();
+
+
+(function TestMapIterator() {
+ var m = new Map;
+ var iter = m.values();
+ assertEquals('Map Iterator', %_ClassOf(iter));
+
+ var MapIteratorPrototype = iter.__proto__;
+ assertFalse(MapIteratorPrototype.hasOwnProperty('constructor'));
+ assertEquals(MapIteratorPrototype.__proto__, Object.prototype);
+
+ var propertyNames = Object.getOwnPropertyNames(MapIteratorPrototype);
+ assertArrayEquals(['next'], propertyNames);
+
+ assertEquals(new Map().values().__proto__, MapIteratorPrototype);
+ assertEquals(new Map().keys().__proto__, MapIteratorPrototype);
+ assertEquals(new Map().entries().__proto__, MapIteratorPrototype);
+})();
+
+
+(function TestMapIteratorValues() {
+ var m = new Map;
+ m.set(1, 11);
+ m.set(2, 22);
+ m.set(3, 33);
+ var iter = m.values();
+
+ assertEquals({value: 11, done: false}, iter.next());
+ assertEquals({value: 22, done: false}, iter.next());
+ assertEquals({value: 33, done: false}, iter.next());
+ assertEquals({value: undefined, done: true}, iter.next());
+ assertEquals({value: undefined, done: true}, iter.next());
+})();
+
+
+(function TestMapIteratorKeys() {
+ var m = new Map;
+ m.set(1, 11);
+ m.set(2, 22);
+ m.set(3, 33);
+ var iter = m.keys();
+
+ assertEquals({value: 1, done: false}, iter.next());
+ assertEquals({value: 2, done: false}, iter.next());
+ assertEquals({value: 3, done: false}, iter.next());
+ assertEquals({value: undefined, done: true}, iter.next());
+ assertEquals({value: undefined, done: true}, iter.next());
+})();
+
+
+(function TestMapIteratorEntries() {
+ var m = new Map;
+ m.set(1, 11);
+ m.set(2, 22);
+ m.set(3, 33);
+ var iter = m.entries();
+
+ assertEquals({value: [1, 11], done: false}, iter.next());
+ assertEquals({value: [2, 22], done: false}, iter.next());
+ assertEquals({value: [3, 33], done: false}, iter.next());
+ assertEquals({value: undefined, done: true}, iter.next());
+ assertEquals({value: undefined, done: true}, iter.next());
+})();
+
+
+(function TestMapInvalidReceiver() {
+ assertThrows(function() {
+ Map.prototype.values.call({});
+ }, TypeError);
+ assertThrows(function() {
+ Map.prototype.keys.call({});
+ }, TypeError);
+ assertThrows(function() {
+ Map.prototype.entries.call({});
+ }, TypeError);
+})();
+
+
+(function TestMapIteratorInvalidReceiver() {
+ var iter = new Map().values();
+ assertThrows(function() {
+ iter.next.call({});
+ }, TypeError);
+})();
+
+
+(function TestMapIteratorSymbol() {
+ assertEquals(Map.prototype[Symbol.iterator], Map.prototype.entries);
+ assertTrue(Map.prototype.hasOwnProperty(Symbol.iterator));
+ assertFalse(Map.prototype.propertyIsEnumerable(Symbol.iterator));
+
+ var iter = new Map().values();
+ assertEquals(iter, iter[Symbol.iterator]());
+ assertEquals(iter[Symbol.iterator].name, '[Symbol.iterator]');
+})();
=======================================
--- /dev/null
+++ /branches/bleeding_edge/test/mjsunit/es6/collections.js Tue Aug 5
19:37:32 2014 UTC
@@ -0,0 +1,1251 @@
+// 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
+// with the distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived
+// from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Flags: --expose-gc --allow-natives-syntax
+
+
+// Test valid getter and setter calls on Sets and WeakSets
+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);
+TestValidMapCalls(new WeakMap);
+
+
+// Test invalid getter and setter calls for WeakMap only
+function TestInvalidCalls(m) {
+ assertThrows(function () { m.get(undefined) }, TypeError);
+ assertThrows(function () { m.set(undefined, 0) }, TypeError);
+ assertThrows(function () { m.get(null) }, TypeError);
+ assertThrows(function () { m.set(null, 0) }, TypeError);
+ assertThrows(function () { m.get(0) }, TypeError);
+ assertThrows(function () { m.set(0, 0) }, TypeError);
+ assertThrows(function () { m.get('a-key') }, TypeError);
+ assertThrows(function () { m.set('a-key', 0) }, TypeError);
+}
+TestInvalidCalls(new WeakMap);
+
+
+// Test expected behavior for Sets and WeakSets
+function TestSet(set, key) {
+ assertFalse(set.has(key));
+ assertSame(set, set.add(key));
+ assertTrue(set.has(key));
+ assertTrue(set.delete(key));
+ assertFalse(set.has(key));
+ assertFalse(set.delete(key));
+ assertFalse(set.has(key));
+}
+function TestSetBehavior(set) {
+ for (var i = 0; i < 20; i++) {
+ TestSet(set, new Object);
+ 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(map, map.set(key, value));
+ assertSame(value, map.get(key));
+}
+function TestMapBehavior1(m) {
+ TestMapping(m, new Object, 23);
+ TestMapping(m, new Object, 'the-value');
+ TestMapping(m, new Object, new Object);
+}
+TestMapBehavior1(new Map);
+TestMapBehavior1(new WeakMap);
+
+
+// Test expected mapping behavior for Maps only
+function TestMapBehavior2(m) {
+ for (var i = 0; i < 20; i++) {
+ TestMapping(m, i, new Object);
+ TestMapping(m, i / 10, new Object);
+ TestMapping(m, 'key-' + i, new Object);
+ }
+ var keys = [ +0, -0, +Infinity, -Infinity, true, false, null, undefined
];
+ for (var i = 0; i < keys.length; i++) {
+ TestMapping(m, keys[i], new Object);
+ }
+}
+TestMapBehavior2(new Map);
+
+
+// Test expected querying behavior of Maps and WeakMaps
+function TestQuery(m) {
+ var key = new Object;
+ var values = [ 'x', 0, +Infinity, -Infinity, true, false, null,
undefined ];
+ for (var i = 0; i < values.length; i++) {
+ TestMapping(m, key, values[i]);
+ assertTrue(m.has(key));
+ assertFalse(m.has(new Object));
+ }
+}
+TestQuery(new Map);
+TestQuery(new WeakMap);
+
+
+// Test expected deletion behavior of Maps and WeakMaps
+function TestDelete(m) {
+ var key = new Object;
+ TestMapping(m, key, 'to-be-deleted');
+ assertTrue(m.delete(key));
+ assertFalse(m.delete(key));
+ assertFalse(m.delete(new Object));
+ assertSame(m.get(key), undefined);
+}
+TestDelete(new Map);
+TestDelete(new WeakMap);
+
+
+// Test GC of Maps and WeakMaps with entry
+function TestGC1(m) {
+ var key = new Object;
+ m.set(key, 'not-collected');
+ gc();
+ assertSame('not-collected', m.get(key));
+}
+TestGC1(new Map);
+TestGC1(new WeakMap);
+
+
+// Test GC of Maps and WeakMaps with chained entries
+function TestGC2(m) {
+ var head = new Object;
+ for (key = head, i = 0; i < 10; i++, key = m.get(key)) {
+ m.set(key, new Object);
+ }
+ gc();
+ var count = 0;
+ for (key = head; key != undefined; key = m.get(key)) {
+ count++;
+ }
+ assertEquals(11, count);
+}
+TestGC2(new Map);
+TestGC2(new WeakMap);
+
+
+// Test property attribute [[Enumerable]]
+function TestEnumerable(func) {
+ function props(x) {
+ var array = [];
+ 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
+assertThrows(function() { Set(); }, TypeError);
+assertThrows(function() { Map(); }, TypeError);
+assertThrows(function() { WeakMap(); }, TypeError);
+assertThrows(function() { WeakSet(); }, TypeError);
+
+
+// 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 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 name of constructor.
+assertEquals("Set", Set.name);
+assertEquals("Map", Map.name);
+assertEquals("WeakMap", WeakMap.name);
+assertEquals("WeakSet", WeakSet.name);
+
+
+// Test prototype property of Set, Map, WeakMap and WeakSet.
+function TestPrototype(C) {
+ assertTrue(C.prototype instanceof Object);
+ assertEquals({
+ value: {},
+ writable: false,
+ enumerable: false,
+ configurable: false
+ }, Object.getOwnPropertyDescriptor(C, "prototype"));
+}
+TestPrototype(Set);
+TestPrototype(Map);
+TestPrototype(WeakMap);
+TestPrototype(WeakSet);
+
+
+// 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, (new C).__proto__.constructor);
+}
+TestConstructor(Set);
+TestConstructor(Map);
+TestConstructor(WeakMap);
+TestConstructor(WeakSet);
+
+
+// Test the Set, Map, WeakMap and WeakSet global properties themselves.
+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);
+var o = Object.create({});
+assertFalse("get" in o);
+assertFalse("set" in o);
+assertEquals(undefined, o.get);
+assertEquals(undefined, o.set);
+var o = Object.create({}, { myValue: {
+ value: 10,
+ enumerable: false,
+ configurable: true,
+ writable: true
+}});
+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, new WeakSet ]),
+ },
+ { proto: Map.prototype,
+ funcs: [ 'get', 'set', 'has', 'delete' ],
+ receivers: alwaysBogus.concat([ new Set, new WeakMap, new WeakSet ]),
+ },
+ { proto: WeakMap.prototype,
+ funcs: [ 'get', 'set', 'has', 'delete' ],
+ 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++) {
+ assertThrows(function () { func.call(receivers[k], {}) },
TypeError);
+ }
+ }
+ }
+}
+TestBogusReceivers(bogusReceiversTestSet);
+
+
+// Stress Test
+// There is a proposed stress-test available at the es-discuss mailing list
+// which cannot be reasonably automated. Check it out by hand if you like:
+// https://mail.mozilla.org/pipermail/es-discuss/2011-May/014096.html
+
+
+// Set and Map size getters
+var setSizeDescriptor =
Object.getOwnPropertyDescriptor(Set.prototype, 'size');
+assertEquals(undefined, setSizeDescriptor.value);
+assertEquals(undefined, setSizeDescriptor.set);
+assertTrue(setSizeDescriptor.get instanceof Function);
+assertEquals(undefined, setSizeDescriptor.get.prototype);
+assertFalse(setSizeDescriptor.enumerable);
+assertTrue(setSizeDescriptor.configurable);
+
+var s = new Set();
+assertFalse(s.hasOwnProperty('size'));
+for (var i = 0; i < 10; i++) {
+ assertEquals(i, s.size);
+ s.add(i);
+}
+for (var i = 9; i >= 0; i--) {
+ s.delete(i);
+ assertEquals(i, s.size);
+}
+
+
+var mapSizeDescriptor =
Object.getOwnPropertyDescriptor(Map.prototype, 'size');
+assertEquals(undefined, mapSizeDescriptor.value);
+assertEquals(undefined, mapSizeDescriptor.set);
+assertTrue(mapSizeDescriptor.get instanceof Function);
+assertEquals(undefined, mapSizeDescriptor.get.prototype);
+assertFalse(mapSizeDescriptor.enumerable);
+assertTrue(mapSizeDescriptor.configurable);
+
+var m = new Map();
+assertFalse(m.hasOwnProperty('size'));
+for (var i = 0; i < 10; i++) {
+ assertEquals(i, m.size);
+ m.set(i, i);
+}
+for (var i = 9; i >= 0; i--) {
+ m.delete(i);
+ assertEquals(i, m.size);
+}
+
+
+// Test Set clear
+(function() {
+ var s = new Set();
+ s.add(42);
+ assertTrue(s.has(42));
+ assertEquals(1, s.size);
+ s.clear();
+ assertFalse(s.has(42));
+ assertEquals(0, s.size);
+})();
+
+
+// Test Map clear
+(function() {
+ var m = new Map();
+ m.set(42, true);
+ assertTrue(m.has(42));
+ assertEquals(1, m.size);
+ m.clear();
+ assertFalse(m.has(42));
+ assertEquals(0, m.size);
+})();
+
+
+// Test WeakMap clear
+(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));
+})();
+
+
+(function TestMinusZeroSet() {
+ var m = new Set();
+ m.add(0);
+ m.add(-0);
+ assertEquals(1, m.size);
+ assertTrue(m.has(0));
+ assertTrue(m.has(-0));
+})();
+
+
+(function TestMinusZeroMap() {
+ var m = new Map();
+ m.set(0, 'plus');
+ m.set(-0, 'minus');
+ assertEquals(1, m.size);
+ assertTrue(m.has(0));
+ assertTrue(m.has(-0));
+ assertEquals('minus', m.get(0));
+ assertEquals('minus', m.get(-0));
+})();
+
+
+(function TestSetForEachInvalidTypes() {
+ assertThrows(function() {
+ Set.prototype.set.forEach.call({});
+ }, TypeError);
+
+ var set = new Set();
+ assertThrows(function() {
+ set.forEach({});
+ }, TypeError);
+})();
+
+
+(function TestSetForEach() {
+ var set = new Set();
+ set.add('a');
+ set.add('b');
+ set.add('c');
+
+ var buffer = '';
+ var receiver = {};
+ set.forEach(function(v, k, s) {
+ assertSame(v, k);
+ assertSame(set, s);
+ assertSame(this, receiver);
+ buffer += v;
+ if (v === 'a') {
+ set.delete('b');
+ set.add('d');
+ set.add('e');
+ set.add('f');
+ } else if (v === 'c') {
+ set.add('b');
+ set.delete('e');
+ }
+ }, receiver);
+
+ assertEquals('acdfb', buffer);
+})();
+
+
+(function TestSetForEachAddAtEnd() {
+ var set = new Set();
+ set.add('a');
+ set.add('b');
+
+ var buffer = '';
+ set.forEach(function(v) {
+ buffer += v;
+ if (v === 'b') {
+ set.add('c');
+ }
+ });
+
+ assertEquals('abc', buffer);
+})();
+
+
+(function TestSetForEachDeleteNext() {
+ var set = new Set();
+ set.add('a');
+ set.add('b');
+ set.add('c');
+
+ var buffer = '';
+ set.forEach(function(v) {
+ buffer += v;
+ if (v === 'b') {
+ set.delete('c');
+ }
+ });
+
+ assertEquals('ab', buffer);
+})();
+
+
+(function TestSetForEachDeleteVisitedAndAddAgain() {
+ var set = new Set();
+ set.add('a');
+ set.add('b');
+ set.add('c');
+
+ var buffer = '';
+ set.forEach(function(v) {
+ buffer += v;
+ if (v === 'b') {
+ set.delete('a');
+ } else if (v === 'c') {
+ set.add('a');
+ }
+ });
+
+ assertEquals('abca', buffer);
+})();
+
+
+(function TestSetForEachClear() {
+ var set = new Set();
+ set.add('a');
+ set.add('b');
+ set.add('c');
+
+ var buffer = '';
+ set.forEach(function(v) {
+ buffer += v;
+ if (v === 'a') {
+ set.clear();
+ set.add('d');
+ set.add('e');
+ }
+ });
+
+ assertEquals('ade', buffer);
+})();
+
+
+(function TestSetForEachNested() {
+ var set = new Set();
+ set.add('a');
+ set.add('b');
+ set.add('c');
+
+ var buffer = '';
+ set.forEach(function(v) {
+ buffer += v;
+ set.forEach(function(v) {
+ buffer += v;
+ if (v === 'a') {
+ set.delete('b');
+ }
+ });
+ });
+
+ assertEquals('aaccac', buffer);
+})();
+
+
+(function TestSetForEachEarlyExit() {
+ var set = new Set();
+ set.add('a');
+ set.add('b');
+ set.add('c');
+
+ var buffer = '';
+ var ex = {};
+ try {
+ set.forEach(function(v) {
+ buffer += v;
+ throw ex;
+ });
+ } catch (e) {
+ assertEquals(ex, e);
+ }
+ assertEquals('a', buffer);
+})();
+
+
+(function TestSetForEachGC() {
+ var set = new Set();
+ for (var i = 0; i < 100; i++) {
+ set.add(i);
+ }
+
+ var accumulated = 0;
+ set.forEach(function(v) {
+ accumulated += v;
+ if (v % 10 === 0) {
+ gc();
+ }
+ });
+ assertEquals(4950, accumulated);
+})();
+
+(function TestMapForEachInvalidTypes() {
+ assertThrows(function() {
+ Map.prototype.map.forEach.call({});
+ }, TypeError);
+
+ var map = new Map();
+ assertThrows(function() {
+ map.forEach({});
+ }, TypeError);
+})();
+
+
+(function TestMapForEach() {
+ var map = new Map();
+ map.set(0, 'a');
+ map.set(1, 'b');
+ map.set(2, 'c');
+
+ var buffer = [];
+ var receiver = {};
+ map.forEach(function(v, k, m) {
+ assertEquals(map, m);
+ assertEquals(this, receiver);
+ buffer.push(k, v);
+ if (k === 0) {
+ map.delete(1);
+ map.set(3, 'd');
+ map.set(4, 'e');
+ map.set(5, 'f');
+ } else if (k === 2) {
+ map.set(1, 'B');
+ map.delete(4);
+ }
+ }, receiver);
+
+ assertArrayEquals([0, 'a', 2, 'c', 3, 'd', 5, 'f', 1, 'B'], buffer);
+})();
+
+
+(function TestMapForEachAddAtEnd() {
+ var map = new Map();
+ map.set(0, 'a');
+ map.set(1, 'b');
+
+ var buffer = [];
+ map.forEach(function(v, k) {
+ buffer.push(k, v);
+ if (k === 1) {
+ map.set(2, 'c');
+ }
+ });
+
+ assertArrayEquals([0, 'a', 1, 'b', 2, 'c'], buffer);
+})();
+
+
+(function TestMapForEachDeleteNext() {
+ var map = new Map();
+ map.set(0, 'a');
+ map.set(1, 'b');
+ map.set(2, 'c');
+
+ var buffer = [];
+ map.forEach(function(v, k) {
+ buffer.push(k, v);
+ if (k === 1) {
+ map.delete(2);
+ }
+ });
+
+ assertArrayEquals([0, 'a', 1, 'b'], buffer);
+})();
+
+
+(function TestSetForEachDeleteVisitedAndAddAgain() {
+ var map = new Map();
+ map.set(0, 'a');
+ map.set(1, 'b');
+ map.set(2, 'c');
+
+ var buffer = [];
+ map.forEach(function(v, k) {
+ buffer.push(k, v);
+ if (k === 1) {
+ map.delete(0);
+ } else if (k === 2) {
+ map.set(0, 'a');
+ }
+ });
+
+ assertArrayEquals([0, 'a', 1, 'b', 2, 'c', 0, 'a'], buffer);
+})();
+
+
+(function TestMapForEachClear() {
+ var map = new Map();
+ map.set(0, 'a');
+ map.set(1, 'b');
+ map.set(2, 'c');
+
+ var buffer = [];
+ map.forEach(function(v, k) {
+ buffer.push(k, v);
+ if (k === 0) {
+ map.clear();
+ map.set(3, 'd');
+ map.set(4, 'e');
+ }
+ });
+
+ assertArrayEquals([0, 'a', 3, 'd', 4, 'e'], buffer);
+})();
+
+
+(function TestMapForEachNested() {
+ var map = new Map();
+ map.set(0, 'a');
+ map.set(1, 'b');
+ map.set(2, 'c');
+
+ var buffer = [];
+ map.forEach(function(v, k) {
+ buffer.push(k, v);
+ map.forEach(function(v, k) {
+ buffer.push(k, v);
+ if (k === 0) {
+ map.delete(1);
+ }
+ });
+ });
+
+ assertArrayEquals([0, 'a', 0, 'a', 2, 'c', 2, 'c', 0, 'a', 2, 'c'],
buffer);
+})();
+
+
+(function TestMapForEachEarlyExit() {
+ var map = new Map();
+ map.set(0, 'a');
+ map.set(1, 'b');
+ map.set(2, 'c');
+
+ var buffer = [];
+ var ex = {};
+ try {
+ map.forEach(function(v, k) {
+ buffer.push(k, v);
+ throw ex;
+ });
+ } catch (e) {
+ assertEquals(ex, e);
+ }
+ assertArrayEquals([0, 'a'], buffer);
+})();
+
+
+(function TestMapForEachGC() {
+ var map = new Map();
+ for (var i = 0; i < 100; i++) {
+ map.set(i, i);
+ }
+
+ var accumulated = 0;
+ map.forEach(function(v) {
+ accumulated += v;
+ if (v % 10 === 0) {
+ gc();
+ }
+ });
+ assertEquals(4950, accumulated);
+})();
+
+
+(function TestMapForEachAllRemovedTransition() {
+ var map = new Map;
+ map.set(0, 0);
+
+ var buffer = [];
+ map.forEach(function(v) {
+ buffer.push(v);
+ if (v === 0) {
+ for (var i = 1; i < 4; i++) {
+ map.set(i, i);
+ }
+ }
+
+ if (v === 3) {
+ for (var i = 0; i < 4; i++) {
+ map.delete(i);
+ }
+ for (var i = 4; i < 8; i++) {
+ map.set(i, i);
+ }
+ }
+ });
+
+ assertArrayEquals([0, 1, 2, 3, 4, 5, 6, 7], buffer);
+})();
+
+
+(function TestMapForEachClearTransition() {
+ var map = new Map;
+ map.set(0, 0);
+
+ var i = 0;
+ var buffer = [];
+ map.forEach(function(v) {
+ buffer.push(v);
+ if (++i < 5) {
+ for (var j = 0; j < 5; j++) {
+ map.clear();
+ map.set(i, i);
+ }
+ }
+ });
+
+ assertArrayEquals([0, 1, 2, 3, 4], buffer);
+})();
+
+
+(function TestMapForEachNestedNonTrivialTransition() {
+ var map = new Map;
+ map.set(0, 0);
+ map.set(1, 1);
+ map.set(2, 2);
+ map.set(3, 3);
+ map.delete(0);
+
+ var i = 0;
+ var buffer = [];
+ map.forEach(function(v) {
+ if (++i > 10) return;
+
+ buffer.push(v);
+
+ if (v == 3) {
+ map.delete(1);
+ for (var j = 4; j < 10; j++) {
+ map.set(j, j);
+ }
+ for (var j = 4; j < 10; j += 2) {
+ map.delete(j);
+ }
+ map.delete(2);
+
+ for (var j = 10; j < 20; j++) {
+ map.set(j, j);
+ }
+ for (var j = 10; j < 20; j += 2) {
+ map.delete(j);
+ }
+
+ map.delete(3);
+ }
+ });
+
+ assertArrayEquals([1, 2, 3, 5, 7, 9, 11, 13, 15, 17], buffer);
+})();
+
+
+(function TestMapForEachAllRemovedTransitionNoClear() {
+ var map = new Map;
+ map.set(0, 0);
+
+ var buffer = [];
+ map.forEach(function(v) {
+ buffer.push(v);
+ if (v === 0) {
+ for (var i = 1; i < 8; i++) {
+ map.set(i, i);
+ }
+ }
+
+ if (v === 4) {
+ for (var i = 0; i < 8; i++) {
+ map.delete(i);
+ }
+ }
+ });
+
+ assertArrayEquals([0, 1, 2, 3, 4], buffer);
+})();
+
+
+(function TestMapForEachNoMoreElementsAfterTransition() {
+ var map = new Map;
+ map.set(0, 0);
+
+ var buffer = [];
+ map.forEach(function(v) {
+ buffer.push(v);
+ if (v === 0) {
+ for (var i = 1; i < 16; i++) {
+ map.set(i, i);
+ }
+ }
+
+ if (v === 4) {
+ for (var i = 5; i < 16; i++) {
+ map.delete(i);
+ }
+ }
+ });
+
+ assertArrayEquals([0, 1, 2, 3, 4], buffer);
+})();
+
+
+(function TestSetConstructor() {
+ var s = new Set(null);
+ assertEquals(s.size, 0);
+
+ s = new Set(undefined);
+ assertEquals(s.size, 0);
+
+ // No @@iterator
+ assertThrows(function() {
***The diff for this file has been truncated for email.***
=======================================
--- /dev/null
+++
/branches/bleeding_edge/test/mjsunit/es6/debug-stepin-collections-foreach.js
Tue Aug 5 19:37:32 2014 UTC
@@ -0,0 +1,118 @@
+// Copyright 2014 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+//
+// Flags: --expose-debug-as debug
+
+Debug = debug.Debug
+
+var exception = false;
+
+function listener(event, exec_state, event_data, data) {
+ try {
+ if (event == Debug.DebugEvent.Break) {
+ if (breaks == 0) {
+ exec_state.prepareStep(Debug.StepAction.StepIn, 2);
+ breaks = 1;
+ } else if (breaks <= 3) {
+ breaks++;
+ // Check whether we break at the expected line.
+ print(event_data.sourceLineText());
+ assertTrue(event_data.sourceLineText().indexOf("Expected to step")
0);
+ exec_state.prepareStep(Debug.StepAction.StepIn, 3);
+ }
+ }
+ } catch (e) {
+ exception = true;
+ }
+}
+
+function cb_set(num) {
+ print("element " + num); // Expected to step to this point.
+ return true;
+}
+
+function cb_map(key, val) {
+ print("key " + key + ", value " + val); // Expected to step to this
point.
+ return true;
+}
+
+var s = new Set();
+s.add(1);
+s.add(2);
+s.add(3);
+s.add(4);
+
+var m = new Map();
+m.set('foo', 1);
+m.set('bar', 2);
+m.set('baz', 3);
+m.set('bat', 4);
+
+Debug.setListener(listener);
+
+var breaks = 0;
+debugger;
+s.forEach(cb_set);
+assertFalse(exception);
+assertEquals(4, breaks);
+
+breaks = 0;
+debugger;
+m.forEach(cb_map);
+assertFalse(exception);
+assertEquals(4, breaks);
+
+Debug.setListener(null);
+
+
+// Test two levels of builtin callbacks:
+// Array.forEach calls a callback function, which by itself uses
+// Array.forEach with another callback function.
+
+function second_level_listener(event, exec_state, event_data, data) {
+ try {
+ if (event == Debug.DebugEvent.Break) {
+ if (breaks == 0) {
+ exec_state.prepareStep(Debug.StepAction.StepIn, 3);
+ breaks = 1;
+ } else if (breaks <= 16) {
+ breaks++;
+ // Check whether we break at the expected line.
+ assertTrue(event_data.sourceLineText().indexOf("Expected to step")
0);
+ // Step two steps further every four breaks to skip the
+ // forEach call in the first level of recurision.
+ var step = (breaks % 4 == 1) ? 6 : 3;
+ exec_state.prepareStep(Debug.StepAction.StepIn, step);
+ }
+ }
+ } catch (e) {
+ exception = true;
+ }
+}
+
+function cb_set_foreach(num) {
+ s.forEach(cb_set);
+ print("back to the first level of recursion.");
+}
+
+function cb_map_foreach(key, val) {
+ m.forEach(cb_set);
+ print("back to the first level of recursion.");
+}
+
+Debug.setListener(second_level_listener);
+
+breaks = 0;
+debugger;
+s.forEach(cb_set_foreach);
+assertFalse(exception);
+assertEquals(17, breaks);
+
+breaks = 0;
+debugger;
+m.forEach(cb_map_foreach);
+assertFalse(exception);
+assertEquals(17, breaks);
+
+Debug.setListener(null);
=======================================
--- /dev/null
+++ /branches/bleeding_edge/test/mjsunit/es6/mirror-collections.js Tue Aug
5 19:37:32 2014 UTC
@@ -0,0 +1,144 @@
+// Copyright 2014 the V8 project authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// Flags: --expose-debug-as debug --expose-gc
+
+function testMapMirror(mirror) {
+ // Create JSON representation.
+ var serializer = debug.MakeMirrorSerializer();
+ var json = JSON.stringify(serializer.serializeValue(mirror));
+
+ // Check the mirror hierachy.
+ assertTrue(mirror instanceof debug.Mirror);
+ assertTrue(mirror instanceof debug.ValueMirror);
+ assertTrue(mirror instanceof debug.ObjectMirror);
+ assertTrue(mirror instanceof debug.MapMirror);
+
+ assertTrue(mirror.isMap());
+
+ // Parse JSON representation and check.
+ var fromJSON = eval('(' + json + ')');
+ assertEquals('map', fromJSON.type);
+}
+
+function testSetMirror(mirror) {
+ // Create JSON representation.
+ var serializer = debug.MakeMirrorSerializer();
+ var json = JSON.stringify(serializer.serializeValue(mirror));
+
+ // Check the mirror hierachy.
+ assertTrue(mirror instanceof debug.Mirror);
+ assertTrue(mirror instanceof debug.ValueMirror);
+ assertTrue(mirror instanceof debug.ObjectMirror);
+ assertTrue(mirror instanceof debug.SetMirror);
+
+ assertTrue(mirror.isSet());
+
+ // Parse JSON representation and check.
+ var fromJSON = eval('(' + json + ')');
+ assertEquals('set', fromJSON.type);
+}
+
+var o1 = new Object();
+var o2 = new Object();
+var o3 = new Object();
+
+// Test the mirror object for Maps
+var map = new Map();
+map.set(o1, 11);
+map.set(o2, 22);
+map.delete(o1);
+var mapMirror = debug.MakeMirror(map);
+testMapMirror(mapMirror);
+var entries = mapMirror.entries();
+assertEquals(1, entries.length);
+assertSame(o2, entries[0].key);
+assertEquals(22, entries[0].value);
+map.set(o1, 33);
+map.set(o3, o2);
+map.delete(o2);
+map.set(undefined, 44);
+entries = mapMirror.entries();
+assertEquals(3, entries.length);
+assertSame(o1, entries[0].key);
+assertEquals(33, entries[0].value);
+assertSame(o3, entries[1].key);
+assertSame(o2, entries[1].value);
+assertEquals(undefined, entries[2].key);
+assertEquals(44, entries[2].value);
+
+// Test the mirror object for Sets
+var set = new Set();
+set.add(o1);
+set.add(o2);
+set.delete(o1);
+set.add(undefined);
+var setMirror = debug.MakeMirror(set);
+testSetMirror(setMirror);
+var values = setMirror.values();
+assertEquals(2, values.length);
+assertSame(o2, values[0]);
+assertEquals(undefined, values[1]);
+
+// Test the mirror object for WeakMaps
+var weakMap = new WeakMap();
+weakMap.set(o1, 11);
+weakMap.set(new Object(), 22);
+weakMap.set(o3, 33);
+weakMap.set(new Object(), 44);
+var weakMapMirror = debug.MakeMirror(weakMap);
+testMapMirror(weakMapMirror);
+weakMap.set(new Object(), 55);
+assertTrue(weakMapMirror.entries().length <= 5);
+gc();
+
+function testWeakMapEntries(weakMapMirror) {
+ var entries = weakMapMirror.entries();
+ assertEquals(2, entries.length);
+ var found = 0;
+ for (var i = 0; i < entries.length; i++) {
+ if (Object.is(entries[i].key, o1)) {
+ assertEquals(11, entries[i].value);
+ found++;
+ }
+ if (Object.is(entries[i].key, o3)) {
+ assertEquals(33, entries[i].value);
+ found++;
+ }
+ }
+ assertEquals(2, found);
+}
+
+testWeakMapEntries(weakMapMirror);
+
+// Test the mirror object for WeakSets
+var weakSet = new WeakSet();
+weakSet.add(o1);
+weakSet.add(new Object());
+weakSet.add(o2);
+weakSet.add(new Object());
+weakSet.add(new Object());
+weakSet.add(o3);
+weakSet.delete(o2);
+var weakSetMirror = debug.MakeMirror(weakSet);
+testSetMirror(weakSetMirror);
+assertTrue(weakSetMirror.values().length <= 5);
+gc();
+
+function testWeakSetValues(weakSetMirror) {
+ var values = weakSetMirror.values();
+ assertEquals(2, values.length);
+ var found = 0;
+ for (var i = 0; i < values.length; i++) {
+ if (Object.is(values[i], o1)) {
+ found++;
+ }
+ if (Object.is(values[i], o3)) {
+ found++;
+ }
+ }
+ assertEquals(2, found);
+}
+
+testWeakSetValues(weakSetMirror);
=======================================
--- /dev/null
+++ /branches/bleeding_edge/test/mjsunit/es6/regress/regress-2186.js Tue
Aug 5 19:37:32 2014 UTC
@@ -0,0 +1,47 @@
+// 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
+// with the distribution.
+// * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived
+// from this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+function heapify(i) {
+ return 2.0 * (i / 2);
+}
+heapify(1);
+
+var ONE = 1;
+var ANOTHER_ONE = heapify(ONE);
+assertSame(ONE, ANOTHER_ONE);
+assertEquals("number", typeof ONE);
+assertEquals("number", typeof ANOTHER_ONE);
+
+var set = new Set;
+set.add(ONE);
+assertTrue(set.has(ONE));
+assertTrue(set.has(ANOTHER_ONE));
+
+var map = new Map;
+map.set(ONE, 23);
+assertSame(23, map.get(ONE));
+assertSame(23, map.get(ANOTHER_ONE));
=======================================
--- /branches/bleeding_edge/test/mjsunit/es6/weak_collections.js Tue Jul 1
09:49:25 2014 UTC
+++ /dev/null
@@ -1,333 +0,0 @@
-// 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
-// with the distribution.
-// * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived
-// from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// Flags: --expose-gc --allow-natives-syntax
-
-
-// Note: this test is superseded by harmony/collections.js.
-// IF YOU CHANGE THIS FILE, apply the same changes to
harmony/collections.js!
-// TODO(rossberg): Remove once non-weak collections have caught up.
-
-// Test valid getter and setter calls on WeakSets.
-function TestValidSetCalls(m) {
- assertDoesNotThrow(function () { m.add(new Object) });
- assertDoesNotThrow(function () { m.has(new Object) });
- assertDoesNotThrow(function () { m.delete(new Object) });
-}
-TestValidSetCalls(new WeakSet);
-
-
-// Test valid getter and setter calls on 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 WeakMap);
-
-
-// Test invalid getter and setter calls for WeakMap
-function TestInvalidCalls(m) {
- assertThrows(function () { m.get(undefined) }, TypeError);
- assertThrows(function () { m.set(undefined, 0) }, TypeError);
- assertThrows(function () { m.get(null) }, TypeError);
- assertThrows(function () { m.set(null, 0) }, TypeError);
- assertThrows(function () { m.get(0) }, TypeError);
- assertThrows(function () { m.set(0, 0) }, TypeError);
- assertThrows(function () { m.get('a-key') }, TypeError);
- assertThrows(function () { m.set('a-key', 0) }, TypeError);
-}
-TestInvalidCalls(new WeakMap);
-
-
-// Test expected behavior for WeakSets
-function TestSet(set, key) {
- assertFalse(set.has(key));
- assertSame(set, set.add(key));
- assertTrue(set.has(key));
- assertTrue(set.delete(key));
- assertFalse(set.has(key));
- assertFalse(set.delete(key));
- assertFalse(set.has(key));
-}
-function TestSetBehavior(set) {
- for (var i = 0; i < 20; i++) {
- TestSet(set, new Object);
- 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]);
- }
-}
-TestSet(new WeakSet, new Object);
-
-
-// Test expected mapping behavior for WeakMaps
-function TestMapping(map, key, value) {
- assertSame(map, map.set(key, value));
- assertSame(value, map.get(key));
-}
-function TestMapBehavior1(m) {
- TestMapping(m, new Object, 23);
- TestMapping(m, new Object, 'the-value');
- TestMapping(m, new Object, new Object);
-}
-TestMapBehavior1(new WeakMap);
-
-
-// Test expected querying behavior of WeakMaps
-function TestQuery(m) {
- var key = new Object;
- var values = [ 'x', 0, +Infinity, -Infinity, true, false, null,
undefined ];
- for (var i = 0; i < values.length; i++) {
- TestMapping(m, key, values[i]);
- assertTrue(m.has(key));
- assertFalse(m.has(new Object));
- }
-}
-TestQuery(new WeakMap);
-
-
-// Test expected deletion behavior of WeakMaps
-function TestDelete(m) {
- var key = new Object;
- TestMapping(m, key, 'to-be-deleted');
- assertTrue(m.delete(key));
- assertFalse(m.delete(key));
- assertFalse(m.delete(new Object));
- assertSame(m.get(key), undefined);
-}
-TestDelete(new WeakMap);
-
-
-// Test GC of WeakMaps with entry
-function TestGC1(m) {
- var key = new Object;
- m.set(key, 'not-collected');
- gc();
- assertSame('not-collected', m.get(key));
-}
-TestGC1(new WeakMap);
-
-
-// Test GC of WeakMaps with chained entries
-function TestGC2(m) {
- var head = new Object;
- for (key = head, i = 0; i < 10; i++, key = m.get(key)) {
- m.set(key, new Object);
- }
- gc();
- var count = 0;
- for (key = head; key != undefined; key = m.get(key)) {
- count++;
- }
- assertEquals(11, count);
-}
-TestGC2(new WeakMap);
-
-
-// Test property attribute [[Enumerable]]
-function TestEnumerable(func) {
- function props(x) {
- var array = [];
- for (var p in x) array.push(p);
- return array.sort();
- }
- assertArrayEquals([], props(func));
- assertArrayEquals([], props(func.prototype));
- assertArrayEquals([], props(new func()));
-}
-TestEnumerable(WeakMap);
-TestEnumerable(WeakSet);
-
-
-// Test arbitrary properties on 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 WeakMap);
-
-
-// Test direct constructor call
-assertThrows(function() { WeakMap(); }, TypeError);
-assertThrows(function() { WeakSet(); }, TypeError);
-
-
-// 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 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("WeakMap", %_ClassOf(new WeakMap))
-assertEquals("Object", %_ClassOf(WeakMap.prototype))
-assertEquals("WeakSet", %_ClassOf(new WeakSet))
-assertEquals("Object", %_ClassOf(WeakMap.prototype))
-
-
-// Test name of constructor.
-assertEquals("WeakMap", WeakMap.name);
-assertEquals("WeakSet", WeakSet.name);
-
-
-// Test prototype property of WeakMap and WeakSet.
-function TestPrototype(C) {
- assertTrue(C.prototype instanceof Object);
- assertEquals({
- value: {},
- writable: false,
- enumerable: false,
- configurable: false
- }, Object.getOwnPropertyDescriptor(C, "prototype"));
-}
-TestPrototype(WeakMap);
-TestPrototype(WeakSet);
-
-
-// Test constructor property of the WeakMap and WeakSet prototype.
-function TestConstructor(C) {
- assertFalse(C === Object.prototype.constructor);
- assertSame(C, C.prototype.constructor);
- assertSame(C, (new C).__proto__.constructor);
-}
-TestConstructor(WeakMap);
-TestConstructor(WeakSet);
-
-
-// Test the WeakMap and WeakSet global properties themselves.
-function TestDescriptor(global, C) {
- assertEquals({
- value: C,
- writable: true,
- enumerable: false,
- configurable: true
- }, Object.getOwnPropertyDescriptor(global, C.name));
-}
-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);
-var o = Object.create({});
-assertFalse("get" in o);
-assertFalse("set" in o);
-assertEquals(undefined, o.get);
-assertEquals(undefined, o.set);
-var o = Object.create({}, { myValue: {
- value: 10,
- enumerable: false,
- configurable: true,
- writable: true
-}});
-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: WeakMap.prototype,
- funcs: [ 'get', 'set', 'has', 'delete' ],
- receivers: alwaysBogus.concat([ new WeakSet ]),
- },
- { proto: WeakSet.prototype,
- funcs: [ 'add', 'has', 'delete' ],
- receivers: alwaysBogus.concat([ 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++) {
- assertThrows(function () { func.call(receivers[k], {}) },
TypeError);
- }
- }
- }
-}
-TestBogusReceivers(bogusReceiversTestSet);
-
-
-// Test WeakMap clear
-(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));
-})();
=======================================
--- /branches/bleeding_edge/test/mjsunit/harmony/collection-iterator.js Mon
Jun 30 14:37:07 2014 UTC
+++ /dev/null
@@ -1,200 +0,0 @@
-// Copyright 2014 the V8 project authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// Flags: --harmony-collections --allow-natives-syntax
-
-
-(function TestSetIterator() {
- var s = new Set;
- var iter = s.values();
- assertEquals('Set Iterator', %_ClassOf(iter));
-
- var SetIteratorPrototype = iter.__proto__;
- assertFalse(SetIteratorPrototype.hasOwnProperty('constructor'));
- assertEquals(SetIteratorPrototype.__proto__, Object.prototype);
-
- var propertyNames = Object.getOwnPropertyNames(SetIteratorPrototype);
- assertArrayEquals(['next'], propertyNames);
-
- assertEquals(new Set().values().__proto__, SetIteratorPrototype);
- assertEquals(new Set().entries().__proto__, SetIteratorPrototype);
-})();
-
-
-(function TestSetIteratorValues() {
- var s = new Set;
- s.add(1);
- s.add(2);
- s.add(3);
- var iter = s.values();
-
- assertEquals({value: 1, done: false}, iter.next());
- assertEquals({value: 2, done: false}, iter.next());
- assertEquals({value: 3, done: false}, iter.next());
- assertEquals({value: undefined, done: true}, iter.next());
- assertEquals({value: undefined, done: true}, iter.next());
-})();
-
-
-(function TestSetIteratorKeys() {
- assertEquals(Set.prototype.keys, Set.prototype.values);
-})();
-
-
-(function TestSetIteratorEntries() {
- var s = new Set;
- s.add(1);
- s.add(2);
- s.add(3);
- var iter = s.entries();
-
- assertEquals({value: [1, 1], done: false}, iter.next());
- assertEquals({value: [2, 2], done: false}, iter.next());
- assertEquals({value: [3, 3], done: false}, iter.next());
- assertEquals({value: undefined, done: true}, iter.next());
- assertEquals({value: undefined, done: true}, iter.next());
-})();
-
-
-(function TestSetIteratorMutations() {
- var s = new Set;
- s.add(1);
- var iter = s.values();
- assertEquals({value: 1, done: false}, iter.next());
- s.add(2);
- s.add(3);
- s.add(4);
- s.add(5);
- assertEquals({value: 2, done: false}, iter.next());
- s.delete(3);
- assertEquals({value: 4, done: false}, iter.next());
- s.delete(5);
- assertEquals({value: undefined, done: true}, iter.next());
- s.add(4);
- assertEquals({value: undefined, done: true}, iter.next());
-})();
-
-
-(function TestSetInvalidReceiver() {
- assertThrows(function() {
- Set.prototype.values.call({});
- }, TypeError);
- assertThrows(function() {
- Set.prototype.entries.call({});
- }, TypeError);
-})();
-
-
-(function TestSetIteratorInvalidReceiver() {
- var iter = new Set().values();
- assertThrows(function() {
- iter.next.call({});
- });
-})();
-
-
-(function TestSetIteratorSymbol() {
- assertEquals(Set.prototype[Symbol.iterator], Set.prototype.values);
- assertTrue(Set.prototype.hasOwnProperty(Symbol.iterator));
- assertFalse(Set.prototype.propertyIsEnumerable(Symbol.iterator));
-
- var iter = new Set().values();
- assertEquals(iter, iter[Symbol.iterator]());
- assertEquals(iter[Symbol.iterator].name, '[Symbol.iterator]');
-})();
-
-
-(function TestMapIterator() {
- var m = new Map;
- var iter = m.values();
- assertEquals('Map Iterator', %_ClassOf(iter));
-
- var MapIteratorPrototype = iter.__proto__;
- assertFalse(MapIteratorPrototype.hasOwnProperty('constructor'));
- assertEquals(MapIteratorPrototype.__proto__, Object.prototype);
-
- var propertyNames = Object.getOwnPropertyNames(MapIteratorPrototype);
- assertArrayEquals(['next'], propertyNames);
-
- assertEquals(new Map().values().__proto__, MapIteratorPrototype);
- assertEquals(new Map().keys().__proto__, MapIteratorPrototype);
- assertEquals(new Map().entries().__proto__, MapIteratorPrototype);
-})();
-
-
-(function TestMapIteratorValues() {
- var m = new Map;
- m.set(1, 11);
- m.set(2, 22);
- m.set(3, 33);
- var iter = m.values();
-
- assertEquals({value: 11, done: false}, iter.next());
- assertEquals({value: 22, done: false}, iter.next());
- assertEquals({value: 33, done: false}, iter.next());
- assertEquals({value: undefined, done: true}, iter.next());
- assertEquals({value: undefined, done: true}, iter.next());
-})();
-
-
-(function TestMapIteratorKeys() {
- var m = new Map;
- m.set(1, 11);
- m.set(2, 22);
- m.set(3, 33);
- var iter = m.keys();
-
- assertEquals({value: 1, done: false}, iter.next());
- assertEquals({value: 2, done: false}, iter.next());
- assertEquals({value: 3, done: false}, iter.next());
- assertEquals({value: undefined, done: true}, iter.next());
- assertEquals({value: undefined, done: true}, iter.next());
-})();
-
-
-(function TestMapIteratorEntries() {
- var m = new Map;
- m.set(1, 11);
- m.set(2, 22);
- m.set(3, 33);
- var iter = m.entries();
-
- assertEquals({value: [1, 11], done: false}, iter.next());
- assertEquals({value: [2, 22], done: false}, iter.next());
- assertEquals({value: [3, 33], done: false}, iter.next());
- assertEquals({value: undefined, done: true}, iter.next());
- assertEquals({value: undefined, done: true}, iter.next());
-})();
-
-
-(function TestMapInvalidReceiver() {
- assertThrows(function() {
- Map.prototype.values.call({});
- }, TypeError);
- assertThrows(function() {
- Map.prototype.keys.call({});
- }, TypeError);
- assertThrows(function() {
- Map.prototype.entries.call({});
- }, TypeError);
-})();
-
-
-(function TestMapIteratorInvalidReceiver() {
- var iter = new Map().values();
- assertThrows(function() {
- iter.next.call({});
- }, TypeError);
-})();
-
-
-(function TestMapIteratorSymbol() {
- assertEquals(Map.prototype[Symbol.iterator], Map.prototype.entries);
- assertTrue(Map.prototype.hasOwnProperty(Symbol.iterator));
- assertFalse(Map.prototype.propertyIsEnumerable(Symbol.iterator));
-
- var iter = new Map().values();
- assertEquals(iter, iter[Symbol.iterator]());
- assertEquals(iter[Symbol.iterator].name, '[Symbol.iterator]');
-})();
=======================================
--- /branches/bleeding_edge/test/mjsunit/harmony/collections.js Tue Jul 1
09:49:25 2014 UTC
+++ /dev/null
@@ -1,1247 +0,0 @@
-// 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
-// with the distribution.
-// * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived
-// from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// Flags: --harmony-collections --harmony-iteration
-// Flags: --expose-gc --allow-natives-syntax
-
-
-// Test valid getter and setter calls on Sets and WeakSets
-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);
-TestValidMapCalls(new WeakMap);
-
-
-// Test invalid getter and setter calls for WeakMap only
-function TestInvalidCalls(m) {
- assertThrows(function () { m.get(undefined) }, TypeError);
- assertThrows(function () { m.set(undefined, 0) }, TypeError);
- assertThrows(function () { m.get(null) }, TypeError);
- assertThrows(function () { m.set(null, 0) }, TypeError);
- assertThrows(function () { m.get(0) }, TypeError);
- assertThrows(function () { m.set(0, 0) }, TypeError);
- assertThrows(function () { m.get('a-key') }, TypeError);
- assertThrows(function () { m.set('a-key', 0) }, TypeError);
-}
-TestInvalidCalls(new WeakMap);
-
-
-// Test expected behavior for Sets and WeakSets
-function TestSet(set, key) {
- assertFalse(set.has(key));
- assertSame(set, set.add(key));
- assertTrue(set.has(key));
- assertTrue(set.delete(key));
- assertFalse(set.has(key));
- assertFalse(set.delete(key));
- assertFalse(set.has(key));
-}
-function TestSetBehavior(set) {
- for (var i = 0; i < 20; i++) {
- TestSet(set, new Object);
- 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(map, map.set(key, value));
- assertSame(value, map.get(key));
-}
-function TestMapBehavior1(m) {
- TestMapping(m, new Object, 23);
- TestMapping(m, new Object, 'the-value');
- TestMapping(m, new Object, new Object);
-}
-TestMapBehavior1(new Map);
-TestMapBehavior1(new WeakMap);
-
-
-// Test expected mapping behavior for Maps only
-function TestMapBehavior2(m) {
- for (var i = 0; i < 20; i++) {
- TestMapping(m, i, new Object);
- TestMapping(m, i / 10, new Object);
- TestMapping(m, 'key-' + i, new Object);
- }
- var keys = [ +0, -0, +Infinity, -Infinity, true, false, null, undefined
];
- for (var i = 0; i < keys.length; i++) {
- TestMapping(m, keys[i], new Object);
- }
-}
-TestMapBehavior2(new Map);
-
-
-// Test expected querying behavior of Maps and WeakMaps
-function TestQuery(m) {
- var key = new Object;
- var values = [ 'x', 0, +Infinity, -Infinity, true, false, null,
undefined ];
- for (var i = 0; i < values.length; i++) {
- TestMapping(m, key, values[i]);
- assertTrue(m.has(key));
- assertFalse(m.has(new Object));
- }
-}
-TestQuery(new Map);
-TestQuery(new WeakMap);
-
-
-// Test expected deletion behavior of Maps and WeakMaps
-function TestDelete(m) {
- var key = new Object;
- TestMapping(m, key, 'to-be-deleted');
- assertTrue(m.delete(key));
- assertFalse(m.delete(key));
- assertFalse(m.delete(new Object));
- assertSame(m.get(key), undefined);
-}
-TestDelete(new Map);
-TestDelete(new WeakMap);
-
-
-// Test GC of Maps and WeakMaps with entry
-function TestGC1(m) {
- var key = new Object;
- m.set(key, 'not-collected');
- gc();
- assertSame('not-collected', m.get(key));
-}
-TestGC1(new Map);
-TestGC1(new WeakMap);
-
-
-// Test GC of Maps and WeakMaps with chained entries
-function TestGC2(m) {
- var head = new Object;
- for (key = head, i = 0; i < 10; i++, key = m.get(key)) {
- m.set(key, new Object);
- }
- gc();
- var count = 0;
- for (key = head; key != undefined; key = m.get(key)) {
- count++;
- }
- assertEquals(11, count);
-}
-TestGC2(new Map);
-TestGC2(new WeakMap);
-
-
-// Test property attribute [[Enumerable]]
-function TestEnumerable(func) {
- function props(x) {
- var array = [];
- 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
-assertThrows(function() { Set(); }, TypeError);
-assertThrows(function() { Map(); }, TypeError);
-assertThrows(function() { WeakMap(); }, TypeError);
-assertThrows(function() { WeakSet(); }, TypeError);
-
-
-// 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 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 name of constructor.
-assertEquals("Set", Set.name);
-assertEquals("Map", Map.name);
-assertEquals("WeakMap", WeakMap.name);
-assertEquals("WeakSet", WeakSet.name);
-
-
-// Test prototype property of Set, Map, WeakMap and WeakSet.
-// TODO(2793): Should all be non-writable, and the extra flag removed.
-function TestPrototype(C, writable) {
- assertTrue(C.prototype instanceof Object);
- assertEquals({
- value: {},
- writable: writable,
- enumerable: false,
- configurable: false
- }, Object.getOwnPropertyDescriptor(C, "prototype"));
-}
-TestPrototype(Set, true);
-TestPrototype(Map, true);
-TestPrototype(WeakMap, false);
-TestPrototype(WeakSet, false);
-
-
-// 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, (new C).__proto__.constructor);
-}
-TestConstructor(Set);
-TestConstructor(Map);
-TestConstructor(WeakMap);
-TestConstructor(WeakSet);
-
-
-// Test the Set, Map, WeakMap and WeakSet global properties themselves.
-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);
-var o = Object.create({});
-assertFalse("get" in o);
-assertFalse("set" in o);
-assertEquals(undefined, o.get);
-assertEquals(undefined, o.set);
-var o = Object.create({}, { myValue: {
- value: 10,
- enumerable: false,
- configurable: true,
- writable: true
-}});
-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, new WeakSet ]),
- },
- { proto: Map.prototype,
- funcs: [ 'get', 'set', 'has', 'delete' ],
- receivers: alwaysBogus.concat([ new Set, new WeakMap, new WeakSet ]),
- },
- { proto: WeakMap.prototype,
- funcs: [ 'get', 'set', 'has', 'delete' ],
- 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++) {
- assertThrows(function () { func.call(receivers[k], {}) },
TypeError);
- }
- }
- }
-}
-TestBogusReceivers(bogusReceiversTestSet);
-
-
-// Stress Test
-// There is a proposed stress-test available at the es-discuss mailing list
-// which cannot be reasonably automated. Check it out by hand if you like:
-// https://mail.mozilla.org/pipermail/es-discuss/2011-May/014096.html
-
-
-// Set and Map size getters
-var setSizeDescriptor =
Object.getOwnPropertyDescriptor(Set.prototype, 'size');
-assertEquals(undefined, setSizeDescriptor.value);
-assertEquals(undefined, setSizeDescriptor.set);
-assertTrue(setSizeDescriptor.get instanceof Function);
-assertEquals(undefined, setSizeDescriptor.get.prototype);
-assertFalse(setSizeDescriptor.enumerable);
-assertTrue(setSizeDescriptor.configurable);
-
-var s = new Set();
-assertFalse(s.hasOwnProperty('size'));
-for (var i = 0; i < 10; i++) {
- assertEquals(i, s.size);
- s.add(i);
-}
-for (var i = 9; i >= 0; i--) {
- s.delete(i);
- assertEquals(i, s.size);
-}
-
-
-var mapSizeDescriptor =
Object.getOwnPropertyDescriptor(Map.prototype, 'size');
-assertEquals(undefined, mapSizeDescriptor.value);
-assertEquals(undefined, mapSizeDescriptor.set);
-assertTrue(mapSizeDescriptor.get instanceof Function);
-assertEquals(undefined, mapSizeDescriptor.get.prototype);
-assertFalse(mapSizeDescriptor.enumerable);
-assertTrue(mapSizeDescriptor.configurable);
-
-var m = new Map();
-assertFalse(m.hasOwnProperty('size'));
-for (var i = 0; i < 10; i++) {
- assertEquals(i, m.size);
- m.set(i, i);
-}
-for (var i = 9; i >= 0; i--) {
- m.delete(i);
- assertEquals(i, m.size);
-}
-
-
-// Test Set clear
-(function() {
- var s = new Set();
- s.add(42);
- assertTrue(s.has(42));
- assertEquals(1, s.size);
- s.clear();
- assertFalse(s.has(42));
- assertEquals(0, s.size);
-})();
-
-
-// Test Map clear
-(function() {
- var m = new Map();
- m.set(42, true);
- assertTrue(m.has(42));
- assertEquals(1, m.size);
- m.clear();
- assertFalse(m.has(42));
- assertEquals(0, m.size);
-})();
-
-
-// Test WeakMap clear
-(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));
-})();
-
-
-(function TestMinusZeroSet() {
- var m = new Set();
- m.add(0);
- m.add(-0);
- assertEquals(1, m.size);
- assertTrue(m.has(0));
- assertTrue(m.has(-0));
-})();
-
-
-(function TestMinusZeroMap() {
- var m = new Map();
- m.set(0, 'plus');
- m.set(-0, 'minus');
- assertEquals(1, m.size);
- assertTrue(m.has(0));
- assertTrue(m.has(-0));
- assertEquals('minus', m.get(0));
- assertEquals('minus', m.get(-0));
-})();
-
-
-(function TestSetForEachInvalidTypes() {
- assertThrows(function() {
- Set.prototype.set.forEach.call({});
- }, TypeError);
-
- var set = new Set();
- assertThrows(function() {
- set.forEach({});
- }, TypeError);
-})();
-
-
-(function TestSetForEach() {
- var set = new Set();
- set.add('a');
- set.add('b');
- set.add('c');
-
- var buffer = '';
- var receiver = {};
- set.forEach(function(v, k, s) {
- assertSame(v, k);
- assertSame(set, s);
- assertSame(this, receiver);
- buffer += v;
- if (v === 'a') {
- set.delete('b');
- set.add('d');
- set.add('e');
- set.add('f');
- } else if (v === 'c') {
- set.add('b');
- set.delete('e');
- }
- }, receiver);
-
- assertEquals('acdfb', buffer);
-})();
-
-
-(function TestSetForEachAddAtEnd() {
- var set = new Set();
- set.add('a');
- set.add('b');
-
- var buffer = '';
- set.forEach(function(v) {
- buffer += v;
- if (v === 'b') {
- set.add('c');
- }
- });
-
- assertEquals('abc', buffer);
-})();
-
-
-(function TestSetForEachDeleteNext() {
- var set = new Set();
- set.add('a');
- set.add('b');
- set.add('c');
-
- var buffer = '';
- set.forEach(function(v) {
- buffer += v;
- if (v === 'b') {
- set.delete('c');
- }
- });
-
- assertEquals('ab', buffer);
-})();
-
-
-(function TestSetForEachDeleteVisitedAndAddAgain() {
- var set = new Set();
- set.add('a');
- set.add('b');
- set.add('c');
-
- var buffer = '';
- set.forEach(function(v) {
- buffer += v;
- if (v === 'b') {
- set.delete('a');
- } else if (v === 'c') {
- set.add('a');
- }
- });
-
- assertEquals('abca', buffer);
-})();
-
-
-(function TestSetForEachClear() {
- var set = new Set();
- set.add('a');
- set.add('b');
- set.add('c');
-
- var buffer = '';
- set.forEach(function(v) {
- buffer += v;
- if (v === 'a') {
- set.clear();
- set.add('d');
- set.add('e');
- }
- });
-
- assertEquals('ade', buffer);
-})();
-
-
-(function TestSetForEachNested() {
- var set = new Set();
- set.add('a');
- set.add('b');
- set.add('c');
-
- var buffer = '';
- set.forEach(function(v) {
- buffer += v;
- set.forEach(function(v) {
- buffer += v;
- if (v === 'a') {
- set.delete('b');
- }
- });
- });
-
- assertEquals('aaccac', buffer);
-})();
-
-
-(function TestSetForEachEarlyExit() {
- var set = new Set();
- set.add('a');
- set.add('b');
- set.add('c');
-
- var buffer = '';
- var ex = {};
- try {
- set.forEach(function(v) {
- buffer += v;
- throw ex;
- });
- } catch (e) {
- assertEquals(ex, e);
- }
- assertEquals('a', buffer);
-})();
-
-
-(function TestSetForEachGC() {
- var set = new Set();
- for (var i = 0; i < 100; i++) {
- set.add(i);
- }
-
- var accumulated = 0;
- set.forEach(function(v) {
- accumulated += v;
- if (v % 10 === 0) {
- gc();
- }
- });
- assertEquals(4950, accumulated);
-})();
-
-(function TestMapForEachInvalidTypes() {
- assertThrows(function() {
- Map.prototype.map.forEach.call({});
- }, TypeError);
-
- var map = new Map();
- assertThrows(function() {
- map.forEach({});
- }, TypeError);
-})();
-
-
-(function TestMapForEach() {
- var map = new Map();
- map.set(0, 'a');
- map.set(1, 'b');
- map.set(2, 'c');
-
- var buffer = [];
- var receiver = {};
- map.forEach(function(v, k, m) {
- assertEquals(map, m);
- assertEquals(this, receiver);
- buffer.push(k, v);
- if (k === 0) {
- map.delete(1);
- map.set(3, 'd');
- map.set(4, 'e');
- map.set(5, 'f');
- } else if (k === 2) {
- map.set(1, 'B');
- map.delete(4);
- }
- }, receiver);
-
- assertArrayEquals([0, 'a', 2, 'c', 3, 'd', 5, 'f', 1, 'B'], buffer);
-})();
-
-
-(function TestMapForEachAddAtEnd() {
- var map = new Map();
- map.set(0, 'a');
- map.set(1, 'b');
-
- var buffer = [];
- map.forEach(function(v, k) {
- buffer.push(k, v);
- if (k === 1) {
- map.set(2, 'c');
- }
- });
-
- assertArrayEquals([0, 'a', 1, 'b', 2, 'c'], buffer);
-})();
-
-
-(function TestMapForEachDeleteNext() {
- var map = new Map();
- map.set(0, 'a');
- map.set(1, 'b');
- map.set(2, 'c');
-
- var buffer = [];
- map.forEach(function(v, k) {
- buffer.push(k, v);
- if (k === 1) {
- map.delete(2);
- }
- });
-
- assertArrayEquals([0, 'a', 1, 'b'], buffer);
-})();
-
-
-(function TestSetForEachDeleteVisitedAndAddAgain() {
- var map = new Map();
- map.set(0, 'a');
- map.set(1, 'b');
- map.set(2, 'c');
-
- var buffer = [];
- map.forEach(function(v, k) {
- buffer.push(k, v);
- if (k === 1) {
- map.delete(0);
- } else if (k === 2) {
- map.set(0, 'a');
- }
- });
-
- assertArrayEquals([0, 'a', 1, 'b', 2, 'c', 0, 'a'], buffer);
-})();
-
-
-(function TestMapForEachClear() {
- var map = new Map();
- map.set(0, 'a');
- map.set(1, 'b');
- map.set(2, 'c');
-
- var buffer = [];
- map.forEach(function(v, k) {
- buffer.push(k, v);
- if (k === 0) {
- map.clear();
- map.set(3, 'd');
- map.set(4, 'e');
- }
- });
-
- assertArrayEquals([0, 'a', 3, 'd', 4, 'e'], buffer);
-})();
-
-
-(function TestMapForEachNested() {
- var map = new Map();
- map.set(0, 'a');
- map.set(1, 'b');
- map.set(2, 'c');
-
- var buffer = [];
- map.forEach(function(v, k) {
- buffer.push(k, v);
- map.forEach(function(v, k) {
- buffer.push(k, v);
- if (k === 0) {
- map.delete(1);
- }
- });
- });
-
- assertArrayEquals([0, 'a', 0, 'a', 2, 'c', 2, 'c', 0, 'a', 2, 'c'],
buffer);
-})();
-
-
-(function TestMapForEachEarlyExit() {
- var map = new Map();
- map.set(0, 'a');
- map.set(1, 'b');
- map.set(2, 'c');
-
- var buffer = [];
- var ex = {};
- try {
- map.forEach(function(v, k) {
- buffer.push(k, v);
- throw ex;
- });
- } catch (e) {
- assertEquals(ex, e);
- }
- assertArrayEquals([0, 'a'], buffer);
-})();
-
-
-(function TestMapForEachGC() {
- var map = new Map();
- for (var i = 0; i < 100; i++) {
- map.set(i, i);
- }
-
- var accumulated = 0;
- map.forEach(function(v) {
- accumulated += v;
- if (v % 10 === 0) {
- gc();
- }
- });
- assertEquals(4950, accumulated);
-})();
-
-
-(function TestMapForEachAllRemovedTransition() {
- var map = new Map;
- map.set(0, 0);
-
- var buffer = [];
- map.forEach(function(v) {
- buffer.push(v);
- if (v === 0) {
- for (var i = 1; i < 4; i++) {
- map.set(i, i);
- }
- }
-
- if (v === 3) {
- for (var i = 0; i < 4; i++) {
- map.delete(i);
- }
- for (var i = 4; i < 8; i++) {
- map.set(i, i);
- }
- }
- });
-
- assertArrayEquals([0, 1, 2, 3, 4, 5, 6, 7], buffer);
-})();
-
-
-(function TestMapForEachClearTransition() {
- var map = new Map;
- map.set(0, 0);
-
- var i = 0;
- var buffer = [];
- map.forEach(function(v) {
- buffer.push(v);
- if (++i < 5) {
- for (var j = 0; j < 5; j++) {
- map.clear();
- map.set(i, i);
- }
- }
- });
-
- assertArrayEquals([0, 1, 2, 3, 4], buffer);
-})();
-
-
-(function TestMapForEachNestedNonTrivialTransition() {
- var map = new Map;
- map.set(0, 0);
- map.set(1, 1);
- map.set(2, 2);
- map.set(3, 3);
- map.delete(0);
-
- var i = 0;
- var buffer = [];
- map.forEach(function(v) {
- if (++i > 10) return;
-
- buffer.push(v);
-
- if (v == 3) {
- map.delete(1);
- for (var j = 4; j < 10; j++) {
- map.set(j, j);
- }
- for (var j = 4; j < 10; j += 2) {
- map.delete(j);
- }
- map.delete(2);
-
- for (var j = 10; j < 20; j++) {
- map.set(j, j);
- }
- for (var j = 10; j < 20; j += 2) {
- map.delete(j);
- }
-
- map.delete(3);
- }
- });
-
- assertArrayEquals([1, 2, 3, 5, 7, 9, 11, 13, 15, 17], buffer);
-})();
-
-
-(function TestMapForEachAllRemovedTransitionNoClear() {
- var map = new Map;
- map.set(0, 0);
-
- var buffer = [];
- map.forEach(function(v) {
- buffer.push(v);
- if (v === 0) {
- for (var i = 1; i < 8; i++) {
- map.set(i, i);
- }
- }
-
- if (v === 4) {
- for (var i = 0; i < 8; i++) {
- map.delete(i);
- }
- }
- });
-
- assertArrayEquals([0, 1, 2, 3, 4], buffer);
-})();
-
-
-(function TestMapForEachNoMoreElementsAfterTransition() {
- var map = new Map;
- map.set(0, 0);
-
- var buffer = [];
- map.forEach(function(v) {
- buffer.push(v);
- if (v === 0) {
- for (var i = 1; i < 16; i++) {
- map.set(i, i);
- }
- }
-
- if (v === 4) {
- for (var i = 5; i < 16; i++) {
- map.delete(i);
- }
- }
- });
-
- assertArrayEquals([0, 1, 2, 3, 4], buffer);
-})();
-
-
-(function TestSetConstructor() {
- var s = new Set(null);
- assertEquals(s.size, 0);
-
- s = new Set(undefined);
- assertEquals(s.size, 0);
-
***The diff for this file has been truncated for email.***
=======================================
---
/branches/bleeding_edge/test/mjsunit/harmony/debug-stepin-collections-foreach.js
Wed May 21 09:25:50 2014 UTC
+++ /dev/null
@@ -1,118 +0,0 @@
-// Copyright 2014 the V8 project authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-//
-// Flags: --expose-debug-as debug --harmony-collections
-
-Debug = debug.Debug
-
-var exception = false;
-
-function listener(event, exec_state, event_data, data) {
- try {
- if (event == Debug.DebugEvent.Break) {
- if (breaks == 0) {
- exec_state.prepareStep(Debug.StepAction.StepIn, 2);
- breaks = 1;
- } else if (breaks <= 3) {
- breaks++;
- // Check whether we break at the expected line.
- print(event_data.sourceLineText());
- assertTrue(event_data.sourceLineText().indexOf("Expected to step")
0);
- exec_state.prepareStep(Debug.StepAction.StepIn, 3);
- }
- }
- } catch (e) {
- exception = true;
- }
-}
-
-function cb_set(num) {
- print("element " + num); // Expected to step to this point.
- return true;
-}
-
-function cb_map(key, val) {
- print("key " + key + ", value " + val); // Expected to step to this
point.
- return true;
-}
-
-var s = new Set();
-s.add(1);
-s.add(2);
-s.add(3);
-s.add(4);
-
-var m = new Map();
-m.set('foo', 1);
-m.set('bar', 2);
-m.set('baz', 3);
-m.set('bat', 4);
-
-Debug.setListener(listener);
-
-var breaks = 0;
-debugger;
-s.forEach(cb_set);
-assertFalse(exception);
-assertEquals(4, breaks);
-
-breaks = 0;
-debugger;
-m.forEach(cb_map);
-assertFalse(exception);
-assertEquals(4, breaks);
-
-Debug.setListener(null);
-
-
-// Test two levels of builtin callbacks:
-// Array.forEach calls a callback function, which by itself uses
-// Array.forEach with another callback function.
-
-function second_level_listener(event, exec_state, event_data, data) {
- try {
- if (event == Debug.DebugEvent.Break) {
- if (breaks == 0) {
- exec_state.prepareStep(Debug.StepAction.StepIn, 3);
- breaks = 1;
- } else if (breaks <= 16) {
- breaks++;
- // Check whether we break at the expected line.
- assertTrue(event_data.sourceLineText().indexOf("Expected to step")
0);
- // Step two steps further every four breaks to skip the
- // forEach call in the first level of recurision.
- var step = (breaks % 4 == 1) ? 6 : 3;
- exec_state.prepareStep(Debug.StepAction.StepIn, step);
- }
- }
- } catch (e) {
- exception = true;
- }
-}
-
-function cb_set_foreach(num) {
- s.forEach(cb_set);
- print("back to the first level of recursion.");
-}
-
-function cb_map_foreach(key, val) {
- m.forEach(cb_set);
- print("back to the first level of recursion.");
-}
-
-Debug.setListener(second_level_listener);
-
-breaks = 0;
-debugger;
-s.forEach(cb_set_foreach);
-assertFalse(exception);
-assertEquals(17, breaks);
-
-breaks = 0;
-debugger;
-m.forEach(cb_map_foreach);
-assertFalse(exception);
-assertEquals(17, breaks);
-
-Debug.setListener(null);
=======================================
--- /branches/bleeding_edge/test/mjsunit/harmony/mirror-collections.js Wed
Jul 23 07:33:47 2014 UTC
+++ /dev/null
@@ -1,144 +0,0 @@
-// Copyright 2014 the V8 project authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-
-// Flags: --expose-debug-as debug --expose-gc --harmony-collections
-
-function testMapMirror(mirror) {
- // Create JSON representation.
- var serializer = debug.MakeMirrorSerializer();
- var json = JSON.stringify(serializer.serializeValue(mirror));
-
- // Check the mirror hierachy.
- assertTrue(mirror instanceof debug.Mirror);
- assertTrue(mirror instanceof debug.ValueMirror);
- assertTrue(mirror instanceof debug.ObjectMirror);
- assertTrue(mirror instanceof debug.MapMirror);
-
- assertTrue(mirror.isMap());
-
- // Parse JSON representation and check.
- var fromJSON = eval('(' + json + ')');
- assertEquals('map', fromJSON.type);
-}
-
-function testSetMirror(mirror) {
- // Create JSON representation.
- var serializer = debug.MakeMirrorSerializer();
- var json = JSON.stringify(serializer.serializeValue(mirror));
-
- // Check the mirror hierachy.
- assertTrue(mirror instanceof debug.Mirror);
- assertTrue(mirror instanceof debug.ValueMirror);
- assertTrue(mirror instanceof debug.ObjectMirror);
- assertTrue(mirror instanceof debug.SetMirror);
-
- assertTrue(mirror.isSet());
-
- // Parse JSON representation and check.
- var fromJSON = eval('(' + json + ')');
- assertEquals('set', fromJSON.type);
-}
-
-var o1 = new Object();
-var o2 = new Object();
-var o3 = new Object();
-
-// Test the mirror object for Maps
-var map = new Map();
-map.set(o1, 11);
-map.set(o2, 22);
-map.delete(o1);
-var mapMirror = debug.MakeMirror(map);
-testMapMirror(mapMirror);
-var entries = mapMirror.entries();
-assertEquals(1, entries.length);
-assertSame(o2, entries[0].key);
-assertEquals(22, entries[0].value);
-map.set(o1, 33);
-map.set(o3, o2);
-map.delete(o2);
-map.set(undefined, 44);
-entries = mapMirror.entries();
-assertEquals(3, entries.length);
-assertSame(o1, entries[0].key);
-assertEquals(33, entries[0].value);
-assertSame(o3, entries[1].key);
-assertSame(o2, entries[1].value);
-assertEquals(undefined, entries[2].key);
-assertEquals(44, entries[2].value);
-
-// Test the mirror object for Sets
-var set = new Set();
-set.add(o1);
-set.add(o2);
-set.delete(o1);
-set.add(undefined);
-var setMirror = debug.MakeMirror(set);
-testSetMirror(setMirror);
-var values = setMirror.values();
-assertEquals(2, values.length);
-assertSame(o2, values[0]);
-assertEquals(undefined, values[1]);
-
-// Test the mirror object for WeakMaps
-var weakMap = new WeakMap();
-weakMap.set(o1, 11);
-weakMap.set(new Object(), 22);
-weakMap.set(o3, 33);
-weakMap.set(new Object(), 44);
-var weakMapMirror = debug.MakeMirror(weakMap);
-testMapMirror(weakMapMirror);
-weakMap.set(new Object(), 55);
-assertTrue(weakMapMirror.entries().length <= 5);
-gc();
-
-function testWeakMapEntries(weakMapMirror) {
- var entries = weakMapMirror.entries();
- assertEquals(2, entries.length);
- var found = 0;
- for (var i = 0; i < entries.length; i++) {
- if (Object.is(entries[i].key, o1)) {
- assertEquals(11, entries[i].value);
- found++;
- }
- if (Object.is(entries[i].key, o3)) {
- assertEquals(33, entries[i].value);
- found++;
- }
- }
- assertEquals(2, found);
-}
-
-testWeakMapEntries(weakMapMirror);
-
-// Test the mirror object for WeakSets
-var weakSet = new WeakSet();
-weakSet.add(o1);
-weakSet.add(new Object());
-weakSet.add(o2);
-weakSet.add(new Object());
-weakSet.add(new Object());
-weakSet.add(o3);
-weakSet.delete(o2);
-var weakSetMirror = debug.MakeMirror(weakSet);
-testSetMirror(weakSetMirror);
-assertTrue(weakSetMirror.values().length <= 5);
-gc();
-
-function testWeakSetValues(weakSetMirror) {
- var values = weakSetMirror.values();
- assertEquals(2, values.length);
- var found = 0;
- for (var i = 0; i < values.length; i++) {
- if (Object.is(values[i], o1)) {
- found++;
- }
- if (Object.is(values[i], o3)) {
- found++;
- }
- }
- assertEquals(2, found);
-}
-
-testWeakSetValues(weakSetMirror);
=======================================
--- /branches/bleeding_edge/test/mjsunit/harmony/regress/regress-2186.js
Fri Feb 28 14:26:32 2014 UTC
+++ /dev/null
@@ -1,49 +0,0 @@
-// 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
-// with the distribution.
-// * Neither the name of Google Inc. nor the names of its
-// contributors may be used to endorse or promote products derived
-// from this software without specific prior written permission.
-//
-// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-// Flags: --harmony-collections
-
-function heapify(i) {
- return 2.0 * (i / 2);
-}
-heapify(1);
-
-var ONE = 1;
-var ANOTHER_ONE = heapify(ONE);
-assertSame(ONE, ANOTHER_ONE);
-assertEquals("number", typeof ONE);
-assertEquals("number", typeof ANOTHER_ONE);
-
-var set = new Set;
-set.add(ONE);
-assertTrue(set.has(ONE));
-assertTrue(set.has(ANOTHER_ONE));
-
-var map = new Map;
-map.set(ONE, 23);
-assertSame(23, map.get(ONE));
-assertSame(23, map.get(ANOTHER_ONE));
=======================================
--- /branches/bleeding_edge/BUILD.gn Tue Aug 5 09:32:55 2014 UTC
+++ /branches/bleeding_edge/BUILD.gn Tue Aug 5 19:37:32 2014 UTC
@@ -192,6 +192,7 @@
"src/v8natives.js",
"src/array.js",
"src/string.js",
+ "src/symbol.js",
"src/uri.js",
"src/math.js",
"src/messages.js",
@@ -204,6 +205,8 @@
"src/regexp.js",
"src/arraybuffer.js",
"src/typedarray.js",
+ "src/collection.js",
+ "src/collection-iterator.js",
"src/weak_collection.js",
"src/promise.js",
"src/object-observe.js",
@@ -244,10 +247,7 @@
sources = [
"src/macros.py",
- "src/symbol.js",
"src/proxy.js",
- "src/collection.js",
- "src/collection-iterator.js",
"src/generator.js",
"src/array-iterator.js",
"src/harmony-string.js",
=======================================
--- /branches/bleeding_edge/src/bootstrapper.cc Mon Aug 4 18:17:54 2014 UTC
+++ /branches/bleeding_edge/src/bootstrapper.cc Tue Aug 5 19:37:32 2014 UTC
@@ -1126,6 +1126,41 @@
Builtins::kIllegal);
native_context()->set_data_view_fun(*data_view_fun);
}
+
+ // -- M a p
+ InstallFunction(global, "Map", JS_MAP_TYPE, JSMap::kSize,
+ isolate->initial_object_prototype(), Builtins::kIllegal);
+
+ // -- S e t
+ InstallFunction(global, "Set", JS_SET_TYPE, JSSet::kSize,
+ isolate->initial_object_prototype(), Builtins::kIllegal);
+
+ { // Set up the iterator result object
+ STATIC_ASSERT(JSGeneratorObject::kResultPropertyCount == 2);
+ Handle<JSFunction>
object_function(native_context()->object_function());
+ DCHECK(object_function->initial_map()->inobject_properties() == 0);
+ Handle<Map> iterator_result_map =
+ Map::Create(object_function,
JSGeneratorObject::kResultPropertyCount);
+ DCHECK(iterator_result_map->inobject_properties() ==
+ JSGeneratorObject::kResultPropertyCount);
+ Map::EnsureDescriptorSlack(iterator_result_map,
+ JSGeneratorObject::kResultPropertyCount);
+
+ FieldDescriptor value_descr(factory->value_string(),
+
JSGeneratorObject::kResultValuePropertyIndex,
+ NONE, Representation::Tagged());
+ iterator_result_map->AppendDescriptor(&value_descr);
+
+ FieldDescriptor done_descr(factory->done_string(),
+ JSGeneratorObject::kResultDonePropertyIndex,
+ NONE, Representation::Tagged());
+ iterator_result_map->AppendDescriptor(&done_descr);
+
+ iterator_result_map->set_unused_property_fields(0);
+ DCHECK_EQ(JSGeneratorObject::kResultSize,
+ iterator_result_map->instance_size());
+ native_context()->set_iterator_result_map(*iterator_result_map);
+ }
// -- W e a k M a p
InstallFunction(global, "WeakMap", JS_WEAK_MAP_TYPE, JSWeakMap::kSize,
@@ -1311,40 +1346,9 @@
void Genesis::InitializeExperimentalGlobal() {
- Handle<JSObject> global =
Handle<JSObject>(native_context()->global_object());
-
// TODO(mstarzinger): Move this into Genesis::InitializeGlobal once we no
// longer need to live behind flags, so functions get added to the
snapshot.
- if (FLAG_harmony_collections) {
- // -- M a p
- InstallFunction(global, "Map", JS_MAP_TYPE, JSMap::kSize,
- isolate()->initial_object_prototype(),
Builtins::kIllegal);
- // -- S e t
- InstallFunction(global, "Set", JS_SET_TYPE, JSSet::kSize,
- isolate()->initial_object_prototype(),
Builtins::kIllegal);
- { // -- S e t I t e r a t o r
- Handle<JSObject> builtins(native_context()->builtins());
- Handle<JSFunction> set_iterator_function =
- InstallFunction(builtins, "SetIterator", JS_SET_ITERATOR_TYPE,
- JSSetIterator::kSize,
- isolate()->initial_object_prototype(),
- Builtins::kIllegal);
- native_context()->set_set_iterator_map(
- set_iterator_function->initial_map());
- }
- { // -- M a p I t e r a t o r
- Handle<JSObject> builtins(native_context()->builtins());
- Handle<JSFunction> map_iterator_function =
- InstallFunction(builtins, "MapIterator", JS_MAP_ITERATOR_TYPE,
- JSMapIterator::kSize,
- isolate()->initial_object_prototype(),
- Builtins::kIllegal);
- native_context()->set_map_iterator_map(
- map_iterator_function->initial_map());
- }
- }
-
if (FLAG_harmony_generators) {
// Create generator meta-objects and install them on the builtins
object.
Handle<JSObject> builtins(native_context()->builtins());
@@ -1406,38 +1410,6 @@
native_context()->set_generator_object_prototype_map(
*generator_object_prototype_map);
}
-
- if (FLAG_harmony_collections || FLAG_harmony_generators) {
- // Collection forEach uses an iterator result object.
- // Generators return iteraror result objects.
-
- STATIC_ASSERT(JSGeneratorObject::kResultPropertyCount == 2);
- Handle<JSFunction>
object_function(native_context()->object_function());
- DCHECK(object_function->initial_map()->inobject_properties() == 0);
- Handle<Map> iterator_result_map = Map::Create(
- object_function, JSGeneratorObject::kResultPropertyCount);
- DCHECK(iterator_result_map->inobject_properties() ==
- JSGeneratorObject::kResultPropertyCount);
- Map::EnsureDescriptorSlack(
- iterator_result_map, JSGeneratorObject::kResultPropertyCount);
-
- FieldDescriptor value_descr(isolate()->factory()->value_string(),
-
JSGeneratorObject::kResultValuePropertyIndex,
- NONE,
- Representation::Tagged());
- iterator_result_map->AppendDescriptor(&value_descr);
-
- FieldDescriptor done_descr(isolate()->factory()->done_string(),
- JSGeneratorObject::kResultDonePropertyIndex,
- NONE,
- Representation::Tagged());
- iterator_result_map->AppendDescriptor(&done_descr);
-
- iterator_result_map->set_unused_property_fields(0);
- DCHECK_EQ(JSGeneratorObject::kResultSize,
- iterator_result_map->instance_size());
- native_context()->set_iterator_result_map(*iterator_result_map);
- }
}
@@ -1924,6 +1896,22 @@
{
InstallInternalArray(builtins, "InternalPackedArray", FAST_ELEMENTS);
}
+
+ { // -- S e t I t e r a t o r
+ Handle<JSFunction> set_iterator_function = InstallFunction(
+ builtins, "SetIterator", JS_SET_ITERATOR_TYPE,
JSSetIterator::kSize,
+ isolate()->initial_object_prototype(), Builtins::kIllegal);
+ native_context()->set_set_iterator_map(
+ set_iterator_function->initial_map());
+ }
+
+ { // -- M a p I t e r a t o r
+ Handle<JSFunction> map_iterator_function = InstallFunction(
+ builtins, "MapIterator", JS_MAP_ITERATOR_TYPE,
JSMapIterator::kSize,
+ isolate()->initial_object_prototype(), Builtins::kIllegal);
+ native_context()->set_map_iterator_map(
+ map_iterator_function->initial_map());
+ }
if (FLAG_disable_native_files) {
PrintF("Warning: Running without installed natives!\n");
@@ -2069,8 +2057,6 @@
i < ExperimentalNatives::GetBuiltinsCount();
i++) {
INSTALL_EXPERIMENTAL_NATIVE(i, proxies, "proxy.js")
- INSTALL_EXPERIMENTAL_NATIVE(i, collections, "collection.js")
- INSTALL_EXPERIMENTAL_NATIVE(i, collections, "collection-iterator.js")
INSTALL_EXPERIMENTAL_NATIVE(i, generators, "generator.js")
INSTALL_EXPERIMENTAL_NATIVE(i, iteration, "array-iterator.js")
INSTALL_EXPERIMENTAL_NATIVE(i, iteration, "string-iterator.js")
=======================================
--- /branches/bleeding_edge/src/flag-definitions.h Tue Aug 5 17:06:01 2014
UTC
+++ /branches/bleeding_edge/src/flag-definitions.h Tue Aug 5 19:37:32 2014
UTC
@@ -154,8 +154,6 @@
DEFINE_BOOL(harmony_modules, false,
"enable harmony modules (implies block scoping)")
DEFINE_BOOL(harmony_proxies, false, "enable harmony proxies")
-DEFINE_BOOL(harmony_collections, false,
- "enable harmony collections (sets, maps)")
DEFINE_BOOL(harmony_generators, false, "enable harmony generators")
DEFINE_BOOL(harmony_iteration, false, "enable harmony iteration (for-of)")
DEFINE_BOOL(harmony_numeric_literals, false,
@@ -168,7 +166,6 @@
DEFINE_IMPLICATION(harmony, harmony_scoping)
DEFINE_IMPLICATION(harmony, harmony_modules)
DEFINE_IMPLICATION(harmony, harmony_proxies)
-DEFINE_IMPLICATION(harmony, harmony_collections)
DEFINE_IMPLICATION(harmony, harmony_generators)
DEFINE_IMPLICATION(harmony, harmony_numeric_literals)
DEFINE_IMPLICATION(harmony, harmony_strings)
@@ -177,7 +174,6 @@
DEFINE_IMPLICATION(harmony_modules, harmony_scoping)
DEFINE_IMPLICATION(harmony, es_staging)
-DEFINE_IMPLICATION(es_staging, harmony_collections)
DEFINE_IMPLICATION(es_staging, harmony_iteration)
// Flags for experimental implementation features.
=======================================
--- /branches/bleeding_edge/test/cctest/test-api.cc Mon Aug 4 18:17:54
2014 UTC
+++ /branches/bleeding_edge/test/cctest/test-api.cc Tue Aug 5 19:37:32
2014 UTC
@@ -21406,7 +21406,6 @@
THREADED_TEST(Regress2535) {
- i::FLAG_harmony_collections = true;
LocalContext context;
v8::HandleScope scope(context->GetIsolate());
Local<Value> set_value = CompileRun("new Set();");
=======================================
--- /branches/bleeding_edge/test/cctest/test-heap-profiler.cc Tue Aug 5
07:08:39 2014 UTC
+++ /branches/bleeding_edge/test/cctest/test-heap-profiler.cc Tue Aug 5
19:37:32 2014 UTC
@@ -494,8 +494,6 @@
TEST(HeapSnapshotWeakCollection) {
- i::FLAG_harmony_collections = true;
-
LocalContext env;
v8::HandleScope scope(env->GetIsolate());
v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
@@ -570,8 +568,6 @@
TEST(HeapSnapshotCollection) {
- i::FLAG_harmony_collections = true;
-
LocalContext env;
v8::HandleScope scope(env->GetIsolate());
v8::HeapProfiler* heap_profiler = env->GetIsolate()->GetHeapProfiler();
=======================================
--- /branches/bleeding_edge/test/cctest/test-heap.cc Tue Aug 5 07:29:13
2014 UTC
+++ /branches/bleeding_edge/test/cctest/test-heap.cc Tue Aug 5 19:37:32
2014 UTC
@@ -3001,7 +3001,8 @@
// Triggering one GC will cause a lot of garbage to be discovered but
// even spread across all allocated pages.
- heap->CollectAllGarbage(Heap::kNoGCFlags, "triggered for preparation");
+ heap->CollectAllGarbage(Heap::kAbortIncrementalMarkingMask,
+ "triggered for preparation");
CHECK_GE(number_of_test_pages + 1, old_pointer_space->CountTotalPages());
// Triggering subsequent GCs should cause at least half of the pages
=======================================
--- /branches/bleeding_edge/test/cctest/test-ordered-hash-table.cc Tue Jun
3 08:12:43 2014 UTC
+++ /branches/bleeding_edge/test/cctest/test-ordered-hash-table.cc Tue Aug
5 19:37:32 2014 UTC
@@ -38,8 +38,6 @@
TEST(Set) {
- i::FLAG_harmony_collections = true;
-
LocalContext context;
Isolate* isolate = CcTest::i_isolate();
Factory* factory = isolate->factory();
@@ -105,8 +103,6 @@
TEST(Map) {
- i::FLAG_harmony_collections = true;
-
LocalContext context;
Isolate* isolate = CcTest::i_isolate();
Factory* factory = isolate->factory();
=======================================
--- /branches/bleeding_edge/test/mjsunit/builtins.js Thu Apr 11 16:28:19
2013 UTC
+++ /branches/bleeding_edge/test/mjsunit/builtins.js Tue Aug 5 19:37:32
2014 UTC
@@ -37,6 +37,12 @@
function isFunction(obj) {
return typeof obj == "function";
}
+
+function isV8Native(name) {
+ return name == "GeneratorFunctionPrototype" ||
+ name == "SetIterator" ||
+ name == "MapIterator";
+}
function checkConstructor(func, name) {
// A constructor is a function with a prototype and properties on the
@@ -54,12 +60,13 @@
assertFalse(proto_desc.writable, name);
assertFalse(proto_desc.configurable, name);
var prototype = proto_desc.value;
- assertEquals(name == "GeneratorFunctionPrototype" ? Object.prototype :
null,
+ assertEquals(isV8Native(name) ? Object.prototype : null,
Object.getPrototypeOf(prototype),
name);
for (var i = 0; i < propNames.length; i++) {
var propName = propNames[i];
if (propName == "constructor") continue;
+ if (isV8Native(name)) continue;
var testName = name + "-" + propName;
var propDesc = Object.getOwnPropertyDescriptor(prototype, propName);
assertTrue(propDesc.hasOwnProperty("value"), testName);
=======================================
--- /branches/bleeding_edge/test/mjsunit/debug-script.js Mon Aug 4
19:17:21 2014 UTC
+++ /branches/bleeding_edge/test/mjsunit/debug-script.js Tue Aug 5
19:37:32 2014 UTC
@@ -59,7 +59,7 @@
}
// This has to be updated if the number of native scripts change.
-assertTrue(named_native_count == 20 || named_native_count == 21);
+assertTrue(named_native_count == 22 || named_native_count == 23);
// Only the 'gc' extension is loaded.
assertEquals(1, extension_count);
// This script and mjsunit.js has been loaded. If using d8, d8 loads
=======================================
--- /branches/bleeding_edge/test/mjsunit/es6/symbols.js Mon Aug 4 18:17:54
2014 UTC
+++ /branches/bleeding_edge/test/mjsunit/es6/symbols.js Tue Aug 5 19:37:32
2014 UTC
@@ -25,7 +25,6 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// Flags: --harmony-collections
// Flags: --expose-gc --allow-natives-syntax
var symbols = []
=======================================
--- /branches/bleeding_edge/test/mjsunit/es7/object-observe.js Mon Aug 4
18:17:54 2014 UTC
+++ /branches/bleeding_edge/test/mjsunit/es7/object-observe.js Tue Aug 5
19:37:32 2014 UTC
@@ -25,7 +25,7 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// Flags: --harmony-proxies --harmony-collections
+// Flags: --harmony-proxies
// Flags: --allow-natives-syntax
var allObservers = [];
=======================================
--- /branches/bleeding_edge/test/mjsunit/harmony/private.js Mon Aug 4
18:17:54 2014 UTC
+++ /branches/bleeding_edge/test/mjsunit/harmony/private.js Tue Aug 5
19:37:32 2014 UTC
@@ -25,7 +25,6 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// Flags: --harmony-collections
// Flags: --expose-gc --allow-natives-syntax
var symbols = []
=======================================
--- /branches/bleeding_edge/test/mjsunit/harmony/proxies-hash.js Tue May 6
14:48:34 2014 UTC
+++ /branches/bleeding_edge/test/mjsunit/harmony/proxies-hash.js Tue Aug 5
19:37:32 2014 UTC
@@ -25,7 +25,7 @@
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-// Flags: --harmony-proxies --harmony-collections
+// Flags: --harmony-proxies
// Helper.
=======================================
--- /branches/bleeding_edge/test/mjsunit/regress/regress-3281.js Tue Jun 3
00:34:01 2014 UTC
+++ /branches/bleeding_edge/test/mjsunit/regress/regress-3281.js Tue Aug 5
19:37:32 2014 UTC
@@ -2,7 +2,7 @@
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
-// Flags: --harmony-collections --expose-natives-as=builtins
+// Flags: --expose-natives-as=builtins
// Should not crash or raise an exception.
var s = new Set();
=======================================
--- /branches/bleeding_edge/tools/gyp/v8.gyp Tue Aug 5 09:32:55 2014 UTC
+++ /branches/bleeding_edge/tools/gyp/v8.gyp Tue Aug 5 19:37:32 2014 UTC
@@ -1435,13 +1435,13 @@
'../../src/promise.js',
'../../src/object-observe.js',
'../../src/symbol.js',
+ '../../src/collection.js',
+ '../../src/collection-iterator.js',
'../../src/macros.py',
],
'experimental_library_files': [
'../../src/macros.py',
'../../src/proxy.js',
- '../../src/collection.js',
- '../../src/collection-iterator.js',
'../../src/generator.js',
'../../src/array-iterator.js',
'../../src/string-iterator.js',
--
--
v8-dev mailing list
[email protected]
http://groups.google.com/group/v8-dev
---
You received this message because you are subscribed to the Google Groups "v8-dev" group.
To unsubscribe from this group and stop receiving emails from it, send an email
to [email protected].
For more options, visit https://groups.google.com/d/optout.
