describe('Array', function() {
|
var testSubject;
|
beforeEach(function() {
|
testSubject = [2, 3, undefined, true, 'hej', null, false, 0];
|
delete testSubject[1];
|
});
|
function createArrayLikeFromArray(arr) {
|
var o = {};
|
Array.prototype.forEach.call(arr, function(e, i) {
|
o[i]=e;
|
});
|
o.length = arr.length;
|
return o;
|
};
|
|
describe('forEach', function() {
|
"use strict";
|
var expected, actual;
|
|
beforeEach(function() {
|
expected = {0:2, 2: undefined, 3:true, 4: 'hej', 5:null, 6:false, 7:0 };
|
actual = {};
|
});
|
it('should pass the right parameters', function() {
|
var callback = jasmine.createSpy('callback'),
|
array = ['1'];
|
array.forEach(callback);
|
expect(callback).toHaveBeenCalledWith('1', 0, array);
|
});
|
it('should not affect elements added to the array after it has begun', function() {
|
var arr = [1,2,3],
|
i = 0;
|
arr.forEach(function(a) {
|
i++;
|
arr.push(a+3);
|
});
|
expect(arr).toEqual([1,2,3,4,5,6]);
|
expect(i).toBe(3);
|
});
|
|
it('should set the right context when given none', function() {
|
var context;
|
[1].forEach(function() {context = this;});
|
expect(context).toBe(function() {return this}.call());
|
});
|
it('should iterate all', function() {
|
testSubject.forEach(function(obj, index) {
|
actual[index] = obj;
|
});
|
expect(actual).toExactlyMatch(expected);
|
});
|
it('should iterate all using a context', function() {
|
var o = { a: actual };
|
|
testSubject.forEach(function(obj, index) {
|
this.a[index] = obj;
|
}, o);
|
expect(actual).toExactlyMatch(expected);
|
});
|
|
it('should iterate all in an array-like object', function() {
|
var ts = createArrayLikeFromArray(testSubject);
|
Array.prototype.forEach.call(ts, function(obj, index) {
|
actual[index] = obj;
|
});
|
expect(actual).toExactlyMatch(expected);
|
});
|
it('should iterate all in an array-like object using a context', function() {
|
var ts = createArrayLikeFromArray(testSubject),
|
o = { a: actual };
|
|
Array.prototype.forEach.call(ts, function(obj, index) {
|
this.a[index] = obj;
|
}, o);
|
expect(actual).toExactlyMatch(expected);
|
});
|
|
describe('strings', function() {
|
var str = 'Hello, World!',
|
toString = Object.prototype.toString;
|
it('should iterate all in a string', function() {
|
actual = [];
|
Array.prototype.forEach.call(str, function(item, index) {
|
actual[index] = item;
|
});
|
expect(actual).toExactlyMatch(str.split(''));
|
});
|
it('should iterate all in a string using a context', function() {
|
actual = [];
|
var o = { a: actual };
|
Array.prototype.forEach.call(str, function(item, index) {
|
this.a[index] = item;
|
}, o);
|
expect(actual).toExactlyMatch(str.split(''));
|
});
|
it('should have String object for third argument of callback', function() {
|
Array.prototype.forEach.call(str, function(item, index, obj) {
|
actual = obj;
|
});
|
expect(typeof actual).toBe("object");
|
expect(toString.call(actual)).toBe("[object String]");
|
});
|
});
|
});
|
describe('some', function() {
|
var actual, expected, numberOfRuns;
|
|
beforeEach(function() {
|
expected = {0:2, 2: undefined, 3:true };
|
actual = {};
|
numberOfRuns = 0;
|
});
|
|
it('should pass the correct values along to the callback', function() {
|
var callback = jasmine.createSpy('callback');
|
var array = ['1'];
|
array.some(callback);
|
expect(callback).toHaveBeenCalledWith('1', 0, array);
|
});
|
it('should not affect elements added to the array after it has begun', function() {
|
var arr = [1,2,3],
|
i = 0;
|
arr.some(function(a) {
|
i++;
|
arr.push(a+3);
|
return i > 3;
|
});
|
expect(arr).toEqual([1,2,3,4,5,6]);
|
expect(i).toBe(3);
|
});
|
it('should set the right context when given none', function() {
|
var context;
|
[1].some(function() {context = this;});
|
expect(context).toBe(function() {return this}.call());
|
});
|
|
it('should return false if it runs to the end', function() {
|
actual = testSubject.some(function() {});
|
expect(actual).toBeFalsy();
|
});
|
it('should return true if it is stopped somewhere', function() {
|
actual = testSubject.some(function() { return true; });
|
expect(actual).toBeTruthy();
|
});
|
it('should return false if there are no elements', function() {
|
actual = [].some(function() { return true; });
|
expect(actual).toBeFalsy();
|
});
|
|
it('should stop after 3 elements', function() {
|
testSubject.some(function(obj, index) {
|
actual[index] = obj;
|
numberOfRuns += 1;
|
if(numberOfRuns == 3) {
|
return true;
|
}
|
return false;
|
});
|
expect(actual).toExactlyMatch(expected);
|
});
|
it('should stop after 3 elements using a context', function() {
|
var o = { a: actual };
|
testSubject.some(function(obj, index) {
|
this.a[index] = obj;
|
numberOfRuns += 1;
|
if(numberOfRuns == 3) {
|
return true;
|
}
|
return false;
|
}, o);
|
expect(actual).toExactlyMatch(expected);
|
});
|
|
it('should stop after 3 elements in an array-like object', function() {
|
var ts = createArrayLikeFromArray(testSubject);
|
Array.prototype.some.call(ts, function(obj, index) {
|
actual[index] = obj;
|
numberOfRuns += 1;
|
if(numberOfRuns == 3) {
|
return true;
|
}
|
return false;
|
});
|
expect(actual).toExactlyMatch(expected);
|
});
|
it('should stop after 3 elements in an array-like object using a context', function() {
|
var ts = createArrayLikeFromArray(testSubject);
|
var o = { a: actual };
|
Array.prototype.some.call(ts, function(obj, index) {
|
this.a[index] = obj;
|
numberOfRuns += 1;
|
if(numberOfRuns == 3) {
|
return true;
|
}
|
return false;
|
}, o);
|
expect(actual).toExactlyMatch(expected);
|
});
|
});
|
describe('every', function() {
|
var actual, expected, numberOfRuns;
|
|
beforeEach(function() {
|
expected = {0:2, 2: undefined, 3:true };
|
actual = {};
|
numberOfRuns = 0;
|
});
|
|
it('should pass the correct values along to the callback', function() {
|
var callback = jasmine.createSpy('callback');
|
var array = ['1'];
|
array.every(callback);
|
expect(callback).toHaveBeenCalledWith('1', 0, array);
|
});
|
it('should not affect elements added to the array after it has begun', function() {
|
var arr = [1,2,3],
|
i = 0;
|
arr.every(function(a) {
|
i++;
|
arr.push(a+3);
|
return i <= 3;
|
});
|
expect(arr).toEqual([1,2,3,4,5,6]);
|
expect(i).toBe(3);
|
});
|
it('should set the right context when given none', function() {
|
var context;
|
[1].every(function() {context = this;});
|
expect(context).toBe(function() {return this}.call());
|
});
|
|
it('should return true if the array is empty', function() {
|
actual = [].every(function() { return true; });
|
expect(actual).toBeTruthy();
|
|
actual = [].every(function() { return false; });
|
expect(actual).toBeTruthy();
|
});
|
it('should return true if it runs to the end', function() {
|
actual = [1,2,3].every(function() { return true; });
|
expect(actual).toBeTruthy();
|
});
|
it('should return false if it is stopped before the end', function() {
|
actual = [1,2,3].every(function() { return false; });
|
expect(actual).toBeFalsy();
|
});
|
|
it('should return after 3 elements', function() {
|
testSubject.every(function(obj, index) {
|
actual[index] = obj;
|
numberOfRuns += 1;
|
if(numberOfRuns == 3) {
|
return false;
|
}
|
return true;
|
});
|
expect(actual).toExactlyMatch(expected);
|
});
|
it('should stop after 3 elements using a context', function() {
|
var o = { a: actual };
|
testSubject.every(function(obj, index) {
|
this.a[index] = obj;
|
numberOfRuns += 1;
|
if(numberOfRuns == 3) {
|
return false;
|
}
|
return true;
|
}, o);
|
expect(actual).toExactlyMatch(expected);
|
});
|
|
it('should stop after 3 elements in an array-like object', function() {
|
var ts = createArrayLikeFromArray(testSubject);
|
Array.prototype.every.call(ts, function(obj, index) {
|
actual[index] = obj;
|
numberOfRuns += 1;
|
if(numberOfRuns == 3) {
|
return false;
|
}
|
return true;
|
});
|
expect(actual).toExactlyMatch(expected);
|
});
|
it('should stop after 3 elements in an array-like object using a context', function() {
|
var ts = createArrayLikeFromArray(testSubject);
|
var o = { a: actual };
|
Array.prototype.every.call(ts, function(obj, index) {
|
this.a[index] = obj;
|
numberOfRuns += 1;
|
if(numberOfRuns == 3) {
|
return false;
|
}
|
return true;
|
}, o);
|
expect(actual).toExactlyMatch(expected);
|
});
|
});
|
|
describe('indexOf', function() {
|
"use strict";
|
var actual, expected, testSubject;
|
|
beforeEach(function() {
|
testSubject = [2, 3, undefined, true, 'hej', null, 2, false, 0];
|
delete testSubject[1];
|
|
});
|
|
it('should find the element', function() {
|
expected = 4;
|
actual = testSubject.indexOf('hej');
|
expect(actual).toEqual(expected);
|
});
|
it('should not find the element', function() {
|
expected = -1;
|
actual = testSubject.indexOf('mus');
|
expect(actual).toEqual(expected);
|
});
|
it('should find undefined as well', function() {
|
expected = -1;
|
actual = testSubject.indexOf(undefined);
|
expect(actual).not.toEqual(expected);
|
});
|
it('should skip unset indexes', function() {
|
expected = 2;
|
actual = testSubject.indexOf(undefined);
|
expect(actual).toEqual(expected);
|
});
|
it('should use a strict test', function() {
|
actual = testSubject.indexOf(null);
|
expect(actual).toEqual(5);
|
|
actual = testSubject.indexOf('2');
|
expect(actual).toEqual(-1);
|
});
|
it('should skip the first if fromIndex is set', function() {
|
expect(testSubject.indexOf(2, 2)).toEqual(6);
|
expect(testSubject.indexOf(2, 0)).toEqual(0);
|
expect(testSubject.indexOf(2, 6)).toEqual(6);
|
});
|
it('should work with negative fromIndex', function() {
|
expect(testSubject.indexOf(2, -3)).toEqual(6);
|
expect(testSubject.indexOf(2, -9)).toEqual(0);
|
});
|
it('should work with fromIndex being greater than the length', function() {
|
expect(testSubject.indexOf(0, 20)).toEqual(-1);
|
});
|
it('should work with fromIndex being negative and greater than the length', function() {
|
expect(testSubject.indexOf('hej', -20)).toEqual(4);
|
});
|
|
describe('Array-like', function ArrayLike() {
|
var indexOf = Array.prototype.indexOf,
|
testAL;
|
beforeEach(function beforeEach() {
|
testAL = {};
|
testSubject = [2, 3, undefined, true, 'hej', null, 2, false, 0];
|
testSubject.forEach(function (o,i) {
|
testAL[i] = o;
|
});
|
testAL.length = testSubject.length;
|
});
|
it('should find the element (array-like)', function() {
|
expected = 4;
|
actual = indexOf.call(testAL, 'hej');
|
expect(actual).toEqual(expected);
|
});
|
it('should not find the element (array-like)', function() {
|
expected = -1;
|
actual = indexOf.call(testAL, 'mus');
|
expect(actual).toEqual(expected);
|
});
|
it('should find undefined as well (array-like)', function() {
|
expected = -1;
|
actual = indexOf.call(testAL, undefined);
|
expect(actual).not.toEqual(expected);
|
});
|
it('should skip unset indexes (array-like)', function() {
|
expected = 2;
|
actual = indexOf.call(testAL, undefined);
|
expect(actual).toEqual(expected);
|
});
|
it('should use a strict test (array-like)', function() {
|
actual = Array.prototype.indexOf.call(testAL, null);
|
expect(actual).toEqual(5);
|
|
actual = Array.prototype.indexOf.call(testAL, '2');
|
expect(actual).toEqual(-1);
|
});
|
it('should skip the first if fromIndex is set (array-like)', function() {
|
expect(indexOf.call(testAL, 2, 2)).toEqual(6);
|
expect(indexOf.call(testAL, 2, 0)).toEqual(0);
|
expect(indexOf.call(testAL, 2, 6)).toEqual(6);
|
});
|
it('should work with negative fromIndex (array-like)', function() {
|
expect(indexOf.call(testAL, 2, -3)).toEqual(6);
|
expect(indexOf.call(testAL, 2, -9)).toEqual(0);
|
});
|
it('should work with fromIndex being greater than the length (array-like)', function() {
|
expect(indexOf.call(testAL, 0, 20)).toEqual(-1);
|
});
|
it('should work with fromIndex being negative and greater than the length (array-like)', function() {
|
expect(indexOf.call(testAL, 'hej', -20)).toEqual(4);
|
});
|
});
|
});
|
describe('lastIndexOf', function() {
|
"use strict";
|
var actual, expected, testSubject, testAL;
|
|
beforeEach(function() {
|
testSubject = [2, 3, undefined, true, 'hej', null, 2, 3, false, 0];
|
delete testSubject[1];
|
delete testSubject[7];
|
});
|
describe('Array', function() {
|
it('should find the element', function() {
|
expected = 4;
|
actual = testSubject.lastIndexOf('hej');
|
expect(actual).toEqual(expected);
|
});
|
it('should not find the element', function() {
|
expected = -1;
|
actual = testSubject.lastIndexOf('mus');
|
expect(actual).toEqual(expected);
|
});
|
it('should find undefined as well', function() {
|
expected = -1;
|
actual = testSubject.lastIndexOf(undefined);
|
expect(actual).not.toEqual(expected);
|
});
|
it('should skip unset indexes', function() {
|
expected = 2;
|
actual = testSubject.lastIndexOf(undefined);
|
expect(actual).toEqual(expected);
|
});
|
it('should use a strict test', function() {
|
actual = testSubject.lastIndexOf(null);
|
expect(actual).toEqual(5);
|
|
actual = testSubject.lastIndexOf('2');
|
expect(actual).toEqual(-1);
|
});
|
it('should skip the first if fromIndex is set', function() {
|
expect(testSubject.lastIndexOf(2, 2)).toEqual(0);
|
expect(testSubject.lastIndexOf(2, 0)).toEqual(0);
|
expect(testSubject.lastIndexOf(2, 6)).toEqual(6);
|
});
|
it('should work with negative fromIndex', function() {
|
expect(testSubject.lastIndexOf(2, -3)).toEqual(6);
|
expect(testSubject.lastIndexOf(2, -9)).toEqual(0);
|
});
|
it('should work with fromIndex being greater than the length', function() {
|
expect(testSubject.lastIndexOf(2, 20)).toEqual(6);
|
});
|
it('should work with fromIndex being negative and greater than the length', function() {
|
expect(testSubject.lastIndexOf(2, -20)).toEqual(-1);
|
});
|
});
|
|
describe('Array like', function() {
|
var lastIndexOf = Array.prototype.lastIndexOf,
|
testAL;
|
beforeEach(function() {
|
testAL = {};
|
testSubject.forEach(function (o,i) {
|
testAL[i] = o;
|
});
|
testAL.length = testSubject.length;
|
});
|
it('should find the element (array-like)', function() {
|
expected = 4;
|
actual = lastIndexOf.call(testAL, 'hej');
|
expect(actual).toEqual(expected);
|
});
|
it('should not find the element (array-like)', function() {
|
expected = -1;
|
actual = lastIndexOf.call(testAL, 'mus');
|
expect(actual).toEqual(expected);
|
});
|
it('should find undefined as well (array-like)', function() {
|
expected = -1;
|
actual = lastIndexOf.call(testAL, undefined);
|
expect(actual).not.toEqual(expected);
|
});
|
it('should skip unset indexes (array-like)', function() {
|
expected = 2;
|
actual = lastIndexOf.call(testAL, undefined);
|
expect(actual).toEqual(expected);
|
});
|
it('should use a strict test (array-like)', function() {
|
actual = lastIndexOf.call(testAL, null);
|
expect(actual).toEqual(5);
|
|
actual = lastIndexOf.call(testAL, '2');
|
expect(actual).toEqual(-1);
|
});
|
it('should skip the first if fromIndex is set', function() {
|
expect(lastIndexOf.call(testAL, 2, 2)).toEqual(0);
|
expect(lastIndexOf.call(testAL, 2, 0)).toEqual(0);
|
expect(lastIndexOf.call(testAL, 2, 6)).toEqual(6);
|
});
|
it('should work with negative fromIndex', function() {
|
expect(lastIndexOf.call(testAL, 2, -3)).toEqual(6);
|
expect(lastIndexOf.call(testAL, 2, -9)).toEqual(0);
|
});
|
it('should work with fromIndex being greater than the length', function() {
|
expect(lastIndexOf.call(testAL, 2, 20)).toEqual(6);
|
});
|
it('should work with fromIndex being negative and greater than the length', function() {
|
expect(lastIndexOf.call(testAL, 2, -20)).toEqual(-1);
|
});
|
});
|
});
|
|
describe('filter', function() {
|
var filteredArray,
|
callback = function callback(o, i, arr) {
|
return (
|
i != 3 && i != 5
|
);
|
};
|
|
beforeEach(function() {
|
testSubject = [2, 3, undefined, true, 'hej', 3, null, false, 0];
|
delete testSubject[1];
|
filteredArray = [2, undefined, 'hej', null, false, 0];
|
});
|
describe('Array object', function() {
|
|
it('should call the callback with the proper arguments', function() {
|
var callback = jasmine.createSpy('callback'),
|
arr = ['1'];
|
arr.filter(callback);
|
expect(callback).toHaveBeenCalledWith('1', 0, arr);
|
});
|
it('should not affect elements added to the array after it has begun', function() {
|
var arr = [1,2,3],
|
i = 0;
|
arr.filter(function(a) {
|
i++;
|
if(i <= 4) {
|
arr.push(a+3);
|
}
|
return true;
|
});
|
expect(arr).toEqual([1,2,3,4,5,6]);
|
expect(i).toBe(3);
|
});
|
it('should skip non-set values', function() {
|
var passedValues = {};
|
testSubject = [1,2,3,4];
|
delete testSubject[1];
|
testSubject.filter(function(o, i) {
|
passedValues[i] = o;
|
return true;
|
});
|
expect(passedValues).toExactlyMatch(testSubject);
|
});
|
it('should pass the right context to the filter', function() {
|
var passedValues = {};
|
testSubject = [1,2,3,4];
|
delete testSubject[1];
|
testSubject.filter(function(o, i) {
|
this[i] = o;
|
return true;
|
}, passedValues);
|
expect(passedValues).toExactlyMatch(testSubject);
|
});
|
it('should set the right context when given none', function() {
|
var context;
|
[1].filter(function() {context = this;});
|
expect(context).toBe(function() {return this}.call());
|
});
|
it('should remove only the values for which the callback returns false', function() {
|
var result = testSubject.filter(callback);
|
expect(result).toExactlyMatch(filteredArray);
|
});
|
it('should leave the original array untouched', function() {
|
var copy = testSubject.slice();
|
testSubject.filter(callback);
|
expect(testSubject).toExactlyMatch(copy);
|
});
|
it('should not be affected by same-index mutation', function () {
|
var results = [1, 2, 3]
|
.filter(function (value, index, array) {
|
array[index] = 'a';
|
return true;
|
});
|
expect(results).toEqual([1, 2, 3]);
|
});
|
});
|
describe('Array like', function() {
|
beforeEach(function() {
|
testSubject = createArrayLikeFromArray(testSubject);
|
});
|
it('should call the callback with the proper arguments', function() {
|
var callback = jasmine.createSpy('callback'),
|
arr = createArrayLikeFromArray(['1']);
|
Array.prototype.filter.call(arr, callback);
|
expect(callback).toHaveBeenCalledWith('1', 0, arr);
|
});
|
it('should not affect elements added to the array after it has begun', function() {
|
var arr = createArrayLikeFromArray([1,2,3]),
|
i = 0;
|
Array.prototype.filter.call(arr, function(a) {
|
i++;
|
if(i <= 4) {
|
arr[i+2] = a+3;
|
}
|
return true;
|
});
|
delete arr.length;
|
expect(arr).toExactlyMatch([1,2,3,4,5,6]);
|
expect(i).toBe(3);
|
});
|
it('should skip non-set values', function() {
|
var passedValues = {};
|
testSubject = createArrayLikeFromArray([1,2,3,4]);
|
delete testSubject[1];
|
Array.prototype.filter.call(testSubject, function(o, i) {
|
passedValues[i] = o;
|
return true;
|
});
|
delete testSubject.length;
|
expect(passedValues).toExactlyMatch(testSubject);
|
});
|
it('should set the right context when given none', function() {
|
var context;
|
Array.prototype.filter.call(createArrayLikeFromArray([1]), function() {context = this;}, undefined);
|
expect(context).toBe(function() {return this}.call());
|
});
|
it('should pass the right context to the filter', function() {
|
var passedValues = {};
|
testSubject = createArrayLikeFromArray([1,2,3,4]);
|
delete testSubject[1];
|
Array.prototype.filter.call(testSubject, function(o, i) {
|
this[i] = o;
|
return true;
|
}, passedValues);
|
delete testSubject.length;
|
expect(passedValues).toExactlyMatch(testSubject);
|
});
|
it('should remove only the values for which the callback returns false', function() {
|
var result = Array.prototype.filter.call(testSubject, callback);
|
expect(result).toExactlyMatch(filteredArray);
|
});
|
it('should leave the original array untouched', function() {
|
var copy = createArrayLikeFromArray(testSubject);
|
Array.prototype.filter.call(testSubject, callback);
|
expect(testSubject).toExactlyMatch(copy);
|
});
|
});
|
});
|
describe('map', function() {
|
var callback;
|
beforeEach(function() {
|
var i = 0;
|
callback = function() {
|
return i++;
|
};
|
});
|
describe('Array object', function() {
|
it('should call callback with the right parameters', function() {
|
var callback = jasmine.createSpy('callback'),
|
array = [1];
|
array.map(callback);
|
expect(callback).toHaveBeenCalledWith(1, 0, array);
|
});
|
it('should set the context correctly', function() {
|
var context = {};
|
testSubject.map(function(o,i) {
|
this[i] = o;
|
}, context);
|
expect(context).toExactlyMatch(testSubject);
|
});
|
it('should set the right context when given none', function() {
|
var context;
|
[1].map(function() {context = this;});
|
expect(context).toBe(function() {return this}.call());
|
});
|
it('should not change the array it is called on', function() {
|
var copy = testSubject.slice();
|
testSubject.map(callback);
|
expect(testSubject).toExactlyMatch(copy);
|
});
|
it('should only run for the number of objects in the array when it started', function() {
|
var arr = [1,2,3],
|
i = 0;
|
arr.map(function(o) {
|
arr.push(o+3);
|
i++;
|
return o;
|
});
|
expect(arr).toExactlyMatch([1,2,3,4,5,6]);
|
expect(i).toBe(3);
|
});
|
it('should properly translate the values as according to the callback', function() {
|
var result = testSubject.map(callback),
|
expected = [0,0,1,2,3,4,5,6];
|
delete expected[1];
|
expect(result).toExactlyMatch(expected);
|
});
|
it('should skip non-existing values', function() {
|
var array = [1,2,3,4],
|
i = 0;
|
delete array[2];
|
array.map(function() {
|
i++;
|
});
|
expect(i).toBe(3);
|
});
|
});
|
describe('Array-like', function() {
|
beforeEach(function() {
|
testSubject = createArrayLikeFromArray(testSubject);
|
});
|
it('should call callback with the right parameters', function() {
|
var callback = jasmine.createSpy('callback'),
|
array = createArrayLikeFromArray([1]);
|
Array.prototype.map.call(array, callback);
|
expect(callback).toHaveBeenCalledWith(1, 0, array);
|
});
|
it('should set the context correctly', function() {
|
var context = {};
|
Array.prototype.map.call(testSubject, function(o,i) {
|
this[i] = o;
|
}, context);
|
delete testSubject.length;
|
expect(context).toExactlyMatch(testSubject);
|
});
|
it('should set the right context when given none', function() {
|
var context;
|
Array.prototype.map.call(createArrayLikeFromArray([1]), function() {context = this;});
|
expect(context).toBe(function() {return this}.call());
|
});
|
it('should not change the array it is called on', function() {
|
var copy = createArrayLikeFromArray(testSubject);
|
Array.prototype.map.call(testSubject, callback);
|
expect(testSubject).toExactlyMatch(copy);
|
});
|
it('should only run for the number of objects in the array when it started', function() {
|
var arr = createArrayLikeFromArray([1,2,3]),
|
i = 0;
|
Array.prototype.map.call(arr, function(o) {
|
Array.prototype.push.call(arr, o+3);
|
i++;
|
return o;
|
});
|
delete arr.length;
|
expect(arr).toExactlyMatch([1,2,3,4,5,6]);
|
expect(i).toBe(3);
|
});
|
it('should properly translate the values as according to the callback', function() {
|
var result = Array.prototype.map.call(testSubject, callback),
|
expected = [0,0,1,2,3,4,5,6];
|
delete expected[1];
|
expect(result).toExactlyMatch(expected);
|
});
|
it('should skip non-existing values', function() {
|
var array = createArrayLikeFromArray([1,2,3,4]),
|
i = 0;
|
delete array[2];
|
Array.prototype.map.call(array, function() {
|
i++;
|
});
|
expect(i).toBe(3);
|
});
|
});
|
});
|
|
describe('reduce', function() {
|
beforeEach(function() {
|
testSubject = [1,2,3];
|
});
|
|
describe('Array', function() {
|
it('should pass the correct arguments to the callback', function() {
|
var spy = jasmine.createSpy().andReturn(0);
|
testSubject.reduce(spy);
|
expect(spy.calls[0].args).toExactlyMatch([1, 2, 1, testSubject]);
|
});
|
it('should start with the right initialValue', function() {
|
var spy = jasmine.createSpy().andReturn(0);
|
testSubject.reduce(spy, 0);
|
expect(spy.calls[0].args).toExactlyMatch([0, 1, 0, testSubject]);
|
});
|
it('should not affect elements added to the array after it has begun', function() {
|
var arr = [1,2,3],
|
i = 0;
|
arr.reduce(function(a, b) {
|
i++;
|
if(i <= 4) {
|
arr.push(a+3);
|
};
|
return b;
|
});
|
expect(arr).toEqual([1,2,3,4,5]);
|
expect(i).toBe(2);
|
});
|
it('should work as expected for empty arrays', function() {
|
var spy = jasmine.createSpy();
|
expect(function() {
|
[].reduce(spy);
|
}).toThrow();
|
expect(spy).not.toHaveBeenCalled();
|
});
|
it('should throw correctly if no callback is given', function() {
|
expect(function() {
|
testSubject.reduce();
|
}).toThrow();
|
});
|
it('should return the expected result', function() {
|
expect(testSubject.reduce(function(a,b) {
|
return (a||'').toString()+(b||'').toString();
|
})).toEqual(testSubject.join(''));
|
});
|
it('should not directly affect the passed array', function() {
|
var copy = testSubject.slice();
|
testSubject.reduce(function(a,b) {
|
return a+b;
|
});
|
expect(testSubject).toEqual(copy);
|
});
|
it('should skip non-set values', function() {
|
delete testSubject[1];
|
var visited = {};
|
testSubject.reduce(function(a,b) {
|
if(a)
|
visited[a] = true;
|
if(b)
|
visited[b] = true;
|
return 0;
|
});
|
|
expect(visited).toEqual({ '1': true, '3': true });
|
});
|
it('should have the right length', function() {
|
expect(testSubject.reduce.length).toBe(1);
|
});
|
});
|
describe('Array-like objects', function() {
|
beforeEach(function() {
|
testSubject = createArrayLikeFromArray(testSubject);
|
testSubject.reduce = Array.prototype.reduce;
|
});
|
it('should pass the correct arguments to the callback', function() {
|
var spy = jasmine.createSpy().andReturn(0);
|
testSubject.reduce(spy);
|
expect(spy.calls[0].args).toExactlyMatch([1, 2, 1, testSubject]);
|
});
|
it('should start with the right initialValue', function() {
|
var spy = jasmine.createSpy().andReturn(0);
|
testSubject.reduce(spy, 0);
|
expect(spy.calls[0].args).toExactlyMatch([0, 1, 0, testSubject]);
|
});
|
it('should not affect elements added to the array after it has begun', function() {
|
var arr = createArrayLikeFromArray([1,2,3]),
|
i = 0;
|
Array.prototype.reduce.call(arr, function(a, b) {
|
i++;
|
if(i <= 4) {
|
arr[i+2] = a+3;
|
};
|
return b;
|
});
|
expect(arr).toEqual({
|
0: 1,
|
1: 2,
|
2: 3,
|
3: 4,
|
4: 5,
|
length: 3
|
});
|
expect(i).toBe(2);
|
});
|
it('should work as expected for empty arrays', function() {
|
var spy = jasmine.createSpy();
|
expect(function() {
|
Array.prototype.reduce.call({length: 0}, spy);
|
}).toThrow();
|
expect(spy).not.toHaveBeenCalled();
|
});
|
it('should throw correctly if no callback is given', function() {
|
expect(function() {
|
testSubject.reduce();
|
}).toThrow();
|
});
|
it('should return the expected result', function() {
|
expect(testSubject.reduce(function(a,b) {
|
return (a||'').toString()+(b||'').toString();
|
})).toEqual('123');
|
});
|
it('should not directly affect the passed array', function() {
|
var copy = createArrayLikeFromArray(testSubject);
|
testSubject.reduce(function(a,b) {
|
return a+b;
|
});
|
delete(testSubject.reduce);
|
expect(testSubject).toEqual(copy);
|
});
|
it('should skip non-set values', function() {
|
delete testSubject[1];
|
var visited = {};
|
testSubject.reduce(function(a,b) {
|
if(a)
|
visited[a] = true;
|
if(b)
|
visited[b] = true;
|
return 0;
|
});
|
|
expect(visited).toEqual({ '1': true, '3': true });
|
});
|
it('should have the right length', function() {
|
expect(testSubject.reduce.length).toBe(1);
|
});
|
});
|
});
|
describe('reduceRight', function() {
|
beforeEach(function() {
|
testSubject = [1,2,3];
|
});
|
|
describe('Array', function() {
|
it('should pass the correct arguments to the callback', function() {
|
var spy = jasmine.createSpy().andReturn(0);
|
testSubject.reduceRight(spy);
|
expect(spy.calls[0].args).toExactlyMatch([3, 2, 1, testSubject]);
|
});
|
it('should start with the right initialValue', function() {
|
var spy = jasmine.createSpy().andReturn(0);
|
testSubject.reduceRight(spy, 0);
|
expect(spy.calls[0].args).toExactlyMatch([0, 3, 2, testSubject]);
|
});
|
it('should not affect elements added to the array after it has begun', function() {
|
var arr = [1,2,3],
|
i = 0;
|
arr.reduceRight(function(a, b) {
|
i++;
|
if(i <= 4) {
|
arr.push(a+3);
|
};
|
return b;
|
});
|
expect(arr).toEqual([1,2,3,6,5]);
|
expect(i).toBe(2);
|
});
|
it('should work as expected for empty arrays', function() {
|
var spy = jasmine.createSpy();
|
expect(function() {
|
[].reduceRight(spy);
|
}).toThrow();
|
expect(spy).not.toHaveBeenCalled();
|
});
|
it('should work as expected for empty arrays with an initial value', function() {
|
var spy = jasmine.createSpy(),
|
result;
|
|
result = [].reduceRight(spy, '');
|
expect(spy).not.toHaveBeenCalled();
|
expect(result).toBe('');
|
});
|
it('should throw correctly if no callback is given', function() {
|
expect(function() {
|
testSubject.reduceRight();
|
}).toThrow();
|
});
|
it('should return the expected result', function() {
|
expect(testSubject.reduceRight(function(a,b) {
|
return (a||'').toString()+(b||'').toString();
|
})).toEqual('321');
|
});
|
it('should not directly affect the passed array', function() {
|
var copy = testSubject.slice();
|
testSubject.reduceRight(function(a,b) {
|
return a+b;
|
});
|
expect(testSubject).toEqual(copy);
|
});
|
it('should skip non-set values', function() {
|
delete testSubject[1];
|
var visited = {};
|
testSubject.reduceRight(function(a,b) {
|
if(a)
|
visited[a] = true;
|
if(b)
|
visited[b] = true;
|
return 0;
|
});
|
|
expect(visited).toEqual({ '1': true, '3': true });
|
});
|
it('should have the right length', function() {
|
expect(testSubject.reduceRight.length).toBe(1);
|
});
|
});
|
describe('Array-like objects', function() {
|
beforeEach(function() {
|
testSubject = createArrayLikeFromArray(testSubject);
|
testSubject.reduceRight = Array.prototype.reduceRight;
|
});
|
it('should pass the correct arguments to the callback', function() {
|
var spy = jasmine.createSpy().andReturn(0);
|
testSubject.reduceRight(spy);
|
expect(spy.calls[0].args).toExactlyMatch([3, 2, 1, testSubject]);
|
});
|
it('should start with the right initialValue', function() {
|
var spy = jasmine.createSpy().andReturn(0);
|
testSubject.reduceRight(spy, 0);
|
expect(spy.calls[0].args).toExactlyMatch([0, 3, 2, testSubject]);
|
});
|
it('should not affect elements added to the array after it has begun', function() {
|
var arr = createArrayLikeFromArray([1,2,3]),
|
i = 0;
|
Array.prototype.reduceRight.call(arr, function(a, b) {
|
i++;
|
if(i <= 4) {
|
arr[i+2] = a+3;
|
};
|
return b;
|
});
|
expect(arr).toEqual({
|
0: 1,
|
1: 2,
|
2: 3,
|
3: 6,
|
4: 5,
|
length: 3 // does not get updated on property assignment
|
});
|
expect(i).toBe(2);
|
});
|
it('should work as expected for empty arrays', function() {
|
var spy = jasmine.createSpy();
|
expect(function() {
|
Array.prototype.reduceRight.call({length:0}, spy);
|
}).toThrow();
|
expect(spy).not.toHaveBeenCalled();
|
});
|
it('should throw correctly if no callback is given', function() {
|
expect(function() {
|
testSubject.reduceRight();
|
}).toThrow();
|
});
|
it('should return the expected result', function() {
|
expect(testSubject.reduceRight(function(a,b) {
|
return (a||'').toString()+(b||'').toString();
|
})).toEqual('321');
|
});
|
it('should not directly affect the passed array', function() {
|
var copy = createArrayLikeFromArray(testSubject);
|
testSubject.reduceRight(function(a,b) {
|
return a+b;
|
});
|
delete(testSubject.reduceRight);
|
expect(testSubject).toEqual(copy);
|
});
|
it('should skip non-set values', function() {
|
delete testSubject[1];
|
var visited = {};
|
testSubject.reduceRight(function(a,b) {
|
if(a)
|
visited[a] = true;
|
if(b)
|
visited[b] = true;
|
return 0;
|
});
|
|
expect(visited).toEqual({ '1': true, '3': true });
|
});
|
it('should have the right length', function() {
|
expect(testSubject.reduceRight.length).toBe(1);
|
});
|
});
|
});
|
|
describe('isArray', function () {
|
it('should work for Array', function () {
|
var ret = Array.isArray([]);
|
|
expect(ret).toBe(true);
|
});
|
|
it('should fail for other objects', function () {
|
var objects = [
|
"someString",
|
true,
|
false,
|
42,
|
0,
|
{},
|
Object.create && Object.create(null) || null,
|
/foo/,
|
arguments,
|
document.getElementsByTagName("div")
|
];
|
|
objects.forEach(function (v) {
|
expect(Array.isArray(v)).toBe(false);
|
});
|
});
|
});
|
|
describe('unshift', function () {
|
it('should return length', function () {
|
expect([].unshift(0)).toEqual(1);
|
});
|
});
|
|
describe('splice', function () {
|
var b = ["b"],
|
a = [1, "a", b],
|
test;
|
|
var makeArray = function(l, prefix) {
|
prefix = prefix || "";
|
var a = [];
|
while (l--) {
|
a.unshift(prefix + Array(l + 1).join(" ") + l)
|
}
|
return a
|
};
|
|
beforeEach(function() {
|
test = a.slice(0);
|
});
|
|
it('basic implementation test 1', function () {
|
expect(test.splice(0)).toEqual(a);
|
});
|
it('basic implementation test 2', function () {
|
test.splice(0, 2);
|
expect(test).toEqual([b]);
|
});
|
|
it('should return right result 1', function () {
|
expect((function() {
|
var array = [];
|
|
array.splice(0, 0, 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20);
|
array.splice(1, 0, "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "F10", "F11", "F12", "F13", "F14", "F15", "F16", "F17", "F18", "F19", "F20", "F21","F22", "F23", "F24", "F25", "F26");
|
array.splice(5, 0, "XXX");
|
|
return array.join("|");
|
}())).toBe("1|F1|F2|F3|F4|XXX|F5|F6|F7|F8|F9|F10|F11|F12|F13|F14|F15|F16|F17|F18|F19|F20|F21|F22|F23|F24|F25|F26|2|3|4|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20");
|
});
|
|
it('should return right result 2', function () {
|
expect((function() {
|
var array = makeArray(6);
|
|
array.splice(array.length - 1, 1, "");
|
array.splice(0, 1, 1,2,3,4);
|
array.splice(0, 0, 1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20, 21, 22, 23,24,25,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45);
|
|
array.splice(4, 0, "99999999999999");
|
return array.join("|");
|
}())).toBe("1|2|3|4|99999999999999|5|6|7|8|9|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|27|28|29|30|31|32|33|34|35|36|37|38|39|40|41|42|43|44|45|1|2|3|4| 1| 2| 3| 4|");
|
});
|
|
it('should return right result 3', function () {
|
expect((function() {
|
var array = [1,2,3];
|
|
array.splice(0);
|
array.splice(0, 1, 1,2,3,4,5,6,7,8,9,10);
|
array.splice(1, 1, "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "F10", "F11", "F12", "F13", "F14", "F15", "F16", "F17", "F18", "F19", "F20", "F21","F22", "F23", "F24", "F25", "F26");
|
array.splice(5, 1, "YYY", "XXX");
|
array.splice(0, 1);
|
array.splice(0, 2);
|
array.pop();
|
array.push.apply(array, makeArray(10, "-"));
|
array.splice(array.length - 2, 10);
|
array.splice();
|
array.splice(1, 1, 1,2,3,4,5,6,7,8,9,10,1,2,3,4,5,6,7,8,9);
|
array.splice(1, 1, "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "F10", "F11", "F12", "F13", "F14", "F15", "F16", "F17", "F18", "F19", "F20", "F21","F22", "F23", "F24", "F25", "F26",1,23,4,5,6,7,8);
|
array.splice(30, 10);
|
array.splice(30, 1);
|
array.splice(30, 0);
|
array.splice(2, 5, 1,2,3,"P", "LLL", "CCC", "YYY", "XXX");
|
array.push(1,2,3,4,5,6);
|
array.splice(1, 6, 1,2,3,4,5,6,7,8,9,4,5,6,7,8,9);
|
array.splice(3, 7);
|
array.unshift(7,8,9,10,11);
|
array.pop();
|
array.splice(5, 2);
|
array.pop();
|
array.unshift.apply(array, makeArray(8, "~"));
|
array.pop();
|
array.splice(3, 1, "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "F10", "F11", "F12", "F13", "F14", "F15", "F16", "F17", "F18", "F19", "F20", "F21","F22", "F23", "F24", "F25", "F26",1,23,4,5,6,7,8);
|
array.splice(4, 5, "P", "LLL", "CCC", "YYY", "XXX");
|
|
return array.join("|");
|
}())).toBe("~0|~ 1|~ 2|F1|P|LLL|CCC|YYY|XXX|F7|F8|F9|F10|F11|F12|F13|F14|F15|F16|F17|F18|F19|F20|F21|F22|F23|F24|F25|F26|1|23|4|5|6|7|8|~ 4|~ 5|~ 6|~ 7|7|8|9|10|11|2|4|5|6|7|8|9|CCC|YYY|XXX|F7|F8|F9|F10|F11|F12|F13|F14|F15|F16|F17|F18|F19|F20|F21|F22|F23|F24|F25|F26|1|23|4|9|10|1|2|3|4|5|6|7|8|9|YYY|XXX|F6|F7|F8|F9|F10|F11|F12|F13|F14|F15|F16|F17|F18|F19|F20|F21|F22|F23|F24|F25|F26|3|4|5|6|7|8|9|-0|- 1|- 2|- 3|- 4|- 5|- 6|- 7|1|2|3");
|
});
|
|
|
it('should do nothing if method called with no arguments', function () {
|
expect(test.splice()).toEqual([]);
|
expect(test).toEqual(a);
|
});
|
//TODO:: Is this realy TRUE behavior?
|
it('should set first argument to 0 if first argument is set but undefined', function () {
|
var test2 = test.slice(0);
|
expect(test.splice(void 0, 2)).toEqual(test2.splice(0, 2));
|
expect(test).toEqual(test2);
|
});
|
|
it('should deleted and return all items after "start" when second argument is undefined', function () {
|
expect(test.splice(0)).toEqual(a);
|
expect(test).toEqual([]);
|
});
|
it('should deleted and return all items after "start" when second argument is undefined', function () {
|
expect(test.splice(2)).toEqual([b]);
|
expect(test).toEqual([1, "a"]);
|
});
|
it('runshould have the right length', function () {
|
expect(test.splice.length).toBe(2);
|
});
|
});
|
|
|
});
|