RubyGems - closure - Versions diffs - 1.1.692 - Mend

closure 1.1.692

Files changed (1494) hide show

data/closure-library/closure/goog/structs/set_test.html ADDED Viewed

@@ -0,0 +1,551 @@
+<!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 2 empty sets 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);
+}
+/**
+ * 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>