sku-pg
Version:
Skulpt is a Javascript implementation of Python 2.x. Python that runs in your browser!
582 lines (489 loc) • 16.6 kB
HTML
<!DOCTYPE html>
<html>
<!--
Copyright 2006 The Closure Library Authors. All Rights Reserved.
Use of this source code is governed by the Apache License, Version 2.0.
See the COPYING file for details.
-->
<head>
<meta http-equiv="X-UA-Compatible" content="IE=edge">
<title>Closure Unit Tests - goog.structs.Set</title>
<script src="../base.js"></script>
<script>
goog.require('goog.iter');
goog.require('goog.structs');
goog.require('goog.structs.Set');
goog.require('goog.testing.jsunit');
</script>
</head>
<body>
<script>
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, ''));
}
</script>
</body>
</html>