java.util.AbstractMap

Here are the examples of the java api class java.util.AbstractMap taken from open source projects.

1. AbstractMapTest#test_keySet()

Project: j2objc
Source File: AbstractMapTest.java
View license
/**
     * java.util.AbstractMap#keySet()
     */
public void test_keySet() {
    AbstractMap map1 = new HashMap(0);
    assertSame("HashMap(0)", map1.keySet(), map1.keySet());
    AbstractMap map2 = new HashMap(10);
    assertSame("HashMap(10)", map2.keySet(), map2.keySet());
    Map map3 = Collections.EMPTY_MAP;
    assertSame("EMPTY_MAP", map3.keySet(), map3.keySet());
    AbstractMap map4 = new IdentityHashMap(1);
    assertSame("IdentityHashMap", map4.keySet(), map4.keySet());
    AbstractMap map5 = new LinkedHashMap(122);
    assertSame("LinkedHashMap", map5.keySet(), map5.keySet());
    AbstractMap map6 = new TreeMap();
    assertSame("TreeMap", map6.keySet(), map6.keySet());
    AbstractMap map7 = new WeakHashMap();
    assertSame("WeakHashMap", map7.keySet(), map7.keySet());
}

2. AbstractMapTest#test_values()

Project: j2objc
Source File: AbstractMapTest.java
View license
/**
     * java.util.AbstractMap#values()
     */
public void test_values() {
    AbstractMap map1 = new HashMap(0);
    assertSame("HashMap(0)", map1.values(), map1.values());
    AbstractMap map2 = new HashMap(10);
    assertSame("HashMap(10)", map2.values(), map2.values());
    Map map3 = Collections.EMPTY_MAP;
    assertSame("EMPTY_MAP", map3.values(), map3.values());
    AbstractMap map4 = new IdentityHashMap(1);
    assertSame("IdentityHashMap", map4.values(), map4.values());
    AbstractMap map5 = new LinkedHashMap(122);
    assertSame("IdentityHashMap", map5.values(), map5.values());
    AbstractMap map6 = new TreeMap();
    assertSame("TreeMap", map6.values(), map6.values());
    AbstractMap map7 = new WeakHashMap();
    assertSame("WeakHashMap", map7.values(), map7.values());
}

3. AbstractMapTest#test_keySet()

Project: j2objc
Source File: AbstractMapTest.java
View license
/**
     * @tests java.util.AbstractMap#keySet()
     */
public void test_keySet() {
    AbstractMap map1 = new HashMap(0);
    assertSame("HashMap(0)", map1.keySet(), map1.keySet());
    AbstractMap map2 = new HashMap(10);
    assertSame("HashMap(10)", map2.keySet(), map2.keySet());
    Map map3 = Collections.EMPTY_MAP;
    assertSame("EMPTY_MAP", map3.keySet(), map3.keySet());
    AbstractMap map4 = new IdentityHashMap(1);
    assertSame("IdentityHashMap", map4.keySet(), map4.keySet());
    AbstractMap map5 = new LinkedHashMap(122);
    assertSame("LinkedHashMap", map5.keySet(), map5.keySet());
    AbstractMap map6 = new TreeMap();
    assertSame("TreeMap", map6.keySet(), map6.keySet());
}

4. AbstractMapTest#test_containsKey()

Project: j2objc
Source File: AbstractMapTest.java
View license
/**
     * @tests java.util.AbstractMap#containsKey(Object)
     */
public void test_containsKey() {
    AbstractMap map = new AMT();
    assertFalse(map.containsKey("k"));
    assertFalse(map.containsKey(null));
    map.put("k", "v");
    map.put("key", null);
    map.put(null, "value");
    map.put(null, null);
    assertTrue(map.containsKey("k"));
    assertTrue(map.containsKey("key"));
    assertTrue(map.containsKey(null));
}

5. AbstractMapTest#test_values()

Project: j2objc
Source File: AbstractMapTest.java
View license
/**
     * @tests java.util.AbstractMap#values()
     */
public void test_values() {
    AbstractMap map1 = new HashMap(0);
    assertSame("HashMap(0)", map1.values(), map1.values());
    AbstractMap map2 = new HashMap(10);
    assertSame("HashMap(10)", map2.values(), map2.values());
    Map map3 = Collections.EMPTY_MAP;
    assertSame("EMPTY_MAP", map3.values(), map3.values());
    AbstractMap map4 = new IdentityHashMap(1);
    assertSame("IdentityHashMap", map4.values(), map4.values());
    AbstractMap map5 = new LinkedHashMap(122);
    assertSame("IdentityHashMap", map5.values(), map5.values());
    AbstractMap map6 = new TreeMap();
    assertSame("TreeMap", map6.values(), map6.values());
}

