Andreas Hocevar
1041 lines
26 KiB
JavaScript
1041 lines
26 KiB
JavaScript
// 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.structsTest');
|
|
goog.setTestOnly('goog.structsTest');
|
|
|
|
goog.require('goog.array');
|
|
goog.require('goog.structs');
|
|
goog.require('goog.structs.Map');
|
|
goog.require('goog.structs.Set'); // needed for filter
|
|
goog.require('goog.testing.jsunit');
|
|
|
|
/*
|
|
|
|
This one does not test Map or Set
|
|
It tests Array, Object, String and a NodeList
|
|
|
|
*/
|
|
|
|
|
|
|
|
function stringifyObject(obj) {
|
|
var sb = [];
|
|
for (var key in obj) {
|
|
sb.push(key + obj[key]);
|
|
}
|
|
return sb.join('');
|
|
}
|
|
|
|
|
|
function getTestElement() {
|
|
return document.getElementById('test');
|
|
}
|
|
|
|
|
|
function getAll() {
|
|
return getTestElement().getElementsByTagName('*');
|
|
}
|
|
|
|
|
|
var node;
|
|
|
|
|
|
function addNode() {
|
|
node = document.createElement('span');
|
|
getTestElement().appendChild(node);
|
|
}
|
|
|
|
|
|
function removeNode() {
|
|
getTestElement().removeChild(node);
|
|
}
|
|
|
|
|
|
function nodeNames(nl) {
|
|
var sb = [];
|
|
for (var i = 0, n; n = nl[i]; i++) {
|
|
sb.push(n.nodeName.toLowerCase());
|
|
}
|
|
return sb.join(',');
|
|
}
|
|
|
|
|
|
var allTagNames1 = 'hr,p,p,p,p,p,p,p,p,h1';
|
|
var allTagNames2 = allTagNames1 + ',span';
|
|
|
|
|
|
function testGetCount() {
|
|
var arr = ['a', 'b', 'c'];
|
|
assertEquals('count, should be 3', 3, goog.structs.getCount(arr));
|
|
arr.push('d');
|
|
assertEquals('count, should be 4', 4, goog.structs.getCount(arr));
|
|
goog.array.remove(arr, 'd');
|
|
assertEquals('count, should be 3', 3, goog.structs.getCount(arr));
|
|
|
|
var obj = {a: 0, b: 1, c: 2};
|
|
assertEquals('count, should be 3', 3, goog.structs.getCount(obj));
|
|
obj.d = 3;
|
|
assertEquals('count, should be 4', 4, goog.structs.getCount(obj));
|
|
delete obj.d;
|
|
assertEquals('count, should be 3', 3, goog.structs.getCount(obj));
|
|
|
|
var s = 'abc';
|
|
assertEquals('count, should be 3', 3, goog.structs.getCount(s));
|
|
s += 'd';
|
|
assertEquals('count, should be 4', 4, goog.structs.getCount(s));
|
|
|
|
var all = getAll();
|
|
assertEquals('count, should be 10', 10, goog.structs.getCount(all));
|
|
addNode();
|
|
assertEquals('count, should be 11', 11, goog.structs.getCount(all));
|
|
removeNode();
|
|
assertEquals('count, should be 10', 10, goog.structs.getCount(all));
|
|
|
|
var aMap = new goog.structs.Map({a: 0, b: 1, c: 2});
|
|
assertEquals('count, should be 3', 3, goog.structs.getCount(aMap));
|
|
aMap.set('d', 3);
|
|
assertEquals('count, should be 4', 4, goog.structs.getCount(aMap));
|
|
aMap.remove('a');
|
|
assertEquals('count, should be 3', 3, goog.structs.getCount(aMap));
|
|
|
|
var aSet = new goog.structs.Set('abc');
|
|
assertEquals('count, should be 3', 3, goog.structs.getCount(aSet));
|
|
aSet.add('d');
|
|
assertEquals('count, should be 4', 4, goog.structs.getCount(aSet));
|
|
aSet.remove('a');
|
|
assertEquals('count, should be 3', 3, goog.structs.getCount(aSet));
|
|
}
|
|
|
|
|
|
function testGetValues() {
|
|
var arr = ['a', 'b', 'c', 'd'];
|
|
assertEquals('abcd', goog.structs.getValues(arr).join(''));
|
|
|
|
var obj = {a: 0, b: 1, c: 2, d: 3};
|
|
assertEquals('0123', goog.structs.getValues(obj).join(''));
|
|
|
|
var s = 'abc';
|
|
assertEquals('abc', goog.structs.getValues(s).join(''));
|
|
s += 'd';
|
|
assertEquals('abcd', goog.structs.getValues(s).join(''));
|
|
|
|
var all = getAll();
|
|
assertEquals(allTagNames1, nodeNames(goog.structs.getValues(all)));
|
|
addNode();
|
|
assertEquals(allTagNames2, nodeNames(goog.structs.getValues(all)));
|
|
removeNode();
|
|
assertEquals(allTagNames1, nodeNames(goog.structs.getValues(all)));
|
|
|
|
var aMap = new goog.structs.Map({a: 1, b: 2, c: 3});
|
|
assertEquals('123', goog.structs.getValues(aMap).join(''));
|
|
|
|
var aSet = new goog.structs.Set([1, 2, 3]);
|
|
assertEquals('123', goog.structs.getValues(aMap).join(''));
|
|
}
|
|
|
|
|
|
function testGetKeys() {
|
|
var arr = ['a', 'b', 'c', 'd'];
|
|
assertEquals('0123', goog.structs.getKeys(arr).join(''));
|
|
|
|
var obj = {a: 0, b: 1, c: 2, d: 3};
|
|
assertEquals('abcd', goog.structs.getKeys(obj).join(''));
|
|
|
|
var s = 'abc';
|
|
assertEquals('012', goog.structs.getKeys(s).join(''));
|
|
s += 'd';
|
|
assertEquals('0123', goog.structs.getKeys(s).join(''));
|
|
|
|
var all = getAll();
|
|
assertEquals('0123456789', goog.structs.getKeys(all).join(''));
|
|
addNode();
|
|
assertEquals('012345678910', goog.structs.getKeys(all).join(''));
|
|
removeNode();
|
|
assertEquals('0123456789', goog.structs.getKeys(all).join(''));
|
|
|
|
var aMap = new goog.structs.Map({a: 1, b: 2, c: 3});
|
|
assertEquals('abc', goog.structs.getKeys(aMap).join(''));
|
|
|
|
var aSet = new goog.structs.Set([1, 2, 3]);
|
|
assertUndefined(goog.structs.getKeys(aSet));
|
|
}
|
|
|
|
function testContains() {
|
|
var arr = ['a', 'b', 'c', 'd'];
|
|
assertTrue("contains, Should contain 'a'", goog.structs.contains(arr, 'a'));
|
|
assertFalse(
|
|
"contains, Should not contain 'e'", goog.structs.contains(arr, 'e'));
|
|
|
|
var obj = {a: 0, b: 1, c: 2, d: 3};
|
|
assertTrue("contains, Should contain '0'", goog.structs.contains(obj, 0));
|
|
assertFalse(
|
|
"contains, Should not contain '4'", goog.structs.contains(obj, 4));
|
|
|
|
var s = 'abc';
|
|
assertTrue("contains, Should contain 'a'", goog.structs.contains(s, 'a'));
|
|
assertFalse(
|
|
"contains, Should not contain 'd'", goog.structs.contains(s, 'd'));
|
|
|
|
var all = getAll();
|
|
assertTrue("contains, Should contain 'h1'",
|
|
goog.structs.contains(all, document.getElementById('h1')));
|
|
assertFalse("contains, Should not contain 'document.body'",
|
|
goog.structs.contains(all, document.body));
|
|
|
|
var aMap = new goog.structs.Map({a: 1, b: 2, c: 3});
|
|
assertTrue("contains, Should contain '1'", goog.structs.contains(aMap, 1));
|
|
assertFalse(
|
|
"contains, Should not contain '4'", goog.structs.contains(aMap, 4));
|
|
|
|
var aSet = new goog.structs.Set([1, 2, 3]);
|
|
assertTrue("contains, Should contain '1'", goog.structs.contains(aSet, 1));
|
|
assertFalse(
|
|
"contains, Should not contain '4'", goog.structs.contains(aSet, 4));
|
|
}
|
|
|
|
|
|
function testClear() {
|
|
var arr = ['a', 'b', 'c', 'd'];
|
|
goog.structs.clear(arr);
|
|
assertTrue('cleared so it should be empty', goog.structs.isEmpty(arr));
|
|
assertFalse(
|
|
"cleared so it should not contain 'a'", goog.structs.contains(arr, 'a'));
|
|
|
|
var obj = {a: 0, b: 1, c: 2, d: 3};
|
|
goog.structs.clear(obj);
|
|
assertTrue('cleared so it should be empty', goog.structs.isEmpty(obj));
|
|
assertFalse(
|
|
"cleared so it should not contain 'a' key",
|
|
goog.structs.contains(obj, 0));
|
|
|
|
var aMap = new goog.structs.Map({a: 1, b: 2, c: 3});
|
|
goog.structs.clear(aMap);
|
|
assertTrue('cleared map so it should be empty', goog.structs.isEmpty(aMap));
|
|
assertFalse("cleared map so it should not contain '1' value",
|
|
goog.structs.contains(aMap, 1));
|
|
|
|
var aSet = new goog.structs.Set([1, 2, 3]);
|
|
goog.structs.clear(aSet);
|
|
assertTrue('cleared set so it should be empty', goog.structs.isEmpty(aSet));
|
|
assertFalse(
|
|
"cleared set so it should not contain '1'",
|
|
goog.structs.contains(aSet, 1));
|
|
|
|
// cannot clear a string or a NodeList
|
|
}
|
|
|
|
|
|
|
|
// Map
|
|
|
|
function testMap() {
|
|
var RV = {};
|
|
var obj = {
|
|
map: function(g) {
|
|
assertEquals(f, g);
|
|
assertEquals(this, obj);
|
|
return RV;
|
|
}
|
|
};
|
|
function f() {}
|
|
assertEquals(RV, goog.structs.map(obj, f));
|
|
}
|
|
|
|
function testMap2() {
|
|
var THIS_OBJ = {};
|
|
var RV = {};
|
|
var obj = {
|
|
map: function(g, obj2) {
|
|
assertEquals(f, g);
|
|
assertEquals(this, obj);
|
|
assertEquals(THIS_OBJ, obj2);
|
|
return RV;
|
|
}
|
|
};
|
|
function f() {}
|
|
assertEquals(RV, goog.structs.map(obj, f, THIS_OBJ));
|
|
}
|
|
|
|
function testMapArrayLike() {
|
|
var col = [0, 1, 2];
|
|
function f(v, i, col2) {
|
|
assertEquals(col, col2);
|
|
assertEquals('number', typeof i);
|
|
return v * v;
|
|
}
|
|
assertArrayEquals([0, 1, 4], goog.structs.map(col, f));
|
|
}
|
|
|
|
function testMapArrayLike2() {
|
|
var THIS_OBJ = {};
|
|
var col = [0, 1, 2];
|
|
function f(v, i, col2) {
|
|
assertEquals(col, col2);
|
|
assertEquals('number', typeof i);
|
|
assertEquals(THIS_OBJ, this);
|
|
return v * v;
|
|
}
|
|
assertArrayEquals([0, 1, 4], goog.structs.map(col, f, THIS_OBJ));
|
|
}
|
|
|
|
function testMapString() {
|
|
var col = '012';
|
|
function f(v, i, col2) {
|
|
// Teh SpiderMonkey Array.map for strings turns the string into a String
|
|
// so we cannot use assertEquals because it uses ===.
|
|
assertTrue(col == col2);
|
|
assertEquals('number', typeof i);
|
|
return Number(v) * Number(v);
|
|
}
|
|
assertArrayEquals([0, 1, 4], goog.structs.map(col, f));
|
|
}
|
|
|
|
function testMapString2() {
|
|
var THIS_OBJ = {};
|
|
var col = '012';
|
|
function f(v, i, col2) {
|
|
// for some reason the strings are equal but identical???
|
|
assertEquals(String(col), String(col2));
|
|
assertEquals('number', typeof i);
|
|
assertEquals(THIS_OBJ, this);
|
|
return Number(v) * Number(v);
|
|
}
|
|
assertArrayEquals([0, 1, 4], goog.structs.map(col, f, THIS_OBJ));
|
|
}
|
|
|
|
function testMapMap() {
|
|
var col = new goog.structs.Map({a: 0, b: 1, c: 2});
|
|
function f(v, key, col2) {
|
|
assertEquals(col, col2);
|
|
assertEquals('string', typeof key);
|
|
return v * v;
|
|
}
|
|
assertObjectEquals({a: 0, b: 1, c: 4}, goog.structs.map(col, f));
|
|
}
|
|
|
|
function testMapMap2() {
|
|
var THIS_OBJ = {};
|
|
var col = new goog.structs.Map({a: 0, b: 1, c: 2});
|
|
function f(v, key, col2) {
|
|
assertEquals(col, col2);
|
|
assertEquals('string', typeof key);
|
|
assertEquals(THIS_OBJ, this);
|
|
return v * v;
|
|
}
|
|
assertObjectEquals({a: 0, b: 1, c: 4}, goog.structs.map(col, f, THIS_OBJ));
|
|
}
|
|
|
|
function testMapSet() {
|
|
var col = new goog.structs.Set([0, 1, 2]);
|
|
function f(v, key, col2) {
|
|
assertEquals(col, col2);
|
|
assertEquals('undefined', typeof key);
|
|
return v * v;
|
|
}
|
|
assertArrayEquals([0, 1, 4], goog.structs.map(col, f));
|
|
}
|
|
|
|
function testMapSet2() {
|
|
var THIS_OBJ = {};
|
|
var col = new goog.structs.Set([0, 1, 2]);
|
|
function f(v, key, col2) {
|
|
assertEquals(col, col2);
|
|
assertEquals('undefined', typeof key);
|
|
assertEquals(THIS_OBJ, this);
|
|
return v * v;
|
|
}
|
|
assertArrayEquals([0, 1, 4], goog.structs.map(col, f, THIS_OBJ));
|
|
}
|
|
|
|
function testMapNodeList() {
|
|
var col = getAll();
|
|
function f(v, i, col2) {
|
|
assertEquals(col, col2);
|
|
assertEquals('number', typeof i);
|
|
return v.tagName;
|
|
}
|
|
assertEquals('HRPPPPPPPPH1', goog.structs.map(col, f).join(''));
|
|
}
|
|
|
|
function testMapNodeList2() {
|
|
var THIS_OBJ = {};
|
|
var col = getAll();
|
|
function f(v, i, col2) {
|
|
assertEquals(col, col2);
|
|
assertEquals('number', typeof i);
|
|
assertEquals(THIS_OBJ, this);
|
|
return v.tagName;
|
|
}
|
|
assertEquals('HRPPPPPPPPH1', goog.structs.map(col, f, THIS_OBJ).join(''));
|
|
}
|
|
|
|
// Filter
|
|
|
|
function testFilter() {
|
|
var RV = {};
|
|
var obj = {
|
|
filter: function(g) {
|
|
assertEquals(f, g);
|
|
assertEquals(this, obj);
|
|
return RV;
|
|
}
|
|
};
|
|
function f() {}
|
|
assertEquals(RV, goog.structs.filter(obj, f));
|
|
}
|
|
|
|
function testFilter2() {
|
|
var THIS_OBJ = {};
|
|
var RV = {};
|
|
var obj = {
|
|
filter: function(g, obj2) {
|
|
assertEquals(f, g);
|
|
assertEquals(this, obj);
|
|
assertEquals(THIS_OBJ, obj2);
|
|
return RV;
|
|
}
|
|
};
|
|
function f() {}
|
|
assertEquals(RV, goog.structs.filter(obj, f, THIS_OBJ));
|
|
}
|
|
|
|
function testFilterArrayLike() {
|
|
var col = [0, 1, 2];
|
|
function f(v, i, col2) {
|
|
assertEquals(col, col2);
|
|
assertEquals('number', typeof i);
|
|
return v > 0;
|
|
}
|
|
assertArrayEquals([1, 2], goog.structs.filter(col, f));
|
|
}
|
|
|
|
function testFilterArrayLike2() {
|
|
var THIS_OBJ = {};
|
|
var col = [0, 1, 2];
|
|
function f(v, i, col2) {
|
|
assertEquals(col, col2);
|
|
assertEquals('number', typeof i);
|
|
assertEquals(THIS_OBJ, this);
|
|
return v > 0;
|
|
}
|
|
assertArrayEquals([1, 2], goog.structs.filter(col, f, THIS_OBJ));
|
|
}
|
|
|
|
function testFilterString() {
|
|
var col = '012';
|
|
function f(v, i, col2) {
|
|
// for some reason the strings are equal but identical???
|
|
assertEquals(String(col), String(col2));
|
|
assertEquals('number', typeof i);
|
|
return Number(v) > 0;
|
|
}
|
|
assertArrayEquals(['1', '2'], goog.structs.filter(col, f));
|
|
}
|
|
|
|
function testFilterString2() {
|
|
var THIS_OBJ = {};
|
|
var col = '012';
|
|
function f(v, i, col2) {
|
|
// for some reason the strings are equal but identical???
|
|
assertEquals(String(col), String(col2));
|
|
assertEquals('number', typeof i);
|
|
assertEquals(THIS_OBJ, this);
|
|
return Number(v) > 0;
|
|
}
|
|
assertArrayEquals(['1', '2'], goog.structs.filter(col, f, THIS_OBJ));
|
|
}
|
|
|
|
function testFilterMap() {
|
|
var col = new goog.structs.Map({a: 0, b: 1, c: 2});
|
|
function f(v, key, col2) {
|
|
assertEquals(col, col2);
|
|
assertEquals('string', typeof key);
|
|
return v > 0;
|
|
}
|
|
assertObjectEquals({b: 1, c: 2}, goog.structs.filter(col, f));
|
|
}
|
|
|
|
function testFilterMap2() {
|
|
var THIS_OBJ = {};
|
|
var col = new goog.structs.Map({a: 0, b: 1, c: 2});
|
|
function f(v, key, col2) {
|
|
assertEquals(col, col2);
|
|
assertEquals('string', typeof key);
|
|
assertEquals(THIS_OBJ, this);
|
|
return v > 0;
|
|
}
|
|
assertObjectEquals({b: 1, c: 2}, goog.structs.filter(col, f, THIS_OBJ));
|
|
}
|
|
|
|
function testFilterSet() {
|
|
var col = new goog.structs.Set([0, 1, 2]);
|
|
function f(v, key, col2) {
|
|
assertEquals(col, col2);
|
|
assertEquals('undefined', typeof key);
|
|
return v > 0;
|
|
}
|
|
assertArrayEquals([1, 2], goog.structs.filter(col, f));
|
|
}
|
|
|
|
function testFilterSet2() {
|
|
var THIS_OBJ = {};
|
|
var col = new goog.structs.Set([0, 1, 2]);
|
|
function f(v, key, col2) {
|
|
assertEquals(col, col2);
|
|
assertEquals('undefined', typeof key);
|
|
assertEquals(THIS_OBJ, this);
|
|
return v > 0;
|
|
}
|
|
assertArrayEquals([1, 2], goog.structs.filter(col, f, THIS_OBJ));
|
|
}
|
|
|
|
function testFilterNodeList() {
|
|
var col = getAll();
|
|
function f(v, i, col2) {
|
|
assertEquals(col, col2);
|
|
assertEquals('number', typeof i);
|
|
return v.tagName == 'P';
|
|
}
|
|
assertEquals('p,p,p,p,p,p,p,p',
|
|
nodeNames(goog.structs.filter(col, f)));
|
|
}
|
|
|
|
function testFilterNodeList2() {
|
|
var THIS_OBJ = {};
|
|
var col = getAll();
|
|
function f(v, i, col2) {
|
|
assertEquals(col, col2);
|
|
assertEquals('number', typeof i);
|
|
assertEquals(THIS_OBJ, this);
|
|
return v.tagName == 'P';
|
|
}
|
|
assertEquals('p,p,p,p,p,p,p,p',
|
|
nodeNames(goog.structs.filter(col, f, THIS_OBJ)));
|
|
}
|
|
|
|
// Some
|
|
|
|
function testSome() {
|
|
var RV = {};
|
|
var obj = {
|
|
some: function(g) {
|
|
assertEquals(f, g);
|
|
assertEquals(this, obj);
|
|
return RV;
|
|
}
|
|
};
|
|
function f() {}
|
|
assertEquals(RV, goog.structs.some(obj, f));
|
|
}
|
|
|
|
function testSome2() {
|
|
var THIS_OBJ = {};
|
|
var RV = {};
|
|
var obj = {
|
|
some: function(g, obj2) {
|
|
assertEquals(f, g);
|
|
assertEquals(this, obj);
|
|
assertEquals(THIS_OBJ, obj2);
|
|
return RV;
|
|
}
|
|
};
|
|
function f() {}
|
|
assertEquals(RV, goog.structs.some(obj, f, THIS_OBJ));
|
|
}
|
|
|
|
function testSomeArrayLike() {
|
|
var limit = 0;
|
|
var col = [0, 1, 2];
|
|
function f(v, i, col2) {
|
|
assertEquals(col, col2);
|
|
assertEquals('number', typeof i);
|
|
return v > limit;
|
|
}
|
|
assertTrue(goog.structs.some(col, f));
|
|
limit = 2;
|
|
assertFalse(goog.structs.some(col, f));
|
|
}
|
|
|
|
function testSomeArrayLike2() {
|
|
var THIS_OBJ = {};
|
|
var limit = 0;
|
|
var col = [0, 1, 2];
|
|
function f(v, i, col2) {
|
|
assertEquals(col, col2);
|
|
assertEquals('number', typeof i);
|
|
assertEquals(THIS_OBJ, this);
|
|
return v > limit;
|
|
}
|
|
assertTrue(goog.structs.some(col, f, THIS_OBJ));
|
|
limit = 2;
|
|
assertFalse(goog.structs.some(col, f, THIS_OBJ));
|
|
}
|
|
|
|
function testSomeString() {
|
|
var limit = 0;
|
|
var col = '012';
|
|
function f(v, i, col2) {
|
|
// for some reason the strings are equal but identical???
|
|
assertEquals(String(col), String(col2));
|
|
assertEquals('number', typeof i);
|
|
return Number(v) > limit;
|
|
}
|
|
assertTrue(goog.structs.some(col, f));
|
|
limit = 2;
|
|
assertFalse(goog.structs.some(col, f));
|
|
}
|
|
|
|
function testSomeString2() {
|
|
var THIS_OBJ = {};
|
|
var limit = 0;
|
|
var col = '012';
|
|
function f(v, i, col2) {
|
|
// for some reason the strings are equal but identical???
|
|
assertEquals(String(col), String(col2));
|
|
assertEquals('number', typeof i);
|
|
assertEquals(THIS_OBJ, this);
|
|
return Number(v) > limit;
|
|
}
|
|
assertTrue(goog.structs.some(col, f, THIS_OBJ));
|
|
limit = 2;
|
|
assertFalse(goog.structs.some(col, f, THIS_OBJ));
|
|
}
|
|
|
|
function testSomeMap() {
|
|
var limit = 0;
|
|
var col = new goog.structs.Map({a: 0, b: 1, c: 2});
|
|
function f(v, key, col2) {
|
|
assertEquals(col, col2);
|
|
assertEquals('string', typeof key);
|
|
return v > limit;
|
|
}
|
|
assertObjectEquals(true, goog.structs.some(col, f));
|
|
limit = 2;
|
|
assertFalse(goog.structs.some(col, f));
|
|
}
|
|
|
|
function testSomeMap2() {
|
|
var THIS_OBJ = {};
|
|
var limit = 0;
|
|
var col = new goog.structs.Map({a: 0, b: 1, c: 2});
|
|
function f(v, key, col2) {
|
|
assertEquals(col, col2);
|
|
assertEquals('string', typeof key);
|
|
assertEquals(THIS_OBJ, this);
|
|
return v > limit;
|
|
}
|
|
assertObjectEquals(true, goog.structs.some(col, f, THIS_OBJ));
|
|
limit = 2;
|
|
assertFalse(goog.structs.some(col, f, THIS_OBJ));
|
|
}
|
|
|
|
function testSomeSet() {
|
|
var limit = 0;
|
|
var col = new goog.structs.Set([0, 1, 2]);
|
|
function f(v, key, col2) {
|
|
assertEquals(col, col2);
|
|
assertEquals('undefined', typeof key);
|
|
return v > limit;
|
|
}
|
|
assertTrue(goog.structs.some(col, f));
|
|
limit = 2;
|
|
assertFalse(goog.structs.some(col, f));
|
|
}
|
|
|
|
function testSomeSet2() {
|
|
var THIS_OBJ = {};
|
|
var limit = 0;
|
|
var col = new goog.structs.Set([0, 1, 2]);
|
|
function f(v, key, col2) {
|
|
assertEquals(col, col2);
|
|
assertEquals('undefined', typeof key);
|
|
assertEquals(THIS_OBJ, this);
|
|
return v > limit;
|
|
}
|
|
assertTrue(goog.structs.some(col, f, THIS_OBJ));
|
|
limit = 2;
|
|
assertFalse(goog.structs.some(col, f, THIS_OBJ));
|
|
}
|
|
|
|
function testSomeNodeList() {
|
|
var tagName = 'P';
|
|
var col = getAll();
|
|
function f(v, i, col2) {
|
|
assertEquals(col, col2);
|
|
assertEquals('number', typeof i);
|
|
return v.tagName == tagName;
|
|
}
|
|
assertTrue(goog.structs.some(col, f));
|
|
tagName = 'MARQUEE';
|
|
assertFalse(goog.structs.some(col, f));
|
|
}
|
|
|
|
function testSomeNodeList2() {
|
|
var THIS_OBJ = {};
|
|
var tagName = 'P';
|
|
var col = getAll();
|
|
function f(v, i, col2) {
|
|
assertEquals(col, col2);
|
|
assertEquals('number', typeof i);
|
|
assertEquals(THIS_OBJ, this);
|
|
return v.tagName == tagName;
|
|
}
|
|
assertTrue(goog.structs.some(col, f, THIS_OBJ));
|
|
tagName = 'MARQUEE';
|
|
assertFalse(goog.structs.some(col, f, THIS_OBJ));
|
|
}
|
|
|
|
// Every
|
|
|
|
function testEvery() {
|
|
var RV = {};
|
|
var obj = {
|
|
every: function(g) {
|
|
assertEquals(f, g);
|
|
assertEquals(this, obj);
|
|
return RV;
|
|
}
|
|
};
|
|
function f() {}
|
|
assertEquals(RV, goog.structs.every(obj, f));
|
|
}
|
|
|
|
function testEvery2() {
|
|
var THIS_OBJ = {};
|
|
var RV = {};
|
|
var obj = {
|
|
every: function(g, obj2) {
|
|
assertEquals(f, g);
|
|
assertEquals(this, obj);
|
|
assertEquals(THIS_OBJ, obj2);
|
|
return RV;
|
|
}
|
|
};
|
|
function f() {}
|
|
assertEquals(RV, goog.structs.every(obj, f, THIS_OBJ));
|
|
}
|
|
|
|
function testEveryArrayLike() {
|
|
var limit = -1;
|
|
var col = [0, 1, 2];
|
|
function f(v, i, col2) {
|
|
assertEquals(col, col2);
|
|
assertEquals('number', typeof i);
|
|
return v > limit;
|
|
}
|
|
assertTrue(goog.structs.every(col, f));
|
|
limit = 1;
|
|
assertFalse(goog.structs.every(col, f));
|
|
}
|
|
|
|
function testEveryArrayLike2() {
|
|
var THIS_OBJ = {};
|
|
var limit = -1;
|
|
var col = [0, 1, 2];
|
|
function f(v, i, col2) {
|
|
assertEquals(col, col2);
|
|
assertEquals('number', typeof i);
|
|
assertEquals(THIS_OBJ, this);
|
|
return v > limit;
|
|
}
|
|
assertTrue(goog.structs.every(col, f, THIS_OBJ));
|
|
limit = 1;
|
|
assertFalse(goog.structs.every(col, f, THIS_OBJ));
|
|
}
|
|
|
|
function testEveryString() {
|
|
var limit = -1;
|
|
var col = '012';
|
|
function f(v, i, col2) {
|
|
// for some reason the strings are equal but identical???
|
|
assertEquals(String(col), String(col2));
|
|
assertEquals('number', typeof i);
|
|
return Number(v) > limit;
|
|
}
|
|
assertTrue(goog.structs.every(col, f));
|
|
limit = 1;
|
|
assertFalse(goog.structs.every(col, f));
|
|
}
|
|
|
|
function testEveryString2() {
|
|
var THIS_OBJ = {};
|
|
var limit = -1;
|
|
var col = '012';
|
|
function f(v, i, col2) {
|
|
// for some reason the strings are equal but identical???
|
|
assertEquals(String(col), String(col2));
|
|
assertEquals('number', typeof i);
|
|
assertEquals(THIS_OBJ, this);
|
|
return Number(v) > limit;
|
|
}
|
|
assertTrue(goog.structs.every(col, f, THIS_OBJ));
|
|
limit = 1;
|
|
assertFalse(goog.structs.every(col, f, THIS_OBJ));
|
|
}
|
|
|
|
function testEveryMap() {
|
|
var limit = -1;
|
|
var col = new goog.structs.Map({a: 0, b: 1, c: 2});
|
|
function f(v, key, col2) {
|
|
assertEquals(col, col2);
|
|
assertEquals('string', typeof key);
|
|
return v > limit;
|
|
}
|
|
assertObjectEquals(true, goog.structs.every(col, f));
|
|
limit = 1;
|
|
assertFalse(goog.structs.every(col, f));
|
|
}
|
|
|
|
function testEveryMap2() {
|
|
var THIS_OBJ = {};
|
|
var limit = -1;
|
|
var col = new goog.structs.Map({a: 0, b: 1, c: 2});
|
|
function f(v, key, col2) {
|
|
assertEquals(col, col2);
|
|
assertEquals('string', typeof key);
|
|
assertEquals(THIS_OBJ, this);
|
|
return v > limit;
|
|
}
|
|
assertObjectEquals(true, goog.structs.every(col, f, THIS_OBJ));
|
|
limit = 1;
|
|
assertFalse(goog.structs.every(col, f, THIS_OBJ));
|
|
}
|
|
|
|
function testEverySet() {
|
|
var limit = -1;
|
|
var col = new goog.structs.Set([0, 1, 2]);
|
|
function f(v, key, col2) {
|
|
assertEquals(col, col2);
|
|
assertEquals('undefined', typeof key);
|
|
return v > limit;
|
|
}
|
|
assertTrue(goog.structs.every(col, f));
|
|
limit = 1;
|
|
assertFalse(goog.structs.every(col, f));
|
|
}
|
|
|
|
function testEverySet2() {
|
|
var THIS_OBJ = {};
|
|
var limit = -1;
|
|
var col = new goog.structs.Set([0, 1, 2]);
|
|
function f(v, key, col2) {
|
|
assertEquals(col, col2);
|
|
assertEquals('undefined', typeof key);
|
|
assertEquals(THIS_OBJ, this);
|
|
return v > limit;
|
|
}
|
|
assertTrue(goog.structs.every(col, f, THIS_OBJ));
|
|
limit = 1;
|
|
assertFalse(goog.structs.every(col, f, THIS_OBJ));
|
|
}
|
|
|
|
function testEveryNodeList() {
|
|
var nodeType = 1; // ELEMENT
|
|
var col = getAll();
|
|
function f(v, i, col2) {
|
|
assertEquals(col, col2);
|
|
assertEquals('number', typeof i);
|
|
return v.nodeType == nodeType;
|
|
}
|
|
assertTrue(goog.structs.every(col, f));
|
|
nodeType = 3; // TEXT
|
|
assertFalse(goog.structs.every(col, f));
|
|
}
|
|
|
|
function testEveryNodeList2() {
|
|
var THIS_OBJ = {};
|
|
var nodeType = 1; // ELEMENT
|
|
var col = getAll();
|
|
function f(v, i, col2) {
|
|
assertEquals(col, col2);
|
|
assertEquals('number', typeof i);
|
|
assertEquals(THIS_OBJ, this);
|
|
return v.nodeType == nodeType;
|
|
}
|
|
assertTrue(goog.structs.every(col, f, THIS_OBJ));
|
|
nodeType = 3; // TEXT
|
|
assertFalse(goog.structs.every(col, f, THIS_OBJ));
|
|
}
|
|
|
|
// For each
|
|
|
|
function testForEach() {
|
|
var called = false;
|
|
var obj = {
|
|
forEach: function(g) {
|
|
assertEquals(f, g);
|
|
assertEquals(this, obj);
|
|
called = true;
|
|
}
|
|
};
|
|
function f() {}
|
|
goog.structs.forEach(obj, f);
|
|
assertTrue(called);
|
|
}
|
|
|
|
function testForEach2() {
|
|
var called = false;
|
|
var THIS_OBJ = {};
|
|
var obj = {
|
|
forEach: function(g, obj2) {
|
|
assertEquals(f, g);
|
|
assertEquals(this, obj);
|
|
assertEquals(THIS_OBJ, obj2);
|
|
called = true;
|
|
}
|
|
};
|
|
function f() {}
|
|
goog.structs.forEach(obj, f, THIS_OBJ);
|
|
assertTrue(called);
|
|
}
|
|
|
|
function testForEachArrayLike() {
|
|
var col = [0, 1, 2];
|
|
var values = [];
|
|
function f(v, i, col2) {
|
|
assertEquals(col, col2);
|
|
assertEquals('number', typeof i);
|
|
values.push(v * v);
|
|
}
|
|
goog.structs.forEach(col, f);
|
|
assertArrayEquals([0, 1, 4], values);
|
|
}
|
|
|
|
function testForEachArrayLike2() {
|
|
var THIS_OBJ = {};
|
|
var col = [0, 1, 2];
|
|
var values = [];
|
|
function f(v, i, col2) {
|
|
assertEquals(col, col2);
|
|
assertEquals('number', typeof i);
|
|
assertEquals(THIS_OBJ, this);
|
|
values.push(v * v);
|
|
}
|
|
goog.structs.forEach(col, f, THIS_OBJ);
|
|
assertArrayEquals([0, 1, 4], values);
|
|
}
|
|
|
|
function testForEachString() {
|
|
var col = '012';
|
|
var values = [];
|
|
function f(v, i, col2) {
|
|
// for some reason the strings are equal but identical???
|
|
assertEquals(String(col), String(col2));
|
|
assertEquals('number', typeof i);
|
|
values.push(Number(v) * Number(v));
|
|
}
|
|
goog.structs.forEach(col, f);
|
|
assertArrayEquals([0, 1, 4], values);
|
|
}
|
|
|
|
function testForEachString2() {
|
|
var THIS_OBJ = {};
|
|
var col = '012';
|
|
var values = [];
|
|
function f(v, i, col2) {
|
|
// for some reason the strings are equal but identical???
|
|
assertEquals(String(col), String(col2));
|
|
assertEquals('number', typeof i);
|
|
assertEquals(THIS_OBJ, this);
|
|
values.push(Number(v) * Number(v));
|
|
}
|
|
goog.structs.forEach(col, f, THIS_OBJ);
|
|
assertArrayEquals([0, 1, 4], values);
|
|
}
|
|
|
|
function testForEachMap() {
|
|
var col = new goog.structs.Map({a: 0, b: 1, c: 2});
|
|
var values = [];
|
|
var keys = [];
|
|
function f(v, key, col2) {
|
|
assertEquals(col, col2);
|
|
assertEquals('string', typeof key);
|
|
values.push(v * v);
|
|
keys.push(key);
|
|
}
|
|
goog.structs.forEach(col, f);
|
|
assertArrayEquals([0, 1, 4], values);
|
|
assertArrayEquals(['a', 'b', 'c'], keys);
|
|
}
|
|
|
|
function testForEachMap2() {
|
|
var THIS_OBJ = {};
|
|
var col = new goog.structs.Map({a: 0, b: 1, c: 2});
|
|
var values = [];
|
|
var keys = [];
|
|
function f(v, key, col2) {
|
|
assertEquals(col, col2);
|
|
assertEquals('string', typeof key);
|
|
assertEquals(THIS_OBJ, this);
|
|
values.push(v * v);
|
|
keys.push(key);
|
|
}
|
|
goog.structs.forEach(col, f, THIS_OBJ);
|
|
assertArrayEquals([0, 1, 4], values);
|
|
assertArrayEquals(['a', 'b', 'c'], keys);
|
|
}
|
|
|
|
function testForEachSet() {
|
|
var col = new goog.structs.Set([0, 1, 2]);
|
|
var values = [];
|
|
function f(v, key, col2) {
|
|
assertEquals(col, col2);
|
|
assertEquals('undefined', typeof key);
|
|
values.push(v * v);
|
|
}
|
|
goog.structs.forEach(col, f);
|
|
assertArrayEquals([0, 1, 4], values);
|
|
}
|
|
|
|
function testForEachSet2() {
|
|
var THIS_OBJ = {};
|
|
var col = new goog.structs.Set([0, 1, 2]);
|
|
var values = [];
|
|
function f(v, key, col2) {
|
|
assertEquals(col, col2);
|
|
assertEquals('undefined', typeof key);
|
|
assertEquals(THIS_OBJ, this);
|
|
values.push(v * v);
|
|
}
|
|
goog.structs.forEach(col, f, THIS_OBJ);
|
|
assertArrayEquals([0, 1, 4], values);
|
|
}
|
|
|
|
function testForEachNodeList() {
|
|
var values = [];
|
|
var col = getAll();
|
|
function f(v, i, col2) {
|
|
assertEquals(col, col2);
|
|
assertEquals('number', typeof i);
|
|
values.push(v.tagName);
|
|
}
|
|
goog.structs.forEach(col, f);
|
|
assertEquals('HRPPPPPPPPH1', values.join(''));
|
|
}
|
|
|
|
function testForEachNodeList2() {
|
|
var THIS_OBJ = {};
|
|
var values = [];
|
|
var col = getAll();
|
|
function f(v, i, col2) {
|
|
assertEquals(col, col2);
|
|
assertEquals('number', typeof i);
|
|
assertEquals(THIS_OBJ, this);
|
|
values.push(v.tagName);
|
|
}
|
|
goog.structs.forEach(col, f, THIS_OBJ);
|
|
assertEquals('HRPPPPPPPPH1', values.join(''));
|
|
}
|