@Override public int adjustOrPutValue(T key, int newValue, int incrValue) { int i = indexOfInsertion(key); if (i < 0) { //already contained i = -i - 1; this.values[i] += incrValue; return this.values[i]; } else { put(key, newValue); return newValue; } }
@Test(expected=UnsupportedOperationException.class) public void testPairsSortedByKeyNotComparable() { OpenObjectIntHashMap<NotComparableKey> map = new OpenObjectIntHashMap<NotComparableKey>(); map.put(ncKeys[0], (int) 11); map.put(ncKeys[1], (int) 12); map.put(ncKeys[2], (int) 13); map.put(ncKeys[3], (int) 14); IntArrayList values = new IntArrayList(); List<NotComparableKey> keys = new ArrayList<NotComparableKey>(); map.pairsSortedByKey(keys, values); }
@Test public void testKeysSortedByValue() { OpenObjectIntHashMap<String> map = new OpenObjectIntHashMap<String>(); map.put("Eleven", (int) 11); map.put("Twelve", (int) 12); map.put("Thirteen", (int) 13); map.put("Fourteen", (int) 14); map.removeKey("Thirteen"); List<String> keys = new ArrayList<String>(); map.keysSortedByValue(keys); String[] keysArray = keys.toArray(new String[keys.size()]); assertArrayEquals(new String[] {"Eleven", "Twelve", "Fourteen"}, keysArray); }
/** */ @Test public void testClearTable() throws Exception { OpenObjectIntHashMap<Integer> m = new OpenObjectIntHashMap<>(); m.clear(); // rehash from the default capacity to the next prime after 1 (3). m.put(1, 2); m.clear(); // Should clear internal references. Field tableField = m.getClass().getDeclaredField("table"); tableField.setAccessible(true); Object[] table = (Object[]) tableField.get(m); assertEquals(Sets.newHashSet(Arrays.asList(new Object[] {null})), Sets.newHashSet(Arrays.asList(table))); }
@Test public void testAdjustOrPutValue() { OpenObjectIntHashMap<String> map = new OpenObjectIntHashMap<String>(); map.put("Eleven", (int) 11); map.put("Twelve", (int) 12); map.put("Thirteen", (int) 13); map.put("Fourteen", (int) 14); map.adjustOrPutValue("Eleven", (int)1, (int)3); assertEquals(14, map.get("Eleven") ); map.adjustOrPutValue("Fifteen", (int)1, (int)3); assertEquals(1, map.get("Fifteen") ); }
@Test public void testKeys() { OpenObjectIntHashMap<String> map = new OpenObjectIntHashMap<String>(); map.put("Eleven", (int) 11); map.put("Twelve", (int) 12); List<String> keys = new ArrayList<String>(); map.keys(keys); Collections.sort(keys); assertSame("Twelve", keys.get(1)); assertSame("Eleven", keys.get(0)); List<String> k2 = map.keys(); Collections.sort(k2); assertEquals(keys, k2); }
@Test public void testForEachKey() { final List<String> keys = new ArrayList<String>(); OpenObjectIntHashMap<String> map = new OpenObjectIntHashMap<String>(); map.put("Eleven", (int) 11); map.put("Twelve", (int) 12); map.put("Thirteen", (int) 13); map.put("Fourteen", (int) 14); map.removeKey("Thirteen"); map.forEachKey(new ObjectProcedure<String>() { @Override public boolean apply(String element) { keys.add(element); return true; } }); assertEquals(3, keys.size()); Collections.sort(keys); assertSame("Fourteen", keys.get(1)); assertSame("Twelve", keys.get(2)); assertSame("Eleven", keys.get(0)); }
final List<Pair> pairs = new ArrayList<Pair>(); OpenObjectIntHashMap<String> map = new OpenObjectIntHashMap<String>(); map.put("Eleven", (int) 11); map.put("Twelve", (int) 12); map.put("Thirteen", (int) 13); map.put("Fourteen", (int) 14); map.removeKey("Thirteen"); map.forEachPair(new ObjectIntProcedure<String>() {
@Test public void testPairsSortedByValue() { OpenObjectIntHashMap<String> map = new OpenObjectIntHashMap<String>(); map.put("Eleven", (int) 11); map.put("Twelve", (int) 12); map.put("Thirteen", (int) 13); map.put("Fourteen", (int) 14); List<String> keys = new ArrayList<String>(); IntArrayList values = new IntArrayList(); map.pairsSortedByValue(keys, values); assertEquals((int) 11, values.get(0) ); assertEquals("Eleven", keys.get(0)); assertEquals((int) 12, values.get(1) ); assertEquals("Twelve", keys.get(1)); assertEquals((int) 13, values.get(2) ); assertEquals("Thirteen", keys.get(2)); assertEquals((int) 14, values.get(3) ); assertEquals("Fourteen", keys.get(3)); }
int newCapacity = chooseGrowCapacity(this.distinct + 1, this.minLoadFactor, this.maxLoadFactor); rehash(newCapacity); return put(key, value);
@Test public void testPairsMatching() { List<String> keyList = new ArrayList<String>(); IntArrayList valueList = new IntArrayList(); OpenObjectIntHashMap<String> map = new OpenObjectIntHashMap<String>(); map.put("Eleven", (int) 11); map.put("Twelve", (int) 12); map.put("Thirteen", (int) 13); map.put("Fourteen", (int) 14); map.removeKey("Thirteen"); map.pairsMatching(new ObjectIntProcedure<String>() { @Override public boolean apply(String first, int second) { return (second % 2) == 0; }}, keyList, valueList); Collections.sort(keyList); valueList.sort(); assertEquals(2, keyList.size()); assertEquals(2, valueList.size()); assertSame("Fourteen", keyList.get(0)); assertSame("Twelve", keyList.get(1)); assertEquals((int)14, valueList.get(1) ); assertEquals((int)12, valueList.get(0) ); }
@Test public void testValues() { OpenObjectIntHashMap<String> map = new OpenObjectIntHashMap<String>(); map.put("Eleven", (int) 11); map.put("Twelve", (int) 12); map.put("Thirteen", (int) 13); map.put("Fourteen", (int) 14); map.removeKey("Thirteen"); IntArrayList values = new IntArrayList(100); map.values(values); assertEquals(3, values.size()); values.sort(); assertEquals(11, values.get(0) ); assertEquals(12, values.get(1) ); assertEquals(14, values.get(2) ); }
@Test public void testPairsSortedByKey() { OpenObjectIntHashMap<String> map = new OpenObjectIntHashMap<String>(); map.put("Eleven", (int) 11); map.put("Twelve", (int) 12); map.put("Thirteen", (int) 13); map.put("Fourteen", (int) 14); IntArrayList values = new IntArrayList(); List<String> keys = new ArrayList<String>(); map.pairsSortedByKey(keys, values); assertEquals(4, keys.size()); assertEquals(4, values.size()); assertEquals((int) 11, values.get(0) ); assertSame("Eleven", keys.get(0)); assertEquals((int) 14, values.get(1) ); assertSame("Fourteen", keys.get(1)); assertEquals((int) 13, values.get(2) ); assertSame("Thirteen", keys.get(2)); assertEquals((int) 12, values.get(3) ); assertSame("Twelve", keys.get(3)); }
@Test public void testEquals() { // since there are no other subclasses of // Abstractxxx available, we have to just test the // obvious. OpenObjectIntHashMap<String> map = new OpenObjectIntHashMap<String>(); map.put("Eleven", (int) 11); map.put("Twelve", (int) 12); map.put("Thirteen", (int) 13); map.put("Fourteen", (int) 14); map.removeKey("Thirteen"); OpenObjectIntHashMap<String> map2 = (OpenObjectIntHashMap<String>) map.copy(); assertEquals(map, map2); assertTrue(map2.equals(map)); assertFalse("Hello Sailor".equals(map)); assertFalse(map.equals("hello sailor")); map2.removeKey("Eleven"); assertFalse(map.equals(map2)); assertFalse(map2.equals(map)); }
@Test public void testContainValue() { OpenObjectIntHashMap<String> map = new OpenObjectIntHashMap<String>(); map.put("Eleven", (int)11); assertTrue(map.containsValue((int)11)); assertFalse(map.containsValue((int)12)); }
@Test @SuppressWarnings("unchecked") public void testClone() { OpenObjectIntHashMap<String> map = new OpenObjectIntHashMap<String>(); map.put("Eleven", (int)11); OpenObjectIntHashMap<String> map2 = (OpenObjectIntHashMap<String>) map.clone(); map.clear(); assertEquals(1, map2.size()); }
@Test public void testCopy() { OpenObjectIntHashMap<String> map = new OpenObjectIntHashMap<String>(); map.put("Eleven", (int)11); OpenObjectIntHashMap<String> map2 = (OpenObjectIntHashMap<String>) map.copy(); map.clear(); assertEquals(1, map2.size()); }
@Test public void testClear() { OpenObjectIntHashMap<String> map = new OpenObjectIntHashMap<String>(); map.put("Eleven", (int)11); assertEquals(1, map.size()); map.clear(); assertEquals(0, map.size()); }
@Test public void testContainsKey() { OpenObjectIntHashMap<String> map = new OpenObjectIntHashMap<String>(); map.put("Eleven", (int)11); assertTrue(map.containsKey("Eleven")); assertTrue(map.containsKey("Eleven")); assertFalse(map.containsKey("Twelve")); }