6. AbstractMapTest#test_clear()

Project: j2objc
Source File: AbstractMapTest.java
View license
/**
     * @tests java.util.AbstractMap#clear()
     */
public void test_clear() {
    // normal clear()
    AbstractMap map = new HashMap();
    map.put(1, 1);
    map.clear();
    assertTrue(map.isEmpty());
    // Special entrySet return a Set with no clear method.
    AbstractMap myMap = new MocAbstractMap();
    try {
        myMap.clear();
        fail("Should throw UnsupportedOprationException");
    } catch (UnsupportedOperationException e) {
    }
}

7. AbstractMapTest#test_containValue()

Project: j2objc
Source File: AbstractMapTest.java
View license
/**
     * @tests java.util.AbstractMap#containsValue(Object)
     */
public void test_containValue() {
    AbstractMap map = new AMT();
    assertFalse(map.containsValue("v"));
    assertFalse(map.containsValue(null));
    map.put("k", "v");
    map.put("key", null);
    map.put(null, "value");
    assertTrue(map.containsValue("v"));
    assertTrue(map.containsValue("value"));
    assertTrue(map.containsValue(null));
}

8. AbstractMapTest#test_get()

Project: j2objc
Source File: AbstractMapTest.java
View license
/**
     * @tests java.util.AbstractMap#get(Object)
     */
public void test_get() {
    AbstractMap map = new AMT();
    assertNull(map.get("key"));
    assertNull(map.get(null));
    map.put("k", "v");
    map.put("key", null);
    map.put(null, "value");
    assertEquals("v", map.get("k"));
    assertNull(map.get("key"));
    assertEquals("value", map.get(null));
}

9. AbstractMapTest#test_removeLjava_lang_Object()

Project: j2objc
Source File: AbstractMapTest.java
View license
/**
     * java.util.AbstractMap#remove(java.lang.Object)
     */
public void test_removeLjava_lang_Object() {
    Object key = new Object();
    Object value = new Object();
    AbstractMap map1 = new HashMap(0);
    map1.put("key", value);
    assertSame("HashMap(0)", map1.remove("key"), value);
    AbstractMap map4 = new IdentityHashMap(1);
    map4.put(key, value);
    assertSame("IdentityHashMap", map4.remove(key), value);
    AbstractMap map5 = new LinkedHashMap(122);
    map5.put(key, value);
    assertSame("LinkedHashMap", map5.remove(key), value);
    AbstractMap map6 = new TreeMap(new Comparator() {

        // Bogus comparator
        public int compare(Object object1, Object object2) {
            return 0;
        }
    });
    map6.put(key, value);
    assertSame("TreeMap", map6.remove(key), value);
    AbstractMap map7 = new WeakHashMap();
    map7.put(key, value);
    assertSame("WeakHashMap", map7.remove(key), value);
    AbstractMap aSpecialMap = new MyMap();
    aSpecialMap.put(specialKey, specialValue);
    Object valueOut = aSpecialMap.remove(specialKey);
    assertSame("MyMap", valueOut, specialValue);
}

10. AbstractMapTest#test_removeLjava_lang_Object()

Project: j2objc
Source File: AbstractMapTest.java
View license
/**
     * @tests java.util.AbstractMap#remove(java.lang.Object)
     */
public void test_removeLjava_lang_Object() {
    Object key = new Object();
    Object value = new Object();
    AbstractMap map1 = new HashMap(0);
    map1.put("key", value);
    assertSame("HashMap(0)", map1.remove("key"), value);
    AbstractMap map4 = new IdentityHashMap(1);
    map4.put(key, value);
    assertSame("IdentityHashMap", map4.remove(key), value);
    AbstractMap map5 = new LinkedHashMap(122);
    map5.put(key, value);
    assertSame("LinkedHashMap", map5.remove(key), value);
    AbstractMap map6 = new TreeMap(new Comparator() {

        // Bogus comparator
        public int compare(Object object1, Object object2) {
            return 0;
        }
    });
    map6.put(key, value);
    assertSame("TreeMap", map6.remove(key), value);
    AbstractMap aSpecialMap = new MyMap();
    aSpecialMap.put(specialKey, specialValue);
    Object valueOut = aSpecialMap.remove(specialKey);
    assertSame("MyMap", valueOut, specialValue);
}

11. HashMapTest#test_clone()

Project: j2objc
Source File: HashMapTest.java
View license
/**
     * java.util.HashMap#clone()
     */
