cocorobolx/closure-library/closure/goog/labs/structs/multimap_test.js

// Copyright 2012 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.labs.structs.MultimapTest');
goog.setTestOnly('goog.labs.structs.MultimapTest');

goog.require('goog.labs.structs.Map');
goog.require('goog.labs.structs.Multimap');
goog.require('goog.testing.jsunit');

var map;


function setUp() {
  map = new goog.labs.structs.Multimap();
}


function testGetCountWithEmptyMultimap() {
  assertEquals(0, map.getCount());
  assertTrue(map.isEmpty());
}


function testClone() {
  map.add('k', 'v');
  map.addAllValues('k2', ['v', 'v1', 'v2']);

  var map2 = map.clone();

  assertSameElements(['v'], map.get('k'));
  assertSameElements(['v', 'v1', 'v2'], map.get('k2'));
}


function testAdd() {
  map.add('key', 'v');
  assertEquals(1, map.getCount());
  map.add('key', 'v2');
  assertEquals(2, map.getCount());
  map.add('key', 'v3');
  assertEquals(3, map.getCount());

  var values = map.get('key');
  assertEquals(3, values.length);
  assertContains('v', values);
  assertContains('v2', values);
  assertContains('v3', values);
}


function testAddValues() {
  map.addAllValues('key', ['v', 'v2', 'v3']);
  assertSameElements(['v', 'v2', 'v3'], map.get('key'));

  map.add('key2', 'a');
  map.addAllValues('key2', ['v', 'v2', 'v3']);
  assertSameElements(['a', 'v', 'v2', 'v3'], map.get('key2'));
}


function testAddAllWithMultimap() {
  map.add('k', 'v');
  map.addAllValues('k2', ['v', 'v1', 'v2']);

  var map2 = new goog.labs.structs.Multimap();
  map2.add('k2', 'v');
  map2.addAllValues('k3', ['a', 'a1', 'a2']);

  map.addAllFromMultimap(map2);
  assertSameElements(['v'], map.get('k'));
  assertSameElements(['v', 'v1', 'v2', 'v'], map.get('k2'));
  assertSameElements(['a', 'a1', 'a2'], map.get('k3'));
}


function testAddAllWithMap() {
  map.add('k', 'v');
  map.addAllValues('k2', ['v', 'v1', 'v2']);

  var map2 = new goog.labs.structs.Map();
  map2.set('k2', 'v');
  map2.set('k3', 'a');

  map.addAllFromMultimap(map2);
  assertSameElements(['v'], map.get('k'));
  assertSameElements(['v', 'v1', 'v2', 'v'], map.get('k2'));
  assertSameElements(['a'], map.get('k3'));
}


function testReplaceValues() {
  map.add('key', 'v');
  map.add('key', 'v2');

  map.replaceValues('key', [0, 1, 2]);
  assertSameElements([0, 1, 2], map.get('key'));
  assertEquals(3, map.getCount());

  map.replaceValues('key', ['v']);
  assertSameElements(['v'], map.get('key'));
  assertEquals(1, map.getCount());

  map.replaceValues('key', []);
  assertSameElements([], map.get('key'));
  assertEquals(0, map.getCount());
}


function testRemove() {
  map.add('key', 'v');
  map.add('key', 'v2');
  map.add('key', 'v3');

  assertTrue(map.remove('key', 'v'));
  var values = map.get('key');
  assertEquals(2, map.getCount());
  assertEquals(2, values.length);
  assertContains('v2', values);
  assertContains('v3', values);
  assertFalse(map.remove('key', 'v'));

  assertTrue(map.remove('key', 'v2'));
  values = map.get('key');
  assertEquals(1, map.getCount());
  assertEquals(1, values.length);
  assertContains('v3', values);
  assertFalse(map.remove('key', 'v2'));

  assertTrue(map.remove('key', 'v3'));
  map.remove('key', 'v3');
  assertTrue(map.isEmpty());
  assertEquals(0, map.get('key').length);
  assertFalse(map.remove('key', 'v2'));
}


function testRemoveWithNaN() {
  map.add('key', NaN);
  map.add('key', NaN);

  assertTrue(map.remove('key', NaN));
  var values = map.get('key');
  assertEquals(1, values.length);
  assertTrue(isNaN(values[0]));

  assertTrue(map.remove('key', NaN));
  assertEquals(0, map.get('key').length);
  assertFalse(map.remove('key', NaN));
}


