| // Copyright 2006 The Closure Library Authors. All Rights Reserved. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS-IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| goog.provide('goog.arrayTest'); |
| goog.setTestOnly('goog.arrayTest'); |
| |
| goog.require('goog.array'); |
| goog.require('goog.dom'); |
| goog.require('goog.testing.PropertyReplacer'); |
| goog.require('goog.testing.jsunit'); |
| goog.require('goog.testing.recordFunction'); |
| |
| function testArrayLast() { |
| assertEquals(goog.array.last([1, 2, 3]), 3); |
| assertEquals(goog.array.last([1]), 1); |
| assertUndefined(goog.array.last([])); |
| } |
| |
| function testArrayLastWhenDeleted() { |
| var a = [1, 2, 3]; |
| delete a[2]; |
| assertUndefined(goog.array.last(a)); |
| } |
| |
| function testArrayIndexOf() { |
| assertEquals(goog.array.indexOf([0, 1, 2, 3], 1), 1); |
| assertEquals(goog.array.indexOf([0, 1, 1, 1], 1), 1); |
| assertEquals(goog.array.indexOf([0, 1, 2, 3], 4), -1); |
| assertEquals(goog.array.indexOf([0, 1, 2, 3], 1, 1), 1); |
| assertEquals(goog.array.indexOf([0, 1, 2, 3], 1, 2), -1); |
| assertEquals(goog.array.indexOf([0, 1, 2, 3], 1, -3), 1); |
| assertEquals(goog.array.indexOf([0, 1, 2, 3], 1, -2), -1); |
| } |
| |
| function testArrayIndexOfOmitsDeleted() { |
| var a = [0, 1, 2, 3]; |
| delete a[1]; |
| delete a[3]; |
| assertEquals(goog.array.indexOf(a, undefined), -1); |
| } |
| |
| function testArrayIndexOfString() { |
| assertEquals(goog.array.indexOf('abcd', 'd'), 3); |
| assertEquals(goog.array.indexOf('abbb', 'b', 2), 2); |
| assertEquals(goog.array.indexOf('abcd', 'e'), -1); |
| assertEquals(goog.array.indexOf('abcd', 'cd'), -1); |
| assertEquals(goog.array.indexOf('0123', 1), -1); |
| } |
| |
| function testArrayLastIndexOf() { |
| assertEquals(goog.array.lastIndexOf([0, 1, 2, 3], 1), 1); |
| assertEquals(goog.array.lastIndexOf([0, 1, 1, 1], 1), 3); |
| assertEquals(goog.array.lastIndexOf([0, 1, 1, 1], 1, 2), 2); |
| } |
| |
| function testArrayLastIndexOfOmitsDeleted() { |
| var a = [0, 1, 2, 3]; |
| delete a[1]; |
| delete a[3]; |
| assertEquals(goog.array.lastIndexOf(a, undefined), -1); |
| } |
| |
| function testArrayLastIndexOfString() { |
| assertEquals(goog.array.lastIndexOf('abcd', 'b'), 1); |
| assertEquals(goog.array.lastIndexOf('abbb', 'b'), 3); |
| assertEquals(goog.array.lastIndexOf('abbb', 'b', 2), 2); |
| assertEquals(goog.array.lastIndexOf('abcd', 'cd'), -1); |
| assertEquals(goog.array.lastIndexOf('0123', 1), -1); |
| } |
| |
| function testArrayForEachBasic() { |
| var s = ''; |
| var a = ['a', 'b', 'c', 'd']; |
| goog.array.forEach(a, function(val, index, a2) { |
| assertEquals(a, a2); |
| assertEquals('Index is not a number', 'number', typeof index); |
| s += val + index; |
| }); |
| assertEquals('a0b1c2d3', s); |
| } |
| |
| function testArrayForEachWithEmptyArray() { |
| var a = new Array(100); |
| goog.array.forEach(a, function(val, index, a2) { |
| fail('The function should not be called since no values were assigned.'); |
| }); |
| } |
| |
| function testArrayForEachWithOnlySomeValuesAsigned() { |
| var count = 0; |
| var a = new Array(1000); |
| a[100] = undefined; |
| goog.array.forEach(a, function(val, index, a2) { |
| assertEquals(100, index); |
| count++; |
| }); |
| assertEquals('Should only call function when a value of array was assigned.', |
| 1, count); |
| } |
| |
| function testArrayForEachWithArrayLikeObject() { |
| var counter = goog.testing.recordFunction(); |
| var a = { |
| 'length': 1, |
| '0': 0, |
| '100': 100, |
| '101': 102 |
| }; |
| goog.array.forEach(a, counter); |
| assertEquals('Number of calls should not exceed the value of its length', 1, |
| counter.getCallCount()); |
| } |
| |
| function testArrayForEachOmitsDeleted() { |
| var s = ''; |
| var a = ['a', 'b', 'c', 'd']; |
| delete a[1]; |
| delete a[3]; |
| goog.array.forEach(a, function(val, index, a2) { |
| assertEquals(a, a2); |
| assertEquals('number', typeof index); |
| s += val + index; |
| }); |
| assertEquals('a0c2', s); |
| } |
| |
| function testArrayForEachScope() { |
| var scope = {}; |
| var a = ['a', 'b', 'c', 'd']; |
| goog.array.forEach(a, function(val, index, a2) { |
| assertEquals(a, a2); |
| assertEquals('number', typeof index); |
| assertEquals(this, scope); |
| }, scope); |
| } |
| |
| function testArrayForEachRight() { |
| var s = ''; |
| var a = ['a', 'b', 'c', 'd']; |
| goog.array.forEachRight(a, function(val, index, a2) { |
| assertEquals(a, a2); |
| assertEquals('number', typeof index); |
| s += val + String(index); |
| }); |
| assertEquals('d3c2b1a0', s); |
| } |
| |
| function testArrayForEachRightOmitsDeleted() { |
| var s = ''; |
| var a = ['a', 'b', 'c', 'd']; |
| delete a[1]; |
| delete a[3]; |
| goog.array.forEachRight(a, function(val, index, a2) { |
| assertEquals(a, a2); |
| assertEquals('number', typeof index); |
| assertEquals('string', typeof val); |
| s += val + String(index); |
| }); |
| assertEquals('c2a0', s); |
| } |
| |
| function testArrayFilter() { |
| var a = [0, 1, 2, 3]; |
| a = goog.array.filter(a, function(val, index, a2) { |
| assertEquals(a, a2); |
| assertEquals('index is not a number', 'number', typeof index); |
| return val > 1; |
| }); |
| assertArrayEquals([2, 3], a); |
| } |
| |
| function testArrayFilterOmitsDeleted() { |
| var a = [0, 1, 2, 3]; |
| delete a[1]; |
| delete a[3]; |
| a = goog.array.filter(a, function(val, index, a2) { |
| assertEquals(a, a2); |
| assertEquals('number', typeof val); |
| assertEquals('index is not a number', 'number', typeof index); |
| return val > 1; |
| }); |
| assertArrayEquals([2], a); |
| } |
| |
| function testArrayFilterPreservesValues() { |
| var a = [0, 1, 2, 3]; |
| a = goog.array.filter(a, function(val, index, a2) { |
| assertEquals(a, a2); |
| // sometimes functions might be evil and do something like this, but we |
| // should still use the original values when returning the filtered array |
| a2[index] = a2[index] - 1; |
| return a2[index] >= 1; |
| }); |
| assertArrayEquals([2, 3], a); |
| } |
| |
| function testArrayMap() { |
| var a = [0, 1, 2, 3]; |
| var result = goog.array.map(a, function(val, index, a2) { |
| assertEquals(a, a2); |
| assertEquals('index is not a number', 'number', typeof index); |
| return val * val; |
| }); |
| assertArrayEquals([0, 1, 4, 9], result); |
| } |
| |
| function testArrayMapOmitsDeleted() { |
| var a = [0, 1, 2, 3]; |
| delete a[1]; |
| delete a[3]; |
| var result = goog.array.map(a, function(val, index, a2) { |
| assertEquals(a, a2); |
| assertEquals('number', typeof val); |
| assertEquals('index is not a number', 'number', typeof index); |
| return val * val; |
| }); |
| var expected = [0, 1, 4, 9]; |
| delete expected[1]; |
| delete expected[3]; |
| |
| assertArrayEquals(expected, result); |
| assertFalse('1' in result); |
| assertFalse('3' in result); |
| } |
| |
| function testArrayReduce() { |
| var a = [0, 1, 2, 3]; |
| assertEquals(6, goog.array.reduce(a, function(rval, val, i, arr) { |
| assertEquals('number', typeof i); |
| assertEquals(a, arr); |
| return rval + val; |
| }, 0)); |
| |
| var scope = { |
| last: 0, |
| testFn: function(r, v, i, arr) { |
| assertEquals('number', typeof i); |
| assertEquals(a, arr); |
| var l = this.last; |
| this.last = r + v; |
| return this.last + l; |
| } |
| }; |
| |
| assertEquals(10, goog.array.reduce(a, scope.testFn, 0, scope)); |
| } |
| |
| function testArrayReduceOmitDeleted() { |
| var a = [0, 1, 2, 3]; |
| delete a[1]; |
| delete a[3]; |
| assertEquals(2, goog.array.reduce(a, function(rval, val, i, arr) { |
| assertEquals('number', typeof i); |
| assertEquals(a, arr); |
| return rval + val; |
| }, 0)); |
| |
| var scope = { |
| last: 0, |
| testFn: function(r, v, i, arr) { |
| assertEquals('number', typeof i); |
| assertEquals(a, arr); |
| var l = this.last; |
| this.last = r + v; |
| return this.last + l; |
| } |
| }; |
| |
| assertEquals(2, goog.array.reduce(a, scope.testFn, 0, scope)); |
| } |
| |
| function testArrayReducePreviousValuePatch(){ |
| assertEquals(3, goog.array.reduce([1,2], function(p, c){ |
| return p + c; |
| })); |
| } |
| |
| function testArrayReduceRight() { |
| var a = [0, 1, 2, 3, 4]; |
| assertEquals('43210', goog.array.reduceRight(a, function(rval, val, i, arr) { |
| assertEquals('number', typeof i); |
| assertEquals(a, arr); |
| return rval + val; |
| }, '')); |
| |
| var scope = { |
| last: '', |
| testFn: function(r, v, i, arr) { |
| assertEquals('number', typeof i); |
| assertEquals(a, arr); |
| var l = this.last; |
| this.last = v; |
| return r + v + l; |
| } |
| }; |
| |
| a = ['a', 'b', 'c']; |
| assertEquals('_cbcab', goog.array.reduceRight(a, scope.testFn, '_', scope)); |
| } |
| |
| function testArrayReduceRightOmitsDeleted() { |
| var a = [0, 1, 2, 3, 4]; |
| delete a[1]; |
| delete a[4]; |
| assertEquals('320', goog.array.reduceRight(a, function(rval, val, i, arr) { |
| assertEquals('number', typeof i); |
| assertEquals(a, arr); |
| return rval + val; |
| }, '')); |
| |
| scope = { |
| last: '', |
| testFn: function(r, v, i, arr) { |
| assertEquals('number', typeof i); |
| assertEquals(a, arr); |
| var l = this.last; |
| this.last = v; |
| return r + v + l; |
| } |
| }; |
| |
| a = ['a', 'b', 'c', 'd']; |
| delete a[1]; |
| delete a[3]; |
| assertEquals('_cac', goog.array.reduceRight(a, scope.testFn, '_', scope)); |
| } |
| |
| function testArrayFind() { |
| var a = [0, 1, 2, 3]; |
| var b = goog.array.find(a, function(val, index, a2) { |
| assertEquals(a, a2); |
| assertEquals('index is not a number', 'number', typeof index); |
| return val > 1; |
| }); |
| assertEquals(2, b); |
| |
| b = goog.array.find(a, function(val, index, a2) { |
| assertEquals(a, a2); |
| assertEquals('index is not a number', 'number', typeof index); |
| return val > 100; |
| }); |
| assertNull(b); |
| |
| a = 'abCD'; |
| b = goog.array.find(a, function(val, index, a2) { |
| assertEquals(a, a2); |
| assertEquals('index is not a number', 'number', typeof index); |
| return val >= 'A' && val <= 'Z'; |
| }); |
| assertEquals('C', b); |
| |
| a = 'abcd'; |
| b = goog.array.find(a, function(val, index, a2) { |
| assertEquals(a, a2); |
| assertEquals('index is not a number', 'number', typeof index); |
| return val >= 'A' && val <= 'Z'; |
| }); |
| assertNull(b); |
| } |
| |
| function testArrayFindOmitsDeleted() { |
| var a = [0, 1, 2, 3]; |
| delete a[1]; |
| delete a[3]; |
| var b = goog.array.find(a, function(val, index, a2) { |
| assertEquals(a, a2); |
| assertEquals('index is not a number', 'number', typeof index); |
| return val > 1; |
| }); |
| |
| assertEquals(2, b); |
| b = goog.array.find(a, function(val, index, a2) { |
| assertEquals(a, a2); |
| assertEquals('index is not a number', 'number', typeof index); |
| return val > 100; |
| }); |
| assertNull(b); |
| } |
| |
| function testArrayFindIndex() { |
| var a = [0, 1, 2, 3]; |
| var b = goog.array.findIndex(a, function(val, index, a2) { |
| assertEquals(a, a2); |
| assertEquals('index is not a number', 'number', typeof index); |
| return val > 1; |
| }); |
| assertEquals(2, b); |
| |
| b = goog.array.findIndex(a, function(val, index, a2) { |
| assertEquals(a, a2); |
| assertEquals('index is not a number', 'number', typeof index); |
| return val > 100; |
| }); |
| assertEquals(-1, b); |
| |
| a = 'abCD'; |
| b = goog.array.findIndex(a, function(val, index, a2) { |
| assertEquals(a, a2); |
| assertEquals('index is not a number', 'number', typeof index); |
| return val >= 'A' && val <= 'Z'; |
| }); |
| assertEquals(2, b); |
| |
| a = 'abcd'; |
| b = goog.array.findIndex(a, function(val, index, a2) { |
| assertEquals(a, a2); |
| assertEquals('index is not a number', 'number', typeof index); |
| return val >= 'A' && val <= 'Z'; |
| }); |
| assertEquals(-1, b); |
| } |
| |
| function testArrayFindIndexOmitsDeleted() { |
| var a = [0, 1, 2, 3]; |
| delete a[1]; |
| delete a[3]; |
| var b = goog.array.findIndex(a, function(val, index, a2) { |
| assertEquals(a, a2); |
| assertEquals('index is not a number', 'number', typeof index); |
| return val > 1; |
| }); |
| assertEquals(2, b); |
| |
| b = goog.array.findIndex(a, function(val, index, a2) { |
| assertEquals(a, a2); |
| assertEquals('index is not a number', 'number', typeof index); |
| return val > 100; |
| }); |
| assertEquals(-1, b); |
| } |
| |
| function testArrayFindRight() { |
| var a = [0, 1, 2, 3]; |
| var b = goog.array.findRight(a, function(val, index, a2) { |
| assertEquals(a, a2); |
| assertEquals('index is not a number', 'number', typeof index); |
| return val < 3; |
| }); |
| assertEquals(2, b); |
| b = goog.array.findRight(a, function(val, index, a2) { |
| assertEquals(a, a2); |
| assertEquals('index is not a number', 'number', typeof index); |
| return val > 100; |
| }); |
| assertNull(b); |
| } |
| |
| function testArrayFindRightOmitsDeleted() { |
| var a = [0, 1, 2, 3]; |
| delete a[1]; |
| delete a[3]; |
| var b = goog.array.findRight(a, function(val, index, a2) { |
| assertEquals(a, a2); |
| assertEquals('index is not a number', 'number', typeof index); |
| return val < 3; |
| }); |
| assertEquals(2, b); |
| b = goog.array.findRight(a, function(val, index, a2) { |
| assertEquals(a, a2); |
| assertEquals('index is not a number', 'number', typeof index); |
| return val > 100; |
| }); |
| assertNull(b); |
| } |
| |
| function testArrayFindIndexRight() { |
| var a = [0, 1, 2, 3]; |
| var b = goog.array.findIndexRight(a, function(val, index, a2) { |
| assertEquals(a, a2); |
| assertEquals('index is not a number', 'number', typeof index); |
| return val < 3; |
| }); |
| assertEquals(2, b); |
| |
| b = goog.array.findIndexRight(a, function(val, index, a2) { |
| assertEquals(a, a2); |
| assertEquals('index is not a number', 'number', typeof index); |
| return val > 100; |
| }); |
| assertEquals(-1, b); |
| |
| a = 'abCD'; |
| b = goog.array.findIndexRight(a, function(val, index, a2) { |
| assertEquals(a, a2); |
| assertEquals('index is not a number', 'number', typeof index); |
| return val >= 'a' && val <= 'z'; |
| }); |
| assertEquals(1, b); |
| |
| a = 'abcd'; |
| b = goog.array.findIndexRight(a, function(val, index, a2) { |
| assertEquals(a, a2); |
| assertEquals('index is not a number', 'number', typeof index); |
| return val >= 'A' && val <= 'Z'; |
| }); |
| assertEquals(-1, b); |
| } |
| |
| function testArrayFindIndexRightOmitsDeleted() { |
| var a = [0, 1, 2, 3]; |
| delete a[1]; |
| delete a[3]; |
| var b = goog.array.findIndexRight(a, function(val, index, a2) { |
| assertEquals(a, a2); |
| assertEquals('index is not a number', 'number', typeof index); |
| return val < 3; |
| }); |
| assertEquals(2, b); |
| b = goog.array.findIndexRight(a, function(val, index, a2) { |
| assertEquals(a, a2); |
| assertEquals('index is not a number', 'number', typeof index); |
| return val > 100; |
| }); |
| assertEquals(-1, b); |
| } |
| |
| function testArraySome() { |
| var a = [0, 1, 2, 3]; |
| var b = goog.array.some(a, function(val, index, a2) { |
| assertEquals(a, a2); |
| assertEquals('index is not a number', 'number', typeof index); |
| return val > 1; |
| }); |
| assertTrue(b); |
| b = goog.array.some(a, function(val, index, a2) { |
| assertEquals(a, a2); |
| assertEquals('index is not a number', 'number', typeof index); |
| return val > 100; |
| }); |
| assertFalse(b); |
| } |
| |
| function testArraySomeOmitsDeleted() { |
| var a = [0, 1, 2, 3]; |
| delete a[1]; |
| delete a[3]; |
| var b = goog.array.some(a, function(val, index, a2) { |
| assertEquals(a, a2); |
| assertEquals('number', typeof val); |
| assertEquals('index is not a number', 'number', typeof index); |
| return val > 1; |
| }); |
| assertTrue(b); |
| b = goog.array.some(a, function(val, index, a2) { |
| assertEquals(a, a2); |
| assertEquals('number', typeof val); |
| assertEquals('index is not a number', 'number', typeof index); |
| return val > 100; |
| }); |
| assertFalse(b); |
| } |
| |
| function testArrayEvery() { |
| var a = [0, 1, 2, 3]; |
| var b = goog.array.every(a, function(val, index, a2) { |
| assertEquals(a, a2); |
| assertEquals('index is not a number', 'number', typeof index); |
| return val >= 0; |
| }); |
| assertTrue(b); |
| b = goog.array.every(a, function(val, index, a2) { |
| assertEquals(a, a2); |
| assertEquals('index is not a number', 'number', typeof index); |
| return val > 1; |
| }); |
| assertFalse(b); |
| } |
| |
| function testArrayEveryOmitsDeleted() { |
| var a = [0, 1, 2, 3]; |
| delete a[1]; |
| delete a[3]; |
| var b = goog.array.every(a, function(val, index, a2) { |
| assertEquals(a, a2); |
| assertEquals('number', typeof val); |
| assertEquals('index is not a number', 'number', typeof index); |
| return val >= 0; |
| }); |
| assertTrue(b); |
| b = goog.array.every(a, function(val, index, a2) { |
| assertEquals(a, a2); |
| assertEquals('number', typeof val); |
| assertEquals('index is not a number', 'number', typeof index); |
| return val > 1; |
| }); |
| assertFalse(b); |
| } |
| |
| function testArrayCount() { |
| var a = [0, 1, 2, 3, 4]; |
| var context = {}; |
| assertEquals(3, goog.array.count(a, function(element, index, array) { |
| assertTrue(goog.isNumber(index)); |
| assertEquals(a, array); |
| assertEquals(context, this); |
| return element % 2 == 0; |
| }, context)); |
| |
| delete a[2]; |
| assertEquals('deleted element is ignored', 4, |
| goog.array.count(a, function() { |
| return true; |
| })); |
| } |
| |
| function testArrayContains() { |
| var a = [0, 1, 2, 3]; |
| assertTrue('contain, Should contain 3', goog.array.contains(a, 3)); |
| assertFalse('contain, Should not contain 4', goog.array.contains(a, 4)); |
| |
| var s = 'abcd'; |
| assertTrue('contain, Should contain d', goog.array.contains(s, 'd')); |
| assertFalse('contain, Should not contain e', goog.array.contains(s, 'e')); |
| } |
| |
| function testArrayContainsOmitsDeleted() { |
| var a = [0, 1, 2, 3]; |
| delete a[1]; |
| delete a[3]; |
| assertFalse('should not contain undefined', |
| goog.array.contains(a, undefined)); |
| } |
| |
| function testArrayInsert() { |
| var a = [0, 1, 2, 3]; |
| |
| goog.array.insert(a, 4); |
| assertEquals('insert, Should append 4', a[4], 4); |
| goog.array.insert(a, 3); |
| assertEquals('insert, Should not append 3', a.length, 5); |
| assertNotEquals('insert, Should not append 3', a[a.length - 1], 3); |
| } |
| |
| function testArrayInsertAt() { |
| var a = [0, 1, 2, 3]; |
| |
| goog.array.insertAt(a, 4, 2); |
| assertArrayEquals('insertAt, insert in middle', [0, 1, 4, 2, 3], a); |
| goog.array.insertAt(a, 5, 10); |
| assertArrayEquals('insertAt, too large value should append', |
| [0, 1, 4, 2, 3, 5], a); |
| goog.array.insertAt(a, 6); |
| assertArrayEquals('insertAt, null/undefined value should insert at 0', |
| [6, 0, 1, 4, 2, 3, 5], a); |
| goog.array.insertAt(a, 7, -2); |
| assertArrayEquals('insertAt, negative values start from end', |
| [6, 0, 1, 4, 2, 7, 3, 5], a); |
| } |
| |
| function testArrayInsertArrayAt() { |
| var a = [2, 5]; |
| goog.array.insertArrayAt(a, [3, 4], 1); |
| assertArrayEquals('insertArrayAt, insert in middle', [2, 3, 4, 5], a); |
| goog.array.insertArrayAt(a, [0, 1], 0); |
| assertArrayEquals('insertArrayAt, insert at beginning', |
| [0, 1, 2, 3, 4, 5], a); |
| goog.array.insertArrayAt(a, [6, 7], 6); |
| assertArrayEquals('insertArrayAt, insert at end', |
| [0, 1, 2, 3, 4, 5, 6, 7], a); |
| goog.array.insertArrayAt(a, ['x'], 4); |
| assertArrayEquals('insertArrayAt, insert one element', |
| [0, 1, 2, 3, 'x', 4, 5, 6, 7], a); |
| goog.array.insertArrayAt(a, [], 4); |
| assertArrayEquals('insertArrayAt, insert 0 elements', |
| [0, 1, 2, 3, 'x', 4, 5, 6, 7], a); |
| goog.array.insertArrayAt(a, ['y', 'z']); |
| assertArrayEquals('insertArrayAt, undefined value should insert at 0', |
| ['y', 'z', 0, 1, 2, 3, 'x', 4, 5, 6, 7], a); |
| goog.array.insertArrayAt(a, ['a'], null); |
| assertArrayEquals('insertArrayAt, null value should insert at 0', |
| ['a', 'y', 'z', 0, 1, 2, 3, 'x', 4, 5, 6, 7], a); |
| goog.array.insertArrayAt(a, ['b'], 100); |
| assertArrayEquals('insertArrayAt, too large value should append', |
| ['a', 'y', 'z', 0, 1, 2, 3, 'x', 4, 5, 6, 7, 'b'], a); |
| goog.array.insertArrayAt(a, ['c', 'd'], -2); |
| assertArrayEquals('insertArrayAt, negative values start from end', |
| ['a', 'y', 'z', 0, 1, 2, 3, 'x', 4, 5, 6, 'c', 'd', 7, 'b'], a); |
| } |
| |
| function testArrayInsertBefore() { |
| var a = ['a', 'b', 'c', 'd']; |
| goog.array.insertBefore(a, 'e', 'b'); |
| assertArrayEquals('insertBefore, with existing element', |
| ['a', 'e', 'b', 'c', 'd'], a); |
| goog.array.insertBefore(a, 'f', 'x'); |
| assertArrayEquals('insertBefore, with non existing element', |
| ['a', 'e', 'b', 'c', 'd', 'f'], a); |
| } |
| |
| function testArrayRemove() { |
| var a = ['a', 'b', 'c', 'd']; |
| goog.array.remove(a, 'c'); |
| assertArrayEquals('remove, remove existing element', ['a', 'b', 'd'], a); |
| goog.array.remove(a, 'x'); |
| assertArrayEquals('remove, remove non existing element', ['a', 'b', 'd'], a); |
| } |
| |
| function testArrayRemoveAt() { |
| var a = [0, 1, 2, 3]; |
| goog.array.removeAt(a, 2); |
| assertArrayEquals('removeAt, remove existing index', [0, 1, 3], a); |
| a = [0, 1, 2, 3]; |
| goog.array.removeAt(a, 10); |
| assertArrayEquals('removeAt, remove non existing index', [0, 1, 2, 3], a); |
| a = [0, 1, 2, 3]; |
| goog.array.removeAt(a, -2); |
| assertArrayEquals('removeAt, remove with negative index', [0, 1, 3], a); |
| } |
| |
| function testArrayRemoveIf() { |
| var a = [0, 1, 2, 3]; |
| var b = goog.array.removeIf(a, function(val, index, a2) { |
| assertEquals(a, a2); |
| assertEquals('index is not a number', 'number', typeof index); |
| return val > 1; |
| }); |
| assertArrayEquals('removeIf, remove existing element', [0, 1, 3], a); |
| |
| a = [0, 1, 2, 3]; |
| var b = goog.array.removeIf(a, function(val, index, a2) { |
| assertEquals(a, a2); |
| assertEquals('index is not a number', 'number', typeof index); |
| return val > 100; |
| }); |
| assertArrayEquals('removeIf, remove non-existing element', [0, 1, 2, 3], a); |
| } |
| |
| function testArrayClone() { |
| var a = [0, 1, 2, 3]; |
| var a2 = goog.array.clone(a); |
| assertArrayEquals('clone, should be equal', a, a2); |
| |
| var b = {0: 0, 1: 1, 2: 2, 3: 3, length: 4}; |
| var b2 = goog.array.clone(b); |
| for (var i = 0; i < b.length; i++) { |
| assertEquals('clone, should be equal', b[i], b2[i]); |
| } |
| } |
| |
| function testToArray() { |
| var a = [0, 1, 2, 3]; |
| var a2 = goog.array.toArray(a); |
| assertArrayEquals('toArray, should be equal', a, a2); |
| |
| var b = {0: 0, 1: 1, 2: 2, 3: 3, length: 4}; |
| var b2 = goog.array.toArray(b); |
| for (var i = 0; i < b.length; i++) { |
| assertEquals('toArray, should be equal', b[i], b2[i]); |
| } |
| } |
| |
| function testToArrayOnNonArrayLike() { |
| var nonArrayLike = {}; |
| assertArrayEquals('toArray on non ArrayLike should return an empty array', |
| [], goog.array.toArray(nonArrayLike)); |
| |
| var nonArrayLike2 = {length: 'hello world'}; |
| assertArrayEquals('toArray on non ArrayLike should return an empty array', |
| [], goog.array.toArray(nonArrayLike2)); |
| } |
| |
| function testExtend() { |
| var a = [0, 1]; |
| goog.array.extend(a, [2, 3]); |
| var a2 = [0, 1, 2, 3]; |
| assertArrayEquals('extend, should be equal', a, a2); |
| |
| var b = [0, 1]; |
| goog.array.extend(b, 2); |
| var b2 = [0, 1, 2]; |
| assertArrayEquals('extend, should be equal', b, b2); |
| |
| a = [0, 1]; |
| goog.array.extend(a, [2, 3], [4, 5]); |
| a2 = [0, 1, 2, 3, 4, 5]; |
| assertArrayEquals('extend, should be equal', a, a2); |
| |
| b = [0, 1]; |
| goog.array.extend(b, 2, 3); |
| b2 = [0, 1, 2, 3]; |
| assertArrayEquals('extend, should be equal', b, b2); |
| |
| var c = [0, 1]; |
| goog.array.extend(c, 2, [3, 4], 5, [6]); |
| var c2 = [0, 1, 2, 3, 4, 5, 6]; |
| assertArrayEquals('extend, should be equal', c, c2); |
| |
| var d = [0, 1]; |
| var arrayLikeObject = {0: 2, 1: 3, length: 2}; |
| goog.array.extend(d, arrayLikeObject); |
| var d2 = [0, 1, 2, 3]; |
| assertArrayEquals('extend, should be equal', d, d2); |
| |
| var e = [0, 1]; |
| var emptyArrayLikeObject = {length: 0}; |
| goog.array.extend(e, emptyArrayLikeObject); |
| assertArrayEquals('extend, should be equal', e, e); |
| |
| var f = [0, 1]; |
| var length3ArrayLikeObject = {0: 2, 1: 4, 2: 8, length: 3}; |
| goog.array.extend(f, length3ArrayLikeObject, length3ArrayLikeObject); |
| var f2 = [0, 1, 2, 4, 8, 2, 4, 8]; |
| assertArrayEquals('extend, should be equal', f2, f); |
| |
| var result = []; |
| var i = 1000000; |
| var bigArray = Array(i); |
| while (i--) { |
| bigArray[i] = i; |
| } |
| goog.array.extend(result, bigArray); |
| assertArrayEquals(bigArray, result); |
| } |
| |
| function testExtendWithArguments() { |
| function f() { |
| return arguments; |
| } |
| var a = [0]; |
| var a2 = [0, 1, 2, 3, 4, 5]; |
| goog.array.extend(a, f(1, 2, 3), f(4, 5)); |
| assertArrayEquals('extend, should be equal', a, a2); |
| } |
| |
| function testExtendWithQuerySelector() { |
| var a = [0]; |
| var d = goog.dom.getElementsByTagNameAndClass('div', 'foo'); |
| goog.array.extend(a, d); |
| assertEquals(2, a.length); |
| } |
| |
| function testArraySplice() { |
| var a = [0, 1, 2, 3]; |
| goog.array.splice(a, 1, 0, 4); |
| assertArrayEquals([0, 4, 1, 2, 3], a); |
| goog.array.splice(a, 1, 1, 5); |
| assertArrayEquals([0, 5, 1, 2, 3], a); |
| goog.array.splice(a, 1, 1); |
| assertArrayEquals([0, 1, 2, 3], a); |
| // var args |
| goog.array.splice(a, 1, 1, 4, 5, 6); |
| assertArrayEquals([0, 4, 5, 6, 2, 3], a); |
| } |
| |
| function testArraySlice() { |
| var a = [0, 1, 2, 3]; |
| a = goog.array.slice(a, 1, 3); |
| assertArrayEquals([1, 2], a); |
| a = [0, 1, 2, 3]; |
| a = goog.array.slice(a, 1, 6); |
| assertArrayEquals('slice, with too large end', [1, 2, 3], a); |
| a = [0, 1, 2, 3]; |
| a = goog.array.slice(a, 1, -1); |
| assertArrayEquals('slice, with negative end', [1, 2], a); |
| a = [0, 1, 2, 3]; |
| a = goog.array.slice(a, -2, 3); |
| assertArrayEquals('slice, with negative start', [2], a); |
| } |
| |
| function assertRemovedDuplicates(expected, original) { |
| var tempArr = goog.array.clone(original); |
| goog.array.removeDuplicates(tempArr); |
| assertArrayEquals(expected, tempArr); |
| } |
| |
| function testRemoveDuplicates() { |
| assertRemovedDuplicates([1, 2, 3, 4, 5, 6], [1, 2, 3, 4, 5, 6]); |
| assertRemovedDuplicates([9, 4, 2, 1, 3, 6, 0, -9], |
| [9, 4, 2, 4, 4, 2, 9, 1, 3, 6, 0, -9]); |
| assertRemovedDuplicates(['four', 'one', 'two', 'three', 'THREE'], |
| ['four', 'one', 'two', 'one', 'three', 'THREE', 'four', 'two']); |
| assertRemovedDuplicates([], []); |
| assertRemovedDuplicates( |
| ['abc', 'hasOwnProperty', 'toString'], |
| ['abc', 'hasOwnProperty', 'toString', 'abc']); |
| |
| var o1 = {}, o2 = {}, o3 = {}, o4 = {}; |
| assertRemovedDuplicates([o1, o2, o3, o4], [o1, o1, o2, o3, o2, o4]); |
| |
| // Mixed object types. |
| assertRemovedDuplicates([1, '1', 2, '2'], [1, '1', 2, '2']); |
| assertRemovedDuplicates([true, 'true', false, 'false'], |
| [true, 'true', false, 'false']); |
| assertRemovedDuplicates(['foo'], [String('foo'), 'foo']); |
| assertRemovedDuplicates([12], [Number(12), 12]); |
| |
| var obj = {}; |
| var uid = goog.getUid(obj); |
| assertRemovedDuplicates([obj, uid], [obj, uid]); |
| } |
| |
| function testRemoveDuplicates_customHashFn() { |
| var object1 = {key: 'foo'}; |
| var object2 = {key: 'bar'}; |
| var dupeObject = {key: 'foo'}; |
| var array = [object1, object2, dupeObject, 'bar']; |
| var hashFn = function(object) { |
| return goog.isObject(object) ? object.key : |
| (typeof object).charAt(0) + object; |
| }; |
| goog.array.removeDuplicates(array, /* opt_rv */ undefined, hashFn); |
| assertArrayEquals([object1, object2, 'bar'], array); |
| } |
| |
| function testBinaryInsertRemove() { |
| var makeChecker = function(array, fn, opt_compareFn) { |
| return function(value, expectResult, expectArray) { |
| var result = fn(array, value, opt_compareFn); |
| assertEquals(expectResult, result); |
| assertArrayEquals(expectArray, array); |
| } |
| }; |
| |
| var a = []; |
| var check = makeChecker(a, goog.array.binaryInsert); |
| check(3, true, [3]); |
| check(3, false, [3]); |
| check(1, true, [1, 3]); |
| check(5, true, [1, 3, 5]); |
| check(2, true, [1, 2, 3, 5]); |
| check(2, false, [1, 2, 3, 5]); |
| |
| check = makeChecker(a, goog.array.binaryRemove); |
| check(0, false, [1, 2, 3, 5]); |
| check(3, true, [1, 2, 5]); |
| check(1, true, [2, 5]); |
| check(5, true, [2]); |
| check(2, true, []); |
| check(2, false, []); |
| |
| // test with custom comparison function, which reverse orders numbers |
| var revNumCompare = function(a, b) { return b - a; }; |
| |
| check = makeChecker(a, goog.array.binaryInsert, revNumCompare); |
| check(3, true, [3]); |
| check(3, false, [3]); |
| check(1, true, [3, 1]); |
| check(5, true, [5, 3, 1]); |
| check(2, true, [5, 3, 2, 1]); |
| check(2, false, [5, 3, 2, 1]); |
| |
| check = makeChecker(a, goog.array.binaryRemove, revNumCompare); |
| check(0, false, [5, 3, 2, 1]); |
| check(3, true, [5, 2, 1]); |
| check(1, true, [5, 2]); |
| check(5, true, [2]); |
| check(2, true, []); |
| check(2, false, []); |
| } |
| |
| function testBinarySearch() { |
| var insertionPoint = function(position) { return -(position + 1)}; |
| var pos; |
| |
| // test default comparison on array of String(s) |
| var a = ['1000', '9', 'AB', 'ABC', 'ABCABC', 'ABD', 'ABDA', 'B', 'B', 'B', |
| 'C', 'CA', 'CC', 'ZZZ', 'ab', 'abc', 'abcabc', 'abd', 'abda', 'b', |
| 'c', 'ca', 'cc', 'zzz']; |
| |
| assertEquals('\'1000\' should be found at index 0', 0, |
| goog.array.binarySearch(a, '1000')); |
| assertEquals('\'zzz\' should be found at index ' + (a.length - 1), |
| a.length - 1, goog.array.binarySearch(a, 'zzz')); |
| assertEquals('\'C\' should be found at index 10', 10, |
| goog.array.binarySearch(a, 'C')); |
| pos = goog.array.binarySearch(a, 'B'); |
| assertTrue('\'B\' should be found at index 7 || 8 || 9', pos == 7 || |
| pos == 8 || pos == 9); |
| pos = goog.array.binarySearch(a, '100'); |
| assertTrue('\'100\' should not be found', pos < 0); |
| assertEquals('\'100\' should have an insertion point of 0', 0, |
| insertionPoint(pos)); |
| pos = goog.array.binarySearch(a, 'zzz0'); |
| assertTrue('\'zzz0\' should not be found', pos < 0); |
| assertEquals('\'zzz0\' should have an insertion point of ' + (a.length), |
| a.length, insertionPoint(pos)); |
| pos = goog.array.binarySearch(a, 'BA'); |
| assertTrue('\'BA\' should not be found', pos < 0); |
| assertEquals('\'BA\' should have an insertion point of 10', 10, |
| insertionPoint(pos)); |
| |
| // test 0 length array with default comparison |
| var b = []; |
| |
| pos = goog.array.binarySearch(b, 'a'); |
| assertTrue('\'a\' should not be found', pos < 0); |
| assertEquals('\'a\' should have an insertion point of 0', 0, |
| insertionPoint(pos)); |
| |
| // test single element array with default lexiographical comparison |
| var c = ['only item']; |
| |
| assertEquals('\'only item\' should be found at index 0', 0, |
| goog.array.binarySearch(c, 'only item')); |
| pos = goog.array.binarySearch(c, 'a'); |
| assertTrue('\'a\' should not be found', pos < 0); |
| assertEquals('\'a\' should have an insertion point of 0', 0, |
| insertionPoint(pos)); |
| pos = goog.array.binarySearch(c, 'z'); |
| assertTrue('\'z\' should not be found', pos < 0); |
| assertEquals('\'z\' should have an insertion point of 1', 1, |
| insertionPoint(pos)); |
| |
| // test default comparison on array of Number(s) |
| var d = [-897123.9, -321434.58758, -1321.3124, -324, -9, -3, 0, 0, 0, |
| 0.31255, 5, 142.88888708, 334, 342, 453, 54254]; |
| |
| assertEquals('-897123.9 should be found at index 0', 0, |
| goog.array.binarySearch(d, -897123.9)); |
| assertEquals('54254 should be found at index ' + (a.length - 1), |
| d.length - 1, goog.array.binarySearch(d, 54254)); |
| assertEquals( |
| '-3 should be found at index 5', 5, goog.array.binarySearch(d, -3)); |
| pos = goog.array.binarySearch(d, 0); |
| assertTrue('0 should be found at index 6 || 7 || 8', pos == 6 || |
| pos == 7 || pos == 8); |
| pos = goog.array.binarySearch(d, -900000); |
| assertTrue('-900000 should not be found', pos < 0); |
| assertEquals('-900000 should have an insertion point of 0', 0, |
| insertionPoint(pos)); |
| pos = goog.array.binarySearch(d, '54255'); |
| assertTrue('54255 should not be found', pos < 0); |
| assertEquals('54255 should have an insertion point of ' + (d.length), |
| d.length, insertionPoint(pos)); |
| pos = goog.array.binarySearch(d, 1.1); |
| assertTrue('1.1 should not be found', pos < 0); |
| assertEquals('1.1 should have an insertion point of 10', 10, |
| insertionPoint(pos)); |
| |
| // test with custom comparison function, which reverse orders numbers |
| var revNumCompare = function(a, b) { return b - a; }; |
| |
| var e = [54254, 453, 342, 334, 142.88888708, 5, 0.31255, 0, 0, 0, -3, |
| -9, -324, -1321.3124, -321434.58758, -897123.9]; |
| |
| assertEquals('54254 should be found at index 0', 0, |
| goog.array.binarySearch(e, 54254, revNumCompare)); |
| assertEquals('-897123.9 should be found at index ' + (e.length - 1), |
| e.length - 1, goog.array.binarySearch(e, -897123.9, revNumCompare)); |
| assertEquals('-3 should be found at index 10', 10, |
| goog.array.binarySearch(e, -3, revNumCompare)); |
| pos = goog.array.binarySearch(e, 0, revNumCompare); |
| assertTrue('0 should be found at index || 10', pos == 7 || |
| pos == 9 || pos == 10); |
| pos = goog.array.binarySearch(e, 54254.1, revNumCompare); |
| assertTrue('54254.1 should not be found', pos < 0); |
| assertEquals('54254.1 should have an insertion point of 0', 0, |
| insertionPoint(pos)); |
| pos = goog.array.binarySearch(e, -897124, revNumCompare); |
| assertTrue('-897124 should not be found', pos < 0); |
| assertEquals('-897124 should have an insertion point of ' + (e.length), |
| e.length, insertionPoint(pos)); |
| pos = goog.array.binarySearch(e, 1.1, revNumCompare); |
| assertTrue('1.1 should not be found', pos < 0); |
| assertEquals('1.1 should have an insertion point of 6', 6, |
| insertionPoint(pos)); |
| |
| // test 0 length array with custom comparison function |
| var f = []; |
| |
| pos = goog.array.binarySearch(f, 0, revNumCompare); |
| assertTrue('0 should not be found', pos < 0); |
| assertEquals('0 should have an insertion point of 0', 0, |
| insertionPoint(pos)); |
| |
| // test single element array with custom comparison function |
| var g = [1]; |
| |
| assertEquals('1 should be found at index 0', 0, goog.array.binarySearch(g, 1, |
| revNumCompare)); |
| pos = goog.array.binarySearch(g, 2, revNumCompare); |
| assertTrue('2 should not be found', pos < 0); |
| assertEquals('2 should have an insertion point of 0', 0, |
| insertionPoint(pos)); |
| pos = goog.array.binarySearch(g, 0, revNumCompare); |
| assertTrue('0 should not be found', pos < 0); |
| assertEquals('0 should have an insertion point of 1', 1, |
| insertionPoint(pos)); |
| |
| assertEquals('binarySearch should find the index of the first 0', |
| 0, goog.array.binarySearch([0, 0, 1], 0)); |
| assertEquals('binarySearch should find the index of the first 1', |
| 1, goog.array.binarySearch([0, 1, 1], 1)); |
| } |
| |
| |
| function testBinarySearchPerformance() { |
| // Ensure that Array#slice, Function#apply and Function#call are not called |
| // from within binarySearch, since they have performance implications in IE. |
| |
| var propertyReplacer = new goog.testing.PropertyReplacer(); |
| propertyReplacer.replace(Array.prototype, 'slice', function() { |
| fail('Should not call Array#slice from binary search.'); |
| }); |
| propertyReplacer.replace(Function.prototype, 'apply', function() { |
| fail('Should not call Function#apply from binary search.'); |
| }); |
| propertyReplacer.replace(Function.prototype, 'call', function() { |
| fail('Should not call Function#call from binary search.'); |
| }); |
| |
| try { |
| var array = [1, 5, 7, 11, 13, 16, 19, 24, 28, 31, 33, 36, 40, 50, 52, 55]; |
| // Test with the default comparison function. |
| goog.array.binarySearch(array, 48); |
| // Test with a custom comparison function. |
| goog.array.binarySearch(array, 13, function(a, b) { |
| return a > b ? 1 : a < b ? -1 : 0; |
| }); |
| } finally { |
| // The test runner uses Function.prototype.apply to call tearDown in the |
| // global context so it has to be reset here. |
| propertyReplacer.reset(); |
| } |
| } |
| |
| |
| function testBinarySelect() { |
| var insertionPoint = function(position) { return -(position + 1)}; |
| var numbers = [-897123.9, -321434.58758, -1321.3124, -324, -9, -3, 0, 0, 0, |
| 0.31255, 5, 142.88888708, 334, 342, 453, 54254]; |
| var objects = goog.array.map(numbers, function(n) {return {n: n};}); |
| function makeEvaluator(target) { |
| return function(obj, i, arr) { |
| assertEquals(objects, arr); |
| assertEquals(obj, arr[i]); |
| return target - obj.n; |
| }; |
| } |
| assertEquals('{n:-897123.9} should be found at index 0', 0, |
| goog.array.binarySelect(objects, makeEvaluator(-897123.9))); |
| assertEquals('{n:54254} should be found at index ' + (objects.length - 1), |
| objects.length - 1, |
| goog.array.binarySelect(objects, makeEvaluator(54254))); |
| assertEquals('{n:-3} should be found at index 5', 5, |
| goog.array.binarySelect(objects, makeEvaluator(-3))); |
| pos = goog.array.binarySelect(objects, makeEvaluator(0)); |
| assertTrue('{n:0} should be found at index 6 || 7 || 8', pos == 6 || |
| pos == 7 || pos == 8); |
| pos = goog.array.binarySelect(objects, makeEvaluator(-900000)); |
| assertTrue('{n:-900000} should not be found', pos < 0); |
| assertEquals('{n:-900000} should have an insertion point of 0', 0, |
| insertionPoint(pos)); |
| pos = goog.array.binarySelect(objects, makeEvaluator('54255')); |
| assertTrue('{n:54255} should not be found', pos < 0); |
| assertEquals('{n:54255} should have an insertion point of ' + |
| (objects.length), objects.length, insertionPoint(pos)); |
| pos = goog.array.binarySelect(objects, makeEvaluator(1.1)); |
| assertTrue('{n:1.1} should not be found', pos < 0); |
| assertEquals('{n:1.1} should have an insertion point of 10', 10, |
| insertionPoint(pos)); |
| } |
| |
| |
| function testArrayEquals() { |
| // Test argument types. |
| assertFalse('array == not array', goog.array.equals([], null)); |
| assertFalse('not array == array', goog.array.equals(null, [])); |
| assertFalse('not array == not array', goog.array.equals(null, null)); |
| |
| // Test with default comparison function. |
| assertTrue('[] == []', goog.array.equals([], [])); |
| assertTrue('[1] == [1]', goog.array.equals([1], [1])); |
| assertTrue('["1"] == ["1"]', goog.array.equals(['1'], ['1'])); |
| assertFalse('[1] == ["1"]', goog.array.equals([1], ['1'])); |
| assertTrue('[null] == [null]', goog.array.equals([null], [null])); |
| assertFalse('[null] == [undefined]', goog.array.equals([null], [undefined])); |
| assertTrue('[1, 2] == [1, 2]', goog.array.equals([1, 2], [1, 2])); |
| assertFalse('[1, 2] == [2, 1]', goog.array.equals([1, 2], [2, 1])); |
| assertFalse('[1, 2] == [1]', goog.array.equals([1, 2], [1])); |
| assertFalse('[1] == [1, 2]', goog.array.equals([1], [1, 2])); |
| assertFalse('[{}] == [{}]', goog.array.equals([{}], [{}])); |
| |
| // Test with custom comparison function. |
| var cmp = function(a, b) { return typeof a == typeof b; }; |
| assertTrue('[] cmp []', goog.array.equals([], [], cmp)); |
| assertTrue('[1] cmp [1]', goog.array.equals([1], [1], cmp)); |
| assertTrue('[1] cmp [2]', goog.array.equals([1], [2], cmp)); |
| assertTrue('["1"] cmp ["1"]', goog.array.equals(['1'], ['1'], cmp)); |
| assertTrue('["1"] cmp ["2"]', goog.array.equals(['1'], ['2'], cmp)); |
| assertFalse('[1] cmp ["1"]', goog.array.equals([1], ['1'], cmp)); |
| assertTrue('[1, 2] cmp [3, 4]', goog.array.equals([1, 2], [3, 4], cmp)); |
| assertFalse('[1] cmp [2, 3]', goog.array.equals([1], [2, 3], cmp)); |
| assertTrue('[{}] cmp [{}]', goog.array.equals([{}], [{}], cmp)); |
| assertTrue('[{}] cmp [{a: 1}]', goog.array.equals([{}], [{a: 1}], cmp)); |
| |
| // Test with array-like objects. |
| assertTrue('[5] == obj [5]', |
| goog.array.equals([5], {0: 5, length: 1})); |
| assertTrue('obj [5] == [5]', |
| goog.array.equals({0: 5, length: 1}, [5])); |
| assertTrue('["x"] == obj ["x"]', |
| goog.array.equals(['x'], {0: 'x', length: 1})); |
| assertTrue('obj ["x"] == ["x"]', |
| goog.array.equals({0: 'x', length: 1}, ['x'])); |
| assertTrue('[5] == {0: 5, 1: 6, length: 1}', |
| goog.array.equals([5], {0: 5, 1: 6, length: 1})); |
| assertTrue('{0: 5, 1: 6, length: 1} == [5]', |
| goog.array.equals({0: 5, 1: 6, length: 1}, [5])); |
| assertFalse('[5, 6] == {0: 5, 1: 6, length: 1}', |
| goog.array.equals([5, 6], {0: 5, 1: 6, length: 1})); |
| assertFalse('{0: 5, 1: 6, length: 1}, [5, 6]', |
| goog.array.equals({0: 5, 1: 6, length: 1}, [5, 6])); |
| assertTrue('[5, 6] == obj [5, 6]', |
| goog.array.equals([5, 6], {0: 5, 1: 6, length: 2})); |
| assertTrue('obj [5, 6] == [5, 6]', |
| goog.array.equals({0: 5, 1: 6, length: 2}, [5, 6])); |
| assertFalse('{0: 5, 1: 6} == [5, 6]', |
| goog.array.equals({0: 5, 1: 6}, [5, 6])); |
| } |
| |
| |
| function testArrayCompare3Basic() { |
| assertEquals(0, goog.array.compare3([], [])); |
| assertEquals(0, goog.array.compare3(['111', '222'], ['111', '222'])); |
| assertEquals(-1, goog.array.compare3(['111', '222'], ['1111', ''])); |
| assertEquals(1, goog.array.compare3(['111', '222'], ['111'])); |
| assertEquals(1, goog.array.compare3(['11', '222', '333'], [])); |
| assertEquals(-1, goog.array.compare3([], ['11', '222', '333'])); |
| } |
| |
| |
| function testArrayCompare3ComparatorFn() { |
| function cmp(a, b) { |
| return a - b; |
| }; |
| assertEquals(0, goog.array.compare3([], [], cmp)); |
| assertEquals(0, goog.array.compare3([8, 4], [8, 4], cmp)); |
| assertEquals(-1, goog.array.compare3([4, 3], [5, 0])); |
| assertEquals(1, goog.array.compare3([6, 2], [6])); |
| assertEquals(1, goog.array.compare3([1, 2, 3], [])); |
| assertEquals(-1, goog.array.compare3([], [1, 2, 3])); |
| } |
| |
| |
| function testSort() { |
| // Test sorting empty array |
| var a = []; |
| goog.array.sort(a); |
| assertEquals('Sorted empty array is still an empty array (length 0)', 0, |
| a.length); |
| |
| // Test sorting homogenous array of String(s) of length > 1 |
| var b = ['JUST', '1', 'test', 'Array', 'to', 'test', 'array', 'Sort', |
| 'about', 'NOW', '!!']; |
| var bSorted = ['!!', '1', 'Array', 'JUST', 'NOW', 'Sort', 'about', 'array', |
| 'test', 'test', 'to']; |
| goog.array.sort(b); |
| assertArrayEquals(bSorted, b); |
| |
| // Test sorting already sorted array of String(s) of length > 1 |
| goog.array.sort(b); |
| assertArrayEquals(bSorted, b); |
| |
| // Test sorting homogenous array of integer Number(s) of length > 1 |
| var c = [100, 1, 2000, -1, 0, 1000023, 12312512, -12331, 123, 54325, |
| -38104783, 93708, 908, -213, -4, 5423, 0]; |
| var cSorted = [-38104783, -12331, -213, -4, -1, 0, 0, 1, 100, 123, 908, |
| 2000, 5423, 54325, 93708, 1000023, 12312512]; |
| goog.array.sort(c); |
| assertArrayEquals(cSorted, c); |
| |
| // Test sorting already sorted array of integer Number(s) of length > 1 |
| goog.array.sort(c); |
| assertArrayEquals(cSorted, c); |
| |
| // Test sorting homogenous array of Number(s) of length > 1 |
| var e = [-1321.3124, 0.31255, 54254, 0, 142.88888708, -321434.58758, -324, |
| 453, 334, -3, 5, -9, 342, -897123.9]; |
| var eSorted = [-897123.9, -321434.58758, -1321.3124, -324, -9, -3, 0, |
| 0.31255, 5, 142.88888708, 334, 342, 453, 54254]; |
| goog.array.sort(e); |
| assertArrayEquals(eSorted, e); |
| |
| // Test sorting already sorted array of Number(s) of length > 1 |
| goog.array.sort(e); |
| assertArrayEquals(eSorted, e); |
| |
| // Test sorting array of Number(s) of length > 1, |
| // using custom comparison function which does reverse ordering |
| var f = [-1321.3124, 0.31255, 54254, 0, 142.88888708, -321434.58758, |
| -324, 453, 334, -3, 5, -9, 342, -897123.9]; |
| var fSorted = [54254, 453, 342, 334, 142.88888708, 5, 0.31255, 0, -3, -9, |
| -324, -1321.3124, -321434.58758, -897123.9]; |
| goog.array.sort(f, function(a, b) { return b - a; }); |
| assertArrayEquals(fSorted, f); |
| |
| // Test sorting already sorted array of Number(s) of length > 1 |
| // using custom comparison function which does reverse ordering |
| goog.array.sort(f, function(a, b) {return b - a; }); |
| assertArrayEquals(fSorted, f); |
| |
| // Test sorting array of custom Object(s) of length > 1 that have |
| // an overriden toString |
| function ComparedObject(value) { |
| this.value = value; |
| }; |
| |
| ComparedObject.prototype.toString = function() { |
| return this.value; |
| }; |
| |
| var co1 = new ComparedObject('a'); |
| var co2 = new ComparedObject('b'); |
| var co3 = new ComparedObject('c'); |
| var co4 = new ComparedObject('d'); |
| |
| var g = [co3, co4, co2, co1]; |
| var gSorted = [co1, co2, co3, co4]; |
| goog.array.sort(g); |
| assertArrayEquals(gSorted, g); |
| |
| // Test sorting already sorted array of custom Object(s) of length > 1 |
| // that have an overriden toString |
| goog.array.sort(g); |
| assertArrayEquals(gSorted, g); |
| |
| // Test sorting an array of custom Object(s) of length > 1 using |
| // a custom comparison function |
| var h = [co4, co2, co1, co3]; |
| var hSorted = [co1, co2, co3, co4]; |
| goog.array.sort(h, function(a, b) { |
| return a.value > b.value ? 1 : a.value < b.value ? -1 : 0; |
| }); |
| assertArrayEquals(hSorted, h); |
| |
| // Test sorting already sorted array of custom Object(s) of length > 1 |
| // using a custom comparison function |
| goog.array.sort(h); |
| assertArrayEquals(hSorted, h); |
| |
| // Test sorting arrays of length 1 |
| var i = ['one']; |
| var iSorted = ['one']; |
| goog.array.sort(i); |
| assertArrayEquals(iSorted, i); |
| |
| var j = [1]; |
| var jSorted = [1]; |
| goog.array.sort(j); |
| assertArrayEquals(jSorted, j); |
| |
| var k = [1.1]; |
| var kSorted = [1.1]; |
| goog.array.sort(k); |
| assertArrayEquals(kSorted, k); |
| |
| var l = [co3]; |
| var lSorted = [co3]; |
| goog.array.sort(l); |
| assertArrayEquals(lSorted, l); |
| |
| var m = [co2]; |
| var mSorted = [co2]; |
| goog.array.sort(m, function(a, b) { |
| return a.value > b.value ? 1 : a.value < b.value ? -1 : 0; |
| }); |
| assertArrayEquals(mSorted, m); |
| } |
| |
| function testStableSort() { |
| // Test array with custom comparison function |
| var arr = [{key: 3, val: 'a'}, {key: 2, val: 'b'}, {key: 3, val: 'c'}, |
| {key: 4, val: 'd'}, {key: 3, val: 'e'}]; |
| var arrClone = goog.array.clone(arr); |
| |
| function comparisonFn(obj1, obj2) { |
| return obj1.key - obj2.key; |
| } |
| goog.array.stableSort(arr, comparisonFn); |
| var sortedValues = []; |
| for (var i = 0; i < arr.length; i++) { |
| sortedValues.push(arr[i].val); |
| } |
| var wantedSortedValues = ['b', 'a', 'c', 'e', 'd']; |
| assertArrayEquals(wantedSortedValues, sortedValues); |
| |
| // Test array without custom comparison function |
| var arr2 = []; |
| for (var i = 0; i < arrClone.length; i++) { |
| arr2.push({val: arrClone[i].val, toString: |
| goog.partial(function(index) { |
| return arrClone[index].key; |
| }, i)}); |
| } |
| goog.array.stableSort(arr2); |
| var sortedValues2 = []; |
| for (var i = 0; i < arr2.length; i++) { |
| sortedValues2.push(arr2[i].val); |
| } |
| assertArrayEquals(wantedSortedValues, sortedValues2); |
| } |
| |
| function testSortByKey() { |
| function Item(value) { |
| this.getValue = function() { |
| return value; |
| }; |
| } |
| var keyFn = function(item) { |
| return item.getValue(); |
| }; |
| |
| // Test without custom key comparison function |
| var arr1 = [new Item(3), new Item(2), new Item(1), new Item(5), new Item(4)]; |
| goog.array.sortByKey(arr1, keyFn); |
| var wantedSortedValues1 = [1, 2, 3, 4, 5]; |
| for (var i = 0; i < arr1.length; i++) { |
| assertEquals(wantedSortedValues1[i], arr1[i].getValue()); |
| } |
| |
| // Test with custom key comparison function |
| var arr2 = [new Item(3), new Item(2), new Item(1), new Item(5), new Item(4)]; |
| function comparisonFn(key1, key2) { |
| return -(key1 - key2); |
| } |
| goog.array.sortByKey(arr2, keyFn, comparisonFn); |
| var wantedSortedValues2 = [5, 4, 3, 2, 1]; |
| for (var i = 0; i < arr2.length; i++) { |
| assertEquals(wantedSortedValues2[i], arr2[i].getValue()); |
| } |
| } |
| |
| function testArrayBucketModulus() { |
| // bucket things by modulus |
| var a = {}; |
| var b = []; |
| |
| function modFive(num) { |
| return num % 5; |
| } |
| |
| for (var i = 0; i < 20; i++) { |
| var mod = modFive(i); |
| a[mod] = a[mod] || []; |
| a[mod].push(i); |
| b.push(i); |
| } |
| |
| var buckets = goog.array.bucket(b, modFive); |
| |
| for (var i = 0; i < 5; i++) { |
| // The order isn't defined, but they should be the same sorted. |
| goog.array.sort(a[i]); |
| goog.array.sort(buckets[i]); |
| assertArrayEquals(a[i], buckets[i]); |
| } |
| } |
| |
| function testArrayBucketEvenOdd() { |
| var a = [1, 2, 3, 4, 5, 6, 7, 8, 9]; |
| |
| // test even/odd |
| function isEven(value, index, array) { |
| assertEquals(value, array[index]); |
| assertEquals('number', typeof index); |
| assertEquals(a, array); |
| return value % 2 == 0; |
| } |
| |
| var b = goog.array.bucket(a, isEven); |
| |
| assertArrayEquals(b[true], [2, 4, 6, 8]); |
| assertArrayEquals(b[false], [1, 3, 5, 7, 9]); |
| } |
| |
| function testArrayBucketUsingThisObject() { |
| var a = [1, 2, 3, 4, 5]; |
| |
| var obj = { |
| specialValue: 2 |
| }; |
| |
| function isSpecialValue(value, index, array) { |
| return value == this.specialValue ? 1 : 0; |
| } |
| |
| var b = goog.array.bucket(a, isSpecialValue, obj); |
| assertArrayEquals(b[0], [1, 3, 4, 5]); |
| assertArrayEquals(b[1], [2]); |
| } |
| |
| function testArrayToObject() { |
| var a = [ |
| {name: 'a'}, |
| {name: 'b'}, |
| {name: 'c'}, |
| {name: 'd'}]; |
| |
| function getName(value, index, array) { |
| assertEquals(value, array[index]); |
| assertEquals('number', typeof index); |
| assertEquals(a, array); |
| return value.name; |
| } |
| |
| var b = goog.array.toObject(a, getName); |
| |
| for (var i = 0; i < a.length; i++) { |
| assertEquals(a[i], b[a[i].name]); |
| } |
| } |
| |
| function testRange() { |
| assertArrayEquals([], goog.array.range(0)); |
| assertArrayEquals([], goog.array.range(5, 5, 5)); |
| assertArrayEquals([], goog.array.range(-3, -3)); |
| assertArrayEquals([], goog.array.range(10, undefined, -1)); |
| assertArrayEquals([], goog.array.range(8, 0)); |
| assertArrayEquals([], goog.array.range(-5, -10, 3)); |
| |
| assertArrayEquals([0], goog.array.range(1)); |
| assertArrayEquals([0, 1, 2, 3, 4, 5, 6, 7, 8, 9], goog.array.range(10)); |
| |
| assertArrayEquals([1], goog.array.range(1, 2)); |
| assertArrayEquals([-3, -2, -1, 0, 1, 2], goog.array.range(-3, 3)); |
| |
| assertArrayEquals([4], goog.array.range(4, 40, 400)); |
| assertArrayEquals([5, 8, 11, 14], goog.array.range(5, 15, 3)); |
| assertArrayEquals([1, -1, -3], goog.array.range(1, -5, -2)); |
| assertElementsRoughlyEqual([.2, .3, .4], goog.array.range(.2, .5, .1), 0.001); |
| |
| assertArrayEquals([0], goog.array.range(7, undefined, 9)); |
| assertArrayEquals([0, 2, 4, 6], goog.array.range(8, undefined, 2)); |
| } |
| |
| function testArrayRepeat() { |
| assertArrayEquals([], goog.array.repeat(3, 0)); |
| assertArrayEquals([], goog.array.repeat(3, -1)); |
| assertArrayEquals([3], goog.array.repeat(3, 1)); |
| assertArrayEquals([3, 3, 3], goog.array.repeat(3, 3)); |
| assertArrayEquals([null, null], goog.array.repeat(null, 2)); |
| } |
| |
| function testArrayFlatten() { |
| assertArrayEquals([1, 2, 3, 4, 5], goog.array.flatten(1, 2, 3, 4, 5)); |
| assertArrayEquals([1, 2, 3, 4, 5], goog.array.flatten(1, [2, [3, [4, 5]]])); |
| assertArrayEquals([1, 2, 3, 4], goog.array.flatten(1, [2, [3, [4]]])); |
| assertArrayEquals([1, 2, 3, 4], goog.array.flatten([[[1], 2], 3], 4)); |
| assertArrayEquals([1], goog.array.flatten([[1]])); |
| assertArrayEquals([], goog.array.flatten()); |
| assertArrayEquals([], goog.array.flatten([])); |
| assertArrayEquals(goog.array.repeat(3, 180002), |
| goog.array.flatten(3, goog.array.repeat(3, 180000), 3)); |
| assertArrayEquals(goog.array.repeat(3, 180000), |
| goog.array.flatten([goog.array.repeat(3, 180000)])); |
| } |
| |
| function testSortObjectsByKey() { |
| var sortedArray = buildSortedObjectArray(4); |
| var objects = |
| [sortedArray[1], sortedArray[2], sortedArray[0], sortedArray[3]]; |
| |
| goog.array.sortObjectsByKey(objects, 'name'); |
| validateObjectArray(sortedArray, objects); |
| } |
| |
| function testSortObjectsByKeyWithCompareFunction() { |
| var sortedArray = buildSortedObjectArray(4); |
| var objects = |
| [sortedArray[1], sortedArray[2], sortedArray[0], sortedArray[3]]; |
| var descSortedArray = |
| [sortedArray[3], sortedArray[2], sortedArray[1], sortedArray[0]]; |
| |
| function descCompare(a, b) { |
| return a < b ? 1 : a > b ? -1 : 0; |
| }; |
| |
| goog.array.sortObjectsByKey(objects, 'name', descCompare); |
| validateObjectArray(descSortedArray, objects); |
| } |
| |
| function buildSortedObjectArray(size) { |
| var objectArray = []; |
| for (var i = 0; i < size; i++) { |
| objectArray.push({ |
| 'name': 'name_' + i, |
| 'id': 'id_' + (size - i) |
| }); |
| } |
| |
| return objectArray; |
| } |
| |
| function validateObjectArray(expected, actual) { |
| assertEquals(expected.length, actual.length); |
| for (var i = 0; i < expected.length; i++) { |
| assertEquals(expected[i].name, actual[i].name); |
| assertEquals(expected[i].id, actual[i].id); |
| } |
| } |
| |
| function testIsSorted() { |
| assertTrue(goog.array.isSorted([1, 2, 3])); |
| assertTrue(goog.array.isSorted([1, 2, 2])); |
| assertFalse(goog.array.isSorted([1, 2, 1])); |
| |
| assertTrue(goog.array.isSorted([1, 2, 3], null, true)); |
| assertFalse(goog.array.isSorted([1, 2, 2], null, true)); |
| assertFalse(goog.array.isSorted([1, 2, 1], null, true)); |
| |
| function compare(a, b) { |
| return b - a; |
| } |
| |
| assertFalse(goog.array.isSorted([1, 2, 3], compare)); |
| assertTrue(goog.array.isSorted([3, 2, 2], compare)); |
| } |
| |
| function assertRotated(expect, array, rotate) { |
| assertArrayEquals(expect, goog.array.rotate(array, rotate)); |
| } |
| |
| function testRotate() { |
| assertRotated([], [], 3); |
| assertRotated([1], [1], 3); |
| assertRotated([1, 2, 3, 4, 0], [0, 1, 2, 3, 4], -6); |
| assertRotated([0, 1, 2, 3, 4], [0, 1, 2, 3, 4], -5); |
| assertRotated([4, 0, 1, 2, 3], [0, 1, 2, 3, 4], -4); |
| assertRotated([3, 4, 0, 1, 2], [0, 1, 2, 3, 4], -3); |
| assertRotated([2, 3, 4, 0, 1], [0, 1, 2, 3, 4], -2); |
| assertRotated([1, 2, 3, 4, 0], [0, 1, 2, 3, 4], -1); |
| assertRotated([0, 1, 2, 3, 4], [0, 1, 2, 3, 4], 0); |
| assertRotated([4, 0, 1, 2, 3], [0, 1, 2, 3, 4], 1); |
| assertRotated([3, 4, 0, 1, 2], [0, 1, 2, 3, 4], 2); |
| assertRotated([2, 3, 4, 0, 1], [0, 1, 2, 3, 4], 3); |
| assertRotated([1, 2, 3, 4, 0], [0, 1, 2, 3, 4], 4); |
| assertRotated([0, 1, 2, 3, 4], [0, 1, 2, 3, 4], 5); |
| assertRotated([4, 0, 1, 2, 3], [0, 1, 2, 3, 4], 6); |
| } |
| |
| function testMoveItemWithArray() { |
| var arr = [0, 1, 2, 3]; |
| goog.array.moveItem(arr, 1, 3); // toIndex > fromIndex |
| assertArrayEquals([0, 2, 3, 1], arr); |
| goog.array.moveItem(arr, 2, 0); // toIndex < fromIndex |
| assertArrayEquals([3, 0, 2, 1], arr); |
| goog.array.moveItem(arr, 1, 1); // toIndex == fromIndex |
| assertArrayEquals([3, 0, 2, 1], arr); |
| // Out-of-bounds indexes throw assertion errors. |
| assertThrows(function() { |
| goog.array.moveItem(arr, -1, 1); |
| }); |
| assertThrows(function() { |
| goog.array.moveItem(arr, 4, 1); |
| }); |
| assertThrows(function() { |
| goog.array.moveItem(arr, 1, -1); |
| }); |
| assertThrows(function() { |
| goog.array.moveItem(arr, 1, 4); |
| }); |
| // The array should not be modified by the out-of-bound calls. |
| assertArrayEquals([3, 0, 2, 1], arr); |
| } |
| |
| function testMoveItemWithArgumentsObject() { |
| var f = function() { |
| goog.array.moveItem(arguments, 0, 1); |
| return arguments; |
| }; |
| assertArrayEquals([1, 0], goog.array.toArray(f(0, 1))); |
| } |
| |
| function testConcat() { |
| var a1 = [1, 2, 3]; |
| var a2 = [4, 5, 6]; |
| var a3 = goog.array.concat(a1, a2); |
| a1.push(1); |
| a2.push(5); |
| assertArrayEquals([1, 2, 3, 4, 5, 6], a3); |
| } |
| |
| function testConcatWithNoSecondArg() { |
| var a1 = [1, 2, 3, 4]; |
| var a2 = goog.array.concat(a1); |
| a1.push(5); |
| assertArrayEquals([1, 2, 3, 4], a2); |
| } |
| |
| function testConcatWithNonArrayArgs() { |
| var a1 = [1, 2, 3, 4]; |
| var o = {0: 'a', 1: 'b', length: 2}; |
| var a2 = goog.array.concat(a1, 5, '10', o); |
| assertArrayEquals([1, 2, 3, 4, 5, '10', o], a2); |
| } |
| |
| function testConcatWithNull() { |
| var a1 = goog.array.concat(null, [1, 2, 3]); |
| var a2 = goog.array.concat([1, 2, 3], null); |
| assertArrayEquals([null, 1, 2, 3], a1); |
| assertArrayEquals([1, 2, 3, null], a2); |
| } |
| |
| function testZip() { |
| var a1 = goog.array.zip([1, 2, 3], [3, 2, 1]); |
| var a2 = goog.array.zip([1, 2], [3, 2, 1]); |
| var a3 = goog.array.zip(); |
| assertArrayEquals([[1, 3], [2, 2], [3, 1]], a1); |
| assertArrayEquals([[1, 3], [2, 2]], a2); |
| assertArrayEquals([], a3); |
| } |
| |
| function testShuffle() { |
| // Test array. This array should have unique values for the purposes of this |
| // test case. |
| var testArray = [1, 2, 3, 4, 5]; |
| var testArrayCopy = goog.array.clone(testArray); |
| |
| // Custom random function, which always returns a value approaching 1, |
| // resulting in a "shuffle" that preserves the order of original array |
| // (for array sizes that we work with here). |
| var noChangeShuffleFunction = function() { |
| return .999999; |
| }; |
| goog.array.shuffle(testArray, noChangeShuffleFunction); |
| assertArrayEquals(testArrayCopy, testArray); |
| |
| // Custom random function, which always returns 0, resulting in a |
| // deterministic "shuffle" that is predictable but differs from the |
| // original order of the array. |
| var testShuffleFunction = function() { |
| return 0; |
| }; |
| goog.array.shuffle(testArray, testShuffleFunction); |
| assertArrayEquals([2, 3, 4, 5, 1], testArray); |
| |
| // Test the use of a real random function(no optional RNG is specified). |
| goog.array.shuffle(testArray); |
| |
| // Ensure the shuffled array comprises the same elements (without regard to |
| // order). |
| assertSameElements(testArrayCopy, testArray); |
| } |
| |
| function testRemoveAllIf() { |
| var testArray = [9, 1, 9, 2, 9, 3, 4, 9, 9, 9, 5]; |
| var expectedArray = [1, 2, 3, 4, 5]; |
| |
| var actualOutput = goog.array.removeAllIf(testArray, function(el) { |
| return el == 9; |
| }); |
| |
| assertEquals(6, actualOutput); |
| assertArrayEquals(expectedArray, testArray); |
| } |
| |
| function testRemoveAllIf_noMatches() { |
| var testArray = [1]; |
| var expectedArray = [1]; |
| |
| var actualOutput = goog.array.removeAllIf(testArray, function(el) { |
| return false; |
| }); |
| |
| assertEquals(0, actualOutput); |
| assertArrayEquals(expectedArray, testArray); |
| } |
| |
| function testCopyByIndex() { |
| var testArray = [1, 2, 'a', 'b', 'c', 'd']; |
| var copyIndexes = [1, 3, 0, 0, 2]; |
| var expectedArray = [2, 'b', 1, 1, 'a']; |
| |
| var actualOutput = goog.array.copyByIndex(testArray, copyIndexes); |
| |
| assertArrayEquals(expectedArray, actualOutput); |
| } |
| |
| function testComparators() { |
| var greater = 42; |
| var smaller = 13; |
| |
| assertTrue(goog.array.defaultCompare(smaller, greater) < 0); |
| assertEquals(0, goog.array.defaultCompare(smaller, smaller)); |
| assertTrue(goog.array.defaultCompare(greater, smaller) > 0); |
| |
| assertTrue(goog.array.inverseDefaultCompare(greater, smaller) < 0); |
| assertEquals(0, goog.array.inverseDefaultCompare(greater, greater)); |
| assertTrue(goog.array.inverseDefaultCompare(smaller, greater) > 0); |
| } |
