summaryrefslogtreecommitdiffstats
path: root/third_party/webkit/PerformanceTests/Speedometer/resources/flightjs-example-app/components/es5-shim/tests/spec/s-array.js
diff options
context:
space:
mode:
Diffstat (limited to '')
-rw-r--r--third_party/webkit/PerformanceTests/Speedometer/resources/flightjs-example-app/components/es5-shim/tests/spec/s-array.js1070
1 files changed, 1070 insertions, 0 deletions
diff --git a/third_party/webkit/PerformanceTests/Speedometer/resources/flightjs-example-app/components/es5-shim/tests/spec/s-array.js b/third_party/webkit/PerformanceTests/Speedometer/resources/flightjs-example-app/components/es5-shim/tests/spec/s-array.js
new file mode 100644
index 0000000000..6c353d85b7
--- /dev/null
+++ b/third_party/webkit/PerformanceTests/Speedometer/resources/flightjs-example-app/components/es5-shim/tests/spec/s-array.js
@@ -0,0 +1,1070 @@
+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);
+ });
+ });
+ });
+
+
+});
generated by cgit v1.2.3 (git 2.39.1) at 2024-07-12 05:15:38 +0000