You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1070 lines
43 KiB
1070 lines
43 KiB
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('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('hej', 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, 'hej', 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 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(null), |
|
/foo/, |
|
arguments, |
|
document.getElementsByTagName("div") |
|
]; |
|
|
|
objects.forEach(function (v) { |
|
expect(Array.isArray(v)).toBe(false); |
|
}); |
|
}); |
|
}); |
|
|
|
|
|
});
|
|
|