156 lines
3.4 KiB
JavaScript
156 lines
3.4 KiB
JavaScript
// should have a length of 1
|
|
//assert.equal(Array.from.length, 1);
|
|
var arr;
|
|
var obj;
|
|
|
|
// should make an array from arguments
|
|
function arrayFromArgs() {
|
|
return Array.from(arguments);
|
|
}
|
|
arr = arrayFromArgs('a', 1);
|
|
|
|
assert.equal(arr.length, 2);
|
|
assert.deepEqual(arr, ['a', 1]);
|
|
assert.isTrue(Array.isArray(arr));
|
|
|
|
// should handle undefined values
|
|
var arrayLike = {0: 'a', 2: 'c', length: 3};
|
|
arr = Array.from(arrayLike);
|
|
|
|
assert.equal(arr.length, 3);
|
|
assert.deepEqual(arr, ['a', undefined, 'c']);
|
|
assert.isTrue(Array.isArray(arr));
|
|
|
|
// should use a mapFn
|
|
arr = Array.from([{'a': 1}, {'a': 2}], function(item, i) {
|
|
return item.a + i;
|
|
});
|
|
|
|
assert.deepEqual(arr, [1, 3]);
|
|
|
|
// should set this in mapFn
|
|
var thisObj = {a: 10};
|
|
arr = Array.from([{'a': 1}, {'a': 2}], function(item, i) {
|
|
return this.a + item.a + i;
|
|
}, thisObj);
|
|
|
|
assert.deepEqual(arr, [11, 13]);
|
|
|
|
// should map on array-like object
|
|
arr = Array.from({0: {'a': 5}, length: 1}, function(item, i) {
|
|
return item.a + i;
|
|
});
|
|
|
|
assert.deepEqual(arr, [5]);
|
|
|
|
// should throw on bad map fn
|
|
assert.throws(function() {
|
|
Array.from([], null)
|
|
}, TypeError);
|
|
|
|
// should make from an array-like object
|
|
var arrayLikeObj = function(len) {
|
|
this.length = len;
|
|
};
|
|
arrayLikeObj.from = Array.from;
|
|
obj = arrayLikeObj.from(['a', 'b', 'c']);
|
|
|
|
assert.equal(obj.length, 3);
|
|
assert.deepEqual(obj, {0: 'a', 1: 'b', 2: 'c', length: 3});
|
|
|
|
// should make from a non-array iterable
|
|
var calledIterator = 0;
|
|
var Iterable = function(len) {
|
|
var self = this;
|
|
|
|
self.length = len;
|
|
self[Symbol.iterator] = function*() {
|
|
for (var i = 0; i < self.length; i++) {
|
|
calledIterator++;
|
|
yield self[i];
|
|
}
|
|
};
|
|
};
|
|
var it = new Iterable(3);
|
|
it[0] = 'a';
|
|
it[1] = 'b';
|
|
it[2] = 'c';
|
|
obj = Array.from(it);
|
|
|
|
assert.equal(obj.length, 3);
|
|
assert.equal(obj[0], 'a');
|
|
assert.equal(obj[1], 'b');
|
|
assert.equal(obj[2], 'c');
|
|
assert.equal(calledIterator, 3);
|
|
|
|
// should make from a sub-classed array
|
|
var length = 0;
|
|
var constructorCounter = 0;
|
|
var lengthSetCounter = 0;
|
|
var lengthGetCounter = 0;
|
|
|
|
class MyArray extends Array {
|
|
constructor(v) {
|
|
constructorCounter++;
|
|
assert.isUndefined(v);
|
|
}
|
|
|
|
set length(v) {
|
|
lengthSetCounter++;
|
|
length = v;
|
|
}
|
|
|
|
get length() {
|
|
lengthGetCounter++;
|
|
return length;
|
|
}
|
|
}
|
|
|
|
var ma = MyArray.from(['a', 'b']);
|
|
assert.instanceOf(ma, MyArray);
|
|
assert.equal(constructorCounter, 1);
|
|
assert.equal(lengthSetCounter, 1);
|
|
assert.equal(lengthGetCounter, 0);
|
|
assert.isTrue(ma.hasOwnProperty('0'));
|
|
assert.isTrue(ma.hasOwnProperty('1'));
|
|
assert.isFalse(ma.hasOwnProperty('length'));
|
|
assert.equal(ma[0], 'a');
|
|
assert.equal(ma[1], 'b');
|
|
assert.equal(ma.length, 2);
|
|
|
|
// should make from a sub-classed array without iterable
|
|
length = 0;
|
|
constructorCounter = 0;
|
|
lengthSetCounter = 0;
|
|
lengthGetCounter = 0;
|
|
|
|
class MyArray2 extends MyArray {
|
|
constructor(v) {
|
|
constructorCounter++;
|
|
assert.equal(v, 2);
|
|
}
|
|
};
|
|
MyArray2.prototype[Symbol.iterator] = undefined;
|
|
|
|
class MyArray3 extends Array {
|
|
constructor(v) {
|
|
this.length = v;
|
|
}
|
|
}
|
|
MyArray3.prototype[Symbol.iterator] = undefined;
|
|
|
|
var ma3 = new MyArray3(2);
|
|
ma3[0] = 'a';
|
|
ma3[1] = 'b';
|
|
ma = MyArray2.from(ma3);
|
|
assert.instanceOf(ma, MyArray2);
|
|
assert.equal(constructorCounter, 1);
|
|
assert.equal(lengthSetCounter, 1);
|
|
assert.equal(lengthGetCounter, 0);
|
|
assert.isTrue(ma.hasOwnProperty('0'));
|
|
assert.isTrue(ma.hasOwnProperty('1'));
|
|
assert.isFalse(ma.hasOwnProperty('length'));
|
|
assert.equal(ma[0], 'a');
|
|
assert.equal(ma[1], 'b');
|
|
assert.equal(ma.length, 2);
|