JSTests/ChakraCore/test/es6/map_basic.js

//-------------------------------------------------------------------------------------------------------
// Copyright (C) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
//-------------------------------------------------------------------------------------------------------

// Basic Map tests -- verifies the API shape

WScript.LoadScriptFile("..\\UnitTestFramework\\UnitTestFramework.js");

var tests = [
    {
        name: "Map is a constructor on the global object",
        body: function () {
            assert.isTrue(Map !== undefined, "Map should be defined");

            var map1 = new Map();
            // Map is no longer allowed to be called as a function unless the object it is given
            // for its this argument already has the [[MapData]] property on it.
            // TODO: When we implement @@create support, update this test to reflect it.
            //var map2 = Map();

            assert.isTrue(map1 instanceof Map, "'new Map()' should create a Map object");
            //assert.isTrue(map2 instanceof Map, "'Map()' should also create a Map object");
            //assert.isTrue(map1 !== map2, "Should be two different Map objects");

            assert.areEqual(0, Map.length, "Map takes one optional argument and spec says length must be 0");
        }
    },
    {
        name: "Map.prototype should have spec defined built-ins",
        body: function () {
            assert.isTrue(Map.prototype.constructor === Map, "Map.prototype should have a constructor property set to Map");

            assert.isTrue(Map.prototype.hasOwnProperty('clear'), "Map.prototype should have a clear method");
            assert.isTrue(Map.prototype.hasOwnProperty('delete'), "Map.prototype should have a delete method");
            assert.isTrue(Map.prototype.hasOwnProperty('forEach'), "Map.prototype should have a forEach method");
            assert.isTrue(Map.prototype.hasOwnProperty('get'), "Map.prototype should have a get method");
            assert.isTrue(Map.prototype.hasOwnProperty('has'), "Map.prototype should have a has method");
            assert.isTrue(Map.prototype.hasOwnProperty('set'), "Map.prototype should have a set method");
            assert.isTrue(Map.prototype.hasOwnProperty('size'), "Map.prototype should have a size accessor");

            assert.isTrue(Map.prototype.clear.length === 0, "clear method takes zero arguments");
            assert.isTrue(Map.prototype.delete.length === 1, "delete method takes one argument");
            assert.isTrue(Map.prototype.forEach.length === 1, "forEach method takes two arguments but second is optional and spec says length must be 1");
            assert.isTrue(Map.prototype.get.length === 1, "get method takes one argument");
            assert.isTrue(Map.prototype.has.length === 1, "has method takes one argument");
            assert.isTrue(Map.prototype.set.length === 2, "set method takes two arguments");

            assert.isTrue(Object.getOwnPropertyDescriptor(Map.prototype, "size").get !== undefined, "size accessor should have get method");
            assert.isTrue(Object.getOwnPropertyDescriptor(Map.prototype, "size").set === undefined, "size accessor should not have set method");
        }
    },
    {
        name: "Map objects' prototype should be Map.prototype",
        body: function () {
            var map1 = new Map();
            // Map is no longer allowed to be called as a function unless the object it is given
            // for its this argument already has the [[MapData]] property on it.
            // TODO: When we implement @@create support, update this test to reflect it.
            //var map2 = Map();

            assert.isTrue(Object.getPrototypeOf(map1) === Map.prototype, "'new Map()' should set the prototype of the returned object to Map.prototype");
            //assert.isTrue(Object.getPrototypeOf(map2) === Map.prototype, "'Map()' should set the prototype of the returned object to Map.prototype");
        }
    },
    {
        name: "toString of a Map object returns [object Map]",
        body: function () {
            var map = new Map();

            assert.areEqual("[object Map]", '' + map, "toString() of map returns [object Map]");
        }
    },
    {
        name: "Map objects are normal extensible dynamic objects",
        body: function () {
            function countEnumerableProperties(o) {
                var count = 0;
                for (p in o) {
                    count += 1;
                }
                return count;
            }

            var map = new Map();

            assert.isTrue(countEnumerableProperties(Map.prototype) == 0, "Built-in methods should not be enumerable on the prototype object");
            assert.isTrue(countEnumerableProperties(map) == 0, "Built-in methods should not be enumerable on an instance object");

            map.foo = 10;
            map.bar = 'hello';

            assert.isTrue(countEnumerableProperties(map) == 2, "Should be able to add user properties");
            assert.isTrue(map.foo === 10, "Property value should be set and retrieved correctly");
            assert.isTrue(map.bar === 'hello', "Property value should be set and retrieved correctly");

            delete map.foo;
            assert.isTrue(countEnumerableProperties(map) == 1, "Should be able to delete user properties");
            assert.isTrue(map.foo === undefined, "Should be able to delete user properties");
        }
    },
    {
        name: "Map is subclassable",
        body: function () {
            // Map is no longer allowed to be called as a function unless the object it is given
            // for its this argument already has the [[MapData]] property on it.
            // TODO: When we implement @@create support, update this test to reflect it.
            //
            // For IE11 we simply throw if Map() is called as a function instead of in a new expression
            assert.throws(function () { Map.call(); }, TypeError, "Map.call() throws TypeError");
            assert.throws(function () { Map.call({ }); }, TypeError, "Map.call() throws TypeError given an object");
            assert.throws(function () { Map.call(123); }, TypeError, "Map.call() throws TypeError given a number");
            assert.throws(function () { Map.call("hello"); }, TypeError, "Map.call() throws TypeError given a string");

            function MyMap() {
                Map.call(this);
            }
            MyMap.prototype = new Map();
            MyMap.prototype.constructor = MyMap;

            assert.throws(function () { var mymap = new MyMap(); }, TypeError, "Map.call(this) throws TypeError when used in the old subclassing pattern");
            /*
            function MyMap() {
                Map.call(this);
            }
            MyMap.prototype = new Map();
            MyMap.prototype.constructor = MyMap;

            var mymap = new MyMap();

            assert.isTrue(mymap instanceof MyMap, "Should be a MyMap object");
            assert.isTrue(mymap instanceof Map, "Should also be a Map object");
            assert.isTrue(Object.getPrototypeOf(mymap) === MyMap.prototype, "Should have MyMap prototype");
            assert.isTrue(Object.getPrototypeOf(mymap) !== Map.prototype, "Should be distinct from Map prototype");

            assert.isTrue(mymap.clear instanceof Function, "Should have clear method");
            assert.isTrue(mymap.delete instanceof Function, "Should have delete method");
            assert.isTrue(mymap.forEach instanceof Function, "Should have forEach method");
            assert.isTrue(mymap.get instanceof Function, "Should have get method");
            assert.isTrue(mymap.has instanceof Function, "Should have has method");
            assert.isTrue(mymap.set instanceof Function, "Should have set method");
            assert.isTrue(mymap.size === 0, "Should have size getter (initially zero)");
            */
        }
    },
];

testRunner.runTests(tests, { verbose: WScript.Arguments[0] != "summary" });