Adding mapbox-gl branch
This commit is contained in:
Andreas Hocevar
@@ -0,0 +1,579 @@
|
||||
// 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.structs.SetTest');
|
||||
goog.setTestOnly('goog.structs.SetTest');
|
||||
|
||||
goog.require('goog.iter');
|
||||
goog.require('goog.structs');
|
||||
goog.require('goog.structs.Set');
|
||||
goog.require('goog.testing.jsunit');
|
||||
|
||||
var Set = goog.structs.Set;
|
||||
|
||||
function stringifySet(s) {
|
||||
return goog.structs.getValues(s).join('');
|
||||
}
|
||||
|
||||
function testGetCount() {
|
||||
var s = new Set;
|
||||
var a = new String('a'); s.add(a);
|
||||
var b = new String('b'); s.add(b);
|
||||
var c = new String('c'); s.add(c);
|
||||
assertEquals('count, should be 3', s.getCount(), 3);
|
||||
var d = new String('d'); s.add(d);
|
||||
assertEquals('count, should be 4', s.getCount(), 4);
|
||||
s.remove(d);
|
||||
assertEquals('count, should be 3', s.getCount(), 3);
|
||||
|
||||
s = new Set;
|
||||
s.add('a');
|
||||
s.add('b');
|
||||
s.add('c');
|
||||
assertEquals('count, should be 3', s.getCount(), 3);
|
||||
s.add('d');
|
||||
assertEquals('count, should be 4', s.getCount(), 4);
|
||||
s.remove('d');
|
||||
assertEquals('count, should be 3', s.getCount(), 3);
|
||||
}
|
||||
|
||||
function testGetValues() {
|
||||
var s = new Set;
|
||||
var a = new String('a'); s.add(a);
|
||||
var b = new String('b'); s.add(b);
|
||||
var c = new String('c'); s.add(c);
|
||||
var d = new String('d'); s.add(d);
|
||||
assertEquals(s.getValues().join(''), 'abcd');
|
||||
|
||||
var s = new Set;
|
||||
s.add('a');
|
||||
s.add('b');
|
||||
s.add('c');
|
||||
s.add('d');
|
||||
assertEquals(s.getValues().join(''), 'abcd');
|
||||
}
|
||||
|
||||
function testContains() {
|
||||
var s = new Set;
|
||||
var a = new String('a'); s.add(a);
|
||||
var b = new String('b'); s.add(b);
|
||||
var c = new String('c'); s.add(c);
|
||||
var d = new String('d'); s.add(d);
|
||||
var e = new String('e');
|
||||
|
||||
assertTrue("contains, Should contain 'a'", s.contains(a));
|
||||
assertFalse("contains, Should not contain 'e'", s.contains(e));
|
||||
|
||||
s = new Set;
|
||||
s.add('a');
|
||||
s.add('b');
|
||||
s.add('c');
|
||||
s.add('d');
|
||||
|
||||
assertTrue("contains, Should contain 'a'", s.contains('a'));
|
||||
assertFalse("contains, Should not contain 'e'", s.contains('e'));
|
||||
}
|
||||
|
||||
function testContainsFunctionValue() {
|
||||
var s = new Set;
|
||||
|
||||
var fn1 = function() {};
|
||||
|
||||
assertFalse(s.contains(fn1));
|
||||
s.add(fn1);
|
||||
assertTrue(s.contains(fn1));
|
||||
|
||||
var fn2 = function() {};
|
||||
|
||||
assertFalse(s.contains(fn2));
|
||||
s.add(fn2);
|
||||
assertTrue(s.contains(fn2));
|
||||
|
||||
assertEquals(s.getCount(), 2);
|
||||
}
|
||||
|
||||
function testContainsAll() {
|
||||
var set = new Set([1, 2, 3]);
|
||||
|
||||
assertTrue('{1, 2, 3} contains []', set.containsAll([]));
|
||||
assertTrue('{1, 2, 3} contains [1]', set.containsAll([1]));
|
||||
assertTrue('{1, 2, 3} contains [1, 1]', set.containsAll([1, 1]));
|
||||
assertTrue('{1, 2, 3} contains [3, 2, 1]', set.containsAll([3, 2, 1]));
|
||||
assertFalse("{1, 2, 3} doesn't contain [4]", set.containsAll([4]));
|
||||
assertFalse("{1, 2, 3} doesn't contain [1, 4]", set.containsAll([1, 4]));
|
||||
|
||||
assertTrue('{1, 2, 3} contains {a: 1}', set.containsAll({a: 1}));
|
||||
assertFalse("{1, 2, 3} doesn't contain {a: 4}", set.containsAll({a: 4}));
|
||||
|
||||
assertTrue('{1, 2, 3} contains {1}', set.containsAll(new Set([1])));
|
||||
assertFalse("{1, 2, 3} doesn't contain {4}", set.containsAll(new Set([4])));
|
||||
}
|
||||
|
||||
function testIntersection() {
|
||||
var emptySet = new Set;
|
||||
|
||||
assertTrue('intersection of empty set and [] should be empty',
|
||||
emptySet.intersection([]).isEmpty());
|
||||
assertIntersection('intersection of 2 empty sets should be empty',
|
||||
emptySet, new Set(), new Set());
|
||||
|
||||
var abcdSet = new Set();
|
||||
abcdSet.add('a');
|
||||
abcdSet.add('b');
|
||||
abcdSet.add('c');
|
||||
abcdSet.add('d');
|
||||
|
||||
assertTrue('intersection of populated set and [] should be empty',
|
||||
abcdSet.intersection([]).isEmpty());
|
||||
assertIntersection(
|
||||
'intersection of populated set and empty set should be empty',
|
||||
abcdSet, new Set(), new Set());
|
||||
|
||||
var bcSet = new Set(['b', 'c']);
|
||||
assertIntersection('intersection of [a,b,c,d] and [b,c]',
|
||||
abcdSet, bcSet, bcSet);
|
||||
|
||||
var bceSet = new Set(['b', 'c', 'e']);
|
||||
assertIntersection('intersection of [a,b,c,d] and [b,c,e]',
|
||||
abcdSet, bceSet, bcSet);
|
||||
}
|
||||
|
||||
function testDifference() {
|
||||
var emptySet = new Set;
|
||||
|
||||
assertTrue('difference of empty set and [] should be empty',
|
||||
emptySet.difference([]).isEmpty());
|
||||
assertTrue('difference of 2 empty sets should be empty',
|
||||
emptySet.difference(new Set()).isEmpty());
|
||||
|
||||
var abcdSet = new Set(['a', 'b', 'c', 'd']);
|
||||
|
||||
assertTrue('difference of populated set and [] should be the populated set',
|
||||
abcdSet.difference([]).equals(abcdSet));
|
||||
assertTrue(
|
||||
'difference of populated set and empty set should be the populated set',
|
||||
abcdSet.difference(new Set()).equals(abcdSet));
|
||||
assertTrue('difference of two identical sets should be the empty set',
|
||||
abcdSet.difference(abcdSet).equals(new Set()));
|
||||
|
||||
var bcSet = new Set(['b', 'c']);
|
||||
assertTrue('difference of [a,b,c,d] and [b,c] shoule be [a,d]',
|
||||
abcdSet.difference(bcSet).equals(new Set(['a', 'd'])));
|
||||
assertTrue('difference of [b,c] and [a,b,c,d] should be the empty set',
|
||||
bcSet.difference(abcdSet).equals(new Set()));
|
||||
|
||||
var xyzSet = new Set(['x', 'y', 'z']);
|
||||
assertTrue('difference of [a,b,c,d] and [x,y,z] should be the [a,b,c,d]',
|
||||
abcdSet.difference(xyzSet).equals(abcdSet));
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Helper function to assert intersection is commutative.
|
||||
*/
|
||||
function assertIntersection(msg, set1, set2, expectedIntersection) {
|
||||
assertTrue(msg + ': set1->set2',
|
||||
set1.intersection(set2).equals(expectedIntersection));
|
||||
assertTrue(msg + ': set2->set1',
|
||||
set2.intersection(set1).equals(expectedIntersection));
|
||||
}
|
||||
|
||||
function testRemoveAll() {
|
||||
assertRemoveAll('removeAll of empty set from empty set', [], [], []);
|
||||
assertRemoveAll('removeAll of empty set from populated set',
|
||||
['a', 'b', 'c', 'd'], [], ['a', 'b', 'c', 'd']);
|
||||
assertRemoveAll('removeAll of [a,d] from [a,b,c,d]',
|
||||
['a', 'b', 'c', 'd'], ['a', 'd'], ['b', 'c']);
|
||||
assertRemoveAll('removeAll of [b,c] from [a,b,c,d]',
|
||||
['a', 'b', 'c', 'd'], ['b', 'c'], ['a', 'd']);
|
||||
assertRemoveAll('removeAll of [b,c,e] from [a,b,c,d]',
|
||||
['a', 'b', 'c', 'd'], ['b', 'c', 'e'], ['a', 'd']);
|
||||
assertRemoveAll('removeAll of [a,b,c,d] from [a,d]',
|
||||
['a', 'd'], ['a', 'b', 'c', 'd'], []);
|
||||
assertRemoveAll('removeAll of [a,b,c,d] from [b,c]',
|
||||
['b', 'c'], ['a', 'b', 'c', 'd'], []);
|
||||
assertRemoveAll('removeAll of [a,b,c,d] from [b,c,e]',
|
||||
['b', 'c', 'e'], ['a', 'b', 'c', 'd'], ['e']);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Helper function to test removeAll.
|
||||
*/
|
||||
function assertRemoveAll(msg, elements1, elements2, expectedResult) {
|
||||
var set1 = new Set(elements1);
|
||||
var set2 = new Set(elements2);
|
||||
set1.removeAll(set2);
|
||||
|
||||
assertTrue(msg + ': set1 count increased after removeAll',
|
||||
elements1.length >= set1.getCount());
|
||||
assertEquals(msg + ': set2 count changed after removeAll',
|
||||
elements2.length, set2.getCount());
|
||||
assertTrue(msg + ': wrong set1 after removeAll', set1.equals(expectedResult));
|
||||
assertIntersection(msg + ': non-empty intersection after removeAll',
|
||||
set1, set2, []);
|
||||
}
|
||||
|
||||
function testAdd() {
|
||||
var s = new Set;
|
||||
var a = new String('a');
|
||||
var b = new String('b');
|
||||
s.add(a);
|
||||
assertTrue(s.contains(a));
|
||||
s.add(b);
|
||||
assertTrue(s.contains(b));
|
||||
|
||||
s = new Set;
|
||||
s.add('a');
|
||||
assertTrue(s.contains('a'));
|
||||
s.add('b');
|
||||
assertTrue(s.contains('b'));
|
||||
s.add(null);
|
||||
assertTrue('contains null', s.contains(null));
|
||||
assertFalse('does not contain "null"', s.contains('null'));
|
||||
}
|
||||
|
||||
|
||||
function testClear() {
|
||||
var s = new Set;
|
||||
var a = new String('a'); s.add(a);
|
||||
var b = new String('b'); s.add(b);
|
||||
var c = new String('c'); s.add(c);
|
||||
var d = new String('d'); s.add(d);
|
||||
s.clear();
|
||||
assertTrue('cleared so it should be empty', s.isEmpty());
|
||||
assertTrue("cleared so it should not contain 'a' key", !s.contains(a));
|
||||
|
||||
s = new Set;
|
||||
s.add('a');
|
||||
s.add('b');
|
||||
s.add('c');
|
||||
s.add('d');
|
||||
s.clear();
|
||||
assertTrue('cleared so it should be empty', s.isEmpty());
|
||||
assertTrue("cleared so it should not contain 'a' key", !s.contains('a'));
|
||||
}
|
||||
|
||||
|
||||
function testAddAll() {
|
||||
var s = new Set;
|
||||
var a = new String('a');
|
||||
var b = new String('b');
|
||||
var c = new String('c');
|
||||
var d = new String('d');
|
||||
s.addAll([a, b, c, d]);
|
||||
assertTrue('addAll so it should not be empty', !s.isEmpty());
|
||||
assertTrue("addAll so it should contain 'c' key", s.contains(c));
|
||||
|
||||
var s2 = new Set;
|
||||
s2.addAll(s);
|
||||
assertTrue('addAll so it should not be empty', !s2.isEmpty());
|
||||
assertTrue("addAll so it should contain 'c' key", s2.contains(c));
|
||||
|
||||
|
||||
s = new Set;
|
||||
s.addAll(['a', 'b', 'c', 'd']);
|
||||
assertTrue('addAll so it should not be empty', !s.isEmpty());
|
||||
assertTrue("addAll so it should contain 'c' key", s.contains('c'));
|
||||
|
||||
s2 = new Set;
|
||||
s2.addAll(s);
|
||||
assertTrue('addAll so it should not be empty', !s2.isEmpty());
|
||||
assertTrue("addAll so it should contain 'c' key", s2.contains('c'));
|
||||
}
|
||||
|
||||
|
||||
function testConstructor() {
|
||||
var s = new Set;
|
||||
var a = new String('a'); s.add(a);
|
||||
var b = new String('b'); s.add(b);
|
||||
var c = new String('c'); s.add(c);
|
||||
var d = new String('d'); s.add(d);
|
||||
var s2 = new Set(s);
|
||||
assertFalse('constr with Set so it should not be empty', s2.isEmpty());
|
||||
assertTrue('constr with Set so it should contain c', s2.contains(c));
|
||||
|
||||
s = new Set;
|
||||
s.add('a');
|
||||
s.add('b');
|
||||
s.add('c');
|
||||
s.add('d');
|
||||
s2 = new Set(s);
|
||||
assertFalse('constr with Set so it should not be empty', s2.isEmpty());
|
||||
assertTrue('constr with Set so it should contain c', s2.contains('c'));
|
||||
}
|
||||
|
||||
|
||||
function testClone() {
|
||||
var s = new Set;
|
||||
var a = new String('a'); s.add(a);
|
||||
var b = new String('b'); s.add(b);
|
||||
var c = new String('c'); s.add(c);
|
||||
var d = new String('d'); s.add(d);
|
||||
|
||||
var s2 = s.clone();
|
||||
assertFalse('clone so it should not be empty', s2.isEmpty());
|
||||
assertTrue("clone so it should contain 'c' key", s2.contains(c));
|
||||
|
||||
var s = new Set;
|
||||
s.add('a');
|
||||
s.add('b');
|
||||
s.add('c');
|
||||
s.add('d');
|
||||
|
||||
s2 = s.clone();
|
||||
assertFalse('clone so it should not be empty', s2.isEmpty());
|
||||
assertTrue("clone so it should contain 'c' key", s2.contains('c'));
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Helper method for testEquals().
|
||||
* @param {Object} a First element to use in the tests.
|
||||
* @param {Object} b Second element to use in the tests.
|
||||
* @param {Object} c Third element to use in the tests.
|
||||
* @param {Object} d Fourth element to use in the tests.
|
||||
*/
|
||||
function helperForTestEquals(a, b, c, d) {
|
||||
var s = new Set([a, b, c]);
|
||||
|
||||
assertTrue('set == itself', s.equals(s));
|
||||
assertTrue('set == same set', s.equals(new Set([a, b, c])));
|
||||
assertTrue('set == its clone', s.equals(s.clone()));
|
||||
assertTrue('set == array of same elements', s.equals([a, b, c]));
|
||||
assertTrue('set == array of same elements in different order',
|
||||
s.equals([c, b, a]));
|
||||
|
||||
assertFalse('set != empty set', s.equals(new Set));
|
||||
assertFalse('set != its subset', s.equals(new Set([a, c])));
|
||||
assertFalse('set != its superset',
|
||||
s.equals(new Set([a, b, c, d])));
|
||||
assertFalse('set != different set',
|
||||
s.equals(new Set([b, c, d])));
|
||||
assertFalse('set != its subset as array', s.equals([a, c]));
|
||||
assertFalse('set != its superset as array', s.equals([a, b, c, d]));
|
||||
assertFalse('set != different set as array', s.equals([b, c, d]));
|
||||
assertFalse('set != [a, b, c, c]', s.equals([a, b, c, c]));
|
||||
assertFalse('set != [a, b, b]', s.equals([a, b, b]));
|
||||
assertFalse('set != [a, a]', s.equals([a, a]));
|
||||
}
|
||||
|
||||
|
||||
function testEquals() {
|
||||
helperForTestEquals(1, 2, 3, 4);
|
||||
helperForTestEquals('a', 'b', 'c', 'd');
|
||||
helperForTestEquals(new String('a'), new String('b'),
|
||||
new String('c'), new String('d'));
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
* Helper method for testIsSubsetOf().
|
||||
* @param {Object} a First element to use in the tests.
|
||||
* @param {Object} b Second element to use in the tests.
|
||||
* @param {Object} c Third element to use in the tests.
|
||||
* @param {Object} d Fourth element to use in the tests.
|
||||
*/
|
||||
function helperForTestIsSubsetOf(a, b, c, d) {
|
||||
var s = new Set([a, b, c]);
|
||||
|
||||
assertTrue('set <= itself', s.isSubsetOf(s));
|
||||
assertTrue('set <= same set',
|
||||
s.isSubsetOf(new Set([a, b, c])));
|
||||
assertTrue('set <= its clone', s.isSubsetOf(s.clone()));
|
||||
assertTrue('set <= array of same elements', s.isSubsetOf([a, b, c]));
|
||||
assertTrue('set <= array of same elements in different order',
|
||||
s.equals([c, b, a]));
|
||||
|
||||
assertTrue('set <= Set([a, b, c, d])',
|
||||
s.isSubsetOf(new Set([a, b, c, d])));
|
||||
assertTrue('set <= [a, b, c, d]', s.isSubsetOf([a, b, c, d]));
|
||||
assertTrue('set <= [a, b, c, c]', s.isSubsetOf([a, b, c, c]));
|
||||
|
||||
assertFalse('set !<= Set([a, b])',
|
||||
s.isSubsetOf(new Set([a, b])));
|
||||
assertFalse('set !<= [a, b]', s.isSubsetOf([a, b]));
|
||||
assertFalse('set !<= Set([c, d])',
|
||||
s.isSubsetOf(new Set([c, d])));
|
||||
assertFalse('set !<= [c, d]', s.isSubsetOf([c, d]));
|
||||
assertFalse('set !<= Set([a, c, d])',
|
||||
s.isSubsetOf(new Set([a, c, d])));
|
||||
assertFalse('set !<= [a, c, d]', s.isSubsetOf([a, c, d]));
|
||||
assertFalse('set !<= [a, a, b]', s.isSubsetOf([a, a, b]));
|
||||
assertFalse('set !<= [a, a, b, b]', s.isSubsetOf([a, a, b, b]));
|
||||
}
|
||||
|
||||
|
||||
function testIsSubsetOf() {
|
||||
helperForTestIsSubsetOf(1, 2, 3, 4);
|
||||
helperForTestIsSubsetOf('a', 'b', 'c', 'd');
|
||||
helperForTestIsSubsetOf(new String('a'), new String('b'),
|
||||
new String('c'), new String('d'));
|
||||
}
|
||||
|
||||
|
||||
function testForEach() {
|
||||
var s = new Set;
|
||||
var a = new String('a'); s.add(a);
|
||||
var b = new String('b'); s.add(b);
|
||||
var c = new String('c'); s.add(c);
|
||||
var d = new String('d'); s.add(d);
|
||||
var str = '';
|
||||
goog.structs.forEach(s, function(val, key, set) {
|
||||
assertUndefined(key);
|
||||
assertEquals(s, set);
|
||||
str += val;
|
||||
});
|
||||
assertEquals(str, 'abcd');
|
||||
|
||||
s = new Set;
|
||||
s.add('a');
|
||||
s.add('b');
|
||||
s.add('c');
|
||||
s.add('d');
|
||||
str = '';
|
||||
goog.structs.forEach(s, function(val, key, set) {
|
||||
assertUndefined(key);
|
||||
assertEquals(s, set);
|
||||
str += val;
|
||||
});
|
||||
assertEquals(str, 'abcd');
|
||||
}
|
||||
|
||||
|
||||
function testFilter() {
|
||||
var s = new Set;
|
||||
var a = new Number(0); s.add(a);
|
||||
var b = new Number(1); s.add(b);
|
||||
var c = new Number(2); s.add(c);
|
||||
var d = new Number(3); s.add(d);
|
||||
|
||||
var s2 = goog.structs.filter(s, function(val, key, set) {
|
||||
assertUndefined(key);
|
||||
assertEquals(s, set);
|
||||
return val > 1;
|
||||
});
|
||||
assertEquals(stringifySet(s2), '23');
|
||||
|
||||
s = new Set;
|
||||
s.add(0);
|
||||
s.add(1);
|
||||
s.add(2);
|
||||
s.add(3);
|
||||
|
||||
s2 = goog.structs.filter(s, function(val, key, set) {
|
||||
assertUndefined(key);
|
||||
assertEquals(s, set);
|
||||
return val > 1;
|
||||
});
|
||||
assertEquals(stringifySet(s2), '23');
|
||||
}
|
||||
|
||||
|
||||
function testSome() {
|
||||
var s = new Set;
|
||||
var a = new Number(0); s.add(a);
|
||||
var b = new Number(1); s.add(b);
|
||||
var c = new Number(2); s.add(c);
|
||||
var d = new Number(3); s.add(d);
|
||||
|
||||
var b = goog.structs.some(s, function(val, key, s2) {
|
||||
assertUndefined(key);
|
||||
assertEquals(s, s2);
|
||||
return val > 1;
|
||||
});
|
||||
assertTrue(b);
|
||||
var b = goog.structs.some(s, function(val, key, s2) {
|
||||
assertUndefined(key);
|
||||
assertEquals(s, s2);
|
||||
return val > 100;
|
||||
});
|
||||
assertFalse(b);
|
||||
|
||||
s = new Set;
|
||||
s.add(0);
|
||||
s.add(1);
|
||||
s.add(2);
|
||||
s.add(3);
|
||||
|
||||
b = goog.structs.some(s, function(val, key, s2) {
|
||||
assertUndefined(key);
|
||||
assertEquals(s, s2);
|
||||
return val > 1;
|
||||
});
|
||||
assertTrue(b);
|
||||
b = goog.structs.some(s, function(val, key, s2) {
|
||||
assertUndefined(key);
|
||||
assertEquals(s, s2);
|
||||
return val > 100;
|
||||
});
|
||||
assertFalse(b);
|
||||
}
|
||||
|
||||
|
||||
function testEvery() {
|
||||
var s = new Set;
|
||||
var a = new Number(0); s.add(a);
|
||||
var b = new Number(1); s.add(b);
|
||||
var c = new Number(2); s.add(c);
|
||||
var d = new Number(3); s.add(d);
|
||||
|
||||
var b = goog.structs.every(s, function(val, key, s2) {
|
||||
assertUndefined(key);
|
||||
assertEquals(s, s2);
|
||||
return val >= 0;
|
||||
});
|
||||
assertTrue(b);
|
||||
b = goog.structs.every(s, function(val, key, s2) {
|
||||
assertUndefined(key);
|
||||
assertEquals(s, s2);
|
||||
return val > 1;
|
||||
});
|
||||
assertFalse(b);
|
||||
|
||||
s = new Set;
|
||||
s.add(0);
|
||||
s.add(1);
|
||||
s.add(2);
|
||||
s.add(3);
|
||||
|
||||
b = goog.structs.every(s, function(val, key, s2) {
|
||||
assertUndefined(key);
|
||||
assertEquals(s, s2);
|
||||
return val >= 0;
|
||||
});
|
||||
assertTrue(b);
|
||||
b = goog.structs.every(s, function(val, key, s2) {
|
||||
assertUndefined(key);
|
||||
assertEquals(s, s2);
|
||||
return val > 1;
|
||||
});
|
||||
assertFalse(b);
|
||||
}
|
||||
|
||||
function testIterator() {
|
||||
var s = new Set;
|
||||
s.add(0);
|
||||
s.add(1);
|
||||
s.add(2);
|
||||
s.add(3);
|
||||
s.add(4);
|
||||
|
||||
assertEquals('01234', goog.iter.join(s, ''));
|
||||
|
||||
s.remove(1);
|
||||
s.remove(3);
|
||||
|
||||
assertEquals('024', goog.iter.join(s, ''));
|
||||
}
|
||||
Reference in New Issue
Block a user