diff options
Diffstat (limited to 'third_party/webkit/PerformanceTests/Speedometer/resources/flightjs-example-app/components/es5-shim/tests/spec')
5 files changed, 1342 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); + }); + }); + }); + + +}); diff --git a/third_party/webkit/PerformanceTests/Speedometer/resources/flightjs-example-app/components/es5-shim/tests/spec/s-date.js b/third_party/webkit/PerformanceTests/Speedometer/resources/flightjs-example-app/components/es5-shim/tests/spec/s-date.js new file mode 100644 index 0000000000..26ab28529e --- /dev/null +++ b/third_party/webkit/PerformanceTests/Speedometer/resources/flightjs-example-app/components/es5-shim/tests/spec/s-date.js @@ -0,0 +1,40 @@ +describe('Date', function () { + + describe('now', function () { + it('should be the current time', function () { + expect(Date.now() === new Date().getTime()).toBe(true); + }); + }); + + describe("parse", function () { + // TODO: Write the rest of the test. + + it('should support extended years', function () { + + expect(Date.parse('0001-01-01T00:00:00Z')).toBe(-62135596800000); + expect(Date.parse('+275760-09-13T00:00:00.000Z')).toBe(8.64e15); + expect(Date.parse('+033658-09-27T01:46:40.000Z')).toBe(1e15); + expect(Date.parse('-000001-01-01T00:00:00Z')).toBe(-62198755200000); + expect(Date.parse('+002009-12-15T00:00:00Z')).toBe(1260835200000); + + }); + + }); + + describe("toISOString", function () { + // TODO: write the rest of the test. + + it('should support extended years', function () { + expect(new Date(-62198755200000).toISOString().indexOf('-000001-01-01')).toBe(0); + expect(new Date(8.64e15).toISOString().indexOf('+275760-09-13')).toBe(0); + }); + }); + + describe("toJSON", function () { + it('should return the isoString when stringified', function () { + var date = new Date(); + expect(JSON.stringify(date.toISOString())).toBe(JSON.stringify(date)); + }) + }); + +});
\ No newline at end of file diff --git a/third_party/webkit/PerformanceTests/Speedometer/resources/flightjs-example-app/components/es5-shim/tests/spec/s-function.js b/third_party/webkit/PerformanceTests/Speedometer/resources/flightjs-example-app/components/es5-shim/tests/spec/s-function.js new file mode 100644 index 0000000000..adb6023fc2 --- /dev/null +++ b/third_party/webkit/PerformanceTests/Speedometer/resources/flightjs-example-app/components/es5-shim/tests/spec/s-function.js @@ -0,0 +1,137 @@ + +describe('Function', function() { + "use strict"; + describe('bind', function() { + var actual, expected, + testSubject; + + testSubject = { + push: function(o) { + this.a.push(o); + } + }; + + function func() { + Array.prototype.forEach.call(arguments, function(a) { + this.push(a); + }, this); + return this; + }; + + beforeEach(function() { + actual = []; + testSubject.a = []; + }); + + it('binds properly without a context', function() { + var context; + testSubject.func = function() { + context = this; + }.bind(); + testSubject.func(); + expect(context).toBe(function() {return this}.call()); + }); + it('binds properly without a context, and still supplies bound arguments', function() { + var a, context; + testSubject.func = function() { + a = Array.prototype.slice.call(arguments); + context = this; + }.bind(undefined, 1,2,3); + testSubject.func(1,2,3); + expect(a).toEqual([1,2,3,1,2,3]); + expect(context).toBe(function() {return this}.call()); + }); + it('binds a context properly', function() { + testSubject.func = func.bind(actual); + testSubject.func(1,2,3); + expect(actual).toEqual([1,2,3]); + expect(testSubject.a).toEqual([]); + }); + it('binds a context and supplies bound arguments', function() { + testSubject.func = func.bind(actual, 1,2,3); + testSubject.func(4,5,6); + expect(actual).toEqual([1,2,3,4,5,6]); + expect(testSubject.a).toEqual([]); + }); + + it('returns properly without binding a context', function() { + testSubject.func = function() { + return this; + }.bind(); + var context = testSubject.func(); + expect(context).toBe(function() {return this}.call()); + }); + it('returns properly without binding a context, and still supplies bound arguments', function() { + var context; + testSubject.func = function() { + context = this; + return Array.prototype.slice.call(arguments); + }.bind(undefined, 1,2,3); + actual = testSubject.func(1,2,3); + expect(context).toBe(function() {return this}.call()); + expect(actual).toEqual([1,2,3,1,2,3]); + }); + it('returns properly while binding a context properly', function() { + var ret; + testSubject.func = func.bind(actual); + ret = testSubject.func(1,2,3); + expect(ret).toBe(actual); + expect(ret).not.toBe(testSubject); + }); + it('returns properly while binding a context and supplies bound arguments', function() { + var ret; + testSubject.func = func.bind(actual, 1,2,3); + ret = testSubject.func(4,5,6); + expect(ret).toBe(actual); + expect(ret).not.toBe(testSubject); + }); + it('passes the correct arguments as a constructor', function() { + var ret, expected = { name: "Correct" }; + testSubject.func = function(arg) { + return arg; + }.bind({ name: "Incorrect" }); + ret = new testSubject.func(expected); + expect(ret).toBe(expected); + }); + it('returns the return value of the bound function when called as a constructor', function () { + var oracle = [1, 2, 3]; + var subject = function () { + return oracle; + }.bind(null); + var result = new subject; + expect(result).toBe(oracle); + }); + it('returns the correct value if constructor returns primitive', function() { + var oracle = [1, 2, 3]; + var subject = function () { + return oracle; + }.bind(null); + var result = new subject; + expect(result).toBe(oracle); + + oracle = {}; + result = new subject; + expect(result).toBe(oracle); + + oracle = function(){}; + result = new subject; + expect(result).toBe(oracle); + + oracle = "asdf"; + result = new subject; + expect(result).not.toBe(oracle); + + oracle = null; + result = new subject; + expect(result).not.toBe(oracle); + + oracle = true; + result = new subject; + expect(result).not.toBe(oracle); + + oracle = 1; + result = new subject; + expect(result).not.toBe(oracle); + }); + }); +}); diff --git a/third_party/webkit/PerformanceTests/Speedometer/resources/flightjs-example-app/components/es5-shim/tests/spec/s-object.js b/third_party/webkit/PerformanceTests/Speedometer/resources/flightjs-example-app/components/es5-shim/tests/spec/s-object.js new file mode 100644 index 0000000000..8f2a87ad8f --- /dev/null +++ b/third_party/webkit/PerformanceTests/Speedometer/resources/flightjs-example-app/components/es5-shim/tests/spec/s-object.js @@ -0,0 +1,84 @@ +describe('Object', function () { + "use strict"; + + describe("Object.keys", function () { + var obj = { + "str": "boz", + "obj": { }, + "arr": [], + "bool": true, + "num": 42, + "null": null, + "undefined": undefined + }; + + var loopedValues = []; + for (var k in obj) { + loopedValues.push(k); + } + + var keys = Object.keys(obj); + it('should have correct length', function () { + expect(keys.length).toBe(7); + }); + + it('should return an Array', function () { + expect(Array.isArray(keys)).toBe(true); + }); + + it('should return names which are own properties', function () { + keys.forEach(function (name) { + expect(obj.hasOwnProperty(name)).toBe(true); + }); + }); + + it('should return names which are enumerable', function () { + keys.forEach(function (name) { + expect(loopedValues.indexOf(name)).toNotBe(-1); + }) + }); + + it('should throw error for non object', function () { + var e = {}; + expect(function () { + try { + Object.keys(42) + } catch (err) { + throw e; + } + }).toThrow(e); + }); + }); + + describe("Object.isExtensible", function () { + var obj = { }; + + it('should return true if object is extensible', function () { + expect(Object.isExtensible(obj)).toBe(true); + }); + + it('should return false if object is not extensible', function () { + expect(Object.isExtensible(Object.preventExtensions(obj))).toBe(false); + }); + + it('should return false if object is seal', function () { + expect(Object.isExtensible(Object.seal(obj))).toBe(false); + }); + + it('should return false if object is freeze', function () { + expect(Object.isExtensible(Object.freeze(obj))).toBe(false); + }); + + it('should throw error for non object', function () { + var e1 = {}; + expect(function () { + try { + Object.isExtensible(42) + } catch (err) { + throw e1; + } + }).toThrow(e1); + }); + }); + +});
\ No newline at end of file diff --git a/third_party/webkit/PerformanceTests/Speedometer/resources/flightjs-example-app/components/es5-shim/tests/spec/s-string.js b/third_party/webkit/PerformanceTests/Speedometer/resources/flightjs-example-app/components/es5-shim/tests/spec/s-string.js new file mode 100644 index 0000000000..c31498dd8a --- /dev/null +++ b/third_party/webkit/PerformanceTests/Speedometer/resources/flightjs-example-app/components/es5-shim/tests/spec/s-string.js @@ -0,0 +1,11 @@ +describe('String', function() { + "use strict"; + describe("trim", function() { + var test = "\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFFHello, World!\x09\x0A\x0B\x0C\x0D\x20\xA0\u1680\u180E\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200A\u202F\u205F\u3000\u2028\u2029\uFEFF"; + + it('trims all ES5 whitespace', function() { + expect(test.trim()).toEqual("Hello, World!"); + expect(test.trim().length).toEqual(13); + }); + }); +}); |