text: /* test Map.prototype.forEach */
  
  load(libdir + 'asserts.js');
  load(libdir + 'iteration.js');
  
  // testing success conditions of Map.prototype.forEach
  
  var testMap = new Map();
  
  function callback(value, key, map) {
      testMap.set(key, value);
      assertEq(map.has(key), true);
      assertEq(map.get(key), value);
  }
  
  var initialMap = new Map([['a', 1], ['b', 2.3], [false, undefined]]);
  initialMap.forEach(callback);
  
  // test that both the Maps are equal and are in same order
  var iterator = initialMap[std_iterator]();
  var count = 0;
  for (var [k, v] of testMap) {
      assertEq(initialMap.has(k), true);
      assertEq(initialMap.get(k), testMap.get(k));
      assertIteratorNext(iterator, [k, testMap.get(k)]);
      count++;
  }
  
  //check both the Maps we have are equal in size
  assertEq(initialMap.size, testMap.size);
  assertEq(initialMap.size, count);
  
  var x = { abc: 'test'};
  function callback2(value, key, map) {
      assertEq(x, this);
  }
  initialMap = new Map([['a', 1]]);
  initialMap.forEach(callback2, x);
  
  // testing failure conditions of Map.prototype.forEach
  
  var s = new Set([1, 2, 3]);
  assertThrowsInstanceOf(function() {
      Map.prototype.forEach.call(s, callback);
  }, TypeError, "Map.prototype.forEach should raise TypeError if not used on a Map");
  
  var fn = 2;
  assertThrowsInstanceOf(function() {
      initialMap.forEach(fn);
  }, TypeError, "Map.prototype.forEach should raise TypeError if callback is not a function");
  
  // testing that Map#forEach uses internal next() function and does not stop when
  // StopIteration exception is thrown
  
  var m = new Map([["one", 1]]);
  Object.getPrototypeOf(m[std_iterator]()).next = function () { throw "FAIL"; };
  assertThrowsInstanceOf(function () {
    m.forEach(function () { throw StopIteration; });
  }, StopIteration, "Map.prototype.forEach should use intrinsic next method.");
  