Implement Array.from routine (#3402)
The patch also revealed a minor issue about Map[Symbol.iterator] which have been fixed as well. Co-authored-by: Daniella Barsony bella@inf.u-szeged.hu JerryScript-DCO-1.0-Signed-off-by: Robert Fancsik frobert@inf.u-szeged.hu
This commit is contained in:
Robert Fancsik
committed by
Zoltan Herczeg
Zoltan Herczeg
parent
d31871d7c9
commit
bfc495f0cb
@@ -0,0 +1,344 @@
|
||||
// Copyright JS Foundation and other contributors, http://js.foundation
|
||||
//
|
||||
// Licensed under the Apache License, Version 2.0 (the "License");
|
||||
// you may not use this file except in compliance with the License.
|
||||
// You may obtain a copy of the License at
|
||||
//
|
||||
// http://www.apache.org/licenses/LICENSE-2.0
|
||||
//
|
||||
// Unless required by applicable law or agreed to in writing, software
|
||||
// distributed under the License is distributed on an "AS IS" BASIS
|
||||
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
// See the License for the specific language governing permissions and
|
||||
// limitations under the License.
|
||||
|
||||
// Copyright 2014 the V8 project authors. All rights reserved.
|
||||
// Use of this source code is governed by a BSD-style license that can be
|
||||
// found in the LICENSE file.
|
||||
|
||||
// Some methods are taken from v8/test/mjsunit/mjsunit.js
|
||||
|
||||
function classOf(object) {
|
||||
// Argument must not be null or undefined.
|
||||
var string = Object.prototype.toString.call(object);
|
||||
// String has format [object <ClassName>].
|
||||
return string.substring(8, string.length - 1);
|
||||
}
|
||||
|
||||
/**
|
||||
* Compares two objects for key/value equality.
|
||||
* Returns true if they are equal, false otherwise.
|
||||
*/
|
||||
function deepObjectEquals(a, b) {
|
||||
var aProps = Object.keys(a);
|
||||
aProps.sort();
|
||||
var bProps = Object.keys(b);
|
||||
bProps.sort();
|
||||
if (!deepEquals(aProps, bProps)) {
|
||||
return false;
|
||||
}
|
||||
for (var i = 0; i < aProps.length; i++) {
|
||||
if (!deepEquals(a[aProps[i]], b[aProps[i]])) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
var assertInstanceof = function assertInstanceof(obj, type) {
|
||||
if (!(obj instanceof type)) {
|
||||
var actualTypeName = null;
|
||||
var actualConstructor = Object.getPrototypeOf(obj).constructor;
|
||||
if (typeof actualConstructor == "function") {
|
||||
actualTypeName = actualConstructor.name || String(actualConstructor);
|
||||
} print("Object <" + obj + "> is not an instance of <" + (type.name || type) + ">" + (actualTypeName ? " but of < " + actualTypeName + ">" : ""));
|
||||
}
|
||||
};
|
||||
|
||||
function deepEquals(a, b) {
|
||||
if (a === b) {
|
||||
if (a === 0) return (1 / a) === (1 / b);
|
||||
return true;
|
||||
}
|
||||
if (typeof a != typeof b) return false;
|
||||
if (typeof a == "number") return isNaN(a) && isNaN(b);
|
||||
if (typeof a !== "object" && typeof a !== "function") return false;
|
||||
var objectClass = classOf(a);
|
||||
if (objectClass !== classOf(b)) return false;
|
||||
if (objectClass === "RegExp") {
|
||||
return (a.toString() === b.toString());
|
||||
}
|
||||
if (objectClass === "Function") return false;
|
||||
if (objectClass === "Array") {
|
||||
var elementCount = 0;
|
||||
if (a.length != b.length) {
|
||||
return false;
|
||||
}
|
||||
for (var i = 0; i < a.length; i++) {
|
||||
if (!deepEquals(a[i], b[i]))
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
if (objectClass == "String" || objectClass == "Number" || objectClass == "Boolean" || objectClass == "Date") {
|
||||
if (a.valueOf() !== b.valueOf()) return false;
|
||||
}
|
||||
return deepObjectEquals(a, b);
|
||||
}
|
||||
|
||||
var assertEquals = function assertEquals(expected, found, name_opt) {
|
||||
if (!deepEquals(found, expected)) {
|
||||
assert(false);
|
||||
}
|
||||
};
|
||||
|
||||
function assertArrayLikeEquals(value, expected, type) {
|
||||
assertInstanceof(value, type);
|
||||
assert(expected.length === value.length);
|
||||
for (var i=0; i<value.length; ++i) {
|
||||
assertEquals(expected[i], value[i]);
|
||||
}
|
||||
}
|
||||
|
||||
assert(1 === Array.from.length);
|
||||
|
||||
// Assert that constructor is called with "length" for array-like objects
|
||||
|
||||
var myCollectionCalled = false;
|
||||
function MyCollection(length) {
|
||||
myCollectionCalled = true;
|
||||
assert(1 === arguments.length);
|
||||
|
||||
assert(5 === length);
|
||||
}
|
||||
|
||||
Array.from.call(MyCollection, {length: 5});
|
||||
assert(myCollectionCalled === true);
|
||||
// Assert that calling mapfn with / without thisArg in sloppy and strict modes
|
||||
// works as expected.
|
||||
|
||||
var global = this;
|
||||
function non_strict(){ assert(global === this); }
|
||||
function strict(){ "use strict"; assert(void 0 === this); }
|
||||
function strict_null(){ "use strict"; assert(null === this); }
|
||||
Array.from([1], non_strict);
|
||||
Array.from([1], non_strict, void 0);
|
||||
Array.from([1], strict);
|
||||
Array.from([1], strict, void 0);
|
||||
|
||||
function testArrayFrom(thisArg, constructor) {
|
||||
assertArrayLikeEquals(Array.from.call(thisArg, [], undefined), [], constructor);
|
||||
assertArrayLikeEquals(Array.from.call(thisArg, NaN), [], constructor);
|
||||
assertArrayLikeEquals(Array.from.call(thisArg, Infinity), [], constructor);
|
||||
assertArrayLikeEquals(Array.from.call(thisArg, 10000000), [], constructor);
|
||||
assertArrayLikeEquals(Array.from.call(thisArg, 'test'), ['t', 'e', 's', 't'], constructor);
|
||||
|
||||
assertArrayLikeEquals(Array.from.call(thisArg,
|
||||
{ length: 1, '0': { 'foo': 'bar' } }), [{'foo': 'bar'}], constructor);
|
||||
assertArrayLikeEquals(Array.from.call(thisArg, { length: -1, '0': { 'foo': 'bar' } }), [], constructor);
|
||||
assertArrayLikeEquals(Array.from.call(thisArg,
|
||||
[ 'foo', 'bar', 'baz' ]), ['foo', 'bar', 'baz'], constructor);
|
||||
var kSet = new Set(['foo', 'bar', 'baz']);
|
||||
assertArrayLikeEquals(Array.from.call(thisArg, kSet), ['foo', 'bar', 'baz'], constructor);
|
||||
var kMap = new Map(['foo', 'bar', 'baz'].entries());
|
||||
assertArrayLikeEquals(Array.from.call(thisArg, kMap), [[0, 'foo'], [1, 'bar'], [2, 'baz']], constructor);
|
||||
assertArrayLikeEquals(Array.from.call(thisArg, 'test', function(x) {
|
||||
return this.filter(x);
|
||||
}, {
|
||||
filter: function(x) { return x.toUpperCase(); }
|
||||
}), ['T', 'E', 'S', 'T'], constructor);
|
||||
assertArrayLikeEquals(Array.from.call(thisArg, 'test', function(x) {
|
||||
return x.toUpperCase();
|
||||
}), ['T', 'E', 'S', 'T'], constructor);
|
||||
|
||||
try {
|
||||
Array.from.call(thisArg, null);
|
||||
assert(false);
|
||||
} catch (e) {
|
||||
assert (e instanceof TypeError);
|
||||
}
|
||||
|
||||
try {
|
||||
Array.from.call(thisArg, undefined);
|
||||
assert(false);
|
||||
} catch (e) {
|
||||
assert (e instanceof TypeError);
|
||||
}
|
||||
|
||||
try {
|
||||
Array.from.call(thisArg, [], null);
|
||||
assert(false);
|
||||
} catch (e) {
|
||||
assert (e instanceof TypeError);
|
||||
}
|
||||
|
||||
try {
|
||||
Array.from.call(thisArg, [], "noncallable");
|
||||
assert(false);
|
||||
} catch (e) {
|
||||
assert (e instanceof TypeError);
|
||||
}
|
||||
|
||||
var nullIterator = {};
|
||||
nullIterator[Symbol.iterator] = null;
|
||||
assertArrayLikeEquals(Array.from.call(thisArg, nullIterator), [],
|
||||
constructor);
|
||||
|
||||
var nonObjIterator = {};
|
||||
nonObjIterator[Symbol.iterator] = function() { return "nonObject"; };
|
||||
|
||||
try {
|
||||
Array.from.call(thisArg, nonObjIterator);
|
||||
assert(false);
|
||||
} catch (e) {
|
||||
assert (e instanceof TypeError);
|
||||
}
|
||||
|
||||
try {
|
||||
Array.from.call(thisArg, [], null);
|
||||
assert(false);
|
||||
} catch (e) {
|
||||
assert (e instanceof TypeError);
|
||||
}
|
||||
|
||||
// Ensure iterator is only accessed once, and only invoked once
|
||||
var called = false;
|
||||
var arr = [1, 2, 3];
|
||||
var obj = {};
|
||||
|
||||
// Test order --- only get iterator method once
|
||||
function testIterator() {
|
||||
assert(called !== "@@iterator should be called only once");
|
||||
called = true;
|
||||
assert(obj === this);
|
||||
return arr[Symbol.iterator]();
|
||||
}
|
||||
var getCalled = false;
|
||||
Object.defineProperty(obj, Symbol.iterator, {
|
||||
get: function() {
|
||||
assert(getCalled !== "@@iterator should be accessed only once");
|
||||
getCalled = true;
|
||||
return testIterator;
|
||||
},
|
||||
set: function() {
|
||||
// "@@iterator should not be set"
|
||||
assert(false);
|
||||
}
|
||||
});
|
||||
assertArrayLikeEquals(Array.from.call(thisArg, obj), [1, 2, 3], constructor);
|
||||
}
|
||||
|
||||
function Other() {}
|
||||
|
||||
var boundFn = (function() {}).bind(Array, 27);
|
||||
|
||||
testArrayFrom(Array, Array);
|
||||
testArrayFrom(null, Array);
|
||||
testArrayFrom({}, Array);
|
||||
testArrayFrom(Object, Object);
|
||||
testArrayFrom(Other, Other);
|
||||
testArrayFrom(Math.cos, Array);
|
||||
testArrayFrom(boundFn, boundFn);
|
||||
|
||||
// Assert that [[DefineOwnProperty]] is used in ArrayFrom, meaning a
|
||||
// setter isn't called, and a failed [[DefineOwnProperty]] will throw.
|
||||
var setterCalled = 0;
|
||||
function exotic() {
|
||||
Object.defineProperty(this, '0', {
|
||||
get: function() { return 2; },
|
||||
set: function() { setterCalled++; }
|
||||
});
|
||||
}
|
||||
|
||||
// Non-configurable properties can't be overwritten with DefineOwnProperty
|
||||
// The setter wasn't called
|
||||
try {
|
||||
Array.from.call(exotic, [1]);
|
||||
assert(false);
|
||||
} catch (e) {
|
||||
assert (e instanceof TypeError);
|
||||
}
|
||||
|
||||
assert( 0 === setterCalled);
|
||||
|
||||
// Non-callable iterators should cause a TypeError before calling the target
|
||||
// constructor.
|
||||
items = {};
|
||||
items[Symbol.iterator] = 7;
|
||||
function TestError() {}
|
||||
function ArrayLike() { throw new TestError() }
|
||||
|
||||
try {
|
||||
Array.from.call(ArrayLike, items);
|
||||
assert(false);
|
||||
} catch (e) {
|
||||
assert (e instanceof TypeError);
|
||||
}
|
||||
|
||||
// Check that array properties defined are writable, enumerable, configurable
|
||||
function ordinary() { }
|
||||
var x = Array.from.call(ordinary, [2]);
|
||||
var xlength = Object.getOwnPropertyDescriptor(x, 'length');
|
||||
assert(1 === xlength.value);
|
||||
assert(true === xlength.writable);
|
||||
assert(true === xlength.enumerable);
|
||||
assert(true === xlength.configurable);
|
||||
var x0 = Object.getOwnPropertyDescriptor(x, 0);
|
||||
assert(2 === x0.value);
|
||||
assert(true === xlength.writable);
|
||||
assert(true === xlength.enumerable);
|
||||
assert(true === xlength.configurable);
|
||||
|
||||
/* Test iterator close */
|
||||
function __createIterableObject (arr, methods) {
|
||||
methods = methods || {};
|
||||
if (typeof Symbol !== 'function' || !Symbol.iterator) {
|
||||
return {};
|
||||
}
|
||||
arr.length++;
|
||||
var iterator = {
|
||||
next: function() {
|
||||
return { value: arr.shift(), done: arr.length <= 0 };
|
||||
},
|
||||
'return': methods['return'],
|
||||
'throw': methods['throw']
|
||||
};
|
||||
var iterable = {};
|
||||
iterable[Symbol.iterator] = function () { return iterator; };
|
||||
return iterable;
|
||||
};
|
||||
|
||||
function close1() {
|
||||
var closed = false;
|
||||
var iter = __createIterableObject([1, 2, 3], {
|
||||
'return': function() { closed = true; return {}; }
|
||||
});
|
||||
|
||||
try {
|
||||
Array.from(iter, x => { throw 5 });
|
||||
assert(false);
|
||||
} catch (e) {
|
||||
assert(e === 5);
|
||||
}
|
||||
|
||||
return closed;
|
||||
}
|
||||
assert(close1());
|
||||
|
||||
function close2() {
|
||||
var closed = false;
|
||||
var iter = __createIterableObject([1, 2, 3], {
|
||||
'return': function() { closed = true; throw 6 }
|
||||
});
|
||||
|
||||
try {
|
||||
Array.from(iter, x => { throw 5 });
|
||||
assert(false);
|
||||
} catch (e) {
|
||||
assert(e === 5);
|
||||
}
|
||||
|
||||
return closed;
|
||||
}
|
||||
assert(close2());
|
||||
|
||||
@@ -62,62 +62,62 @@ methods.forEach(function (method) {
|
||||
}
|
||||
});
|
||||
|
||||
var valueIterators = [m.values(), m[Symbol.iterator]()];
|
||||
var entryIterators = [m.entries(), m[Symbol.iterator]()];
|
||||
var keyIterator = m.keys();
|
||||
var entryIterator = m.entries();
|
||||
var valueIterator = m.values();
|
||||
var elementCount = m.size;
|
||||
|
||||
for (var i = 0; i < elementCount; i++) {
|
||||
valueIterators.forEach(function(element) {
|
||||
entryIterators.forEach(function(element) {
|
||||
var next = element.next();
|
||||
assert(next.done === false);
|
||||
assert(next.value === i);
|
||||
assert(next.value[0] === '' + i);
|
||||
assert(next.value[1] === i);
|
||||
});
|
||||
|
||||
var next = keyIterator.next();
|
||||
assert(next.done === false);
|
||||
assert(next.value === '' + i);
|
||||
|
||||
var next = entryIterator.next();
|
||||
var next = valueIterator.next();
|
||||
assert(next.done === false);
|
||||
assert(next.value[0] === '' + i);
|
||||
assert(next.value[1] === i);
|
||||
assert(next.value === i);
|
||||
}
|
||||
|
||||
valueIterators.forEach(function(element) {
|
||||
var next = element.next();
|
||||
assert(next.done === true);
|
||||
assert(next.value === undefined);
|
||||
});
|
||||
entryIterators.forEach(function(element) {
|
||||
var next = element.next();
|
||||
assert(next.done === true);
|
||||
assert(next.value === undefined);
|
||||
});
|
||||
|
||||
var next = keyIterator.next();
|
||||
assert(next.done === true);
|
||||
assert(next.value === undefined);
|
||||
|
||||
next = entryIterator.next();
|
||||
next = valueIterator.next();
|
||||
assert(next.done === true);
|
||||
assert(next.value === undefined);
|
||||
|
||||
var valueIterators = [m.values(), m[Symbol.iterator]()];
|
||||
var entryIterators = [m.entries(), m[Symbol.iterator]()];
|
||||
var keyIterator = m.keys();
|
||||
var entryIterator = m.entries();
|
||||
var valueIterator = m.values();
|
||||
var elementCount = m.size;
|
||||
|
||||
for (var i = 0; i < elementCount; i++) {
|
||||
valueIterators.forEach(function(element) {
|
||||
entryIterators.forEach(function(element) {
|
||||
var next = element.next();
|
||||
assert(next.done === false);
|
||||
assert(next.value === i);
|
||||
assert(next.value[0] === '' + i);
|
||||
assert(next.value[1] === i);
|
||||
});
|
||||
|
||||
var next = keyIterator.next();
|
||||
assert(next.done === false);
|
||||
assert(next.value === '' + i);
|
||||
|
||||
var next = entryIterator.next();
|
||||
var next = valueIterator.next();
|
||||
assert(next.done === false);
|
||||
assert(next.value[0] === '' + i);
|
||||
assert(next.value[1] === i);
|
||||
assert(next.value === i);
|
||||
m.delete('' + i);
|
||||
}
|
||||
|
||||
|
||||
Reference in New Issue
Block a user