function testRemoveWithNegativeZero() {
  map.add('key', 0);
  map.add('key', -0);

  assertTrue(map.remove('key', -0));
  var values = map.get('key');
  assertEquals(1, values.length);
  assertTrue(1 / values[0] === 1 / 0);
  assertFalse(map.remove('key', -0));

  map.add('key', -0);

  assertTrue(map.remove('key', 0));
  var values = map.get('key');
  assertEquals(1, values.length);
  assertTrue(1 / values[0] === 1 / -0);
  assertFalse(map.remove('key', 0));

  assertTrue(map.remove('key', -0));
  assertEquals(0, map.get('key').length);
}


function testRemoveAll() {
  map.add('key', 'v');
  map.add('key', 'v2');
  map.add('key', 'v3');
  map.add('key', 'v4');
  map.add('key2', 'v');

  assertTrue(map.removeAll('key'));
  assertSameElements([], map.get('key'));
  assertSameElements(['v'], map.get('key2'));
  assertFalse(map.removeAll('key'));
  assertEquals(1, map.getCount());

  assertTrue(map.removeAll('key2'));
  assertSameElements([], map.get('key2'));
  assertFalse(map.removeAll('key2'));
  assertTrue(map.isEmpty());
}


function testAddWithDuplicateValue() {
  map.add('key', 'v');
  map.add('key', 'v');
  map.add('key', 'v');
  assertArrayEquals(['v', 'v', 'v'], map.get('key'));
}


function testContainsEntry() {
  assertFalse(map.containsEntry('k', 'v'));
  assertFalse(map.containsEntry('k', 'v2'));
  assertFalse(map.containsEntry('k2', 'v'));

  map.add('k', 'v');
  assertTrue(map.containsEntry('k', 'v'));
  assertFalse(map.containsEntry('k', 'v2'));
  assertFalse(map.containsEntry('k2', 'v'));

  map.add('k', 'v2');
  assertTrue(map.containsEntry('k', 'v'));
  assertTrue(map.containsEntry('k', 'v2'));
  assertFalse(map.containsEntry('k2', 'v'));

  map.add('k2', 'v');
  assertTrue(map.containsEntry('k', 'v'));
  assertTrue(map.containsEntry('k', 'v2'));
  assertTrue(map.containsEntry('k2', 'v'));
}


function testContainsKey() {
  assertFalse(map.containsKey('k'));
  assertFalse(map.containsKey('k2'));

  map.add('k', 'v');
  assertTrue(map.containsKey('k'));
  map.add('k2', 'v');
  assertTrue(map.containsKey('k2'));

  map.remove('k', 'v');
  assertFalse(map.containsKey('k'));
  map.remove('k2', 'v');
  assertFalse(map.containsKey('k2'));
}


function testContainsValue() {
  assertFalse(map.containsValue('v'));
  assertFalse(map.containsValue('v2'));

  map.add('key', 'v');
  assertTrue(map.containsValue('v'));
  map.add('key', 'v2');
  assertTrue(map.containsValue('v2'));
}


function testGetEntries() {
  map.add('key', 'v');
  map.add('key', 'v2');
  map.add('key2', 'v3');

  var entries = map.getEntries();
  assertEquals(3, entries.length);
  assertContainsEntry(['key', 'v'], entries);
  assertContainsEntry(['key', 'v2'], entries);
  assertContainsEntry(['key2', 'v3'], entries);
}


function testGetKeys() {
  map.add('key', 'v');
  map.add('key', 'v2');
  map.add('key2', 'v3');
  map.add('key3', 'v4');
  map.removeAll('key3');

  assertSameElements(['key', 'key2'], map.getKeys());
}


function testGetKeys() {
  map.add('key', 'v');
  map.add('key', 'v2');
  map.add('key2', 'v2');
  map.add('key3', 'v4');
  map.removeAll('key3');

  assertSameElements(['v', 'v2', 'v2'], map.getValues());
}


function testGetReturnsDefensiveCopyOfUnderlyingData() {
  map.add('key', 'v');
  map.add('key', 'v2');
  map.add('key', 'v3');

  var values = map.get('key');
  values.push('v4');
  assertFalse(map.containsEntry('key', 'v4'));
}


function testClear() {
  map.add('key', 'v');
  map.add('key', 'v2');
  map.add('key2', 'v3');

  map.clear();
  assertTrue(map.isEmpty());
  assertSameElements([], map.getEntries());
}


function assertContainsEntry(entry, entryList) {
  for (var i = 0; i < entryList.length; ++i) {
    if (entry[0] == entryList[i][0] && entry[1] === entryList[i][1]) {
      return;
    }
  }
  fail('Did not find entry: ' + entry + ' in: ' + entryList);
}