var hasStrictMode = require('has-strict-mode')();
|
|
var global = Function('return this')(); // eslint-disable-line no-new-func
|
var identity = function (x) { return x; };
|
|
var canDistinguishSparseFromUndefined = 0 in [undefined]; // IE 6 - 8 have a bug where this returns false.
|
var undefinedIfNoSparseBug = canDistinguishSparseFromUndefined ? undefined : { valueOf: function () { return 0; } };
|
|
var createArrayLikeFromArray = function createArrayLike(arr) {
|
var o = {};
|
for (var i = 0; i < arr.length; i += 1) {
|
if (i in arr) {
|
o[i] = arr[i];
|
}
|
}
|
o.length = arr.length;
|
return o;
|
};
|
|
module.exports = function (reduce, t) {
|
t.test('passes the correct values to the callback', function (st) {
|
st.plan(7);
|
|
var expectedValue = {};
|
var initialValue = {};
|
var expectedResult = {};
|
var arr = [expectedValue];
|
var result = reduce(
|
arr,
|
function (accumulator, value, key, list) {
|
st.equal(arguments.length, 4);
|
st.equal(accumulator, initialValue, 'first argument is the accumulator');
|
st.equal(value, expectedValue, 'second argument is the value');
|
st.equal(key, 0, 'third argument is the index');
|
st.equal(list, arr, 'fourth argument is the array being iterated');
|
st.equal(this, global, 'sloppy: receiver is the expected value');
|
|
return expectedResult;
|
},
|
initialValue
|
);
|
st.equal(result, expectedResult, 'result is last return value of accumulator');
|
|
st.end();
|
});
|
|
t.test('strict mode callback receiver', { skip: !hasStrictMode }, function (st) {
|
reduce(
|
[null],
|
function () {
|
'use strict';
|
|
st.equal(this, undefined, 'strict: receiver is the expected value');
|
}
|
);
|
|
st.end();
|
});
|
|
t.test('starts with the right initialValue', function (st) {
|
var firstValue = {};
|
var secondValue = {};
|
|
reduce(
|
[firstValue, secondValue],
|
function (accumulator, value) {
|
st.equal(accumulator, firstValue, 'accumulator starts out as the first value when initialValue is omitted');
|
st.equal(value, secondValue, 'value starts out as the second value when initialValue is omitted');
|
}
|
);
|
|
reduce(
|
[secondValue],
|
function (accumulator, value) {
|
st.equal(accumulator, firstValue, 'accumulator starts out as the initialValue when provided');
|
st.equal(value, secondValue, 'value starts out as the first value when initialValue is provided');
|
},
|
firstValue
|
);
|
|
st.end();
|
});
|
|
t.test('does not visit elements added to the array after it has begun', function (st) {
|
st.plan(8);
|
|
var arr = [1, 2, 3];
|
var i = 0;
|
reduce(arr, function (acc, v) {
|
i += 1;
|
arr.push(v + 3);
|
});
|
st.deepEqual(arr, [1, 2, 3, 5, 6], 'array has received 3 new elements. initialValue omitted');
|
st.equal(i, 2, 'reduce callback only called twice');
|
|
i = 0;
|
arr = [1, 2, 3];
|
reduce(
|
arr,
|
function (acc, v) {
|
i += 1;
|
arr.push(v + 3);
|
},
|
null
|
);
|
st.deepEqual(arr, [1, 2, 3, 4, 5, 6], 'array has received 3 new elements. initialValue provided');
|
st.equal(i, 3, 'reduce callback only called thrice');
|
|
var arrayLike = createArrayLikeFromArray([1, 2, 3]);
|
i = 0;
|
reduce(arrayLike, function (acc, v) {
|
i += 1;
|
arrayLike[arrayLike.length] = v + 3;
|
arrayLike.length += 1;
|
});
|
st.deepEqual(Array.prototype.slice.call(arrayLike), [1, 2, 3, 5, 6], 'arrayLike has received 3 new elements. initialValue omitted');
|
st.equal(i, 2, 'reduce callback only called twice');
|
|
arrayLike = createArrayLikeFromArray([1, 2, 3]);
|
i = 0;
|
reduce(
|
arrayLike,
|
function (acc, v) {
|
i += 1;
|
arrayLike[arrayLike.length] = v + 3;
|
arrayLike.length += 1;
|
},
|
null
|
);
|
st.deepEqual(Array.prototype.slice.call(arrayLike), [1, 2, 3, 4, 5, 6], 'arrayLike has received 3 new elements. initialValue provided');
|
st.equal(i, 3, 'reduce callback only called thrice');
|
|
st.end();
|
});
|
|
t.test('empty array', function (st) {
|
var initialValue = {};
|
var actual = reduce([], identity, initialValue);
|
st.equal(actual, initialValue, 'empty array returns callback return');
|
|
st['throws'](
|
function () { reduce([], identity); },
|
TypeError,
|
'empty array with omitted initialValue throws'
|
);
|
|
var sparse = Array(10);
|
st['throws'](
|
function () { reduce(sparse, identity); },
|
TypeError,
|
'only-holes array with omitted initialValue throws (test262: 15.4.4.21-8-c-1)'
|
);
|
|
st.end();
|
});
|
|
t.test('skips holes', function (st) {
|
var arr = [1, undefinedIfNoSparseBug, 3];
|
var visited = {};
|
reduce(
|
arr,
|
function (a, b) {
|
if (a) { visited[a] = true; }
|
if (b) { visited[b] = true; }
|
return 0;
|
},
|
null
|
);
|
st.deepEqual(visited, { 1: true, 3: true }, 'only non-holes are visited; initialValue provided');
|
|
visited = {};
|
reduce(
|
arr,
|
function (a, b) {
|
if (a) { visited[a] = true; }
|
if (b) { visited[b] = true; }
|
return 0;
|
}
|
);
|
st.deepEqual(visited, { 1: true, 3: true }, 'only non-holes are visited; initialValue omitted');
|
|
st.end();
|
});
|
|
t.test('list arg boxing', function (st) {
|
st.plan(4);
|
|
reduce(
|
'f',
|
function (acc, item, index, list) {
|
st.equal(acc, null, 'accumulator matches');
|
st.equal(item, 'f', 'letter matches');
|
st.equal(typeof list, 'object', 'primitive list arg is boxed');
|
st.equal(Object.prototype.toString.call(list), '[object String]', 'boxed list arg is a String');
|
},
|
null
|
);
|
|
st.end();
|
});
|
|
t.test('test262: 15.4.4.21-3-12', function (st) {
|
var obj = {
|
1: 11,
|
2: 9,
|
length: '-4294967294'
|
};
|
|
var cb = function callbackfn(prevVal, curVal, idx, object) {
|
st.equal(object, obj, '4th argument is receiver');
|
return curVal === 11 && idx === 1;
|
};
|
|
st.equal(reduce(obj, cb, 1), 1, 'reduce(obj, callbackfn, 1)');
|
|
st.end();
|
});
|
};
|
