diff --git a/test/built-ins/Map/constructor.js b/test/built-ins/Map/constructor.js
new file mode 100644
index 0000000000000000000000000000000000000000..18194c10fe2938b28a0cfe6a5ac035d56a77f8da
--- /dev/null
+++ b/test/built-ins/Map/constructor.js
@@ -0,0 +1,10 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.1
+description: >
+ The Map constructor is the %Map% intrinsic object and the initial value of the
+ Map property of the global object.
+---*/
+
+assert.sameValue(typeof Map, 'function', 'typeof Map is "function"');
diff --git a/test/built-ins/Map/does-not-throw-when-set-is-not-callable.js b/test/built-ins/Map/does-not-throw-when-set-is-not-callable.js
new file mode 100644
index 0000000000000000000000000000000000000000..aedeff14ae4fc706c4278a7f7d42b4069811dae7
--- /dev/null
+++ b/test/built-ins/Map/does-not-throw-when-set-is-not-callable.js
@@ -0,0 +1,29 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.1.1
+description: >
+ Creating a new Map object without arguments doesn't throw if `set` is not
+ callable
+info: >
+ Map ( [ iterable ] )
+
+ When the Set function is called with optional argument iterable the following steps are taken:
+
+ ...
+ 5. If iterable is not present, let iterable be undefined.
+ 6. If iterable is either undefined or null, let iter be undefined.
+ 7. Else,
+ a. Let adder be Get(map, "set").
+ b. ReturnIfAbrupt(adder).
+ c. If IsCallable(adder) is false, throw a TypeError exception.
+ ...
+ 8. If iter is undefined, return map.
+ ...
+---*/
+
+Map.prototype.set = null;
+
+var m = new Map();
+
+assert.sameValue(m.size, 0, 'The value of `m.size` is `0`');
diff --git a/test/built-ins/Map/get-set-method-failure.js b/test/built-ins/Map/get-set-method-failure.js
new file mode 100644
index 0000000000000000000000000000000000000000..e6cf4f27d2f1b27ab476b4884bac279522b1abdb
--- /dev/null
+++ b/test/built-ins/Map/get-set-method-failure.js
@@ -0,0 +1,26 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.1.1
+description: >
+ new Map returns abrupt from getting Map.prototype.set.
+description: >
+ Map ( [ iterable ] )
+
+ ...
+ 7. Else,
+ a. Let adder be Get(map, "add").
+ b. ReturnIfAbrupt(adder).
+---*/
+
+Object.defineProperty(Map.prototype, 'set', {
+ get: function() {
+ throw new Test262Error();
+ }
+});
+
+new Map();
+
+assert.throws(Test262Error, function() {
+ new Map([]);
+});
diff --git a/test/built-ins/Map/iterable-calls-set.js b/test/built-ins/Map/iterable-calls-set.js
new file mode 100644
index 0000000000000000000000000000000000000000..c8599da200765a82c55193638ff06916746d8202
--- /dev/null
+++ b/test/built-ins/Map/iterable-calls-set.js
@@ -0,0 +1,39 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.1.1
+description: >
+ new Map calls `set` for each item on the iterable argument in order.
+info: >
+ Map ( [ iterable ] )
+
+ ...
+ 9. Repeat
+ ...
+ k. Let status be Call(adder, map, «k.[[value]], v.[[value]]»).
+ ...
+includes: [compareArray.js]
+---*/
+
+var mapSet = Map.prototype.set;
+var counter = 0;
+
+var iterable = [["foo", 1], ["bar", 2]];
+var results = [];
+var _this = [];
+
+Map.prototype.set = function(k, v) {
+ counter++;
+ results.push([k, v]);
+ _this.push(this);
+ mapSet.call(this, k, v);
+};
+
+var map = new Map(iterable);
+
+assert.sameValue(counter, 2, "`Map.prototype.set` called twice.");
+
+assert(compareArray(results[0], iterable[0]));
+assert(compareArray(results[1], iterable[1]));
+assert.sameValue(_this[0], map);
+assert.sameValue(_this[1], map);
diff --git a/test/built-ins/Map/iterator-close-after-set-failure.js b/test/built-ins/Map/iterator-close-after-set-failure.js
new file mode 100644
index 0000000000000000000000000000000000000000..9aff61eaef8bf921c5ca4e1462762f3557152eba
--- /dev/null
+++ b/test/built-ins/Map/iterator-close-after-set-failure.js
@@ -0,0 +1,36 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.1.1
+description: >
+ The iterator is closed when `Map.prototype.set` throws an error.
+info: >
+ Map ( [ iterable ] )
+
+ ...
+ 9. Repeat
+ ...
+ k. Let status be Call(adder, map, «k.[[value]], v.[[value]]»).
+ l. If status is an abrupt completion, return IteratorClose(iter, status).
+features: [Symbol.iterator]
+---*/
+
+var count = 0;
+var iterable = {};
+iterable[Symbol.iterator] = function() {
+ return {
+ next: function() {
+ return { value: [], done: false };
+ },
+ return: function() {
+ count += 1;
+ }
+ };
+};
+Map.prototype.set = function() { throw new Test262Error(); }
+
+assert.throws(Test262Error, function() {
+ new Map(iterable);
+});
+
+assert.sameValue(count, 1);
diff --git a/test/built-ins/Map/iterator-item-first-entry-returns-abrupt.js b/test/built-ins/Map/iterator-item-first-entry-returns-abrupt.js
new file mode 100644
index 0000000000000000000000000000000000000000..dd899318e5e8ad13150bcd526cbd9aa657b63503
--- /dev/null
+++ b/test/built-ins/Map/iterator-item-first-entry-returns-abrupt.js
@@ -0,0 +1,47 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.1.1
+description: >
+ Closes iterator if item first entry completes abruptly.
+info: >
+ Map ( [ iterable ] )
+
+ ...
+ 9. Repeat
+ ...
+ d. Let nextItem be IteratorValue(next).
+ ...
+ g. Let k be Get(nextItem, "0").
+ h. If k is an abrupt completion, return IteratorClose(iter, k).
+ ...
+features: [Symbol.iterator]
+---*/
+
+var count = 0;
+var item = ['foo', 'bar'];
+Object.defineProperty(item, 0, {
+ get: function() {
+ throw new Test262Error();
+ }
+});
+var iterable = {};
+iterable[Symbol.iterator] = function() {
+ return {
+ next: function() {
+ return {
+ value: item,
+ done: false
+ };
+ },
+ return: function() {
+ count++;
+ }
+ };
+};
+
+assert.throws(Test262Error, function() {
+ new Map(iterable);
+});
+
+assert.sameValue(count, 1, 'The get error closed the iterator');
diff --git a/test/built-ins/Map/iterator-item-second-entry-returns-abrupt.js b/test/built-ins/Map/iterator-item-second-entry-returns-abrupt.js
new file mode 100644
index 0000000000000000000000000000000000000000..e6ea6e46409d8057b142781b97bbe52e524a7484
--- /dev/null
+++ b/test/built-ins/Map/iterator-item-second-entry-returns-abrupt.js
@@ -0,0 +1,47 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.1.1
+description: >
+ Closes iterator if item second entry completes abruptly.
+info: >
+ Map ( [ iterable ] )
+
+ ...
+ 9. Repeat
+ ...
+ d. Let nextItem be IteratorValue(next).
+ ...
+ i. Let v be Get(nextItem, "1").
+ j. If v is an abrupt completion, return IteratorClose(iter, v).
+ ...
+features: [Symbol.iterator]
+---*/
+
+var count = 0;
+var item = ['foo', 'bar'];
+Object.defineProperty(item, 1, {
+ get: function() {
+ throw new Test262Error();
+ }
+});
+var iterable = {};
+iterable[Symbol.iterator] = function() {
+ return {
+ next: function() {
+ return {
+ value: item,
+ done: false
+ };
+ },
+ return: function() {
+ count++;
+ }
+ };
+};
+
+assert.throws(Test262Error, function() {
+ new Map(iterable);
+});
+
+assert.sameValue(count, 1, 'The get error closed the iterator');
diff --git a/test/built-ins/Map/iterator-items-are-not-object-close-iterator.js b/test/built-ins/Map/iterator-items-are-not-object-close-iterator.js
new file mode 100644
index 0000000000000000000000000000000000000000..6b8d2ad3697b1cbb35af4abab916abae72e54f9e
--- /dev/null
+++ b/test/built-ins/Map/iterator-items-are-not-object-close-iterator.js
@@ -0,0 +1,72 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.1.1
+description: >
+ Closes the iterator after `not Object` error.
+info: >
+ Map ( [ iterable ] )
+
+ ...
+ 9. Repeat
+ ...
+ d. Let nextItem be IteratorValue(next).
+ e. ReturnIfAbrupt(nextItem).
+ f. If Type(nextItem) is not Object,
+ i. Let error be Completion{[[type]]: throw, [[value]]: a newly created
+ TypeError object, [[target]]:empty}.
+ ii. Return IteratorClose(iter, error).
+features:
+ - Symbol
+ - Symbol.iterator
+---*/
+
+var count = 0;
+var nextItem;
+var iterable = {};
+iterable[Symbol.iterator] = function() {
+ return {
+ next: function() {
+ return { value: nextItem, done: false };
+ },
+ return: function() {
+ count += 1;
+ }
+ };
+};
+
+nextItem = 1;
+assert.throws(TypeError, function() {
+ new Map(iterable);
+});
+assert.sameValue(count, 1);
+
+nextItem = true;
+assert.throws(TypeError, function() {
+ new Map(iterable);
+});
+assert.sameValue(count, 2);
+
+nextItem = '';
+assert.throws(TypeError, function() {
+ new Map(iterable);
+});
+assert.sameValue(count, 3);
+
+nextItem = null;
+assert.throws(TypeError, function() {
+ new Map(iterable);
+});
+assert.sameValue(count, 4);
+
+nextItem = undefined;
+assert.throws(TypeError, function() {
+ new Map(iterable);
+});
+assert.sameValue(count, 5);
+
+nextItem = Symbol('a');
+assert.throws(TypeError, function() {
+ new Map(iterable);
+});
+assert.sameValue(count, 6);
diff --git a/test/built-ins/Map/iterator-items-are-not-object.js b/test/built-ins/Map/iterator-items-are-not-object.js
new file mode 100644
index 0000000000000000000000000000000000000000..edbed018577ac0732c586ab369495c8647226a2d
--- /dev/null
+++ b/test/built-ins/Map/iterator-items-are-not-object.js
@@ -0,0 +1,48 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.1.1
+description: >
+ Throws a TypeError if iterable itens are not Objects.
+info: >
+ Map ( [ iterable ] )
+
+ ...
+ 9. Repeat
+ ...
+ d. Let nextItem be IteratorValue(next).
+ e. ReturnIfAbrupt(nextItem).
+ f. If Type(nextItem) is not Object,
+ i. Let error be Completion{[[type]]: throw, [[value]]: a newly created
+ TypeError object, [[target]]:empty}.
+ ii. Return IteratorClose(iter, error).
+features: [Symbol]
+---*/
+
+assert.throws(TypeError, function() {
+ new Map([1]);
+});
+
+assert.throws(TypeError, function() {
+ new Map(['']);
+});
+
+assert.throws(TypeError, function() {
+ new Map([true]);
+});
+
+assert.throws(TypeError, function() {
+ new Map([null]);
+});
+
+assert.throws(TypeError, function() {
+ new Map([Symbol('a')]);
+});
+
+assert.throws(TypeError, function() {
+ new Map([undefined]);
+});
+
+assert.throws(TypeError, function() {
+ new Map([['a', 1], 2]);
+});
diff --git a/test/built-ins/Map/iterator-next-failure.js b/test/built-ins/Map/iterator-next-failure.js
new file mode 100644
index 0000000000000000000000000000000000000000..3ce7c8b4f7ede84303f73468133a10a6cca3d5a5
--- /dev/null
+++ b/test/built-ins/Map/iterator-next-failure.js
@@ -0,0 +1,28 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.1.1
+description: >
+ The iterator is closed when iterable `next` throws an error.
+info: >
+ Map ( [ iterable ] )
+
+ ...
+ 9. Repeat
+ a. Let next be IteratorStep(iter).
+ b. ReturnIfAbrupt(next).
+features: [Symbol.iterator]
+---*/
+
+var iterable = {};
+iterable[Symbol.iterator] = function() {
+ return {
+ next: function() {
+ throw new Test262Error();
+ }
+ };
+};
+
+assert.throws(Test262Error, function() {
+ new Map(iterable);
+});
diff --git a/test/built-ins/Map/iterator-value-failure.js b/test/built-ins/Map/iterator-value-failure.js
new file mode 100644
index 0000000000000000000000000000000000000000..880dc9d89e7821ce036362c447944416a2beddb7
--- /dev/null
+++ b/test/built-ins/Map/iterator-value-failure.js
@@ -0,0 +1,34 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.1.1
+description: >
+ The iterator is closed when iterable `next` value throws an error.
+info: >
+ Map ( [ iterable ] )
+
+ ...
+ 9. Repeat
+ ...
+ d. Let nextItem be IteratorValue(next).
+ e. ReturnIfAbrupt(nextItem).
+features: [Symbol.iterator]
+---*/
+
+var iterable = {};
+iterable[Symbol.iterator] = function() {
+ return {
+ next: function() {
+ return {
+ get value() {
+ throw new Test262Error();
+ },
+ done: false
+ };
+ }
+ };
+};
+
+assert.throws(Test262Error, function() {
+ new Map(iterable);
+});
diff --git a/test/built-ins/Map/length.js b/test/built-ins/Map/length.js
new file mode 100644
index 0000000000000000000000000000000000000000..031cfcbcd0fc958d73a600561326e1cb9a1153d0
--- /dev/null
+++ b/test/built-ins/Map/length.js
@@ -0,0 +1,17 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.2
+description: Map.length is 0.
+info: >
+ Properties of the Map Constructor
+
+ Besides the length property (whose value is 0)
+includes: [propertyHelper.js]
+---*/
+
+assert.sameValue(Map.length, 0, 'The value of Map.length is 0');
+
+verifyNotEnumerable(Map, 'length');
+verifyNotWritable(Map, 'length');
+verifyConfigurable(Map, 'length');
diff --git a/test/built-ins/Map/map-iterable-empty-does-not-call-set.js b/test/built-ins/Map/map-iterable-empty-does-not-call-set.js
new file mode 100644
index 0000000000000000000000000000000000000000..230de090737a2beb02a67f49d5668f19550aff28
--- /dev/null
+++ b/test/built-ins/Map/map-iterable-empty-does-not-call-set.js
@@ -0,0 +1,31 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.1.1
+description: >
+ A Map constructed with an empty iterable argument does not call set.
+info: >
+ Map ( [ iterable ] )
+
+ When the Map function is called with optional argument the following steps are
+ taken:
+
+ ...
+ 8. If iter is undefined, return map.
+ 9. Repeat
+ a. Let next be IteratorStep(iter).
+ b. ReturnIfAbrupt(next).
+ c. If next is false, return map.
+---*/
+
+var set = Map.prototype.set;
+var counter = 0;
+
+Map.prototype.set = function(value) {
+ counter++;
+ set.call(this, value);
+};
+
+new Map([]);
+
+assert.sameValue(counter, 0, '`Map.prototype.set` was not called.');
diff --git a/test/built-ins/Map/map-iterable-throws-when-set-is-not-callable.js b/test/built-ins/Map/map-iterable-throws-when-set-is-not-callable.js
new file mode 100644
index 0000000000000000000000000000000000000000..e7e62e41f246d79773a1152b428cdc36ca48eb42
--- /dev/null
+++ b/test/built-ins/Map/map-iterable-throws-when-set-is-not-callable.js
@@ -0,0 +1,27 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.1.1
+description: >
+ Throws a TypeError if `set` is not callable on Map constructor with a
+ iterable argument.
+info: >
+ Map ( [ iterable ] )
+
+ When the Map function is called with optional argument the following steps are
+ taken:
+
+ ...
+ 5. If iterable is not present, let iterable be undefined.
+ 6. If iterable is either undefined or null, let iter be undefined.
+ 7. Else,
+ a. Let adder be Get(map, "set").
+ b. ReturnIfAbrupt(adder).
+ c. If IsCallable(adder) is false, throw a TypeError exception.
+---*/
+
+Map.prototype.set = null;
+
+assert.throws(TypeError, function() {
+ new Map([[1,1], [2,2]]);
+});
diff --git a/test/built-ins/Map/map-iterable.js b/test/built-ins/Map/map-iterable.js
new file mode 100644
index 0000000000000000000000000000000000000000..125929d30de2ec38ab2c57d88c90f0f58bf5794b
--- /dev/null
+++ b/test/built-ins/Map/map-iterable.js
@@ -0,0 +1,26 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.1.1
+description: >
+ Contructor returns a map object set with the elements from the iterable
+ argument.
+info: >
+ Map ( [ iterable ] )
+
+ ...
+ 9. Repeat
+ a. Let next be IteratorStep(iter).
+ b. ReturnIfAbrupt(next).
+ c. If next is false, return map.
+ ...
+---*/
+
+var m = new Map([
+ [ "attr", 1 ],
+ [ "foo", 2 ]
+]);
+
+assert.sameValue(m.size, 2, 'The value of `m.size` is `2`');
+assert.sameValue(m.get("attr"), 1);
+assert.sameValue(m.get("foo"), 2);
diff --git a/test/built-ins/Map/map-no-iterable-does-not-call-set.js b/test/built-ins/Map/map-no-iterable-does-not-call-set.js
new file mode 100644
index 0000000000000000000000000000000000000000..aac53a6156658744858887b93b0b473c1dbc51ae
--- /dev/null
+++ b/test/built-ins/Map/map-no-iterable-does-not-call-set.js
@@ -0,0 +1,35 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.1.1
+description: >
+ A Map constructed without a iterable argument does not call set.
+info: >
+ Map ( [ iterable ] )
+
+ When the Map function is called with optional argument the following steps are
+ taken:
+
+ ...
+ 5. If iterable is not present, let iterable be undefined.
+ 6. If iterable is either undefined or null, let iter be undefined.
+ 7. Else,
+ a. Let adder be Get(map, "set").
+ b. ReturnIfAbrupt(adder).
+ c. If IsCallable(adder) is false, throw a TypeError exception.
+ d. Let iter be GetIterator(iterable).
+ e. ReturnIfAbrupt(iter).
+ 8. If iter is undefined, return map.
+---*/
+
+var set = Map.prototype.set;
+var counter = 0;
+
+Map.prototype.set = function(value) {
+ counter++;
+ set.call(this, value);
+};
+
+new Map();
+
+assert.sameValue(counter, 0, '`Map.prototype.set` was not called.');
diff --git a/test/built-ins/Map/map-no-iterable.js b/test/built-ins/Map/map-no-iterable.js
new file mode 100644
index 0000000000000000000000000000000000000000..f01fcdc05b3a25fe7196a73f83f3ffc2aeba04de
--- /dev/null
+++ b/test/built-ins/Map/map-no-iterable.js
@@ -0,0 +1,32 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.1.1
+description: >
+ Returns the new Map object with the new empty list if the iterable argument is
+ undefined.
+info: >
+ Map ( [ iterable ] )
+
+ ...
+ 2. Let map be OrdinaryCreateFromConstructor(NewTarget, "%MapPrototype%",
+ «â€[[MapData]]» ).
+ ...
+ 4. Map map’s [[MapData]] internal slot to a new empty List.
+ 5. If iterable is not present, let iterable be undefined.
+ 6. If iterable is either undefined or null, let iter be undefined.
+ ...
+ 8. If iter is undefined, return map.
+---*/
+
+var m1 = new Map();
+var m2 = new Map(undefined);
+var m3 = new Map(null);
+
+assert.sameValue(m1.size, 0, 'The value of `new Map().size` is `0`');
+assert.sameValue(m2.size, 0, 'The value of `new Map(undefined).size` is `0`');
+assert.sameValue(m3.size, 0, 'The value of `new Map(null).size` is `0`');
+
+assert(m1 instanceof Map);
+assert(m2 instanceof Map);
+assert(m3 instanceof Map);
diff --git a/test/built-ins/Map/map.js b/test/built-ins/Map/map.js
new file mode 100644
index 0000000000000000000000000000000000000000..1e416c174ce35a36ed1abf38764e1eaf3ed1a4f7
--- /dev/null
+++ b/test/built-ins/Map/map.js
@@ -0,0 +1,17 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.1.1
+description: >
+ Map descriptor as a standard built-in object.
+info: >
+ Map ( [ iterable ] )
+
+ 17 ECMAScript Standard Built-in Objects
+
+includes: [propertyHelper.js]
+---*/
+
+verifyNotEnumerable(this, 'Map');
+verifyWritable(this, 'Map');
+verifyConfigurable(this, 'Map');
diff --git a/test/built-ins/Map/name.js b/test/built-ins/Map/name.js
new file mode 100644
index 0000000000000000000000000000000000000000..ccab8736d154a99f24b0bfeb2b20624f517a0fdc
--- /dev/null
+++ b/test/built-ins/Map/name.js
@@ -0,0 +1,18 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.1.1
+description: Map.name value and descriptor.
+info: >
+ Map ( [ iterable ] )
+
+ 17 ECMAScript Standard Built-in Objects
+
+includes: [propertyHelper.js]
+---*/
+
+assert.sameValue(Map.name, 'Map', 'The value of Map.name is "Map"');
+
+verifyNotEnumerable(Map, 'name');
+verifyNotWritable(Map, 'name');
+verifyConfigurable(Map, 'name');
diff --git a/test/built-ins/Map/newtarget.js b/test/built-ins/Map/newtarget.js
new file mode 100644
index 0000000000000000000000000000000000000000..271b10851fe48be6c94514f0acf0d72860691253
--- /dev/null
+++ b/test/built-ins/Map/newtarget.js
@@ -0,0 +1,34 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.1.1
+description: >
+ The new Map object's prototype is Map.prototype
+info: >
+ Map ( [ iterable ] )
+
+ When the Map function is called with optional argument the following steps
+ are taken:
+
+ ...
+ 2. Let map be OrdinaryCreateFromConstructor(NewTarget, "%MapPrototype%",
+ «â€[[MapData]]» ).
+ ...
+
+---*/
+
+var m1 = new Map();
+
+assert.sameValue(
+ Object.getPrototypeOf(m1),
+ Map.prototype,
+ "`Object.getPrototypeOf(m1)` returns `Map.prototype`"
+);
+
+var m2 = new Map([[1, 1], [2, 2]]);
+
+assert.sameValue(
+ Object.getPrototypeOf(m2),
+ Map.prototype,
+ "`Object.getPrototypeOf(m2)` returns `Map.prototype`"
+);
diff --git a/test/built-ins/Map/properties-of-map-instances.js b/test/built-ins/Map/properties-of-map-instances.js
new file mode 100644
index 0000000000000000000000000000000000000000..7930e1538f9cb33de7fc1cdc100ccd5c3b557a35
--- /dev/null
+++ b/test/built-ins/Map/properties-of-map-instances.js
@@ -0,0 +1,14 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.4
+description: >
+ Map instances are ordinary objects that inherit properties from the Map
+ prototype.
+---*/
+
+assert.sameValue(
+ Object.getPrototypeOf(new Map()),
+ Map.prototype,
+ '`Object.getPrototypeOf(new Map())` returns `Map.prototype`'
+);
diff --git a/test/built-ins/Map/properties-of-the-map-prototype-object.js b/test/built-ins/Map/properties-of-the-map-prototype-object.js
new file mode 100644
index 0000000000000000000000000000000000000000..4fdc17aa8b69a29aba0344044050cb228461dee4
--- /dev/null
+++ b/test/built-ins/Map/properties-of-the-map-prototype-object.js
@@ -0,0 +1,18 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3
+description: >
+ The prototype of Map.prototype is Object.prototype.
+info: >
+ The Map prototype object is the intrinsic object %MapPrototype%. The value
+ of the [[Prototype]] internal slot of the Map prototype object is the
+ intrinsic object %ObjectPrototype% (19.1.3). The Map prototype object is an
+ ordinary object. It does not have a [[MapData]] internal slot.
+---*/
+
+assert.sameValue(
+ Object.getPrototypeOf(Map.prototype),
+ Object.prototype,
+ 'Object.getPrototypeOf(Map.prototype) returns Object.prototype'
+);
diff --git a/test/built-ins/Map/prototype-of-map.js b/test/built-ins/Map/prototype-of-map.js
new file mode 100644
index 0000000000000000000000000000000000000000..07e21a9b1a2818493084aaf1b367658a0af0f346
--- /dev/null
+++ b/test/built-ins/Map/prototype-of-map.js
@@ -0,0 +1,16 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.2
+description: >
+ The prototype of Map is the intrinsic FunctionPrototype.
+info: >
+ The value of the [[Prototype]] internal slot of the Map constructor is the
+ intrinsic object %FunctionPrototype% (19.2.3).
+---*/
+
+assert.sameValue(
+ Object.getPrototypeOf(Map),
+ Function.prototype,
+ '`Object.getPrototypeOf(Map)` returns `Function.prototype`'
+);
diff --git a/test/built-ins/Map/prototype/Symbol.iterator.js b/test/built-ins/Map/prototype/Symbol.iterator.js
index 3c6a1d6e6504f527de38e957294d246983df0800..25de1616f39b33188019d0f4b982ffb6a851dac3 100644
--- a/test/built-ins/Map/prototype/Symbol.iterator.js
+++ b/test/built-ins/Map/prototype/Symbol.iterator.js
@@ -1,19 +1,19 @@
// Copyright (C) 2014 the V8 project authors. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
-
/*---
+es6id: 23.1.3.12
description: Initial state of the Symbol.iterator property
info: >
- The initial value of the @@iterator property is the same function object as
- the initial value of the entries property.
+ The initial value of the @@iterator property is the same function object as
+ the initial value of the entries property.
- Per ES6 section 17, the method should exist on the Array prototype, and it
- should be writable and configurable, but not enumerable.
+ Per ES6 section 17, the method should exist on the Array prototype, and it
+ should be writable and configurable, but not enumerable.
includes: [propertyHelper.js]
features: [Symbol.iterator]
-es6id: 23.1.3.12
---*/
+assert.sameValue(Map.prototype[Symbol.iterator], Map.prototype.entries);
verifyNotEnumerable(Map.prototype, Symbol.iterator);
verifyWritable(Map.prototype, Symbol.iterator);
verifyConfigurable(Map.prototype, Symbol.iterator);
diff --git a/test/built-ins/Map/prototype/Symbol.toStringTag/property-descriptor.js b/test/built-ins/Map/prototype/Symbol.toStringTag/property-descriptor.js
new file mode 100644
index 0000000000000000000000000000000000000000..efc2514cf993bd5b610ee429292d9ff7dbcb4798
--- /dev/null
+++ b/test/built-ins/Map/prototype/Symbol.toStringTag/property-descriptor.js
@@ -0,0 +1,21 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.13
+description: >
+ Map.prototype[ @@toStringTag ] value and descriptor.
+includes: [propertyHelper.js]
+features: [Symbol.toStringTag]
+ ---*/
+
+var MapProto = Object.getPrototypeOf(new Map());
+
+assert.sameValue(
+ MapProto[Symbol.toStringTag],
+ 'Map',
+ 'The value of MapProto[Symbol.toStringTag] is Map'
+);
+
+verifyNotEnumerable(MapProto, Symbol.toStringTag);
+verifyNotWritable(MapProto, Symbol.toStringTag);
+verifyConfigurable(MapProto, Symbol.toStringTag);
diff --git a/test/built-ins/Map/prototype/clear/clear-map.js b/test/built-ins/Map/prototype/clear/clear-map.js
new file mode 100644
index 0000000000000000000000000000000000000000..90b73444731948ffa5e75c4aff2eeb5e85cdee02
--- /dev/null
+++ b/test/built-ins/Map/prototype/clear/clear-map.js
@@ -0,0 +1,33 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.1
+description: >
+ Clears a Map.
+info: >
+ Map.prototype.clear ( )
+
+ ...
+ 4. Let entries be the List that is the value of M’s [[MapData]] internal slot.
+ 5. Repeat for each Record {[[key]], [[value]]} p that is an element of
+ entries,
+ a. Set p.[[key]] to empty.
+ b. Set p.[[value]] to empty.
+ 6. Return undefined.
+features: [Symbol]
+---*/
+
+var m1 = new Map([['foo', 'bar'], [1, 1]]);
+var m2 = new Map();
+var m3 = new Map();
+m2.set('foo', 'bar');
+m2.set(1,1);
+m2.set(Symbol('a'), Symbol('a'));
+
+m1.clear();
+m2.clear();
+m3.clear();
+
+assert.sameValue(m1.size, 0);
+assert.sameValue(m2.size, 0);
+assert.sameValue(m3.size, 0);
diff --git a/test/built-ins/Map/prototype/clear/clear.js b/test/built-ins/Map/prototype/clear/clear.js
new file mode 100644
index 0000000000000000000000000000000000000000..59f28de2e90d7e66fbbf99172305ff14ff335712
--- /dev/null
+++ b/test/built-ins/Map/prototype/clear/clear.js
@@ -0,0 +1,21 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.1
+description: >
+ Map.prototype.clear ( )
+
+ 17 ECMAScript Standard Built-in Objects
+
+includes: [propertyHelper.js]
+---*/
+
+assert.sameValue(
+ typeof Map.prototype.clear,
+ 'function',
+ 'typeof Map.prototype.clear is "function"'
+);
+
+verifyNotEnumerable(Map.prototype, 'clear');
+verifyWritable(Map.prototype, 'clear');
+verifyConfigurable(Map.prototype, 'clear');
diff --git a/test/built-ins/Map/prototype/clear/context-is-not-map-object.js b/test/built-ins/Map/prototype/clear/context-is-not-map-object.js
new file mode 100644
index 0000000000000000000000000000000000000000..ab3b04b6aaaa089ed48771055d1932c802b4253a
--- /dev/null
+++ b/test/built-ins/Map/prototype/clear/context-is-not-map-object.js
@@ -0,0 +1,23 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.1
+description: >
+ Throws a TypeError if `this` does not have a [[MapData]] internal slot.
+info: >
+ Map.prototype.clear ( )
+
+ 1. Let M be the this value.
+ 2. If Type(M) is not Object, throw a TypeError exception.
+ 3. If M does not have a [[MapData]] internal slot, throw a TypeError
+ exception.
+ ...
+---*/
+
+assert.throws(TypeError, function() {
+ Map.prototype.clear.call({});
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.clear.call([]);
+});
diff --git a/test/built-ins/Map/prototype/clear/context-is-not-object.js b/test/built-ins/Map/prototype/clear/context-is-not-object.js
new file mode 100644
index 0000000000000000000000000000000000000000..c74d01abdf28c9781298a434c012347157821782
--- /dev/null
+++ b/test/built-ins/Map/prototype/clear/context-is-not-object.js
@@ -0,0 +1,38 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.1
+description: >
+ Throws a TypeError if `this` is not an Object.
+info: >
+ Map.prototype.clear ( )
+
+ 1. Let M be the this value.
+ 2. If Type(M) is not Object, throw a TypeError exception.
+ ...
+features: [Symbol]
+---*/
+
+assert.throws(TypeError, function() {
+ Map.prototype.clear.call(1);
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.clear.call(true);
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.clear.call('');
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.clear.call(null);
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.clear.call(undefined);
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.clear.call(Symbol());
+});
diff --git a/test/built-ins/Map/prototype/clear/context-is-set-object-throws.js b/test/built-ins/Map/prototype/clear/context-is-set-object-throws.js
new file mode 100644
index 0000000000000000000000000000000000000000..5b28047ff5155de32e9694adc96e87ad805c474f
--- /dev/null
+++ b/test/built-ins/Map/prototype/clear/context-is-set-object-throws.js
@@ -0,0 +1,20 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.1
+description: >
+ Throws a TypeError if `this` is a Set object.
+info: >
+ Map.prototype.clear ( )
+
+ 1. Let M be the this value.
+ 2. If Type(M) is not Object, throw a TypeError exception.
+ 3. If M does not have a [[MapData]] internal slot, throw a TypeError
+ exception.
+ ...
+features: [Set]
+---*/
+
+assert.throws(TypeError, function() {
+ Map.prototype.clear.call(new Set());
+});
diff --git a/test/built-ins/Map/prototype/clear/context-is-weakmap-object-throws.js b/test/built-ins/Map/prototype/clear/context-is-weakmap-object-throws.js
new file mode 100644
index 0000000000000000000000000000000000000000..f73121aefa38c5537e3b8e1b6040f99007ca1172
--- /dev/null
+++ b/test/built-ins/Map/prototype/clear/context-is-weakmap-object-throws.js
@@ -0,0 +1,20 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.1
+description: >
+ Throws a TypeError if `this` is a WeakMap object.
+info: >
+ Map.prototype.clear ( )
+
+ 1. Let M be the this value.
+ 2. If Type(M) is not Object, throw a TypeError exception.
+ 3. If M does not have a [[MapData]] internal slot, throw a TypeError
+ exception.
+ ...
+features: [WeakMap]
+---*/
+
+assert.throws(TypeError, function() {
+ Map.prototype.clear.call(new WeakMap());
+});
diff --git a/test/built-ins/Map/prototype/clear/length.js b/test/built-ins/Map/prototype/clear/length.js
new file mode 100644
index 0000000000000000000000000000000000000000..60a923c5deb2e2e8e1e7b8080ea1ab38afd14b1e
--- /dev/null
+++ b/test/built-ins/Map/prototype/clear/length.js
@@ -0,0 +1,22 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.1
+description: >
+ Map.prototype.clear.length value and descriptor.
+info: >
+ Map.prototype.clear ( )
+
+ 17 ECMAScript Standard Built-in Objects
+
+includes: [propertyHelper.js]
+---*/
+
+assert.sameValue(
+ Map.prototype.clear.length, 0,
+ 'The value of `Map.prototype.clear.length` is `0`'
+);
+
+verifyNotEnumerable(Map.prototype.clear, 'length');
+verifyNotWritable(Map.prototype.clear, 'length');
+verifyConfigurable(Map.prototype.clear, 'length');
diff --git a/test/built-ins/Map/prototype/clear/map-data-list-is-preserved.js b/test/built-ins/Map/prototype/clear/map-data-list-is-preserved.js
new file mode 100644
index 0000000000000000000000000000000000000000..9df3adf8f235e1ce7832a0bf9a59ccd02e2befc6
--- /dev/null
+++ b/test/built-ins/Map/prototype/clear/map-data-list-is-preserved.js
@@ -0,0 +1,31 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.1
+description: >
+ The existing [[MapData]] List is preserved.
+info: >
+ The existing [[MapData]] List is preserved because there may be existing
+ MapIterator objects that are suspended midway through iterating over that
+ List.
+
+ Map.prototype.clear ( )
+
+ ...
+ 4. Let entries be the List that is the value of M’s [[MapData]] internal slot.
+ 5. Repeat for each Record {[[key]], [[value]]} p that is an element of
+ entries,
+ a. Set p.[[key]] to empty.
+ b. Set p.[[value]] to empty.
+ 6. Return undefined.
+---*/
+
+var m = new Map([[1,1], [2,2], [3,3]]);
+var e = m.entries();
+
+e.next();
+m.clear();
+
+var n = e.next();
+assert.sameValue(n.value, undefined);
+assert.sameValue(n.done, true);
diff --git a/test/built-ins/Map/prototype/clear/name.js b/test/built-ins/Map/prototype/clear/name.js
new file mode 100644
index 0000000000000000000000000000000000000000..b498f506e3b41ac8c184ec2f66a1f09be8928c90
--- /dev/null
+++ b/test/built-ins/Map/prototype/clear/name.js
@@ -0,0 +1,22 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.1
+description: >
+ Map.prototype.entries.name value and descriptor.
+info: >
+ Map.prototype.clear ( )
+
+ 17 ECMAScript Standard Built-in Objects
+
+includes: [propertyHelper.js]
+---*/
+
+assert.sameValue(
+ Map.prototype.clear.name, 'clear',
+ 'The value of `Map.prototype.clear.name` is `"clear"`'
+);
+
+verifyNotEnumerable(Map.prototype.clear, 'name');
+verifyNotWritable(Map.prototype.clear, 'name');
+verifyConfigurable(Map.prototype.clear, 'name');
diff --git a/test/built-ins/Map/prototype/clear/returns-undefined.js b/test/built-ins/Map/prototype/clear/returns-undefined.js
new file mode 100644
index 0000000000000000000000000000000000000000..1b971d9a5df7f17f97c1d349294d951161cbc960
--- /dev/null
+++ b/test/built-ins/Map/prototype/clear/returns-undefined.js
@@ -0,0 +1,22 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.1
+description: >
+ Returns undefined.
+info: >
+ Map.prototype.clear ( )
+
+ ...
+ 4. Let entries be the List that is the value of M’s [[MapData]] internal slot.
+ 5. Repeat for each Record {[[key]], [[value]]} p that is an element of
+ entries,
+ a. Set p.[[key]] to empty.
+ b. Set p.[[value]] to empty.
+ 6. Return undefined.
+---*/
+
+var m1 = new Map([['foo', 'bar'], [1, 1]]);
+
+assert.sameValue(m1.clear(), undefined, 'clears a map and returns undefined');
+assert.sameValue(m1.clear(), undefined, 'returns undefined on an empty map');
diff --git a/test/built-ins/Map/prototype/constructor.js b/test/built-ins/Map/prototype/constructor.js
new file mode 100644
index 0000000000000000000000000000000000000000..37eea8ba27677e28585e2528da4e53a0d4188cee
--- /dev/null
+++ b/test/built-ins/Map/prototype/constructor.js
@@ -0,0 +1,16 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.2
+description: Map.prototype.constructor value and descriptor
+info: >
+ The initial value of Map.prototype.constructor is the intrinsic object %Map%.
+includes: [propertyHelper.js]
+---*/
+
+assert.sameValue(Map.prototype.constructor, Map);
+assert.sameValue((new Map()).constructor, Map);
+
+verifyNotEnumerable(Map.prototype, 'constructor');
+verifyWritable(Map.prototype, 'constructor');
+verifyConfigurable(Map.prototype, 'constructor');
diff --git a/test/built-ins/Map/prototype/delete/context-is-not-map-object.js b/test/built-ins/Map/prototype/delete/context-is-not-map-object.js
new file mode 100644
index 0000000000000000000000000000000000000000..db993074e7494a9a09dab58cdc278db49fec169e
--- /dev/null
+++ b/test/built-ins/Map/prototype/delete/context-is-not-map-object.js
@@ -0,0 +1,23 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.3
+description: >
+ Throws a TypeError if `this` does not have a [[MapData]] internal slot.
+info: >
+ Map.prototype.delete ( key )
+
+ 1. Let M be the this value.
+ 2. If Type(M) is not Object, throw a TypeError exception.
+ 3. If M does not have a [[MapData]] internal slot, throw a TypeError
+ exception.
+ ...
+---*/
+
+assert.throws(TypeError, function() {
+ Map.prototype.delete.call({}, 'attr');
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.delete.call([], 'attr');
+});
diff --git a/test/built-ins/Map/prototype/delete/context-is-not-object.js b/test/built-ins/Map/prototype/delete/context-is-not-object.js
new file mode 100644
index 0000000000000000000000000000000000000000..fe341ce5269706b2e0a2635d574f5bb93baeb72f
--- /dev/null
+++ b/test/built-ins/Map/prototype/delete/context-is-not-object.js
@@ -0,0 +1,38 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.3
+description: >
+ Throws a TypeError if `this` is not an Object.
+info: >
+ Map.prototype.delete ( key )
+
+ 1. Let M be the this value.
+ 2. If Type(M) is not Object, throw a TypeError exception.
+ ...
+features: [Symbol]
+---*/
+
+assert.throws(TypeError, function() {
+ Map.prototype.delete.call(1, 'attr');
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.delete.call(true, 'attr');
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.delete.call('', 'attr');
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.delete.call(null, 'attr');
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.delete.call(undefined, 'attr');
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.delete.call(Symbol(), 'attr');
+});
diff --git a/test/built-ins/Map/prototype/delete/context-is-set-object-throws.js b/test/built-ins/Map/prototype/delete/context-is-set-object-throws.js
new file mode 100644
index 0000000000000000000000000000000000000000..a9a38850e59b5b7856c2babbe768d6addc2ed229
--- /dev/null
+++ b/test/built-ins/Map/prototype/delete/context-is-set-object-throws.js
@@ -0,0 +1,20 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.3
+description: >
+ Throws a TypeError if `this` is a Set object.
+info: >
+ Map.prototype.delete ( key )
+
+ 1. Let M be the this value.
+ 2. If Type(M) is not Object, throw a TypeError exception.
+ 3. If M does not have a [[MapData]] internal slot, throw a TypeError
+ exception.
+ ...
+features: [Set]
+---*/
+
+assert.throws(TypeError, function() {
+ Map.prototype.delete.call(new Set(), 'attr');
+});
diff --git a/test/built-ins/Map/prototype/delete/context-is-weakmap-object-throws.js b/test/built-ins/Map/prototype/delete/context-is-weakmap-object-throws.js
new file mode 100644
index 0000000000000000000000000000000000000000..bda619f5706c43698bf25d4f6eb2917891b643f3
--- /dev/null
+++ b/test/built-ins/Map/prototype/delete/context-is-weakmap-object-throws.js
@@ -0,0 +1,20 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.3
+description: >
+ Throws a TypeError if `this` is a WeakMap object.
+info: >
+ Map.prototype.delete ( key )
+
+ 1. Let M be the this value.
+ 2. If Type(M) is not Object, throw a TypeError exception.
+ 3. If M does not have a [[MapData]] internal slot, throw a TypeError
+ exception.
+ ...
+features: [WeakMap]
+---*/
+
+assert.throws(TypeError, function() {
+ Map.prototype.delete.call(new WeakMap(), 'attr');
+});
diff --git a/test/built-ins/Map/prototype/delete/delete.js b/test/built-ins/Map/prototype/delete/delete.js
new file mode 100644
index 0000000000000000000000000000000000000000..4bf8688efab59b555a816167c3eea8aab5168b41
--- /dev/null
+++ b/test/built-ins/Map/prototype/delete/delete.js
@@ -0,0 +1,21 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.3
+description: >
+ Map.prototype.delete ( )
+
+ 17 ECMAScript Standard Built-in Objects
+
+includes: [propertyHelper.js]
+---*/
+
+assert.sameValue(
+ typeof Map.prototype.delete,
+ 'function',
+ 'typeof Map.prototype.delete is "function"'
+);
+
+verifyNotEnumerable(Map.prototype, 'delete');
+verifyWritable(Map.prototype, 'delete');
+verifyConfigurable(Map.prototype, 'delete');
diff --git a/test/built-ins/Map/prototype/delete/does-not-break-iterators.js b/test/built-ins/Map/prototype/delete/does-not-break-iterators.js
new file mode 100644
index 0000000000000000000000000000000000000000..35c09f6594bf0470314a4310ae20e4c7fe529098
--- /dev/null
+++ b/test/built-ins/Map/prototype/delete/does-not-break-iterators.js
@@ -0,0 +1,32 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.3
+description: >
+ Deleting an entry does not break a [[MapData]] List.
+info: >
+ Map.prototype.delete ( key )
+
+ 4. Let entries be the List that is the value of M’s [[MapData]] internal slot.
+ 5. Repeat for each Record {[[key]], [[value]]} p that is an element of entries,
+ a. If p.[[key]] is not empty and SameValueZero(p.[[key]], key) is true, then
+ i. Set p.[[key]] to empty.
+ ii. Set p.[[value]] to empty.
+ iii. Return true.
+ ...
+---*/
+
+var m = new Map([['a',1], ['b', 2], ['c', 3]]);
+var e = m.entries();
+
+e.next();
+m.delete('b');
+
+var n = e.next();
+
+assert.sameValue(n.value[0], 'c');
+assert.sameValue(n.value[1], 3);
+
+n = e.next();
+assert.sameValue(n.value, undefined);
+assert.sameValue(n.done, true);
diff --git a/test/built-ins/Map/prototype/delete/length.js b/test/built-ins/Map/prototype/delete/length.js
new file mode 100644
index 0000000000000000000000000000000000000000..7ec03d5867ed8da945b5b7b6499bd92a516e021b
--- /dev/null
+++ b/test/built-ins/Map/prototype/delete/length.js
@@ -0,0 +1,22 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.3
+description: >
+ Map.prototype.delete.length value and descriptor.
+info: >
+ Map.prototype.delete ( key )
+
+ 17 ECMAScript Standard Built-in Objects
+
+includes: [propertyHelper.js]
+---*/
+
+assert.sameValue(
+ Map.prototype.delete.length, 1,
+ 'The value of `Map.prototype.delete.length` is `1`'
+);
+
+verifyNotEnumerable(Map.prototype.delete, 'length');
+verifyNotWritable(Map.prototype.delete, 'length');
+verifyConfigurable(Map.prototype.delete, 'length');
diff --git a/test/built-ins/Map/prototype/delete/name.js b/test/built-ins/Map/prototype/delete/name.js
new file mode 100644
index 0000000000000000000000000000000000000000..b82efa02a786f365ba47991f848fa74a88b282f5
--- /dev/null
+++ b/test/built-ins/Map/prototype/delete/name.js
@@ -0,0 +1,22 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.3
+description: >
+ Map.prototype.delete.name value and descriptor.
+info: >
+ Map.prototype.delete ( key )
+
+ 17 ECMAScript Standard Built-in Objects
+
+includes: [propertyHelper.js]
+---*/
+
+assert.sameValue(
+ Map.prototype.delete.name, 'delete',
+ 'The value of `Map.prototype.delete.name` is `"delete"`'
+);
+
+verifyNotEnumerable(Map.prototype.delete, 'name');
+verifyNotWritable(Map.prototype.delete, 'name');
+verifyConfigurable(Map.prototype.delete, 'name');
diff --git a/test/built-ins/Map/prototype/delete/returns-false.js b/test/built-ins/Map/prototype/delete/returns-false.js
new file mode 100644
index 0000000000000000000000000000000000000000..4152d58c234db7a80c935a76eb0c8c9ef51d47b2
--- /dev/null
+++ b/test/built-ins/Map/prototype/delete/returns-false.js
@@ -0,0 +1,23 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.3
+description: >
+ Returns false when it does not delete an entry.
+info: >
+ Map.prototype.delete ( key )
+
+ 4. Let entries be the List that is the value of M’s [[MapData]] internal slot.
+ 5. Repeat for each Record {[[key]], [[value]]} p that is an element of entries,
+ a. If p.[[key]] is not empty and SameValueZero(p.[[key]], key) is true, then
+ ...
+ iii. Return true.
+ 6. Return false.
+---*/
+
+var m = new Map([['a',1], ['b', 2]]);
+
+assert.sameValue(m.delete('not-in-the-map'), false);
+
+m.delete('a');
+assert.sameValue(m.delete('a'), false);
diff --git a/test/built-ins/Map/prototype/delete/returns-true-for-deleted-entry.js b/test/built-ins/Map/prototype/delete/returns-true-for-deleted-entry.js
new file mode 100644
index 0000000000000000000000000000000000000000..79c1e138f3e435c4070ddf44b3ad18bbd5207040
--- /dev/null
+++ b/test/built-ins/Map/prototype/delete/returns-true-for-deleted-entry.js
@@ -0,0 +1,24 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.3
+description: >
+ Returns true when deletes an entry.
+info: >
+ Map.prototype.delete ( key )
+
+ 4. Let entries be the List that is the value of M’s [[MapData]] internal slot.
+ 5. Repeat for each Record {[[key]], [[value]]} p that is an element of entries,
+ a. If p.[[key]] is not empty and SameValueZero(p.[[key]], key) is true, then
+ i. Set p.[[key]] to empty.
+ ii. Set p.[[value]] to empty.
+ iii. Return true.
+ ...
+---*/
+
+var m = new Map([['a',1], ['b', 2]]);
+
+var result = m.delete('a');
+
+assert(result);
+assert.sameValue(m.size, 1);
diff --git a/test/built-ins/Map/prototype/descriptor.js b/test/built-ins/Map/prototype/descriptor.js
new file mode 100644
index 0000000000000000000000000000000000000000..5d5bbec580f96da3a3befd24859e14d87d6b4a48
--- /dev/null
+++ b/test/built-ins/Map/prototype/descriptor.js
@@ -0,0 +1,14 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.2.1
+description: Map.prototype property attributes.
+info: >
+ This property has the attributes { [[Writable]]: false, [[Enumerable]]: false,
+ [[Configurable]]: false }.
+includes: [propertyHelper.js]
+---*/
+
+verifyNotEnumerable(Map, 'prototype');
+verifyNotWritable(Map, 'prototype');
+verifyNotConfigurable(Map, 'prototype');
diff --git a/test/built-ins/Map/prototype/entries-no-map-data.js b/test/built-ins/Map/prototype/entries-no-map-data.js
deleted file mode 100644
index 30d1f494cc3f25ddb0695b396a332861fe2b2ab2..0000000000000000000000000000000000000000
--- a/test/built-ins/Map/prototype/entries-no-map-data.js
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright (C) 2014 the V8 project authors. All rights reserved.
-// This code is governed by the BSD license found in the LICENSE file.
-
-/*---
- description: >
- If the context does not have a [[MapData]] internal slot, throw a
- TypeError exception as per 23.1.5.1.
- es6id: 23.1.3.4
- ---*/
-
-assert.throws(TypeError, function() {
- Map.prototype.entries.call({});
-});
diff --git a/test/built-ins/Map/prototype/entries/does-not-have-mapdata-internal-slot-set.js b/test/built-ins/Map/prototype/entries/does-not-have-mapdata-internal-slot-set.js
new file mode 100644
index 0000000000000000000000000000000000000000..cc11d2e11ed5739f86441dda0a815e1fc12b2280
--- /dev/null
+++ b/test/built-ins/Map/prototype/entries/does-not-have-mapdata-internal-slot-set.js
@@ -0,0 +1,29 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.4
+description: >
+ Throws a TypeError if `this` is a Set object.
+info: >
+ Map.prototype.entries ( )
+
+ 1. Let M be the this value.
+ 2. Return CreateMapIterator(M, "key+value").
+
+ 23.1.5.1 CreateMapIterator Abstract Operation
+
+ ...
+ 2. If map does not have a [[MapData]] internal slot, throw a TypeError
+ exception.
+ ...
+features: [Set]
+---*/
+
+assert.throws(TypeError, function() {
+ Map.prototype.entries.call(new Set());
+});
+
+assert.throws(TypeError, function() {
+ var m = new Map();
+ m.entries.call(new Set());
+});
diff --git a/test/built-ins/Map/prototype/entries/does-not-have-mapdata-internal-slot-weakmap.js b/test/built-ins/Map/prototype/entries/does-not-have-mapdata-internal-slot-weakmap.js
new file mode 100644
index 0000000000000000000000000000000000000000..57a7a03113453943dac9ecdd978b2403ecf89b2d
--- /dev/null
+++ b/test/built-ins/Map/prototype/entries/does-not-have-mapdata-internal-slot-weakmap.js
@@ -0,0 +1,29 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.4
+description: >
+ Throws a TypeError if `this` is a WeakMap object.
+info: >
+ Map.prototype.entries ( )
+
+ 1. Let M be the this value.
+ 2. Return CreateMapIterator(M, "key+value").
+
+ 23.1.5.1 CreateMapIterator Abstract Operation
+
+ ...
+ 2. If map does not have a [[MapData]] internal slot, throw a TypeError
+ exception.
+ ...
+features: [WeakMap]
+---*/
+
+assert.throws(TypeError, function() {
+ Map.prototype.entries.call(new WeakMap());
+});
+
+assert.throws(TypeError, function() {
+ var m = new Map();
+ m.entries.call(new WeakMap());
+});
diff --git a/test/built-ins/Map/prototype/entries/does-not-have-mapdata-internal-slot.js b/test/built-ins/Map/prototype/entries/does-not-have-mapdata-internal-slot.js
new file mode 100644
index 0000000000000000000000000000000000000000..2ecb0de14c527d998ccb0b25929b059bfff60b03
--- /dev/null
+++ b/test/built-ins/Map/prototype/entries/does-not-have-mapdata-internal-slot.js
@@ -0,0 +1,38 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.4
+description: >
+ Throws a TypeError if `this` object does not have a [[MapData]] internal slot.
+info: >
+ Map.prototype.entries ( )
+
+ 1. Let M be the this value.
+ 2. Return CreateMapIterator(M, "key+value").
+
+ 23.1.5.1 CreateMapIterator Abstract Operation
+
+ ...
+ 2. If map does not have a [[MapData]] internal slot, throw a TypeError
+ exception.
+ ...
+
+---*/
+
+var m = new Map();
+
+assert.throws(TypeError, function() {
+ Map.prototype.entries.call([]);
+});
+
+assert.throws(TypeError, function() {
+ m.entries.call([]);
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.entries.call({});
+});
+
+assert.throws(TypeError, function() {
+ m.entries.call({});
+});
diff --git a/test/built-ins/Map/prototype/entries/entries.js b/test/built-ins/Map/prototype/entries/entries.js
new file mode 100644
index 0000000000000000000000000000000000000000..853b1f96dc30db2c166df1c7b002a6a124512480
--- /dev/null
+++ b/test/built-ins/Map/prototype/entries/entries.js
@@ -0,0 +1,22 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.4
+description: >
+ Property type and descriptor.
+info: >
+ Map.prototype.entries ( )
+
+ 17 ECMAScript Standard Built-in Objects
+includes: [propertyHelper.js]
+---*/
+
+assert.sameValue(
+ typeof Map.prototype.entries,
+ 'function',
+ '`typeof Map.prototype.entries` is `function`'
+);
+
+verifyNotEnumerable(Map.prototype, 'entries');
+verifyWritable(Map.prototype, 'entries');
+verifyConfigurable(Map.prototype, 'entries');
diff --git a/test/built-ins/Map/prototype/entries/length.js b/test/built-ins/Map/prototype/entries/length.js
new file mode 100644
index 0000000000000000000000000000000000000000..fef6c7f47387485744534b52e45b0da5d31eee6f
--- /dev/null
+++ b/test/built-ins/Map/prototype/entries/length.js
@@ -0,0 +1,22 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.4
+description: >
+ Map.prototype.entries.length value and descriptor.
+info: >
+ Map.prototype.entries ( )
+
+ 17 ECMAScript Standard Built-in Objects
+
+includes: [propertyHelper.js]
+---*/
+
+assert.sameValue(
+ Map.prototype.entries.length, 0,
+ 'The value of `Map.prototype.entries.length` is `0`'
+);
+
+verifyNotEnumerable(Map.prototype.entries, 'length');
+verifyNotWritable(Map.prototype.entries, 'length');
+verifyConfigurable(Map.prototype.entries, 'length');
diff --git a/test/built-ins/Map/prototype/entries/name.js b/test/built-ins/Map/prototype/entries/name.js
new file mode 100644
index 0000000000000000000000000000000000000000..f80d0380904ae5ce64d3558ac437c50a52c9f94c
--- /dev/null
+++ b/test/built-ins/Map/prototype/entries/name.js
@@ -0,0 +1,22 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.4
+description: >
+ Map.prototype.entries.name value and descriptor.
+info: >
+ Map.prototype.entries ( )
+
+ 17 ECMAScript Standard Built-in Objects
+
+includes: [propertyHelper.js]
+---*/
+
+assert.sameValue(
+ Map.prototype.entries.name, 'entries',
+ 'The value of `Map.prototype.entries.name` is `"entries"`'
+);
+
+verifyNotEnumerable(Map.prototype.entries, 'name');
+verifyNotWritable(Map.prototype.entries, 'name');
+verifyConfigurable(Map.prototype.entries, 'name');
diff --git a/test/built-ins/Map/prototype/entries/returns-iterator-empty.js b/test/built-ins/Map/prototype/entries/returns-iterator-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..2584d4d5ca818f96b711239de4de0ee3ff608724
--- /dev/null
+++ b/test/built-ins/Map/prototype/entries/returns-iterator-empty.js
@@ -0,0 +1,27 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.4
+description: >
+ Returns an iterator on an empty Map object.
+info: >
+ Map.prototype.entries ( )
+
+ ...
+ 2. Return CreateMapIterator(M, "key+value").
+
+ 23.1.5.1 CreateMapIterator Abstract Operation
+
+ ...
+ 7. Return iterator.
+---*/
+
+var map = new Map();
+var iterator = map.entries();
+var result = iterator.next();
+
+assert.sameValue(
+ result.value, undefined,
+ 'The value of `result.value` is `undefined`'
+);
+assert.sameValue(result.done, true, 'The value of `result.done` is `true`');
diff --git a/test/built-ins/Map/prototype/entries-iteration.js b/test/built-ins/Map/prototype/entries/returns-iterator.js
similarity index 57%
rename from test/built-ins/Map/prototype/entries-iteration.js
rename to test/built-ins/Map/prototype/entries/returns-iterator.js
index 72b605101077781a0ee60aa12473676c4bc3431a..5e6ad2b2e317b580250d008b0fcd1c4979b12266 100644
--- a/test/built-ins/Map/prototype/entries-iteration.js
+++ b/test/built-ins/Map/prototype/entries/returns-iterator.js
@@ -1,36 +1,44 @@
-// Copyright (C) 2014 the V8 project authors. All rights reserved.
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
-
/*---
- description: >
- The method should return a valid iterator with the context as the
- IteratedObject.
- es6id: 23.1.3.4
- ---*/
+es6id: 23.1.3.4
+description: >
+ Returns an iterator.
+info: >
+ Map.prototype.entries ( )
+
+ ...
+ 2. Return CreateMapIterator(M, "key+value").
+
+ 23.1.5.1 CreateMapIterator Abstract Operation
+
+ ...
+ 7. Return iterator.
+---*/
var map = new Map();
-map.set(1, 11);
-map.set(2, 22);
-map.set(3, 33);
+map.set('a',1);
+map.set('b',2);
+map.set('c',3);
var iterator = map.entries();
var result;
result = iterator.next();
-assert.sameValue(result.value[0], 1, 'First result `value` (map key)');
-assert.sameValue(result.value[1], 11, 'First result `value` (map value)');
+assert.sameValue(result.value[0], 'a', 'First result `value` ("key")');
+assert.sameValue(result.value[1], 1, 'First result `value` ("value")');
assert.sameValue(result.value.length, 2, 'First result `value` (length)');
assert.sameValue(result.done, false, 'First result `done` flag');
result = iterator.next();
-assert.sameValue(result.value[0], 2, 'Second result `value` (map key)');
-assert.sameValue(result.value[1], 22, 'Second result `value` (map value)');
+assert.sameValue(result.value[0], 'b', 'Second result `value` ("key")');
+assert.sameValue(result.value[1], 2, 'Second result `value` ("value")');
assert.sameValue(result.value.length, 2, 'Second result `value` (length)');
assert.sameValue(result.done, false, 'Second result `done` flag');
result = iterator.next();
-assert.sameValue(result.value[0], 3, 'Third result `value` (map key)');
-assert.sameValue(result.value[1], 33, 'Third result `value` (map value)');
+assert.sameValue(result.value[0], 'c', 'Third result `value` ("key")');
+assert.sameValue(result.value[1], 3, 'Third result `value` ("value")');
assert.sameValue(result.value.length, 2, 'Third result `value` (length)');
assert.sameValue(result.done, false, 'Third result `done` flag');
diff --git a/test/built-ins/Map/prototype/entries/this-not-object-throw.js b/test/built-ins/Map/prototype/entries/this-not-object-throw.js
new file mode 100644
index 0000000000000000000000000000000000000000..6e5d56213bd39072bf1a6cadcaf426e3404674dd
--- /dev/null
+++ b/test/built-ins/Map/prototype/entries/this-not-object-throw.js
@@ -0,0 +1,47 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.4
+description: >
+ Throws a TypeError if `this` is not an Object.
+info: >
+ Map.prototype.entries ( )
+
+ ...
+ 2. Return CreateSetIterator(M, "key+value").
+
+ 23.1.5.1 CreateSetIterator Abstract Operation
+
+ 1. If Type(map) is not Object, throw a TypeError exception.
+ ...
+features: [Symbol]
+---*/
+
+assert.throws(TypeError, function() {
+ Map.prototype.entries.call(false);
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.entries.call(1);
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.entries.call('');
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.entries.call(undefined);
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.entries.call(null);
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.entries.call(Symbol());
+});
+
+assert.throws(TypeError, function() {
+ var map = new Map();
+ map.entries.call(false);
+});
diff --git a/test/built-ins/Map/prototype/forEach/callback-parameters.js b/test/built-ins/Map/prototype/forEach/callback-parameters.js
new file mode 100644
index 0000000000000000000000000000000000000000..0688762f8aa1fc9ff575f0cfd645d9a8a685f910
--- /dev/null
+++ b/test/built-ins/Map/prototype/forEach/callback-parameters.js
@@ -0,0 +1,44 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.5
+description: >
+ Verify the parameters order on the given callback.
+info: >
+ Map.prototype.forEach ( callbackfn [ , thisArg ] )
+
+ ...
+ 5. If thisArg was supplied, let T be thisArg; else let T be undefined.
+ 6. Let entries be the List that is the value of M’s [[MapData]] internal slot.
+ 7. Repeat for each Record {[[key]], [[value]]} e that is an element of
+ entries, in original key insertion order
+ a. If e.[[key]] is not empty, then
+ i. Let funcResult be Call(callbackfn, T, «e.[[value]], e.[[key]], M»).
+ ...
+---*/
+
+var map = new Map();
+map.set('foo', 42);
+map.set('bar', 'baz');
+
+var results = [];
+
+var callback = function(value, key, thisArg) {
+ results.push({
+ value: value,
+ key: key,
+ thisArg: thisArg
+ });
+};
+
+map.forEach(callback);
+
+assert.sameValue(results[0].value, 42);
+assert.sameValue(results[0].key, 'foo');
+assert.sameValue(results[0].thisArg, map);
+
+assert.sameValue(results[1].value, 'baz');
+assert.sameValue(results[1].key, 'bar');
+assert.sameValue(results[1].thisArg, map);
+
+assert.sameValue(results.length, 2);
diff --git a/test/built-ins/Map/prototype/forEach/callback-result-is-abrupt.js b/test/built-ins/Map/prototype/forEach/callback-result-is-abrupt.js
new file mode 100644
index 0000000000000000000000000000000000000000..5b31a39bc319b25958a92e46e2b0a064cce8c9dc
--- /dev/null
+++ b/test/built-ins/Map/prototype/forEach/callback-result-is-abrupt.js
@@ -0,0 +1,28 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.5
+description: >
+ Returns error from callback result is abrupt.
+info: >
+ Map.prototype.forEach ( callbackfn [ , thisArg ] )
+
+ ...
+ 5. If thisArg was supplied, let T be thisArg; else let T be undefined.
+ 6. Let entries be the List that is the value of M’s [[MapData]] internal slot.
+ 7. Repeat for each Record {[[key]], [[value]]} e that is an element of
+ entries, in original key insertion order
+ a. If e.[[key]] is not empty, then
+ i. Let funcResult be Call(callbackfn, T, «e.[[value]], e.[[key]], M»).
+ ii. ReturnIfAbrupt(funcResult).
+ ...
+flags: [noStrict]
+---*/
+
+var map = new Map([[0, 0]]);
+
+assert.throws(Test262Error, function() {
+ map.forEach(function() {
+ throw new Test262Error();
+ });
+});
diff --git a/test/built-ins/Map/prototype/forEach/callback-this-non-strict.js b/test/built-ins/Map/prototype/forEach/callback-this-non-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..d1190b419780fbac5b3bff8eedd3f629906eaa8d
--- /dev/null
+++ b/test/built-ins/Map/prototype/forEach/callback-this-non-strict.js
@@ -0,0 +1,35 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.5
+description: >
+ If a thisArg is not provided, undefined will be used as the this value for
+ each invocation of callbackfn.
+info: >
+ Map.prototype.forEach ( callbackfn [ , thisArg ] )
+
+ ...
+ 5. If thisArg was supplied, let T be thisArg; else let T be undefined.
+ 6. Let entries be the List that is the value of M’s [[MapData]] internal slot.
+ 7. Repeat for each Record {[[key]], [[value]]} e that is an element of
+ entries, in original key insertion order
+ a. If e.[[key]] is not empty, then
+ i. Let funcResult be Call(callbackfn, T, «e.[[value]], e.[[key]], M»).
+ ...
+flags: [noStrict]
+---*/
+
+var _this = [];
+var map = new Map();
+
+map.set(0, 0);
+map.set(1, 1);
+map.set(2, 2);
+
+map.forEach(function() {
+ _this.push(this);
+});
+
+assert.sameValue(_this[0], this);
+assert.sameValue(_this[1], this);
+assert.sameValue(_this[2], this);
diff --git a/test/built-ins/Map/prototype/forEach/callback-this-strict.js b/test/built-ins/Map/prototype/forEach/callback-this-strict.js
new file mode 100644
index 0000000000000000000000000000000000000000..a7f557211d7eb2061773fcfb85572c8ba2bb939d
--- /dev/null
+++ b/test/built-ins/Map/prototype/forEach/callback-this-strict.js
@@ -0,0 +1,35 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.5
+description: >
+ If a thisArg is not provided, undefined will be used as the this value for
+ each invocation of callbackfn.
+info: >
+ Map.prototype.forEach ( callbackfn [ , thisArg ] )
+
+ ...
+ 5. If thisArg was supplied, let T be thisArg; else let T be undefined.
+ 6. Let entries be the List that is the value of M’s [[MapData]] internal slot.
+ 7. Repeat for each Record {[[key]], [[value]]} e that is an element of
+ entries, in original key insertion order
+ a. If e.[[key]] is not empty, then
+ i. Let funcResult be Call(callbackfn, T, «e.[[value]], e.[[key]], M»).
+ ...
+flags: [onlyStrict]
+---*/
+
+var _this = [];
+var map = new Map();
+
+map.set(0, 0);
+map.set(1, 1);
+map.set(2, 2);
+
+map.forEach(function() {
+ _this.push(this);
+});
+
+assert.sameValue(_this[0], undefined);
+assert.sameValue(_this[1], undefined);
+assert.sameValue(_this[2], undefined);
diff --git a/test/built-ins/Map/prototype/forEach/deleted-values-during-foreach.js b/test/built-ins/Map/prototype/forEach/deleted-values-during-foreach.js
new file mode 100644
index 0000000000000000000000000000000000000000..51f70be6f75e8ad320ddebe0285d59608b7467e2
--- /dev/null
+++ b/test/built-ins/Map/prototype/forEach/deleted-values-during-foreach.js
@@ -0,0 +1,41 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.5
+description: >
+ Map state with deleted values during forEach.
+info: >
+ Map.prototype.forEach ( callbackfn [ , thisArg ] )
+
+ ...
+ 5. If thisArg was supplied, let T be thisArg; else let T be undefined.
+ 6. Let entries be the List that is the value of M’s [[MapData]] internal slot.
+ 7. Repeat for each Record {[[key]], [[value]]} e that is an element of
+ entries, in original key insertion order
+ a. If e.[[key]] is not empty, then
+ i. Let funcResult be Call(callbackfn, T, «e.[[value]], e.[[key]], M»).
+ ii. ReturnIfAbrupt(funcResult).
+ ...
+---*/
+
+var map = new Map();
+map.set('foo', 0);
+map.set('bar', 1);
+
+var count = 0;
+var results = [];
+
+map.forEach(function(value, key) {
+ if (count === 0) {
+ map.delete('bar');
+ }
+ results.push({
+ value: value,
+ key: key
+ });
+ count++;
+});
+
+assert.sameValue(results.length, 1);
+assert.sameValue(results[0].key, 'foo');
+assert.sameValue(results[0].value, 0);
diff --git a/test/built-ins/Map/prototype/forEach/does-not-have-mapdata-internal-slot-set.js b/test/built-ins/Map/prototype/forEach/does-not-have-mapdata-internal-slot-set.js
new file mode 100644
index 0000000000000000000000000000000000000000..81c42614a9e280a90f457d280b9cf9ef5830674b
--- /dev/null
+++ b/test/built-ins/Map/prototype/forEach/does-not-have-mapdata-internal-slot-set.js
@@ -0,0 +1,24 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.5
+description: >
+ Throws a TypeError if `this` is a Set object.
+info: >
+ Map.prototype.forEach ( callbackfn [ , thisArg ] )
+
+ ...
+ 3. If M does not have a [[MapData]] internal slot, throw a TypeError
+ exception.
+ ...
+features: [Set]
+---*/
+
+assert.throws(TypeError, function() {
+ Map.prototype.forEach.call(new Set(), function() {});
+});
+
+assert.throws(TypeError, function() {
+ var m = new Map();
+ m.forEach.call(new Set(), function() {});
+});
diff --git a/test/built-ins/Map/prototype/forEach/does-not-have-mapdata-internal-slot-weakmap.js b/test/built-ins/Map/prototype/forEach/does-not-have-mapdata-internal-slot-weakmap.js
new file mode 100644
index 0000000000000000000000000000000000000000..551c29bc9ad63d8f454cbaddb557e71db1c8bfd1
--- /dev/null
+++ b/test/built-ins/Map/prototype/forEach/does-not-have-mapdata-internal-slot-weakmap.js
@@ -0,0 +1,24 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.5
+description: >
+ Throws a TypeError if `this` is a WeakMap object.
+info: >
+ Map.prototype.forEach ( callbackfn [ , thisArg ] )
+
+ ...
+ 3. If M does not have a [[MapData]] internal slot, throw a TypeError
+ exception.
+ ...
+features: [WeakMap]
+---*/
+
+assert.throws(TypeError, function() {
+ Map.prototype.forEach.call(new WeakMap(), function() {});
+});
+
+assert.throws(TypeError, function() {
+ var m = new Map();
+ m.forEach.call(new WeakMap(), function() {});
+});
diff --git a/test/built-ins/Map/prototype/forEach/does-not-have-mapdata-internal-slot.js b/test/built-ins/Map/prototype/forEach/does-not-have-mapdata-internal-slot.js
new file mode 100644
index 0000000000000000000000000000000000000000..c5035291b159d20d8f6aab5e01056b9e29df8964
--- /dev/null
+++ b/test/built-ins/Map/prototype/forEach/does-not-have-mapdata-internal-slot.js
@@ -0,0 +1,32 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.5
+description: >
+ Throws a TypeError if `this` object does not have a [[MapData]] internal slot.
+info: >
+ Map.prototype.forEach ( callbackfn [ , thisArg ] )
+
+ ...
+ 3. If M does not have a [[MapData]] internal slot, throw a TypeError
+ exception.
+ ...
+---*/
+
+var m = new Map();
+
+assert.throws(TypeError, function() {
+ Map.prototype.forEach.call([], function() {});
+});
+
+assert.throws(TypeError, function() {
+ m.forEach.call([], function() {});
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.forEach.call({}, function() {});
+});
+
+assert.throws(TypeError, function() {
+ m.forEach.call({}, function() {});
+});
diff --git a/test/built-ins/Map/prototype/forEach/first-argument-is-not-callable.js b/test/built-ins/Map/prototype/forEach/first-argument-is-not-callable.js
new file mode 100644
index 0000000000000000000000000000000000000000..996d67b56becb718ec90a1f15b28cdd31b0580b3
--- /dev/null
+++ b/test/built-ins/Map/prototype/forEach/first-argument-is-not-callable.js
@@ -0,0 +1,43 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.5
+description: >
+ Throws a TypeError if first argument is not callable.
+info: >
+ Map.prototype.forEach ( callbackfn [ , thisArg ] )
+
+ 4. If IsCallable(callbackfn) is false, throw a TypeError exception.
+ ...
+features: [Symbol]
+---*/
+
+var map = new Map();
+
+assert.throws(TypeError, function() {
+ map.forEach({});
+});
+
+assert.throws(TypeError, function() {
+ map.forEach([]);
+});
+
+assert.throws(TypeError, function() {
+ map.forEach(1);
+});
+
+assert.throws(TypeError, function() {
+ map.forEach('');
+});
+
+assert.throws(TypeError, function() {
+ map.forEach(null);
+});
+
+assert.throws(TypeError, function() {
+ map.forEach(undefined);
+});
+
+assert.throws(TypeError, function() {
+ map.forEach(Symbol());
+});
diff --git a/test/built-ins/Map/prototype/forEach/forEach.js b/test/built-ins/Map/prototype/forEach/forEach.js
new file mode 100644
index 0000000000000000000000000000000000000000..bf80ca900e24b8bfab4c97f8a337ad856eb6a91e
--- /dev/null
+++ b/test/built-ins/Map/prototype/forEach/forEach.js
@@ -0,0 +1,22 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.5
+description: >
+ Property type and descriptor.
+info: >
+ Map.prototype.forEach ( callbackfn [ , thisArg ] )
+
+ 17 ECMAScript Standard Built-in Objects
+includes: [propertyHelper.js]
+---*/
+
+assert.sameValue(
+ typeof Map.prototype.forEach,
+ 'function',
+ '`typeof Map.prototype.forEach` is `function`'
+);
+
+verifyNotEnumerable(Map.prototype, 'forEach');
+verifyWritable(Map.prototype, 'forEach');
+verifyConfigurable(Map.prototype, 'forEach');
diff --git a/test/built-ins/Map/prototype/forEach/iterates-in-key-insertion-order.js b/test/built-ins/Map/prototype/forEach/iterates-in-key-insertion-order.js
new file mode 100644
index 0000000000000000000000000000000000000000..36a27cc55f5a1971fcec8111f2331759aff8488d
--- /dev/null
+++ b/test/built-ins/Map/prototype/forEach/iterates-in-key-insertion-order.js
@@ -0,0 +1,51 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.5
+description: >
+ Repeats for each non-empty record, in original key insertion order.
+info: >
+ Map.prototype.forEach ( callbackfn [ , thisArg ] )
+
+ ...
+ 5. If thisArg was supplied, let T be thisArg; else let T be undefined.
+ 6. Let entries be the List that is the value of M’s [[MapData]] internal slot.
+ 7. Repeat for each Record {[[key]], [[value]]} e that is an element of
+ entries, in original key insertion order
+ a. If e.[[key]] is not empty, then
+ i. Let funcResult be Call(callbackfn, T, «e.[[value]], e.[[key]], M»).
+ ...
+---*/
+
+var map = new Map([
+ ['foo', 'valid foo'],
+ ['bar', false],
+ ['baz', 'valid baz']
+]);
+map.set(0, false);
+map.set(1, false);
+map.set(2, 'valid 2');
+map.delete(1);
+map.delete('bar');
+
+// Not setting a new key, just changing the value
+map.set(0, 'valid 0');
+
+var results = [];
+var callback = function(value) {
+ results.push(value);
+};
+
+map.forEach(callback);
+
+assert.sameValue(results[0], 'valid foo');
+assert.sameValue(results[1], 'valid baz');
+assert.sameValue(results[2], 'valid 0');
+assert.sameValue(results[3], 'valid 2');
+assert.sameValue(results.length, 4);
+
+map.clear();
+results = [];
+
+map.forEach(callback);
+assert.sameValue(results.length, 0);
diff --git a/test/built-ins/Map/prototype/forEach/iterates-values-added-after-foreach-begins.js b/test/built-ins/Map/prototype/forEach/iterates-values-added-after-foreach-begins.js
new file mode 100644
index 0000000000000000000000000000000000000000..e398400cc0b5d63f29e427319151e50ba7c38dc7
--- /dev/null
+++ b/test/built-ins/Map/prototype/forEach/iterates-values-added-after-foreach-begins.js
@@ -0,0 +1,49 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.5
+description: >
+ New keys are visited if created during forEach execution.
+info: >
+ Map.prototype.forEach ( callbackfn [ , thisArg ] )
+
+ ...
+ 5. If thisArg was supplied, let T be thisArg; else let T be undefined.
+ 6. Let entries be the List that is the value of M’s [[MapData]] internal slot.
+ 7. Repeat for each Record {[[key]], [[value]]} e that is an element of
+ entries, in original key insertion order
+ a. If e.[[key]] is not empty, then
+ i. Let funcResult be Call(callbackfn, T, «e.[[value]], e.[[key]], M»).
+ ii. ReturnIfAbrupt(funcResult).
+ ...
+---*/
+
+var map = new Map();
+map.set('foo', 0);
+map.set('bar', 1);
+
+var count = 0;
+var results = [];
+
+map.forEach(function(value, key) {
+ if (count === 0) {
+ map.set('baz', 2);
+ }
+ results.push({
+ value: value,
+ key: key
+ });
+ count++;
+});
+
+assert.sameValue(count, 3);
+assert.sameValue(map.size, 3);
+
+assert.sameValue(results[0].key, 'foo');
+assert.sameValue(results[0].value, 0);
+
+assert.sameValue(results[1].key, 'bar');
+assert.sameValue(results[1].value, 1);
+
+assert.sameValue(results[2].key, 'baz');
+assert.sameValue(results[2].value, 2);
diff --git a/test/built-ins/Map/prototype/forEach/iterates-values-deleted-then-readded.js b/test/built-ins/Map/prototype/forEach/iterates-values-deleted-then-readded.js
new file mode 100644
index 0000000000000000000000000000000000000000..0aaaff50944e8c873e8c67616ef007da80fbc83e
--- /dev/null
+++ b/test/built-ins/Map/prototype/forEach/iterates-values-deleted-then-readded.js
@@ -0,0 +1,50 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.5
+description: >
+ New keys are visited if created during forEach execution.
+info: >
+ Map.prototype.forEach ( callbackfn [ , thisArg ] )
+
+ ...
+ 5. If thisArg was supplied, let T be thisArg; else let T be undefined.
+ 6. Let entries be the List that is the value of M’s [[MapData]] internal slot.
+ 7. Repeat for each Record {[[key]], [[value]]} e that is an element of
+ entries, in original key insertion order
+ a. If e.[[key]] is not empty, then
+ i. Let funcResult be Call(callbackfn, T, «e.[[value]], e.[[key]], M»).
+ ii. ReturnIfAbrupt(funcResult).
+ ...
+---*/
+
+var map = new Map();
+map.set('foo', 0);
+map.set('bar', 1);
+
+var count = 0;
+var results = [];
+
+map.forEach(function(value, key) {
+ if (count === 0) {
+ map.delete('foo');
+ map.set('foo', 'baz');
+ }
+ results.push({
+ value: value,
+ key: key
+ });
+ count++;
+});
+
+assert.sameValue(count, 3);
+assert.sameValue(map.size, 2);
+
+assert.sameValue(results[0].key, 'foo');
+assert.sameValue(results[0].value, 0);
+
+assert.sameValue(results[1].key, 'bar');
+assert.sameValue(results[1].value, 1);
+
+assert.sameValue(results[2].key, 'foo');
+assert.sameValue(results[2].value, 'baz');
diff --git a/test/built-ins/Map/prototype/forEach/length.js b/test/built-ins/Map/prototype/forEach/length.js
new file mode 100644
index 0000000000000000000000000000000000000000..3145a46003cdc5a9f2bc9b5c0f6e89b385c571eb
--- /dev/null
+++ b/test/built-ins/Map/prototype/forEach/length.js
@@ -0,0 +1,22 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.5
+description: >
+ Map.prototype.forEach.length value and descriptor.
+info: >
+ Map.prototype.forEach ( callbackfn [ , thisArg ] )
+
+ 17 ECMAScript Standard Built-in Objects
+
+includes: [propertyHelper.js]
+---*/
+
+assert.sameValue(
+ Map.prototype.forEach.length, 1,
+ 'The value of `Map.prototype.forEach.length` is `1`'
+);
+
+verifyNotEnumerable(Map.prototype.forEach, 'length');
+verifyNotWritable(Map.prototype.forEach, 'length');
+verifyConfigurable(Map.prototype.forEach, 'length');
diff --git a/test/built-ins/Map/prototype/forEach/name.js b/test/built-ins/Map/prototype/forEach/name.js
new file mode 100644
index 0000000000000000000000000000000000000000..8b4efed913b9deb33ec53ba196f7ea0524b1d325
--- /dev/null
+++ b/test/built-ins/Map/prototype/forEach/name.js
@@ -0,0 +1,22 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.5
+description: >
+ Map.prototype.forEach.name value and descriptor.
+info: >
+ Map.prototype.forEach ( callbackfn [ , thisArg ] )
+
+ 17 ECMAScript Standard Built-in Objects
+
+includes: [propertyHelper.js]
+---*/
+
+assert.sameValue(
+ Map.prototype.forEach.name, 'forEach',
+ 'The value of `Map.prototype.forEach.name` is `"forEach"`'
+);
+
+verifyNotEnumerable(Map.prototype.forEach, 'name');
+verifyNotWritable(Map.prototype.forEach, 'name');
+verifyConfigurable(Map.prototype.forEach, 'name');
diff --git a/test/built-ins/Map/prototype/forEach/return-undefined.js b/test/built-ins/Map/prototype/forEach/return-undefined.js
new file mode 100644
index 0000000000000000000000000000000000000000..67f443109ca4738dc39e3160d2d3b5cccdefdb3f
--- /dev/null
+++ b/test/built-ins/Map/prototype/forEach/return-undefined.js
@@ -0,0 +1,27 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.5
+description: >
+ Returns undefined.
+info: >
+ Map.prototype.forEach ( callbackfn [ , thisArg ] )
+
+ ...
+ 8. Return undefined.
+---*/
+
+var map = new Map();
+
+var result = map.forEach(function() {
+ return true;
+});
+
+assert.sameValue(result, undefined, 'Empty map#forEach returns undefined');
+
+map.set(1, 1);
+result = map.forEach(function() {
+ return true;
+});
+
+assert.sameValue(result, undefined, 'map#forEach returns undefined');
diff --git a/test/built-ins/Map/prototype/forEach/second-parameter-as-callback-context.js b/test/built-ins/Map/prototype/forEach/second-parameter-as-callback-context.js
new file mode 100644
index 0000000000000000000000000000000000000000..4aec8ce2303df2b29dbe51511c16c57956cf892e
--- /dev/null
+++ b/test/built-ins/Map/prototype/forEach/second-parameter-as-callback-context.js
@@ -0,0 +1,37 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.5
+description: >
+ If a thisArg parameter is provided, it will be used as the this value for each
+ invocation of callbackfn.
+info: >
+ Map.prototype.forEach ( callbackfn [ , thisArg ] )
+
+ ...
+ 5. If thisArg was supplied, let T be thisArg; else let T be undefined.
+ 6. Let entries be the List that is the value of M’s [[MapData]] internal slot.
+ 7. Repeat for each Record {[[key]], [[value]]} e that is an element of
+ entries, in original key insertion order
+ a. If e.[[key]] is not empty, then
+ i. Let funcResult be Call(callbackfn, T, «e.[[value]], e.[[key]], M»).
+ ...
+---*/
+
+var expectedThis = {};
+var _this = [];
+
+var map = new Map();
+map.set(0, 0);
+map.set(1, 1);
+map.set(2, 2);
+
+var callback = function() {
+ _this.push(this);
+};
+
+map.forEach(callback, expectedThis);
+
+assert.sameValue(_this[0], expectedThis);
+assert.sameValue(_this[1], expectedThis);
+assert.sameValue(_this[2], expectedThis);
diff --git a/test/built-ins/Map/prototype/forEach/this-not-object-throw.js b/test/built-ins/Map/prototype/forEach/this-not-object-throw.js
new file mode 100644
index 0000000000000000000000000000000000000000..94edf4ce02710a7b8d44a0e1f998f330268ff1e6
--- /dev/null
+++ b/test/built-ins/Map/prototype/forEach/this-not-object-throw.js
@@ -0,0 +1,43 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.5
+description: >
+ Throws a TypeError if `this` is not an Object.
+info: >
+ Map.prototype.forEach ( callbackfn [ , thisArg ] )
+
+ 1. Let M be the this value.
+ 2. If Type(M) is not Object, throw a TypeError exception.
+ ...
+features: [Symbol]
+---*/
+
+assert.throws(TypeError, function() {
+ Map.prototype.forEach.call(false, function() {});
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.forEach.call(1, function() {});
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.forEach.call('', function() {});
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.forEach.call(undefined, function() {});
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.forEach.call(null, function() {});
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.forEach.call(Symbol(), function() {});
+});
+
+assert.throws(TypeError, function() {
+ var map = new Map();
+ map.forEach.call(false, function() {});
+});
diff --git a/test/built-ins/Map/prototype/get/does-not-have-mapdata-internal-slot-set.js b/test/built-ins/Map/prototype/get/does-not-have-mapdata-internal-slot-set.js
new file mode 100644
index 0000000000000000000000000000000000000000..94a00466bc4ae91a4c546ecdead87abe124a3c79
--- /dev/null
+++ b/test/built-ins/Map/prototype/get/does-not-have-mapdata-internal-slot-set.js
@@ -0,0 +1,24 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.6
+description: >
+ Throws a TypeError if `this` is a Set object.
+info: >
+ Map.prototype.get ( key )
+
+ ...
+ 3. If M does not have a [[MapData]] internal slot, throw a TypeError
+ exception.
+ ...
+features: [Set]
+---*/
+
+assert.throws(TypeError, function() {
+ Map.prototype.get.call(new Set(), 1);
+});
+
+assert.throws(TypeError, function() {
+ var m = new Map();
+ m.get.call(new Set(), 1);
+});
diff --git a/test/built-ins/Map/prototype/get/does-not-have-mapdata-internal-slot-weakmap.js b/test/built-ins/Map/prototype/get/does-not-have-mapdata-internal-slot-weakmap.js
new file mode 100644
index 0000000000000000000000000000000000000000..535c655755fdec30b15164c14c27218e98bae0d0
--- /dev/null
+++ b/test/built-ins/Map/prototype/get/does-not-have-mapdata-internal-slot-weakmap.js
@@ -0,0 +1,24 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.6
+description: >
+ Throws a TypeError if `this` is a WeakMap object.
+info: >
+ Map.prototype.get ( key )
+
+ ...
+ 3. If M does not have a [[MapData]] internal slot, throw a TypeError
+ exception.
+ ...
+features: [WeakMap]
+---*/
+
+assert.throws(TypeError, function() {
+ Map.prototype.get.call(new WeakMap(), 1);
+});
+
+assert.throws(TypeError, function() {
+ var m = new Map();
+ m.get.call(new WeakMap(), 1);
+});
diff --git a/test/built-ins/Map/prototype/get/does-not-have-mapdata-internal-slot.js b/test/built-ins/Map/prototype/get/does-not-have-mapdata-internal-slot.js
new file mode 100644
index 0000000000000000000000000000000000000000..50f7ecc3b6c47c127dc74a245ebaa4285970dafc
--- /dev/null
+++ b/test/built-ins/Map/prototype/get/does-not-have-mapdata-internal-slot.js
@@ -0,0 +1,32 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.6
+description: >
+ Throws a TypeError if `this` object does not have a [[MapData]] internal slot.
+info: >
+ Map.prototype.get ( key )
+
+ ...
+ 3. If M does not have a [[MapData]] internal slot, throw a TypeError
+ exception.
+ ...
+---*/
+
+var m = new Map();
+
+assert.throws(TypeError, function() {
+ Map.prototype.get.call([], 1);
+});
+
+assert.throws(TypeError, function() {
+ m.get.call([], 1);
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.get.call({}, 1);
+});
+
+assert.throws(TypeError, function() {
+ m.get.call({}, 1);
+});
diff --git a/test/built-ins/Map/prototype/get/get.js b/test/built-ins/Map/prototype/get/get.js
new file mode 100644
index 0000000000000000000000000000000000000000..dc455d5b2043dd335c8e349670daee8505fa1664
--- /dev/null
+++ b/test/built-ins/Map/prototype/get/get.js
@@ -0,0 +1,22 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.6
+description: >
+ Property type and descriptor.
+info: >
+ Map.prototype.get ( key )
+
+ 17 ECMAScript Standard Built-in Objects
+includes: [propertyHelper.js]
+---*/
+
+assert.sameValue(
+ typeof Map.prototype.get,
+ 'function',
+ '`typeof Map.prototype.get` is `function`'
+);
+
+verifyNotEnumerable(Map.prototype, 'get');
+verifyWritable(Map.prototype, 'get');
+verifyConfigurable(Map.prototype, 'get');
diff --git a/test/built-ins/Map/prototype/get/length.js b/test/built-ins/Map/prototype/get/length.js
new file mode 100644
index 0000000000000000000000000000000000000000..1cf71d324517e9b472c5b9995e6d94cc55050fd1
--- /dev/null
+++ b/test/built-ins/Map/prototype/get/length.js
@@ -0,0 +1,22 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.6
+description: >
+ Map.prototype.get.length value and descriptor.
+info: >
+ Map.prototype.get ( key )
+
+ 17 ECMAScript Standard Built-in Objects
+
+includes: [propertyHelper.js]
+---*/
+
+assert.sameValue(
+ Map.prototype.get.length, 1,
+ 'The value of `Map.prototype.get.length` is `1`'
+);
+
+verifyNotEnumerable(Map.prototype.get, 'length');
+verifyNotWritable(Map.prototype.get, 'length');
+verifyConfigurable(Map.prototype.get, 'length');
diff --git a/test/built-ins/Map/prototype/get/name.js b/test/built-ins/Map/prototype/get/name.js
new file mode 100644
index 0000000000000000000000000000000000000000..1ddbf258c8d398bef669dd48abfa7c35fec3e718
--- /dev/null
+++ b/test/built-ins/Map/prototype/get/name.js
@@ -0,0 +1,22 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.6
+description: >
+ Map.prototype.get.name value and descriptor.
+info: >
+ Map.prototype.get ( key )
+
+ 17 ECMAScript Standard Built-in Objects
+
+includes: [propertyHelper.js]
+---*/
+
+assert.sameValue(
+ Map.prototype.get.name, 'get',
+ 'The value of `Map.prototype.get.name` is `"get"`'
+);
+
+verifyNotEnumerable(Map.prototype.get, 'name');
+verifyNotWritable(Map.prototype.get, 'name');
+verifyConfigurable(Map.prototype.get, 'name');
diff --git a/test/built-ins/Map/prototype/get/returns-undefined.js b/test/built-ins/Map/prototype/get/returns-undefined.js
new file mode 100644
index 0000000000000000000000000000000000000000..3adcdd16f139b32523a0721de082eb9196280735
--- /dev/null
+++ b/test/built-ins/Map/prototype/get/returns-undefined.js
@@ -0,0 +1,41 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.6
+description: >
+ Returns undefined when key is not on the map.
+info: >
+ Map.prototype.get ( key )
+
+ 4. Let entries be the List that is the value of M’s [[MapData]] internal slot.
+ 5. Repeat for each Record {[[key]], [[value]]} p that is an element of
+ entries,
+ a. If p.[[key]] is not empty and SameValueZero(p.[[key]], key) is true,
+ return p.[[value]].
+ 6. Return undefined.
+ ...
+---*/
+
+var map = new Map();
+
+assert.sameValue(
+ map.get('item'), undefined,
+ 'returns undefined if key is not on the map'
+);
+
+map.set('item', 1);
+map.set('another_item', 2);
+map.delete('item');
+
+assert.sameValue(
+ map.get('item'), undefined,
+ 'returns undefined if key was deleted'
+);
+
+map.set('item', 1);
+map.clear();
+
+assert.sameValue(
+ map.get('item'), undefined,
+ 'returns undefined after map is cleared'
+);
diff --git a/test/built-ins/Map/prototype/get/returns-value-different-key-types.js b/test/built-ins/Map/prototype/get/returns-value-different-key-types.js
new file mode 100644
index 0000000000000000000000000000000000000000..8f7ea286d2f520796045e059bba6a775dd429055
--- /dev/null
+++ b/test/built-ins/Map/prototype/get/returns-value-different-key-types.js
@@ -0,0 +1,48 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.6
+description: >
+ Returns the value from the specified key on different types.
+info: >
+ Map.prototype.get ( key )
+
+ 4. Let entries be the List that is the value of M’s [[MapData]] internal slot.
+ 5. Repeat for each Record {[[key]], [[value]]} p that is an element of
+ entries,
+ a. If p.[[key]] is not empty and SameValueZero(p.[[key]], key) is true,
+ return p.[[value]].
+ ...
+features: [Symbol]
+---*/
+
+var map = new Map();
+
+map.set('bar', 0);
+assert.sameValue(map.get('bar'), 0);
+
+map.set(1, 42);
+assert.sameValue(map.get(1), 42);
+
+map.set(NaN, 1);
+assert.sameValue(map.get(NaN), 1);
+
+var item = {};
+map.set(item, 2);
+assert.sameValue(map.get(item), 2);
+
+item = [];
+map.set(item, 3);
+assert.sameValue(map.get(item), 3);
+
+item = Symbol('item');
+map.set(item, 4);
+assert.sameValue(map.get(item), 4);
+
+item = null;
+map.set(item, 5);
+assert.sameValue(map.get(item), 5);
+
+item = undefined;
+map.set(item, 6);
+assert.sameValue(map.get(item), 6);
diff --git a/test/built-ins/Map/prototype/get/returns-value-normalized-zero-key.js b/test/built-ins/Map/prototype/get/returns-value-normalized-zero-key.js
new file mode 100644
index 0000000000000000000000000000000000000000..93a9ee842423f5c5dcb5afb869a405c9109f1ca6
--- /dev/null
+++ b/test/built-ins/Map/prototype/get/returns-value-normalized-zero-key.js
@@ -0,0 +1,25 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.6
+description: >
+ -0 and +0 are normalized to +0;
+info: >
+ Map.prototype.get ( key )
+
+ 4. Let entries be the List that is the value of M’s [[MapData]] internal slot.
+ 5. Repeat for each Record {[[key]], [[value]]} p that is an element of
+ entries,
+ a. If p.[[key]] is not empty and SameValueZero(p.[[key]], key) is true,
+ return p.[[value]].
+ ...
+---*/
+
+var map = new Map();
+
+map.set(+0, 42);
+assert.sameValue(map.get(-0), 42);
+
+map = new Map();
+map.set(-0, 43);
+assert.sameValue(map.get(+0), 43);
diff --git a/test/built-ins/Map/prototype/get/this-not-object-throw.js b/test/built-ins/Map/prototype/get/this-not-object-throw.js
new file mode 100644
index 0000000000000000000000000000000000000000..44ac9d9cb42064e06f5144a844a2016d3f299bae
--- /dev/null
+++ b/test/built-ins/Map/prototype/get/this-not-object-throw.js
@@ -0,0 +1,43 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.6
+description: >
+ Throws a TypeError if `this` is not an Object.
+info: >
+ Map.prototype.get ( key )
+
+ 1. Let M be the this value.
+ 2. If Type(M) is not Object, throw a TypeError exception.
+ ...
+features: [Symbol]
+---*/
+
+assert.throws(TypeError, function() {
+ Map.prototype.get.call(false, 1);
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.get.call(1, 1);
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.get.call('', 1);
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.get.call(undefined, 1);
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.get.call(null, 1);
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.get.call(Symbol(), 1);
+});
+
+assert.throws(TypeError, function() {
+ var map = new Map();
+ map.get.call(false, 1);
+});
diff --git a/test/built-ins/Map/prototype/has/does-not-have-mapdata-internal-slot-set.js b/test/built-ins/Map/prototype/has/does-not-have-mapdata-internal-slot-set.js
new file mode 100644
index 0000000000000000000000000000000000000000..8463ed436a394b28bdd0f320889e92e2a2e22be2
--- /dev/null
+++ b/test/built-ins/Map/prototype/has/does-not-have-mapdata-internal-slot-set.js
@@ -0,0 +1,24 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.7
+description: >
+ Throws a TypeError if `this` is a Set object.
+info: >
+ Map.prototype.has ( key )
+
+ ...
+ 3. If M does not have a [[MapData]] internal slot, throw a TypeError
+ exception.
+ ...
+features: [Set]
+---*/
+
+assert.throws(TypeError, function() {
+ Map.prototype.has.call(new Set(), 1);
+});
+
+assert.throws(TypeError, function() {
+ var m = new Map();
+ m.has.call(new Set(), 1);
+});
diff --git a/test/built-ins/Map/prototype/has/does-not-have-mapdata-internal-slot-weakmap.js b/test/built-ins/Map/prototype/has/does-not-have-mapdata-internal-slot-weakmap.js
new file mode 100644
index 0000000000000000000000000000000000000000..a095316c349e4df2a0cdeeb6fb2b58935d4a9968
--- /dev/null
+++ b/test/built-ins/Map/prototype/has/does-not-have-mapdata-internal-slot-weakmap.js
@@ -0,0 +1,24 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.7
+description: >
+ Throws a TypeError if `this` is a WeakMap object.
+info: >
+ Map.prototype.has ( key )
+
+ ...
+ 3. If M does not have a [[MapData]] internal slot, throw a TypeError
+ exception.
+ ...
+features: [WeakMap]
+---*/
+
+assert.throws(TypeError, function() {
+ Map.prototype.has.call(new WeakMap(), 1);
+});
+
+assert.throws(TypeError, function() {
+ var m = new Map();
+ m.has.call(new WeakMap(), 1);
+});
diff --git a/test/built-ins/Map/prototype/has/does-not-have-mapdata-internal-slot.js b/test/built-ins/Map/prototype/has/does-not-have-mapdata-internal-slot.js
new file mode 100644
index 0000000000000000000000000000000000000000..0a43e5b92034e94f5b4c36e7d090ccf62bf32c25
--- /dev/null
+++ b/test/built-ins/Map/prototype/has/does-not-have-mapdata-internal-slot.js
@@ -0,0 +1,32 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.7
+description: >
+ Throws a TypeError if `this` object does not have a [[MapData]] internal slot.
+info: >
+ Map.prototype.has ( key )
+
+ ...
+ 3. If M does not have a [[MapData]] internal slot, throw a TypeError
+ exception.
+ ...
+---*/
+
+var m = new Map();
+
+assert.throws(TypeError, function() {
+ Map.prototype.has.call([], 1);
+});
+
+assert.throws(TypeError, function() {
+ m.has.call([], 1);
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.has.call({}, 1);
+});
+
+assert.throws(TypeError, function() {
+ m.has.call({}, 1);
+});
diff --git a/test/built-ins/Map/prototype/has/has.js b/test/built-ins/Map/prototype/has/has.js
new file mode 100644
index 0000000000000000000000000000000000000000..1785c6731dbc427a19434acb9b160f8e27ac71e8
--- /dev/null
+++ b/test/built-ins/Map/prototype/has/has.js
@@ -0,0 +1,22 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.7
+description: >
+ Property type and descriptor.
+info: >
+ Map.prototype.has ( key )
+
+ 17 ECMAScript Standard Built-in Objects
+includes: [propertyHelper.js]
+---*/
+
+assert.sameValue(
+ typeof Map.prototype.has,
+ 'function',
+ '`typeof Map.prototype.has` is `function`'
+);
+
+verifyNotEnumerable(Map.prototype, 'has');
+verifyWritable(Map.prototype, 'has');
+verifyConfigurable(Map.prototype, 'has');
diff --git a/test/built-ins/Map/prototype/has/length.js b/test/built-ins/Map/prototype/has/length.js
new file mode 100644
index 0000000000000000000000000000000000000000..7ad1d6d286b56cd2f164ad4fab284b7ddf323b4f
--- /dev/null
+++ b/test/built-ins/Map/prototype/has/length.js
@@ -0,0 +1,22 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.7
+description: >
+ Map.prototype.has.length value and descriptor.
+info: >
+ Map.prototype.has ( key )
+
+ 17 ECMAScript Standard Built-in Objects
+
+includes: [propertyHelper.js]
+---*/
+
+assert.sameValue(
+ Map.prototype.has.length, 1,
+ 'The value of `Map.prototype.has.length` is `1`'
+);
+
+verifyNotEnumerable(Map.prototype.has, 'length');
+verifyNotWritable(Map.prototype.has, 'length');
+verifyConfigurable(Map.prototype.has, 'length');
diff --git a/test/built-ins/Map/prototype/has/name.js b/test/built-ins/Map/prototype/has/name.js
new file mode 100644
index 0000000000000000000000000000000000000000..cf6b6f912326a83e6382a68164b86ab53c0e61ef
--- /dev/null
+++ b/test/built-ins/Map/prototype/has/name.js
@@ -0,0 +1,22 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.7
+description: >
+ Map.prototype.has.name value and descriptor.
+info: >
+ Map.prototype.has ( key )
+
+ 17 ECMAScript Standard Built-in Objects
+
+includes: [propertyHelper.js]
+---*/
+
+assert.sameValue(
+ Map.prototype.has.name, 'has',
+ 'The value of `Map.prototype.has.name` is `"has"`'
+);
+
+verifyNotEnumerable(Map.prototype.has, 'name');
+verifyNotWritable(Map.prototype.has, 'name');
+verifyConfigurable(Map.prototype.has, 'name');
diff --git a/test/built-ins/Map/prototype/has/normalizes-zero-key.js b/test/built-ins/Map/prototype/has/normalizes-zero-key.js
new file mode 100644
index 0000000000000000000000000000000000000000..c8a31e1d3a9ba51c0fcadcd32fa08afdbc85573b
--- /dev/null
+++ b/test/built-ins/Map/prototype/has/normalizes-zero-key.js
@@ -0,0 +1,30 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.7
+description: >
+ -0 and +0 are normalized to +0;
+info: >
+ Map.prototype.has ( key )
+
+ 5. Repeat for each Record {[[key]], [[value]]} p that is an element of
+ entries,
+ a. If p.[[key]] is not empty and SameValueZero(p.[[key]], key) is true,
+ return true.
+ ...
+---*/
+
+var map = new Map();
+
+assert.sameValue(map.has(-0), false);
+assert.sameValue(map.has(+0), false);
+
+map.set(-0, 42);
+assert.sameValue(map.has(-0), true);
+assert.sameValue(map.has(+0), true);
+
+map.clear();
+
+map.set(+0, 42);
+assert.sameValue(map.has(-0), true);
+assert.sameValue(map.has(+0), true);
diff --git a/test/built-ins/Map/prototype/has/return-false-different-key-types.js b/test/built-ins/Map/prototype/has/return-false-different-key-types.js
new file mode 100644
index 0000000000000000000000000000000000000000..4567fb119da9c8661a4d793c8570d78960f05166
--- /dev/null
+++ b/test/built-ins/Map/prototype/has/return-false-different-key-types.js
@@ -0,0 +1,29 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.7
+description: >
+ Returns true for existing keys, using different key types.
+info: >
+ Map.prototype.has ( key )
+
+ 5. Repeat for each Record {[[key]], [[value]]} p that is an element of
+ entries,
+ i. If p.[[key]] is not empty and SameValueZero(p.[[key]], key) is true,
+ return true.
+ ...
+features: [Symbol]
+---*/
+
+var map = new Map();
+
+assert.sameValue(map.has('str'), false);
+assert.sameValue(map.has(1), false);
+assert.sameValue(map.has(NaN), false);
+assert.sameValue(map.has(true), false);
+assert.sameValue(map.has(false), false);
+assert.sameValue(map.has({}), false);
+assert.sameValue(map.has([]), false);
+assert.sameValue(map.has(Symbol()), false);
+assert.sameValue(map.has(null), false);
+assert.sameValue(map.has(undefined), false);
diff --git a/test/built-ins/Map/prototype/has/return-true-different-key-types.js b/test/built-ins/Map/prototype/has/return-true-different-key-types.js
new file mode 100644
index 0000000000000000000000000000000000000000..21fdb2f723069d789ad995766615b48109536e84
--- /dev/null
+++ b/test/built-ins/Map/prototype/has/return-true-different-key-types.js
@@ -0,0 +1,44 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.7
+description: >
+ Returns true for existing keys, using different key types.
+info: >
+ Map.prototype.has ( key )
+
+ 5. Repeat for each Record {[[key]], [[value]]} p that is an element of
+ entries,
+ i. If p.[[key]] is not empty and SameValueZero(p.[[key]], key) is true,
+ return true.
+ ...
+features: [Symbol]
+---*/
+
+var map = new Map();
+
+var obj = {};
+var arr = [];
+var symb = Symbol();
+
+map.set('str', undefined);
+map.set(1, undefined);
+map.set(NaN, undefined);
+map.set(true, undefined);
+map.set(false, undefined);
+map.set(obj, undefined);
+map.set(arr, undefined);
+map.set(symb, undefined);
+map.set(null, undefined);
+map.set(undefined, undefined);
+
+assert.sameValue(map.has('str'), true);
+assert.sameValue(map.has(1), true);
+assert.sameValue(map.has(NaN), true);
+assert.sameValue(map.has(true), true);
+assert.sameValue(map.has(false), true);
+assert.sameValue(map.has(obj), true);
+assert.sameValue(map.has(arr), true);
+assert.sameValue(map.has(symb), true);
+assert.sameValue(map.has(null), true);
+assert.sameValue(map.has(undefined), true);
diff --git a/test/built-ins/Map/prototype/has/this-not-object-throw.js b/test/built-ins/Map/prototype/has/this-not-object-throw.js
new file mode 100644
index 0000000000000000000000000000000000000000..4664fed22f386638775c1ff902b7e86068d81e1f
--- /dev/null
+++ b/test/built-ins/Map/prototype/has/this-not-object-throw.js
@@ -0,0 +1,43 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.7
+description: >
+ Throws a TypeError if `this` is not an Object.
+info: >
+ Map.prototype.has ( key )
+
+ 1. Let M be the this value.
+ 2. If Type(M) is not Object, throw a TypeError exception.
+ ...
+features: [Symbol]
+---*/
+
+assert.throws(TypeError, function() {
+ Map.prototype.has.call(false, 1);
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.has.call(1, 1);
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.has.call('', 1);
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.has.call(undefined, 1);
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.has.call(null, 1);
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.has.call(Symbol(), 1);
+});
+
+assert.throws(TypeError, function() {
+ var map = new Map();
+ map.has.call(false, 1);
+});
diff --git a/test/built-ins/Map/prototype/keys-no-map-data.js b/test/built-ins/Map/prototype/keys-no-map-data.js
deleted file mode 100644
index f026c9f152376a73cda9fc4b44668ab80eac2115..0000000000000000000000000000000000000000
--- a/test/built-ins/Map/prototype/keys-no-map-data.js
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright (C) 2014 the V8 project authors. All rights reserved.
-// This code is governed by the BSD license found in the LICENSE file.
-
-/*---
- description: >
- If the context does not have a [[MapData]] internal slot, throw a
- TypeError exception as per 23.1.5.1.
- es6id: 23.1.3.8
- ---*/
-
-assert.throws(TypeError, function() {
- Map.prototype.keys.call({});
-});
diff --git a/test/built-ins/Map/prototype/keys/does-not-have-mapdata-internal-slot-set.js b/test/built-ins/Map/prototype/keys/does-not-have-mapdata-internal-slot-set.js
new file mode 100644
index 0000000000000000000000000000000000000000..93d71a75d8ea02ff3bae0a3a296dfb7410832ab7
--- /dev/null
+++ b/test/built-ins/Map/prototype/keys/does-not-have-mapdata-internal-slot-set.js
@@ -0,0 +1,29 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.8
+description: >
+ Throws a TypeError if `this` is a Set object.
+info: >
+ Map.prototype.keys ()
+
+ 1. Let M be the this value.
+ 2. Return CreateMapIterator(M, "key").
+
+ 23.1.5.1 CreateMapIterator Abstract Operation
+
+ ...
+ 2. If map does not have a [[MapData]] internal slot, throw a TypeError
+ exception.
+ ...
+features: [Set]
+---*/
+
+assert.throws(TypeError, function() {
+ Map.prototype.keys.call(new Set());
+});
+
+assert.throws(TypeError, function() {
+ var m = new Map();
+ m.keys.call(new Set());
+});
diff --git a/test/built-ins/Map/prototype/keys/does-not-have-mapdata-internal-slot-weakmap.js b/test/built-ins/Map/prototype/keys/does-not-have-mapdata-internal-slot-weakmap.js
new file mode 100644
index 0000000000000000000000000000000000000000..7ed7992d9016f1436d7591a2cd9ccae22ee47a95
--- /dev/null
+++ b/test/built-ins/Map/prototype/keys/does-not-have-mapdata-internal-slot-weakmap.js
@@ -0,0 +1,29 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.8
+description: >
+ Throws a TypeError if `this` is a WeakMap object.
+info: >
+ Map.prototype.keys ()
+
+ 1. Let M be the this value.
+ 2. Return CreateMapIterator(M, "key").
+
+ 23.1.5.1 CreateMapIterator Abstract Operation
+
+ ...
+ 2. If map does not have a [[MapData]] internal slot, throw a TypeError
+ exception.
+ ...
+features: [WeakMap]
+---*/
+
+assert.throws(TypeError, function() {
+ Map.prototype.keys.call(new WeakMap());
+});
+
+assert.throws(TypeError, function() {
+ var m = new Map();
+ m.keys.call(new WeakMap());
+});
diff --git a/test/built-ins/Map/prototype/keys/does-not-have-mapdata-internal-slot.js b/test/built-ins/Map/prototype/keys/does-not-have-mapdata-internal-slot.js
new file mode 100644
index 0000000000000000000000000000000000000000..9ee5cc471aab73e899bc0094759f08b2eee687bc
--- /dev/null
+++ b/test/built-ins/Map/prototype/keys/does-not-have-mapdata-internal-slot.js
@@ -0,0 +1,38 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.8
+description: >
+ Throws a TypeError if `this` object does not have a [[MapData]] internal slot.
+info: >
+ Map.prototype.keys ()
+
+ 1. Let M be the this value.
+ 2. Return CreateMapIterator(M, "key").
+
+ 23.1.5.1 CreateMapIterator Abstract Operation
+
+ ...
+ 2. If map does not have a [[MapData]] internal slot, throw a TypeError
+ exception.
+ ...
+
+---*/
+
+var m = new Map();
+
+assert.throws(TypeError, function() {
+ Map.prototype.keys.call([]);
+});
+
+assert.throws(TypeError, function() {
+ m.keys.call([]);
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.keys.call({});
+});
+
+assert.throws(TypeError, function() {
+ m.keys.call({});
+});
diff --git a/test/built-ins/Map/prototype/keys/keys.js b/test/built-ins/Map/prototype/keys/keys.js
new file mode 100644
index 0000000000000000000000000000000000000000..3405754e9b0f768cde264f8818508ab5d9cf6364
--- /dev/null
+++ b/test/built-ins/Map/prototype/keys/keys.js
@@ -0,0 +1,22 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.8
+description: >
+ Property type and descriptor.
+info: >
+ Map.prototype.keys ()
+
+ 17 ECMAScript Standard Built-in Objects
+includes: [propertyHelper.js]
+---*/
+
+assert.sameValue(
+ typeof Map.prototype.keys,
+ 'function',
+ '`typeof Map.prototype.keys` is `function`'
+);
+
+verifyNotEnumerable(Map.prototype, 'keys');
+verifyWritable(Map.prototype, 'keys');
+verifyConfigurable(Map.prototype, 'keys');
diff --git a/test/built-ins/Map/prototype/keys/length.js b/test/built-ins/Map/prototype/keys/length.js
new file mode 100644
index 0000000000000000000000000000000000000000..485c1322641d3dda4282b2105a2b3632d71b1e13
--- /dev/null
+++ b/test/built-ins/Map/prototype/keys/length.js
@@ -0,0 +1,22 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.8
+description: >
+ Map.prototype.keys.length value and descriptor.
+info: >
+ Map.prototype.keys ()
+
+ 17 ECMAScript Standard Built-in Objects
+
+includes: [propertyHelper.js]
+---*/
+
+assert.sameValue(
+ Map.prototype.keys.length, 0,
+ 'The value of `Map.prototype.keys.length` is `0`'
+);
+
+verifyNotEnumerable(Map.prototype.keys, 'length');
+verifyNotWritable(Map.prototype.keys, 'length');
+verifyConfigurable(Map.prototype.keys, 'length');
diff --git a/test/built-ins/Map/prototype/keys/name.js b/test/built-ins/Map/prototype/keys/name.js
new file mode 100644
index 0000000000000000000000000000000000000000..c5464b0912cc41f6c0865f8db35bca3c3d93d22a
--- /dev/null
+++ b/test/built-ins/Map/prototype/keys/name.js
@@ -0,0 +1,22 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.8
+description: >
+ Map.prototype.keys.name value and descriptor.
+info: >
+ Map.prototype.keys ()
+
+ 17 ECMAScript Standard Built-in Objects
+
+includes: [propertyHelper.js]
+---*/
+
+assert.sameValue(
+ Map.prototype.keys.name, 'keys',
+ 'The value of `Map.prototype.keys.name` is `"keys"`'
+);
+
+verifyNotEnumerable(Map.prototype.keys, 'name');
+verifyNotWritable(Map.prototype.keys, 'name');
+verifyConfigurable(Map.prototype.keys, 'name');
diff --git a/test/built-ins/Map/prototype/keys/returns-iterator-empty.js b/test/built-ins/Map/prototype/keys/returns-iterator-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..08618c34bdca149f8e8cf639b3d4bff656688ec4
--- /dev/null
+++ b/test/built-ins/Map/prototype/keys/returns-iterator-empty.js
@@ -0,0 +1,27 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.8
+description: >
+ Returns an iterator on an empty Map object.
+info: >
+ Map.prototype.keys ()
+
+ ...
+ 2. Return CreateMapIterator(M, "key").
+
+ 23.1.5.1 CreateMapIterator Abstract Operation
+
+ ...
+ 7. Return iterator.
+---*/
+
+var map = new Map();
+var iterator = map.keys();
+var result = iterator.next();
+
+assert.sameValue(
+ result.value, undefined,
+ 'The value of `result.value` is `undefined`'
+);
+assert.sameValue(result.done, true, 'The value of `result.done` is `true`');
diff --git a/test/built-ins/Map/prototype/keys-iteration.js b/test/built-ins/Map/prototype/keys/returns-iterator.js
similarity index 58%
rename from test/built-ins/Map/prototype/keys-iteration.js
rename to test/built-ins/Map/prototype/keys/returns-iterator.js
index 5d0bd671bfb654798dbbd0e4b0a4b0bd89c21b50..786284b32076041758dbea1360b9690e7e7c3fa0 100644
--- a/test/built-ins/Map/prototype/keys-iteration.js
+++ b/test/built-ins/Map/prototype/keys/returns-iterator.js
@@ -1,31 +1,40 @@
-// Copyright (C) 2014 the V8 project authors. All rights reserved.
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
-
/*---
- description: >
- The method should return a valid iterator with the context as the
- IteratedObject.
- es6id: 23.1.3.8
- ---*/
+es6id: 23.1.3.8
+description: >
+ Returns an iterator.
+info: >
+ Map.prototype.keys ( )
+
+ ...
+ 2. Return CreateMapIterator(M, "key").
+
+ 23.1.5.1 CreateMapIterator Abstract Operation
+
+ ...
+ 7. Return iterator.
+---*/
+var obj = {};
var map = new Map();
-map.set(1, 11);
-map.set(2, 22);
-map.set(3, 33);
+map.set('foo', 1);
+map.set(obj, 2);
+map.set(map, 3);
var iterator = map.keys();
var result;
result = iterator.next();
-assert.sameValue(result.value, 1, 'First result `value`');
+assert.sameValue(result.value, 'foo', 'First result `value` ("key")');
assert.sameValue(result.done, false, 'First result `done` flag');
result = iterator.next();
-assert.sameValue(result.value, 2, 'Second result `value`');
+assert.sameValue(result.value, obj, 'Second result `value` ("key")');
assert.sameValue(result.done, false, 'Second result `done` flag');
result = iterator.next();
-assert.sameValue(result.value, 3, 'Third result `value`');
+assert.sameValue(result.value, map, 'Third result `value` ("key")');
assert.sameValue(result.done, false, 'Third result `done` flag');
result = iterator.next();
diff --git a/test/built-ins/Map/prototype/keys/this-not-object-throw.js b/test/built-ins/Map/prototype/keys/this-not-object-throw.js
new file mode 100644
index 0000000000000000000000000000000000000000..1b81e80ebaeb0e868852f56728a7426d5291ddb9
--- /dev/null
+++ b/test/built-ins/Map/prototype/keys/this-not-object-throw.js
@@ -0,0 +1,47 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.8
+description: >
+ Throws a TypeError if `this` is not an Object.
+info: >
+ Map.prototype.keys ()
+
+ ...
+ 2. Return CreateMapIterator(M, "key").
+
+ 23.1.5.1 CreateMapIterator Abstract Operation
+
+ 1. If Type(map) is not Object, throw a TypeError exception.
+ ...
+features: [Symbol]
+---*/
+
+assert.throws(TypeError, function() {
+ Map.prototype.keys.call(false);
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.keys.call(1);
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.keys.call('');
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.keys.call(undefined);
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.keys.call(null);
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.keys.call(Symbol());
+});
+
+assert.throws(TypeError, function() {
+ var map = new Map();
+ map.keys.call(false);
+});
diff --git a/test/built-ins/Map/prototype/set/append-new-values-normalizes-zero-key.js b/test/built-ins/Map/prototype/set/append-new-values-normalizes-zero-key.js
new file mode 100644
index 0000000000000000000000000000000000000000..8e3d46725a11ed8703a94cc9214c42c2ffc996ff
--- /dev/null
+++ b/test/built-ins/Map/prototype/set/append-new-values-normalizes-zero-key.js
@@ -0,0 +1,25 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.9
+description: >
+ Appends new value in the map normalizing +0 and -0.
+info: >
+ Map.prototype.set ( key , value )
+
+ ...
+ 6. If key is −0, let key be +0.
+ 7. Let p be the Record {[[key]]: key, [[value]]: value}.
+ 8. Append p as the last element of entries.
+ 9. Return M.
+ ...
+---*/
+
+var map = new Map();
+map.set(-0, 42);
+
+assert.sameValue(map.get(0), 42);
+
+map = new Map();
+map.set(+0, 43);
+assert.sameValue(map.get(0), 43);
diff --git a/test/built-ins/Map/prototype/set/append-new-values-return-map.js b/test/built-ins/Map/prototype/set/append-new-values-return-map.js
new file mode 100644
index 0000000000000000000000000000000000000000..440858b7c0e591f2cc1adb94acb8fdc9b3819985
--- /dev/null
+++ b/test/built-ins/Map/prototype/set/append-new-values-return-map.js
@@ -0,0 +1,30 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.9
+description: >
+ Map.prototype.set returns the given `this` object.
+info: >
+ Map.prototype.set ( key , value )
+
+ ...
+ 6. If key is −0, let key be +0.
+ 7. Let p be the Record {[[key]]: key, [[value]]: value}.
+ 8. Append p as the last element of entries.
+ 9. Return M.
+ ...
+---*/
+
+var map = new Map();
+var result = map.set(1, 1);
+
+assert.sameValue(result, map);
+
+result = map.set(1,1).set(2,2).set(3,3);
+
+assert.sameValue(result, map, 'Map.prototype.set is chainable');
+
+var map2 = new Map();
+result = map2.set.call(map, 4, 4);
+
+assert.sameValue(result, map);
diff --git a/test/built-ins/Map/prototype/set/append-new-values.js b/test/built-ins/Map/prototype/set/append-new-values.js
new file mode 100644
index 0000000000000000000000000000000000000000..2c15ffed71fc1fbf57a77fef88711fe7cb93a45d
--- /dev/null
+++ b/test/built-ins/Map/prototype/set/append-new-values.js
@@ -0,0 +1,47 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.9
+description: >
+ Append a new value as the last element of entries.
+info: >
+ Map.prototype.set ( key , value )
+
+ ...
+ 6. If key is −0, let key be +0.
+ 7. Let p be the Record {[[key]]: key, [[value]]: value}.
+ 8. Append p as the last element of entries.
+ 9. Return M.
+ ...
+features: [Symbol]
+---*/
+
+var s = Symbol(2);
+var map = new Map([[4, 4], ['foo3', 3], [s, 2]]);
+
+map.set(null, 42);
+map.set(1, 'valid');
+
+assert.sameValue(map.size, 5);
+assert.sameValue(map.get(1), 'valid');
+
+var results = [];
+
+map.forEach(function(value, key) {
+ results.push({
+ value: value,
+ key: key
+ });
+});
+
+var result = results.pop();
+assert.sameValue(result.value, 'valid');
+assert.sameValue(result.key, 1);
+
+result = results.pop();
+assert.sameValue(result.value, 42);
+assert.sameValue(result.key, null);
+
+result = results.pop();
+assert.sameValue(result.value, 2);
+assert.sameValue(result.key, s);
diff --git a/test/built-ins/Map/prototype/set/does-not-have-mapdata-internal-slot-set.js b/test/built-ins/Map/prototype/set/does-not-have-mapdata-internal-slot-set.js
new file mode 100644
index 0000000000000000000000000000000000000000..35e1946f90eea527df23d0eca0542458549f77cf
--- /dev/null
+++ b/test/built-ins/Map/prototype/set/does-not-have-mapdata-internal-slot-set.js
@@ -0,0 +1,24 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.9
+description: >
+ Throws a TypeError if `this` is a Set object.
+info: >
+ Map.prototype.set ( key , value )
+
+ ...
+ 3. If M does not have a [[MapData]] internal slot, throw a TypeError
+ exception.
+ ...
+features: [Set]
+---*/
+
+assert.throws(TypeError, function() {
+ Map.prototype.set.call(new Set(), 1, 1);
+});
+
+assert.throws(TypeError, function() {
+ var m = new Map();
+ m.set.call(new Set(), 1, 1);
+});
diff --git a/test/built-ins/Map/prototype/set/does-not-have-mapdata-internal-slot-weakmap.js b/test/built-ins/Map/prototype/set/does-not-have-mapdata-internal-slot-weakmap.js
new file mode 100644
index 0000000000000000000000000000000000000000..8f01f626b2842bfd9e734b87b3042c7ee719289f
--- /dev/null
+++ b/test/built-ins/Map/prototype/set/does-not-have-mapdata-internal-slot-weakmap.js
@@ -0,0 +1,24 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.9
+description: >
+ Throws a TypeError if `this` is a WeakMap object.
+info: >
+ Map.prototype.set ( key , value )
+
+ ...
+ 3. If M does not have a [[MapData]] internal slot, throw a TypeError
+ exception.
+ ...
+features: [WeakMap]
+---*/
+
+assert.throws(TypeError, function() {
+ Map.prototype.set.call(new WeakMap(), 1, 1);
+});
+
+assert.throws(TypeError, function() {
+ var m = new Map();
+ m.set.call(new WeakMap(), 1, 1);
+});
diff --git a/test/built-ins/Map/prototype/set/does-not-have-mapdata-internal-slot.js b/test/built-ins/Map/prototype/set/does-not-have-mapdata-internal-slot.js
new file mode 100644
index 0000000000000000000000000000000000000000..d5106a7b86a1e3676fe39f1884210ad7cc71b962
--- /dev/null
+++ b/test/built-ins/Map/prototype/set/does-not-have-mapdata-internal-slot.js
@@ -0,0 +1,32 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.9
+description: >
+ Throws a TypeError if `this` object does not have a [[MapData]] internal slot.
+info: >
+ Map.prototype.set ( key , value )
+
+ ...
+ 3. If M does not have a [[MapData]] internal slot, throw a TypeError
+ exception.
+ ...
+---*/
+
+var m = new Map();
+
+assert.throws(TypeError, function() {
+ Map.prototype.set.call([], 1, 1);
+});
+
+assert.throws(TypeError, function() {
+ m.set.call([], 1, 1);
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.set.call({}, 1, 1);
+});
+
+assert.throws(TypeError, function() {
+ m.set.call({}, 1, 1);
+});
diff --git a/test/built-ins/Map/prototype/set/length.js b/test/built-ins/Map/prototype/set/length.js
new file mode 100644
index 0000000000000000000000000000000000000000..c6bdc232bb7fc3a8eddc50e5f16c3eb35face07b
--- /dev/null
+++ b/test/built-ins/Map/prototype/set/length.js
@@ -0,0 +1,22 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.9
+description: >
+ Map.prototype.set.length value and descriptor.
+info: >
+ Map.prototype.set ( key , value )
+
+ 17 ECMAScript Standard Built-in Objects
+
+includes: [propertyHelper.js]
+---*/
+
+assert.sameValue(
+ Map.prototype.set.length, 2,
+ 'The value of `Map.prototype.set.length` is `2`'
+);
+
+verifyNotEnumerable(Map.prototype.set, 'length');
+verifyNotWritable(Map.prototype.set, 'length');
+verifyConfigurable(Map.prototype.set, 'length');
diff --git a/test/built-ins/Map/prototype/set/name.js b/test/built-ins/Map/prototype/set/name.js
new file mode 100644
index 0000000000000000000000000000000000000000..263b2a2250b1c7c2314bc52455049dcce69e40f7
--- /dev/null
+++ b/test/built-ins/Map/prototype/set/name.js
@@ -0,0 +1,22 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.9
+description: >
+ Map.prototype.set.name value and descriptor.
+info: >
+ Map.prototype.set ( key , value )
+
+ 17 ECMAScript Standard Built-in Objects
+
+includes: [propertyHelper.js]
+---*/
+
+assert.sameValue(
+ Map.prototype.set.name, 'set',
+ 'The value of `Map.prototype.set.name` is `"set"`'
+);
+
+verifyNotEnumerable(Map.prototype.set, 'name');
+verifyNotWritable(Map.prototype.set, 'name');
+verifyConfigurable(Map.prototype.set, 'name');
diff --git a/test/built-ins/Map/prototype/set/replaces-a-value-normalizes-zero-key.js b/test/built-ins/Map/prototype/set/replaces-a-value-normalizes-zero-key.js
new file mode 100644
index 0000000000000000000000000000000000000000..484e891a39d1460c6016a4da2d2c254e06259134
--- /dev/null
+++ b/test/built-ins/Map/prototype/set/replaces-a-value-normalizes-zero-key.js
@@ -0,0 +1,26 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.9
+description: >
+ Replaces a value in the map normalizing +0 and -0.
+info: >
+ Map.prototype.set ( key , value )
+
+ ...
+ 5. Repeat for each Record {[[key]], [[value]]} p that is an element of
+ entries,
+ a. If p.[[key]] is not empty and SameValueZero(p.[[key]], key) is true, then
+ i. Set p.[[value]] to value.
+ ii. Return M.
+ ...
+---*/
+
+var map = new Map([[+0, 1]]);
+
+map.set(-0, 42);
+assert.sameValue(map.get(+0), 42, 'zero key is normalized in SameValueZero');
+
+map = new Map([[-0, 1]]);
+map.set(+0, 42);
+assert.sameValue(map.get(-0), 42, 'zero key is normalized in SameValueZero');
diff --git a/test/built-ins/Map/prototype/set/replaces-a-value-returns-map.js b/test/built-ins/Map/prototype/set/replaces-a-value-returns-map.js
new file mode 100644
index 0000000000000000000000000000000000000000..41f3b06963bdaf760985620d5b29e24d3735610b
--- /dev/null
+++ b/test/built-ins/Map/prototype/set/replaces-a-value-returns-map.js
@@ -0,0 +1,30 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.9
+description: >
+ Map.prototype.set returns the given `this` map object.
+info: >
+ Map.prototype.set ( key , value )
+
+ 1. Let M be the this value.
+ ...
+ 5. Repeat for each Record {[[key]], [[value]]} p that is an element of
+ entries,
+ a. If p.[[key]] is not empty and SameValueZero(p.[[key]], key) is true, then
+ i. Set p.[[value]] to value.
+ ii. Return M.
+ ...
+---*/
+
+var map = new Map([['item', 0]]);
+var map2 = new Map();
+
+var x = map.set('item', 42);
+assert.sameValue(x, map);
+
+x = Map.prototype.set.call(map, 'item', 0);
+assert.sameValue(x, map);
+
+x = map2.set.call(map, 'item', 0);
+assert.sameValue(x, map, 'Map#set returns the map `this` value');
diff --git a/test/built-ins/Map/prototype/set/replaces-a-value.js b/test/built-ins/Map/prototype/set/replaces-a-value.js
new file mode 100644
index 0000000000000000000000000000000000000000..f082ceca8749b0e24c5c21b71ecaf7937bd7b6e9
--- /dev/null
+++ b/test/built-ins/Map/prototype/set/replaces-a-value.js
@@ -0,0 +1,23 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.9
+description: >
+ Replaces a value in the map.
+info: >
+ Map.prototype.set ( key , value )
+
+ ...
+ 5. Repeat for each Record {[[key]], [[value]]} p that is an element of
+ entries,
+ a. If p.[[key]] is not empty and SameValueZero(p.[[key]], key) is true, then
+ i. Set p.[[value]] to value.
+ ii. Return M.
+ ...
+---*/
+
+var m = new Map([['item', 1]]);
+
+m.set('item', 42);
+assert.sameValue(m.get('item'), 42);
+assert.sameValue(m.size, 1);
diff --git a/test/built-ins/Map/prototype/set/set.js b/test/built-ins/Map/prototype/set/set.js
new file mode 100644
index 0000000000000000000000000000000000000000..36e0577d38885615e4b1678874ef9549c71b8f96
--- /dev/null
+++ b/test/built-ins/Map/prototype/set/set.js
@@ -0,0 +1,22 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.9
+description: >
+ Property type and descriptor.
+info: >
+ Map.prototype.set ( key , value )
+
+ 17 ECMAScript Standard Built-in Objects
+includes: [propertyHelper.js]
+---*/
+
+assert.sameValue(
+ typeof Map.prototype.set,
+ 'function',
+ '`typeof Map.prototype.set` is `function`'
+);
+
+verifyNotEnumerable(Map.prototype, 'set');
+verifyWritable(Map.prototype, 'set');
+verifyConfigurable(Map.prototype, 'set');
diff --git a/test/built-ins/Map/prototype/set/this-not-object-throw.js b/test/built-ins/Map/prototype/set/this-not-object-throw.js
new file mode 100644
index 0000000000000000000000000000000000000000..0e0d4fea68358963cef1772beea6c070dcb158dd
--- /dev/null
+++ b/test/built-ins/Map/prototype/set/this-not-object-throw.js
@@ -0,0 +1,43 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.9
+description: >
+ Throws a TypeError if `this` is not an Object.
+info: >
+ Map.prototype.set ( key , value )
+
+ 1. Let M be the this value.
+ 2. If Type(M) is not Object, throw a TypeError exception.
+ ...
+features: [Symbol]
+---*/
+
+assert.throws(TypeError, function() {
+ Map.prototype.set.call(false, 1, 1);
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.set.call(1, 1, 1);
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.set.call('', 1, 1);
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.set.call(undefined, 1, 1);
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.set.call(null, 1, 1);
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.set.call(Symbol(), 1, 1);
+});
+
+assert.throws(TypeError, function() {
+ var map = new Map();
+ map.set.call(false, 1, 1);
+});
diff --git a/test/built-ins/Map/prototype/size/does-not-have-mapdata-internal-slot-set.js b/test/built-ins/Map/prototype/size/does-not-have-mapdata-internal-slot-set.js
new file mode 100644
index 0000000000000000000000000000000000000000..b2d487cc35076afcfd50a2e5579daced5dc8abd3
--- /dev/null
+++ b/test/built-ins/Map/prototype/size/does-not-have-mapdata-internal-slot-set.js
@@ -0,0 +1,26 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.10
+description: >
+ Throws a TypeError if `this` is a Set object.
+info: >
+ Map.prototype.set ( key , value )
+
+ ...
+ 3. If M does not have a [[MapData]] internal slot, throw a TypeError
+ exception.
+ ...
+features: [Set]
+---*/
+
+var descriptor = Object.getOwnPropertyDescriptor(Map.prototype, 'size');
+
+var map = new Map();
+
+// Does not throw
+descriptor.get.call(map);
+
+assert.throws(TypeError, function() {
+ descriptor.get.call(new Set());
+});
diff --git a/test/built-ins/Map/prototype/size/does-not-have-mapdata-internal-slot-weakmap.js b/test/built-ins/Map/prototype/size/does-not-have-mapdata-internal-slot-weakmap.js
new file mode 100644
index 0000000000000000000000000000000000000000..2cc3e8b586b278084942481d4e313b46fc6aa8dd
--- /dev/null
+++ b/test/built-ins/Map/prototype/size/does-not-have-mapdata-internal-slot-weakmap.js
@@ -0,0 +1,27 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.9
+description: >
+ Throws a TypeError if `this` is a WeakMap object.
+info: >
+ get Map.prototype.size
+
+ 1. Let M be the this value.
+ 2. If Type(M) is not Object, throw a TypeError exception.
+ 3. If M does not have a [[MapData]] internal slot, throw a TypeError
+ exception.
+ ...
+features: [WeakMap]
+---*/
+
+var descriptor = Object.getOwnPropertyDescriptor(Map.prototype, 'size');
+
+var map = new Map();
+
+// Does not throw
+descriptor.get.call(map);
+
+assert.throws(TypeError, function() {
+ descriptor.get.call(new WeakMap());
+});
diff --git a/test/built-ins/Map/prototype/size/does-not-have-mapdata-internal-slot.js b/test/built-ins/Map/prototype/size/does-not-have-mapdata-internal-slot.js
new file mode 100644
index 0000000000000000000000000000000000000000..ae115355d49e57b6660360f2700046e38d73d34e
--- /dev/null
+++ b/test/built-ins/Map/prototype/size/does-not-have-mapdata-internal-slot.js
@@ -0,0 +1,26 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.9
+description: >
+ Throws a TypeError if `this` object does not have a [[MapData]] internal slot.
+info: >
+ get Map.prototype.size
+
+ 1. Let M be the this value.
+ 2. If Type(M) is not Object, throw a TypeError exception.
+ 3. If M does not have a [[MapData]] internal slot, throw a TypeError
+ exception.
+ ...
+---*/
+
+var descriptor = Object.getOwnPropertyDescriptor(Map.prototype, 'size');
+
+var map = new Map();
+
+// Does not throw
+descriptor.get.call(map);
+
+assert.throws(TypeError, function() {
+ descriptor.get.call([]);
+});
diff --git a/test/built-ins/Map/prototype/size/length.js b/test/built-ins/Map/prototype/size/length.js
new file mode 100644
index 0000000000000000000000000000000000000000..27a8c7fe6dccf8fc3b588e267d3a578c5c95d1a4
--- /dev/null
+++ b/test/built-ins/Map/prototype/size/length.js
@@ -0,0 +1,23 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.10
+description: >
+ Map.prototype.size.length value and descriptor.
+info: >
+ get Map.prototype.size
+
+ 17 ECMAScript Standard Built-in Objects
+includes: [propertyHelper.js]
+---*/
+
+var descriptor = Object.getOwnPropertyDescriptor(Map.prototype, 'size');
+
+assert.sameValue(
+ descriptor.get.length, 0,
+ 'The value of `Map.prototype.size.length` is `0`'
+);
+
+verifyNotEnumerable(descriptor.get, 'length');
+verifyNotWritable(descriptor.get, 'length');
+verifyConfigurable(descriptor.get, 'length');
diff --git a/test/built-ins/Map/prototype/size/name.js b/test/built-ins/Map/prototype/size/name.js
new file mode 100644
index 0000000000000000000000000000000000000000..c1ec7cb7c04234e4dbf11e010087269c19733575
--- /dev/null
+++ b/test/built-ins/Map/prototype/size/name.js
@@ -0,0 +1,27 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.10
+description: >
+ Map.prototype.size.name value and descriptor.
+info: >
+ get Map.prototype.size
+
+ 17 ECMAScript Standard Built-in Objects
+
+ Functions that are specified as get or set accessor functions of built-in
+ properties have "get " or "set " prepended to the property name string.
+
+includes: [propertyHelper.js]
+---*/
+
+var descriptor = Object.getOwnPropertyDescriptor(Map.prototype, 'size');
+
+assert.sameValue(descriptor.get.name,
+ 'get size',
+ 'The value of `descriptor.get.name` is `get size`'
+);
+
+verifyNotEnumerable(descriptor.get, 'name');
+verifyNotWritable(descriptor.get, 'name');
+verifyConfigurable(descriptor.get, 'name');
diff --git a/test/built-ins/Map/prototype/size/returns-count-of-present-values-before-after-set-clear.js b/test/built-ins/Map/prototype/size/returns-count-of-present-values-before-after-set-clear.js
new file mode 100644
index 0000000000000000000000000000000000000000..e46bca6906fd63b551378189c746025b02861377
--- /dev/null
+++ b/test/built-ins/Map/prototype/size/returns-count-of-present-values-before-after-set-clear.js
@@ -0,0 +1,30 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.10
+description: >
+ Returns count of present values before and after using `set` and `clear`.
+info: >
+ get Map.prototype.size
+
+ 5. Let count be 0.
+ 6. For each Record {[[key]], [[value]]} p that is an element of entries
+ a. If p.[[key]] is not empty, set count to count+1.
+---*/
+
+var map = new Map();
+
+assert.sameValue(map.size, 0, 'The value of `map.size` is `0`');
+
+map.set(1, 1);
+map.set(2, 2);
+assert.sameValue(
+ map.size, 2,
+ 'The value of `map.size` is `2`'
+);
+
+map.clear();
+assert.sameValue(
+ map.size, 0,
+ 'The value of `map.size` is `0`, after executing `map.clear()`'
+);
diff --git a/test/built-ins/Map/prototype/size/returns-count-of-present-values-before-after-set-delete.js b/test/built-ins/Map/prototype/size/returns-count-of-present-values-before-after-set-delete.js
new file mode 100644
index 0000000000000000000000000000000000000000..b14852a4e80ed2d1bf2b628d845f6f3b6de4462c
--- /dev/null
+++ b/test/built-ins/Map/prototype/size/returns-count-of-present-values-before-after-set-delete.js
@@ -0,0 +1,29 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.10
+description: >
+ Returns count of present values before and after using `set` and `delete`.
+info: >
+ get Map.prototype.size
+
+ 5. Let count be 0.
+ 6. For each Record {[[key]], [[value]]} p that is an element of entries
+ a. If p.[[key]] is not empty, set count to count+1.
+---*/
+
+var map = new Map();
+
+assert.sameValue(map.size, 0, 'The value of `map.size` is `0`');
+
+map.set(1, 1);
+assert.sameValue(
+ map.size, 1,
+ 'The value of `map.size` is `1`, after executing `map.set(1, 1)`'
+);
+
+map.delete(1);
+assert.sameValue(
+ map.size, 0,
+ 'The value of `map.size` is `0`, after executing `map.delete(1)`'
+);
diff --git a/test/built-ins/Map/prototype/size/returns-count-of-present-values-by-insertion.js b/test/built-ins/Map/prototype/size/returns-count-of-present-values-by-insertion.js
new file mode 100644
index 0000000000000000000000000000000000000000..eb2c5270ac42fddc14e29b730b1cd07578c90071
--- /dev/null
+++ b/test/built-ins/Map/prototype/size/returns-count-of-present-values-by-insertion.js
@@ -0,0 +1,26 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.10
+description: >
+ Returns count of present values inserted with set.
+info: >
+ get Map.prototype.size
+
+ 5. Let count be 0.
+ 6. For each Record {[[key]], [[value]]} p that is an element of entries
+ a. If p.[[key]] is not empty, set count to count+1.
+features: [Symbol]
+---*/
+
+var map = new Map();
+
+map.set(0, undefined);
+map.set(undefined, undefined);
+map.set(false, undefined);
+map.set(NaN, undefined);
+map.set(null, undefined);
+map.set('', undefined);
+map.set(Symbol(), undefined);
+
+assert.sameValue(map.size, 7, 'The value of `map.size` is `7`');
diff --git a/test/built-ins/Map/prototype/size/returns-count-of-present-values-by-iterable.js b/test/built-ins/Map/prototype/size/returns-count-of-present-values-by-iterable.js
new file mode 100644
index 0000000000000000000000000000000000000000..4f15613ed7e67f2bd4a36876e13f6a5f869f3664
--- /dev/null
+++ b/test/built-ins/Map/prototype/size/returns-count-of-present-values-by-iterable.js
@@ -0,0 +1,26 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.10
+description: >
+ Returns count of present values inserted via iterable argument.
+info: >
+ get Map.prototype.size
+
+ 5. Let count be 0.
+ 6. For each Record {[[key]], [[value]]} p that is an element of entries
+ a. If p.[[key]] is not empty, set count to count+1.
+features: [Symbol]
+---*/
+
+var map = new Map([
+ [0, undefined],
+ [undefined, undefined],
+ [false, undefined],
+ [NaN, undefined],
+ [null, undefined],
+ ['', undefined],
+ [Symbol(), undefined],
+]);
+
+assert.sameValue(map.size, 7, 'The value of `map.size` is `7`');
diff --git a/test/built-ins/Map/prototype/size/size.js b/test/built-ins/Map/prototype/size/size.js
new file mode 100644
index 0000000000000000000000000000000000000000..519870f55e10d211d8cb10db5468d24d66b07218
--- /dev/null
+++ b/test/built-ins/Map/prototype/size/size.js
@@ -0,0 +1,29 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.10
+description: >
+ Property type and descriptor.
+info: >
+ get Map.prototype.size
+
+ 17 ECMAScript Standard Built-in Objects
+
+includes: [propertyHelper.js]
+---*/
+
+var descriptor = Object.getOwnPropertyDescriptor(Map.prototype, 'size');
+
+assert.sameValue(
+ typeof descriptor.get,
+ 'function',
+ 'typeof descriptor.get is function'
+);
+assert.sameValue(
+ typeof descriptor.set,
+ 'undefined',
+ 'typeof descriptor.set is undefined'
+);
+
+verifyNotEnumerable(Map.prototype, 'size');
+verifyConfigurable(Map.prototype, 'size');
diff --git a/test/built-ins/Map/prototype/size/this-not-object-throw.js b/test/built-ins/Map/prototype/size/this-not-object-throw.js
new file mode 100644
index 0000000000000000000000000000000000000000..d55730db89cdc0a6d1d62bb866e1f8d786a8b47d
--- /dev/null
+++ b/test/built-ins/Map/prototype/size/this-not-object-throw.js
@@ -0,0 +1,47 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.10
+description: >
+ Throws a TypeError if `this` is not an Object.
+info: >
+ get Map.prototype.size
+
+ 1. Let M be the this value.
+ 2. If Type(M) is not Object, throw a TypeError exception.
+ 3. If M does not have a [[MapData]] internal slot, throw a TypeError
+ exception.
+ ...
+
+includes: [propertyHelper.js]
+---*/
+
+var descriptor = Object.getOwnPropertyDescriptor(Map.prototype, 'size');
+
+assert.throws(TypeError, function() {
+ descriptor.get.call(1);
+});
+
+assert.throws(TypeError, function() {
+ descriptor.get.call(false);
+});
+
+assert.throws(TypeError, function() {
+ descriptor.get.call(1);
+});
+
+assert.throws(TypeError, function() {
+ descriptor.get.call('');
+});
+
+assert.throws(TypeError, function() {
+ descriptor.get.call(undefined);
+});
+
+assert.throws(TypeError, function() {
+ descriptor.get.call(null);
+});
+
+assert.throws(TypeError, function() {
+ descriptor.get.call(Symbol());
+});
diff --git a/test/built-ins/Map/prototype/values-iteration-mutable.js b/test/built-ins/Map/prototype/values-iteration-mutable.js
deleted file mode 100644
index 40d8cca525d3aeef7d1935b6875a7b55c812e0a8..0000000000000000000000000000000000000000
--- a/test/built-ins/Map/prototype/values-iteration-mutable.js
+++ /dev/null
@@ -1,46 +0,0 @@
-// Copyright (C) 2014 the V8 project authors. All rights reserved.
-// This code is governed by the BSD license found in the LICENSE file.
-
-/*---
- description: >
- When an item is added to the map after the iterator is created but before
- the iterator is "done" (as defined by 23.1.5.2.1), the new item should be
- accessible via iteration. When an item is added to the map after the
- iterator is "done", the new item should not be accessible via iteration.
- es6id: 23.1.3.11
- ---*/
-
-var map = new Map();
-map.set(1, 11);
-map.set(2, 22);
-
-var iterator = map.values();
-var result;
-
-result = iterator.next();
-assert.sameValue(result.value, 11, 'First result `value`');
-assert.sameValue(result.done, false, 'First result `done` flag');
-
-map.set(3, 33);
-
-result = iterator.next();
-assert.sameValue(result.value, 22, 'Second result `value`');
-assert.sameValue(result.done, false, 'Second result `done` flag');
-
-result = iterator.next();
-assert.sameValue(result.value, 33, 'Third result `value`');
-assert.sameValue(result.done, false, 'Third result `done` flag');
-
-result = iterator.next();
-assert.sameValue(result.value, undefined, 'Exhausted result `value`');
-assert.sameValue(result.done, true, 'Exhausted result `done` flag');
-
-map.set(4, 44);
-
-result = iterator.next();
-assert.sameValue(
- result.value, undefined, 'Exhausted result `value` (repeated request)'
-);
-assert.sameValue(
- result.done, true, 'Exhausted result `done` flag (repeated request)'
-);
diff --git a/test/built-ins/Map/prototype/values-no-map-data.js b/test/built-ins/Map/prototype/values-no-map-data.js
deleted file mode 100644
index ccc666ee15d00cf27306f76e9711923098b0bbb7..0000000000000000000000000000000000000000
--- a/test/built-ins/Map/prototype/values-no-map-data.js
+++ /dev/null
@@ -1,13 +0,0 @@
-// Copyright (C) 2014 the V8 project authors. All rights reserved.
-// This code is governed by the BSD license found in the LICENSE file.
-
-/*---
- description: >
- If the context does not have a [[MapData]] internal slot, throw a
- TypeError exception as per 23.1.5.1.
- es6id: 23.1.3.4
- ---*/
-
-assert.throws(TypeError, function() {
- Map.prototype.values.call({});
-});
diff --git a/test/built-ins/Map/prototype/values/does-not-have-mapdata-internal-slot-set.js b/test/built-ins/Map/prototype/values/does-not-have-mapdata-internal-slot-set.js
new file mode 100644
index 0000000000000000000000000000000000000000..35d889d6a8d0e33554709aa774b085d68ff375a8
--- /dev/null
+++ b/test/built-ins/Map/prototype/values/does-not-have-mapdata-internal-slot-set.js
@@ -0,0 +1,29 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.11
+description: >
+ Throws a TypeError if `this` is a Set object.
+info: >
+ Map.prototype.values ()
+
+ 1. Let M be the this value.
+ 2. Return CreateMapIterator(M, "value").
+
+ 23.1.5.1 CreateMapIterator Abstract Operation
+
+ ...
+ 2. If map does not have a [[MapData]] internal slot, throw a TypeError
+ exception.
+ ...
+features: [Set]
+---*/
+
+assert.throws(TypeError, function() {
+ Map.prototype.values.call(new Set());
+});
+
+assert.throws(TypeError, function() {
+ var m = new Map();
+ m.values.call(new Set());
+});
diff --git a/test/built-ins/Map/prototype/values/does-not-have-mapdata-internal-slot-weakmap.js b/test/built-ins/Map/prototype/values/does-not-have-mapdata-internal-slot-weakmap.js
new file mode 100644
index 0000000000000000000000000000000000000000..a8b00b225cf1801bb65675e54cbc47975e21c37e
--- /dev/null
+++ b/test/built-ins/Map/prototype/values/does-not-have-mapdata-internal-slot-weakmap.js
@@ -0,0 +1,29 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.11
+description: >
+ Throws a TypeError if `this` is a WeakMap object.
+info: >
+ Map.prototype.values ()
+
+ 1. Let M be the this value.
+ 2. Return CreateMapIterator(M, "value").
+
+ 23.1.5.1 CreateMapIterator Abstract Operation
+
+ ...
+ 2. If map does not have a [[MapData]] internal slot, throw a TypeError
+ exception.
+ ...
+features: [WeakMap]
+---*/
+
+assert.throws(TypeError, function() {
+ Map.prototype.values.call(new WeakMap());
+});
+
+assert.throws(TypeError, function() {
+ var m = new Map();
+ m.values.call(new WeakMap());
+});
diff --git a/test/built-ins/Map/prototype/values/does-not-have-mapdata-internal-slot.js b/test/built-ins/Map/prototype/values/does-not-have-mapdata-internal-slot.js
new file mode 100644
index 0000000000000000000000000000000000000000..1085ccc9a1993d4cee4f9fd986b07a835b44f980
--- /dev/null
+++ b/test/built-ins/Map/prototype/values/does-not-have-mapdata-internal-slot.js
@@ -0,0 +1,38 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.11
+description: >
+ Throws a TypeError if `this` object does not have a [[MapData]] internal slot.
+info: >
+ Map.prototype.values ()
+
+ 1. Let M be the this value.
+ 2. Return CreateMapIterator(M, "value").
+
+ 23.1.5.1 CreateMapIterator Abstract Operation
+
+ ...
+ 2. If map does not have a [[MapData]] internal slot, throw a TypeError
+ exception.
+ ...
+
+---*/
+
+var m = new Map();
+
+assert.throws(TypeError, function() {
+ Map.prototype.values.call([]);
+});
+
+assert.throws(TypeError, function() {
+ m.values.call([]);
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.values.call({});
+});
+
+assert.throws(TypeError, function() {
+ m.values.call({});
+});
diff --git a/test/built-ins/Map/prototype/values/length.js b/test/built-ins/Map/prototype/values/length.js
new file mode 100644
index 0000000000000000000000000000000000000000..5e94cab8986ae127330a6e7b45bc582dc3782135
--- /dev/null
+++ b/test/built-ins/Map/prototype/values/length.js
@@ -0,0 +1,22 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.11
+description: >
+ Map.prototype.values.length value and descriptor.
+info: >
+ Map.prototype.values ()
+
+ 17 ECMAScript Standard Built-in Objects
+
+includes: [propertyHelper.js]
+---*/
+
+assert.sameValue(
+ Map.prototype.values.length, 0,
+ 'The value of `Map.prototype.values.length` is `0`'
+);
+
+verifyNotEnumerable(Map.prototype.values, 'length');
+verifyNotWritable(Map.prototype.values, 'length');
+verifyConfigurable(Map.prototype.values, 'length');
diff --git a/test/built-ins/Map/prototype/values/name.js b/test/built-ins/Map/prototype/values/name.js
new file mode 100644
index 0000000000000000000000000000000000000000..b211bd6d7773b8ebe83caacc172be92cb783f564
--- /dev/null
+++ b/test/built-ins/Map/prototype/values/name.js
@@ -0,0 +1,22 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.11
+description: >
+ Map.prototype.values.name value and descriptor.
+info: >
+ Map.prototype.values ()
+
+ 17 ECMAScript Standard Built-in Objects
+
+includes: [propertyHelper.js]
+---*/
+
+assert.sameValue(
+ Map.prototype.values.name, 'values',
+ 'The value of `Map.prototype.values.name` is `"values"`'
+);
+
+verifyNotEnumerable(Map.prototype.values, 'name');
+verifyNotWritable(Map.prototype.values, 'name');
+verifyConfigurable(Map.prototype.values, 'name');
diff --git a/test/built-ins/Map/prototype/values/returns-iterator-empty.js b/test/built-ins/Map/prototype/values/returns-iterator-empty.js
new file mode 100644
index 0000000000000000000000000000000000000000..9ef4f39a301d7972fb0b0fb2b6d0bd5cefa56793
--- /dev/null
+++ b/test/built-ins/Map/prototype/values/returns-iterator-empty.js
@@ -0,0 +1,27 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.11
+description: >
+ Returns an iterator on an empty Map object.
+info: >
+ Map.prototype.values ()
+
+ ...
+ 2. Return CreateMapIterator(M, "value").
+
+ 23.1.5.1 CreateMapIterator Abstract Operation
+
+ ...
+ 7. Return iterator.
+---*/
+
+var map = new Map();
+var iterator = map.values();
+var result = iterator.next();
+
+assert.sameValue(
+ result.value, undefined,
+ 'The value of `result.value` is `undefined`'
+);
+assert.sameValue(result.done, true, 'The value of `result.done` is `true`');
diff --git a/test/built-ins/Map/prototype/values-iteration.js b/test/built-ins/Map/prototype/values/returns-iterator.js
similarity index 58%
rename from test/built-ins/Map/prototype/values-iteration.js
rename to test/built-ins/Map/prototype/values/returns-iterator.js
index 3680a036dd5c9f2f394f7d1c2042e0368e34f95f..e86ac67748ce4ae38fda0e6d410fe3d8552042a7 100644
--- a/test/built-ins/Map/prototype/values-iteration.js
+++ b/test/built-ins/Map/prototype/values/returns-iterator.js
@@ -1,31 +1,40 @@
-// Copyright (C) 2014 the V8 project authors. All rights reserved.
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
// This code is governed by the BSD license found in the LICENSE file.
-
/*---
- description: >
- The method should return a valid iterator with the context as the
- IteratedObject.
- es6id: 23.1.3.11
- ---*/
+es6id: 23.1.3.11
+description: >
+ Returns an iterator.
+info: >
+ Map.prototype.values ( )
+
+ ...
+ 2. Return CreateMapIterator(M, "value").
+
+ 23.1.5.1 CreateMapIterator Abstract Operation
+
+ ...
+ 7. Return iterator.
+---*/
+var obj = {};
var map = new Map();
-map.set(1, 11);
-map.set(2, 22);
-map.set(3, 33);
+map.set(1, 'foo');
+map.set(2, obj);
+map.set(3, map);
var iterator = map.values();
var result;
result = iterator.next();
-assert.sameValue(result.value, 11, 'First result `value`');
+assert.sameValue(result.value, 'foo', 'First result `value` ("value")');
assert.sameValue(result.done, false, 'First result `done` flag');
result = iterator.next();
-assert.sameValue(result.value, 22, 'Second result `value`');
+assert.sameValue(result.value, obj, 'Second result `value` ("value")');
assert.sameValue(result.done, false, 'Second result `done` flag');
result = iterator.next();
-assert.sameValue(result.value, 33, 'Third result `value`');
+assert.sameValue(result.value, map, 'Third result `value` ("value")');
assert.sameValue(result.done, false, 'Third result `done` flag');
result = iterator.next();
diff --git a/test/built-ins/Map/prototype/values/this-not-object-throw.js b/test/built-ins/Map/prototype/values/this-not-object-throw.js
new file mode 100644
index 0000000000000000000000000000000000000000..116d2cef798977de79a465ef644fd2e86be97fa7
--- /dev/null
+++ b/test/built-ins/Map/prototype/values/this-not-object-throw.js
@@ -0,0 +1,47 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.11
+description: >
+ Throws a TypeError if `this` is not an Object.
+info: >
+ Map.prototype.values ()
+
+ ...
+ 2. Return CreateMapIterator(M, "values").
+
+ 23.1.5.1 CreateMapIterator Abstract Operation
+
+ 1. If Type(map) is not Object, throw a TypeError exception.
+ ...
+features: [Symbol]
+---*/
+
+assert.throws(TypeError, function() {
+ Map.prototype.values.call(false);
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.values.call(1);
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.values.call('');
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.values.call(undefined);
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.values.call(null);
+});
+
+assert.throws(TypeError, function() {
+ Map.prototype.values.call(Symbol());
+});
+
+assert.throws(TypeError, function() {
+ var map = new Map();
+ map.values.call(false);
+});
diff --git a/test/built-ins/Map/prototype/values/values.js b/test/built-ins/Map/prototype/values/values.js
new file mode 100644
index 0000000000000000000000000000000000000000..4489bbea280d0a16506a18dc5c699f3baf838c27
--- /dev/null
+++ b/test/built-ins/Map/prototype/values/values.js
@@ -0,0 +1,22 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.3.11
+description: >
+ Property type and descriptor.
+info: >
+ Map.prototype.values ()
+
+ 17 ECMAScript Standard Built-in Objects
+includes: [propertyHelper.js]
+---*/
+
+assert.sameValue(
+ typeof Map.prototype.values,
+ 'function',
+ '`typeof Map.prototype.values` is `function`'
+);
+
+verifyNotEnumerable(Map.prototype, 'values');
+verifyWritable(Map.prototype, 'values');
+verifyConfigurable(Map.prototype, 'values');
diff --git a/test/built-ins/Map/symbol-as-entry-key.js b/test/built-ins/Map/symbol-as-entry-key.js
index cf82d615a1544b8404587e1fa1b5615fa61ec8c8..4aedb7075a77ec6ea95d3a0a9021287b2c9a4783 100644
--- a/test/built-ins/Map/symbol-as-entry-key.js
+++ b/test/built-ins/Map/symbol-as-entry-key.js
@@ -4,7 +4,7 @@
es6id: 19.4
description: >
Symbol as Map key
-features: [Map]
+features: [Symbol]
---*/
var map = new Map();
var sym = Symbol();
@@ -16,4 +16,3 @@ assert.sameValue(map.has(sym), true, "`map.has(sym)` returns `true`");
assert.sameValue(map.get(sym), 1, "`map.get(sym)` returns `1`");
assert.sameValue(map.delete(sym), true, "`map.delete(sym)` returns `true`");
assert.sameValue(map.size, 0, "The value of `map.size` is `0`");
-
diff --git a/test/built-ins/Map/undefined-newtarget.js b/test/built-ins/Map/undefined-newtarget.js
new file mode 100644
index 0000000000000000000000000000000000000000..edbf41ada81c28f84f0073cba6a36265c726a5c2
--- /dev/null
+++ b/test/built-ins/Map/undefined-newtarget.js
@@ -0,0 +1,24 @@
+// Copyright (C) 2015 the V8 project authors. All rights reserved.
+// This code is governed by the BSD license found in the LICENSE file.
+/*---
+es6id: 23.1.1.1
+description: >
+ Throws a TypeError if Map is called without a newTarget.
+info: >
+ Map ( [ iterable ] )
+
+ When the Map function is called with optional argument the following steps
+ are taken:
+
+ 1. If NewTarget is undefined, throw a TypeError exception.
+ ...
+
+---*/
+
+assert.throws(TypeError, function() {
+ Map();
+});
+
+assert.throws(TypeError, function() {
+ Map([]);
+});