public void test_clone() {
    // Test for method java.lang.Object java.util.HashMap.clone()
    HashMap hm2 = (HashMap) hm.clone();
    assertTrue("Clone answered equivalent HashMap", hm2 != hm);
    for (int counter = 0; counter < hmSize; counter++) assertTrue("Clone answered unequal HashMap", hm.get(objArray2[counter]) == hm2.get(objArray2[counter]));
    HashMap map = new HashMap();
    map.put("key", "value");
    // get the keySet() and values() on the original Map
    Set keys = map.keySet();
    Collection values = map.values();
    assertEquals("values() does not work", "value", values.iterator().next());
    assertEquals("keySet() does not work", "key", keys.iterator().next());
    AbstractMap map2 = (AbstractMap) map.clone();
    map2.put("key", "value2");
    Collection values2 = map2.values();
    assertTrue("values() is identical", values2 != values);
    // values() and keySet() on the cloned() map should be different
    assertEquals("values() was not cloned", "value2", values2.iterator().next());
    map2.clear();
    map2.put("key2", "value3");
    Set key2 = map2.keySet();
    assertTrue("keySet() is identical", key2 != keys);
    assertEquals("keySet() was not cloned", "key2", key2.iterator().next());
    // regresion test for HARMONY-4603
    HashMap hashmap = new HashMap();
    MockClonable mock = new MockClonable(1);
    hashmap.put(1, mock);
    assertEquals(1, ((MockClonable) hashmap.get(1)).i);
    HashMap hm3 = (HashMap) hashmap.clone();
    assertEquals(1, ((MockClonable) hm3.get(1)).i);
    mock.i = 0;
    assertEquals(0, ((MockClonable) hashmap.get(1)).i);
    assertEquals(0, ((MockClonable) hm3.get(1)).i);
}

12. LinkedHashMapTest#test_clone()

Project: j2objc
Source File: LinkedHashMapTest.java
View license
/**
     * java.util.LinkedHashMap#clone()
     */
public void test_clone() {
    // Test for method java.lang.Object java.util.LinkedHashMap.clone()
    LinkedHashMap hm2 = (LinkedHashMap) hm.clone();
    assertTrue("Clone answered equivalent LinkedHashMap", hm2 != hm);
    for (int counter = 0; counter < hmSize; counter++) assertTrue("Clone answered unequal LinkedHashMap", hm.get(objArray2[counter]) == hm2.get(objArray2[counter]));
    LinkedHashMap map = new LinkedHashMap();
    map.put("key", "value");
    // get the keySet() and values() on the original Map
    Set keys = map.keySet();
    Collection values = map.values();
    assertEquals("values() does not work", "value", values.iterator().next());
    assertEquals("keySet() does not work", "key", keys.iterator().next());
    AbstractMap map2 = (AbstractMap) map.clone();
    map2.put("key", "value2");
    Collection values2 = map2.values();
    assertTrue("values() is identical", values2 != values);
    // values() and keySet() on the cloned() map should be different
    assertEquals("values() was not cloned", "value2", values2.iterator().next());
    map2.clear();
    map2.put("key2", "value3");
    Set key2 = map2.keySet();
    assertTrue("keySet() is identical", key2 != keys);
    assertEquals("keySet() was not cloned", "key2", key2.iterator().next());
}

13. TreeMapTest#test_clone()

Project: j2objc
Source File: TreeMapTest.java
View license
/**
     * @tests java.util.TreeMap#clone()
     */
public void test_clone() {
    // Test for method java.lang.Object java.util.TreeMap.clone()
    TreeMap clonedMap = (TreeMap) tm.clone();
    assertTrue("Cloned map does not equal the original map", clonedMap.equals(tm));
    assertTrue("Cloned map is the same reference as the original map", clonedMap != tm);
    for (Object element : objArray) {
        assertTrue("Cloned map contains incorrect elements", clonedMap.get(element.toString()) == tm.get(element.toString()));
    }
    TreeMap map = new TreeMap();
    map.put("key", "value");
    // get the keySet() and values() on the original Map
    Set keys = map.keySet();
    Collection values = map.values();
    assertEquals("values() does not work", "value", values.iterator().next());
    assertEquals("keySet() does not work", "key", keys.iterator().next());
    AbstractMap map2 = (AbstractMap) map.clone();
    map2.put("key", "value2");
    Collection values2 = map2.values();
    assertTrue("values() is identical", values2 != values);
    // values() and keySet() on the cloned() map should be different
    assertEquals("values() was not cloned", "value2", values2.iterator().next());
    map2.clear();
    map2.put("key2", "value3");
    Set key2 = map2.keySet();
    assertTrue("keySet() is identical", key2 != keys);
    assertEquals("keySet() was not cloned", "key2", key2.iterator().next());
}