/luni/src/test/api/common/org/apache/harmony/luni/tests/java/util/TreeMapTest.java
Java | 2043 lines | 1570 code | 162 blank | 311 comment | 90 complexity | f492579f2282a5326f62229fabb46ccc MD5 | raw file
Large files files are truncated, but you can click here to view the full file
- /*
- * Licensed to the Apache Software Foundation (ASF) under one or more
- * contributor license agreements. See the NOTICE file distributed with
- * this work for additional information regarding copyright ownership.
- * The ASF licenses this file to You 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.
- */
- package org.apache.harmony.luni.tests.java.util;
- import java.io.BufferedInputStream;
- import java.io.BufferedOutputStream;
- import java.io.ByteArrayInputStream;
- import java.io.ByteArrayOutputStream;
- import java.io.ObjectInputStream;
- import java.io.ObjectOutputStream;
- import java.io.Serializable;
- import java.text.CollationKey;
- import java.text.Collator;
- import java.util.AbstractMap;
- import java.util.Arrays;
- import java.util.BitSet;
- import java.util.Collection;
- import java.util.Comparator;
- import java.util.HashMap;
- import java.util.Iterator;
- import java.util.LinkedList;
- import java.util.List;
- import java.util.Map;
- import java.util.NavigableMap;
- import java.util.NavigableSet;
- import java.util.NoSuchElementException;
- import java.util.Random;
- import java.util.Set;
- import java.util.SortedMap;
- import java.util.TreeMap;
- import java.util.Map.Entry;
- import org.apache.harmony.testframework.serialization.SerializationTest;
- import tests.support.Support_MapTest2;
- import tests.support.Support_UnmodifiableCollectionTest;
- public class TreeMapTest extends junit.framework.TestCase {
- public static class ReversedComparator implements Comparator {
- public int compare(Object o1, Object o2) {
- return -(((Comparable) o1).compareTo(o2));
- }
- public boolean equals(Object o1, Object o2) {
- return (((Comparable) o1).compareTo(o2)) == 0;
- }
- }
- // Regression for Harmony-1026
- public static class MockComparator<T extends Comparable<T>> implements
- Comparator<T>, Serializable {
- public int compare(T o1, T o2) {
- if (o1 == o2) {
- return 0;
- }
- if (null == o1 || null == o2) {
- return -1;
- }
- T c1 = o1;
- T c2 = o2;
- return c1.compareTo(c2);
- }
- }
- // Regression for Harmony-1161
- class MockComparatorNullTolerable implements Comparator<String> {
- public int compare(String o1, String o2) {
- if (o1 == o2) {
- return 0;
- }
- if (null == o1) {
- return -1;
- }
- if (null == o2) { // comparator should be symmetric
- return 1;
- }
- return o1.compareTo(o2);
- }
- }
- TreeMap tm;
- Object objArray[] = new Object[1000];
- /**
- * @tests java.util.TreeMap#TreeMap()
- */
- public void test_Constructor() {
- // Test for method java.util.TreeMap()
- new Support_MapTest2(new TreeMap()).runTest();
- assertTrue("New treeMap non-empty", new TreeMap().isEmpty());
- }
- /**
- * @tests java.util.TreeMap#TreeMap(java.util.Comparator)
- */
- public void test_ConstructorLjava_util_Comparator() {
- // Test for method java.util.TreeMap(java.util.Comparator)
- Comparator comp = new ReversedComparator();
- TreeMap reversedTreeMap = new TreeMap(comp);
- assertTrue("TreeMap answered incorrect comparator", reversedTreeMap
- .comparator() == comp);
- reversedTreeMap.put(new Integer(1).toString(), new Integer(1));
- reversedTreeMap.put(new Integer(2).toString(), new Integer(2));
- assertTrue("TreeMap does not use comparator (firstKey was incorrect)",
- reversedTreeMap.firstKey().equals(new Integer(2).toString()));
- assertTrue("TreeMap does not use comparator (lastKey was incorrect)",
- reversedTreeMap.lastKey().equals(new Integer(1).toString()));
- }
- /**
- * @tests java.util.TreeMap#TreeMap(java.util.Map)
- */
- public void test_ConstructorLjava_util_Map() {
- // Test for method java.util.TreeMap(java.util.Map)
- TreeMap myTreeMap = new TreeMap(new HashMap(tm));
- assertTrue("Map is incorrect size", myTreeMap.size() == objArray.length);
- for (Object element : objArray) {
- assertTrue("Map has incorrect mappings", myTreeMap.get(
- element.toString()).equals(element));
- }
- }
- /**
- * @tests java.util.TreeMap#TreeMap(java.util.SortedMap)
- */
- public void test_ConstructorLjava_util_SortedMap() {
- // Test for method java.util.TreeMap(java.util.SortedMap)
- Comparator comp = new ReversedComparator();
- TreeMap reversedTreeMap = new TreeMap(comp);
- reversedTreeMap.put(new Integer(1).toString(), new Integer(1));
- reversedTreeMap.put(new Integer(2).toString(), new Integer(2));
- TreeMap anotherTreeMap = new TreeMap(reversedTreeMap);
- assertTrue("New tree map does not answer correct comparator",
- anotherTreeMap.comparator() == comp);
- assertTrue("TreeMap does not use comparator (firstKey was incorrect)",
- anotherTreeMap.firstKey().equals(new Integer(2).toString()));
- assertTrue("TreeMap does not use comparator (lastKey was incorrect)",
- anotherTreeMap.lastKey().equals(new Integer(1).toString()));
- }
- /**
- * @tests java.util.TreeMap#clear()
- */
- public void test_clear() {
- // Test for method void java.util.TreeMap.clear()
- tm.clear();
- assertEquals("Cleared map returned non-zero size", 0, tm.size());
- }
- /**
- * @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());
- }
- /**
- * @tests java.util.TreeMap#comparator()
- */
- public void test_comparator() {
- // Test for method java.util.Comparator java.util.TreeMap.comparator()\
- Comparator comp = new ReversedComparator();
- TreeMap reversedTreeMap = new TreeMap(comp);
- assertTrue("TreeMap answered incorrect comparator", reversedTreeMap
- .comparator() == comp);
- reversedTreeMap.put(new Integer(1).toString(), new Integer(1));
- reversedTreeMap.put(new Integer(2).toString(), new Integer(2));
- assertTrue("TreeMap does not use comparator (firstKey was incorrect)",
- reversedTreeMap.firstKey().equals(new Integer(2).toString()));
- assertTrue("TreeMap does not use comparator (lastKey was incorrect)",
- reversedTreeMap.lastKey().equals(new Integer(1).toString()));
- }
- /**
- * @tests java.util.TreeMap#containsKey(java.lang.Object)
- */
- public void test_containsKeyLjava_lang_Object() {
- // Test for method boolean
- // java.util.TreeMap.containsKey(java.lang.Object)
- assertTrue("Returned false for valid key", tm.containsKey("95"));
- assertTrue("Returned true for invalid key", !tm.containsKey("XXXXX"));
- }
- /**
- * @tests java.util.TreeMap#containsValue(java.lang.Object)
- */
- public void test_containsValueLjava_lang_Object() {
- // Test for method boolean
- // java.util.TreeMap.containsValue(java.lang.Object)
- assertTrue("Returned false for valid value", tm
- .containsValue(objArray[986]));
- assertTrue("Returned true for invalid value", !tm
- .containsValue(new Object()));
- }
- /**
- * @tests java.util.TreeMap#entrySet()
- */
- public void test_entrySet() {
- // Test for method java.util.Set java.util.TreeMap.entrySet()
- Set anEntrySet = tm.entrySet();
- Iterator entrySetIterator = anEntrySet.iterator();
- assertTrue("EntrySet is incorrect size",
- anEntrySet.size() == objArray.length);
- Map.Entry entry;
- while (entrySetIterator.hasNext()) {
- entry = (Map.Entry) entrySetIterator.next();
- assertTrue("EntrySet does not contain correct mappings", tm
- .get(entry.getKey()) == entry.getValue());
- }
- }
- /**
- * @tests java.util.TreeMap#firstKey()
- */
- public void test_firstKey() {
- // Test for method java.lang.Object java.util.TreeMap.firstKey()
- assertEquals("Returned incorrect first key", "0", tm.firstKey());
- }
- /**
- * @tests java.util.TreeMap#get(java.lang.Object)
- */
- public void test_getLjava_lang_Object() {
- // Test for method java.lang.Object
- // java.util.TreeMap.get(java.lang.Object)
- Object o = new Object();
- tm.put("Hello", o);
- assertTrue("Failed to get mapping", tm.get("Hello") == o);
-
- // Test for the same key & same value
- tm = new TreeMap();
- Object o2 = new Object();
- Integer key1 = 1;
- Integer key2 = 2;
- assertNull(tm.put(key1, o));
- assertNull(tm.put(key2, o));
- assertEquals(2, tm.values().size());
- assertEquals(2, tm.keySet().size());
- assertSame(tm.get(key1), tm.get(key2));
- assertSame(o, tm.put(key1, o2));
- assertSame(o2, tm.get(key1));
- }
- /**
- * @tests java.util.TreeMap#headMap(java.lang.Object)
- */
- public void test_headMapLjava_lang_Object() {
- // Test for method java.util.SortedMap
- // java.util.TreeMap.headMap(java.lang.Object)
- Map head = tm.headMap("100");
- assertEquals("Returned map of incorrect size", 3, head.size());
- assertTrue("Returned incorrect elements", head.containsKey("0")
- && head.containsValue(new Integer("1"))
- && head.containsKey("10"));
- // Regression for Harmony-1026
- TreeMap<Integer, Double> map = new TreeMap<Integer, Double>(
- new MockComparator());
- map.put(1, 2.1);
- map.put(2, 3.1);
- map.put(3, 4.5);
- map.put(7, 21.3);
- map.put(null, null);
- SortedMap<Integer, Double> smap = map.headMap(null);
- assertEquals(0, smap.size());
- Set<Integer> keySet = smap.keySet();
- assertEquals(0, keySet.size());
- Set<Map.Entry<Integer, Double>> entrySet = smap.entrySet();
- assertEquals(0, entrySet.size());
- Collection<Double> valueCollection = smap.values();
- assertEquals(0, valueCollection.size());
- // Regression for Harmony-1066
- assertTrue(head instanceof Serializable);
- // Regression for ill-behaved collator
- Collator c = new Collator() {
- @Override
- public int compare(String o1, String o2) {
- if (o1 == null) {
- return 0;
- }
- return o1.compareTo(o2);
- }
- @Override
- public CollationKey getCollationKey(String string) {
- return null;
- }
- @Override
- public int hashCode() {
- return 0;
- }
- };
- TreeMap<String, String> treemap = new TreeMap<String, String>(c);
- assertEquals(0, treemap.headMap(null).size());
-
- treemap = new TreeMap();
- SortedMap<String, String> headMap = treemap.headMap("100");
- headMap.headMap("100");
- SortedMap<Integer,Integer> intMap,sub;
- int size = 16;
- intMap = new TreeMap<Integer,Integer>();
- for(int i=0; i<size; i++) {
- intMap.put(i,i);
- }
- sub = intMap.headMap(-1);
- assertEquals("size should be zero",sub.size(),0);
- assertTrue("submap should be empty",sub.isEmpty());
- try{
- sub.firstKey();
- fail("java.util.NoSuchElementException should be thrown");
- } catch(java.util.NoSuchElementException e) {
- }
-
- TreeMap t = new TreeMap();
- try {
- SortedMap th = t.headMap(null);
- fail("Should throw a NullPointerException");
- } catch( NullPointerException npe) {
- // expected
- }
- try{
- sub.lastKey();
- fail("java.util.NoSuchElementException should be thrown");
- } catch(java.util.NoSuchElementException e) {
- }
- size = 256;
- intMap = new TreeMap<Integer,Integer>();
- for(int i=0; i<size; i++) {
- intMap.put(i,i);
- }
- sub = intMap.headMap(-1);
- assertEquals("size should be zero",sub.size(),0);
- assertTrue("submap should be empty",sub.isEmpty());
- try{
- sub.firstKey();
- fail("java.util.NoSuchElementException should be thrown");
- } catch(java.util.NoSuchElementException e) {
- }
-
- try{
- sub.lastKey();
- fail("java.util.NoSuchElementException should be thrown");
- } catch(java.util.NoSuchElementException e) {
- }
- }
- /**
- * @tests java.util.TreeMap#keySet()
- */
- public void test_keySet() {
- // Test for method java.util.Set java.util.TreeMap.keySet()
- Set ks = tm.keySet();
- assertTrue("Returned set of incorrect size",
- ks.size() == objArray.length);
- for (int i = 0; i < tm.size(); i++) {
- assertTrue("Returned set is missing keys", ks.contains(new Integer(
- i).toString()));
- }
- }
- /**
- * @tests java.util.TreeMap#lastKey()
- */
- public void test_lastKey() {
- // Test for method java.lang.Object java.util.TreeMap.lastKey()
- assertTrue("Returned incorrect last key", tm.lastKey().equals(
- objArray[objArray.length - 1].toString()));
- assertNotSame(objArray[objArray.length - 1].toString(), tm.lastKey());
- assertEquals(objArray[objArray.length - 2].toString(), tm
- .headMap("999").lastKey());
- assertEquals(objArray[objArray.length - 1].toString(), tm
- .tailMap("123").lastKey());
- assertEquals(objArray[objArray.length - 2].toString(), tm.subMap("99",
- "999").lastKey());
- }
-
- public void test_lastKey_after_subMap() {
- TreeMap<String, String> tm = new TreeMap<String, String>();
- tm.put("001", "VAL001");
- tm.put("003", "VAL003");
- tm.put("002", "VAL002");
- SortedMap<String, String> sm = tm;
- String firstKey = (String) sm.firstKey();
- String lastKey="";
- for (int i = 1; i <= tm.size(); i++) {
- try{
- lastKey = (String) sm.lastKey();
- }
- catch(NoSuchElementException excep){
- fail("NoSuchElementException thrown when there are elements in the map");
- }
- sm = sm.subMap(firstKey, lastKey);
- }
- }
- /**
- * @tests java.util.TreeMap#put(java.lang.Object, java.lang.Object)
- */
- public void test_putLjava_lang_ObjectLjava_lang_Object() {
- // Test for method java.lang.Object
- // java.util.TreeMap.put(java.lang.Object, java.lang.Object)
- Object o = new Object();
- tm.put("Hello", o);
- assertTrue("Failed to put mapping", tm.get("Hello") == o);
- // regression for Harmony-780
- tm = new TreeMap();
- assertNull(tm.put(new Object(), new Object()));
- try {
- tm.put(new Integer(1), new Object());
- fail("should throw ClassCastException");
- } catch (ClassCastException e) {
- // expected
- }
- tm = new TreeMap();
- assertNull(tm.put(new Integer(1), new Object()));
-
- try {
- tm.put(new Object(), new Object());
- fail("Should throw a ClassCastException");
- } catch (ClassCastException e) {
- // expected
- }
- // regression for Harmony-2474
- // but RI6 changes its behavior
- // so the test changes too
- tm = new TreeMap();
- try {
- tm.remove(o);
- fail("should throw ClassCastException");
- } catch (ClassCastException e) {
- //expected
- }
- }
- /**
- * @tests java.util.TreeMap#putAll(java.util.Map)
- */
- public void test_putAllLjava_util_Map() {
- // Test for method void java.util.TreeMap.putAll(java.util.Map)
- TreeMap x = new TreeMap();
- x.putAll(tm);
- assertTrue("Map incorrect size after put", x.size() == tm.size());
- for (Object element : objArray) {
- assertTrue("Failed to put all elements", x.get(element.toString())
- .equals(element));
- }
- }
- /**
- * @tests java.util.TreeMap#remove(java.lang.Object)
- */
- public void test_removeLjava_lang_Object() {
- // Test for method java.lang.Object
- // java.util.TreeMap.remove(java.lang.Object)
- tm.remove("990");
- assertTrue("Failed to remove mapping", !tm.containsKey("990"));
- }
- /**
- * @tests java.util.TreeMap#size()
- */
- public void test_size() {
- // Test for method int java.util.TreeMap.size()
- assertEquals("Returned incorrect size", 1000, tm.size());
- assertEquals("Returned incorrect size", 447, tm.headMap("500").size());
- assertEquals("Returned incorrect size", 1000, tm.headMap("null").size());
- assertEquals("Returned incorrect size", 0, tm.headMap("").size());
- assertEquals("Returned incorrect size", 448, tm.headMap("500a").size());
- assertEquals("Returned incorrect size", 553, tm.tailMap("500").size());
- assertEquals("Returned incorrect size", 0, tm.tailMap("null").size());
- assertEquals("Returned incorrect size", 1000, tm.tailMap("").size());
- assertEquals("Returned incorrect size", 552, tm.tailMap("500a").size());
- assertEquals("Returned incorrect size", 111, tm.subMap("500", "600")
- .size());
- try {
- tm.subMap("null", "600");
- fail("Should throw an IllegalArgumentException");
- } catch (IllegalArgumentException e) {
- // expected
- }
- assertEquals("Returned incorrect size", 1000, tm.subMap("", "null")
- .size());
- }
- /**
- * @tests java.util.TreeMap#subMap(java.lang.Object, java.lang.Object)
- */
- public void test_subMapLjava_lang_ObjectLjava_lang_Object() {
- // Test for method java.util.SortedMap
- // java.util.TreeMap.subMap(java.lang.Object, java.lang.Object)
- SortedMap subMap = tm.subMap(objArray[100].toString(), objArray[109]
- .toString());
- assertEquals("subMap is of incorrect size", 9, subMap.size());
- for (int counter = 100; counter < 109; counter++) {
- assertTrue("SubMap contains incorrect elements", subMap.get(
- objArray[counter].toString()).equals(objArray[counter]));
- }
- try {
- tm.subMap(objArray[9].toString(), objArray[1].toString());
- fail("end key less than start key should throw IllegalArgumentException");
- } catch (IllegalArgumentException e) {
- // Expected
- }
- // Regression for Harmony-1161
- TreeMap<String, String> treeMapWithNull = new TreeMap<String, String>(
- new MockComparatorNullTolerable());
- treeMapWithNull.put("key1", "value1"); //$NON-NLS-1$ //$NON-NLS-2$
- treeMapWithNull.put(null, "value2"); //$NON-NLS-1$
- SortedMap<String, String> subMapWithNull = treeMapWithNull.subMap(null,
- "key1"); //$NON-NLS-1$
- assertEquals("Size of subMap should be 1:", 1, subMapWithNull.size()); //$NON-NLS-1$
- // Regression test for typo in lastKey method
- SortedMap<String, String> map = new TreeMap<String, String>();
- map.put("1", "one"); //$NON-NLS-1$ //$NON-NLS-2$
- map.put("2", "two"); //$NON-NLS-1$ //$NON-NLS-2$
- map.put("3", "three"); //$NON-NLS-1$ //$NON-NLS-2$
- assertEquals("3", map.lastKey());
- SortedMap<String, String> sub = map.subMap("1", "3"); //$NON-NLS-1$ //$NON-NLS-2$
- assertEquals("2", sub.lastKey()); //$NON-NLS-1$
-
- TreeMap t = new TreeMap();
- try {
- SortedMap th = t.subMap(null,new Object());
- fail("Should throw a NullPointerException");
- } catch( NullPointerException npe) {
- // expected
- }
- }
-
-
- /**
- * @tests java.util.TreeMap#subMap(java.lang.Object, java.lang.Object)
- */
- public void test_subMap_Iterator() {
- TreeMap<String, String> map = new TreeMap<String, String>();
- String[] keys = { "1", "2", "3" };
- String[] values = { "one", "two", "three" };
- for (int i = 0; i < keys.length; i++) {
- map.put(keys[i], values[i]);
- }
- assertEquals(3, map.size());
- Map subMap = map.subMap("", "test");
- assertEquals(3, subMap.size());
- Set entrySet = subMap.entrySet();
- Iterator iter = entrySet.iterator();
- int size = 0;
- while (iter.hasNext()) {
- Map.Entry<String, String> entry = (Map.Entry<String, String>) iter
- .next();
- assertTrue(map.containsKey(entry.getKey()));
- assertTrue(map.containsValue(entry.getValue()));
- size++;
- }
- assertEquals(map.size(), size);
- Set<String> keySet = subMap.keySet();
- iter = keySet.iterator();
- size = 0;
- while (iter.hasNext()) {
- String key = (String) iter.next();
- assertTrue(map.containsKey(key));
- size++;
- }
- assertEquals(map.size(), size);
- }
- /**
- * @tests java.util.TreeMap#tailMap(java.lang.Object)
- */
- public void test_tailMapLjava_lang_Object() {
- // Test for method java.util.SortedMap
- // java.util.TreeMap.tailMap(java.lang.Object)
- Map tail = tm.tailMap(objArray[900].toString());
- assertTrue("Returned map of incorrect size : " + tail.size(), tail
- .size() == (objArray.length - 900) + 9);
- for (int i = 900; i < objArray.length; i++) {
- assertTrue("Map contains incorrect entries", tail
- .containsValue(objArray[i]));
- }
- // Regression for Harmony-1066
- assertTrue(tail instanceof Serializable);
- SortedMap<Integer,Integer> intMap,sub;
- int size = 16;
- intMap = new TreeMap<Integer,Integer>();
- for(int i=0; i<size; i++) {
- intMap.put(i,i);
- }
- sub = intMap.tailMap(size);
- assertEquals("size should be zero",sub.size(),0);
- assertTrue("submap should be empty",sub.isEmpty());
- try{
- sub.firstKey();
- fail("java.util.NoSuchElementException should be thrown");
- } catch(java.util.NoSuchElementException e) {
- }
-
- TreeMap t = new TreeMap();
- try {
- SortedMap th = t.tailMap(null);
- fail("Should throw a NullPointerException");
- } catch( NullPointerException npe) {
- // expected
- }
- try{
- sub.lastKey();
- fail("java.util.NoSuchElementException should be thrown");
- } catch(java.util.NoSuchElementException e) {
- }
- size = 256;
- intMap = new TreeMap<Integer,Integer>();
- for(int i=0; i<size; i++) {
- intMap.put(i,i);
- }
- sub = intMap.tailMap(size);
- assertEquals("size should be zero",sub.size(),0);
- assertTrue("submap should be empty",sub.isEmpty());
- try{
- sub.firstKey();
- fail("java.util.NoSuchElementException should be thrown");
- } catch(java.util.NoSuchElementException e) {
- }
-
- try{
- sub.lastKey();
- fail("java.util.NoSuchElementException should be thrown");
- } catch(java.util.NoSuchElementException e) {
- }
- }
- /**
- * @tests java.util.TreeMap#values()
- */
- public void test_values() {
- // Test for method java.util.Collection java.util.TreeMap.values()
- Collection vals = tm.values();
- vals.iterator();
- assertTrue("Returned collection of incorrect size",
- vals.size() == objArray.length);
- for (Object element : objArray) {
- assertTrue("Collection contains incorrect elements", vals
- .contains(element));
- }
- assertEquals(1000, vals.size());
- int j = 0;
- for (Iterator iter = vals.iterator(); iter.hasNext();) {
- Object element = (Object) iter.next();
- j++;
- }
- assertEquals(1000, j);
-
- vals = tm.descendingMap().values();
- vals.iterator();
- assertTrue("Returned collection of incorrect size",
- vals.size() == objArray.length);
- for (Object element : objArray) {
- assertTrue("Collection contains incorrect elements", vals
- .contains(element));
- }
- assertEquals(1000, vals.size());
- j = 0;
- for (Iterator iter = vals.iterator(); iter.hasNext();) {
- Object element = (Object) iter.next();
- j++;
- }
- assertEquals(1000, j);
-
- TreeMap myTreeMap = new TreeMap();
- for (int i = 0; i < 100; i++) {
- myTreeMap.put(objArray[i], objArray[i]);
- }
- Collection values = myTreeMap.values();
- new Support_UnmodifiableCollectionTest(
- "Test Returned Collection From TreeMap.values()", values)
- .runTest();
- values.remove(new Integer(0));
- assertTrue(
- "Removing from the values collection should remove from the original map",
- !myTreeMap.containsValue(new Integer(0)));
- assertEquals(99, values.size());
- j = 0;
- for (Iterator iter = values.iterator(); iter.hasNext();) {
- Object element = (Object) iter.next();
- j++;
- }
- assertEquals(99, j);
-
- }
-
- /**
- * @tests java.util.TreeMap the values() method in sub maps
- */
- public void test_subMap_values_size() {
- TreeMap myTreeMap = new TreeMap();
- for (int i = 0; i < 1000; i++) {
- myTreeMap.put(i, objArray[i]);
- }
- // Test for method values() in subMaps
- Collection vals = myTreeMap.subMap(200, 400).values();
- assertTrue("Returned collection of incorrect size", vals.size() == 200);
- for (int i = 200; i < 400; i++) {
- assertTrue("Collection contains incorrect elements" + i, vals
- .contains(objArray[i]));
- }
- assertEquals(200,vals.toArray().length);
- vals.remove(objArray[300]);
- assertTrue(
- "Removing from the values collection should remove from the original map",
- !myTreeMap.containsValue(objArray[300]));
- assertTrue("Returned collection of incorrect size", vals.size() == 199);
- assertEquals(199,vals.toArray().length);
- myTreeMap.put(300, objArray[300]);
- // Test for method values() in subMaps
- vals = myTreeMap.headMap(400).values();
- assertEquals("Returned collection of incorrect size", vals.size(), 400);
- for (int i = 0; i < 400; i++) {
- assertTrue("Collection contains incorrect elements "+i, vals
- .contains(objArray[i]));
- }
- assertEquals(400,vals.toArray().length);
- vals.remove(objArray[300]);
- assertTrue(
- "Removing from the values collection should remove from the original map",
- !myTreeMap.containsValue(objArray[300]));
- assertTrue("Returned collection of incorrect size", vals.size() == 399);
- assertEquals(399,vals.toArray().length);
-
- myTreeMap.put(300, objArray[300]);
- // Test for method values() in subMaps
- vals = myTreeMap.tailMap(400).values();
- assertEquals("Returned collection of incorrect size", vals.size(), 600);
- for (int i = 400; i < 1000; i++) {
- assertTrue("Collection contains incorrect elements "+i, vals
- .contains(objArray[i]));
- }
- assertEquals(600,vals.toArray().length);
- vals.remove(objArray[600]);
- assertTrue(
- "Removing from the values collection should remove from the original map",
- !myTreeMap.containsValue(objArray[600]));
- assertTrue("Returned collection of incorrect size", vals.size() == 599);
- assertEquals(599,vals.toArray().length);
-
-
- myTreeMap.put(600, objArray[600]);
- // Test for method values() in subMaps
- vals = myTreeMap.descendingMap().headMap(400).values();
- assertEquals("Returned collection of incorrect size", vals.size(), 599);
- for (int i = 401; i < 1000; i++) {
- assertTrue("Collection contains incorrect elements "+i, vals
- .contains(objArray[i]));
- }
- assertEquals(599,vals.toArray().length);
- vals.remove(objArray[600]);
- assertTrue(
- "Removing from the values collection should remove from the original map",
- !myTreeMap.containsValue(objArray[600]));
- assertTrue("Returned collection of incorrect size", vals.size() == 598);
- assertEquals(598,vals.toArray().length);
-
- myTreeMap.put(600, objArray[600]);
- // Test for method values() in subMaps
- vals = myTreeMap.descendingMap().tailMap(400).values();
- assertEquals("Returned collection of incorrect size", vals.size(), 401);
- for (int i = 0; i <= 400; i++) {
- assertTrue("Collection contains incorrect elements "+i, vals
- .contains(objArray[i]));
- }
- assertEquals(401,vals.toArray().length);
- vals.remove(objArray[300]);
- assertTrue(
- "Removing from the values collection should remove from the original map",
- !myTreeMap.containsValue(objArray[300]));
- assertTrue("Returned collection of incorrect size", vals.size() == 400);
- assertEquals(400,vals.toArray().length);
-
- }
-
- /**
- * @tests java.util.TreeMap#subMap()
- */
- public void test_subMap_Iterator2() {
- TreeMap<String, String> map = new TreeMap<String, String>();
- String[] keys = { "1", "2", "3" };
- String[] values = { "one", "two", "three" };
- for (int i = 0; i < keys.length; i++) {
- map.put(keys[i], values[i]);
- }
- assertEquals(3, map.size());
- Map subMap = map.subMap("", "test");
- assertEquals(3, subMap.size());
- Set entrySet = subMap.entrySet();
- Iterator iter = entrySet.iterator();
- int size = 0;
- while (iter.hasNext()) {
- Map.Entry<String, String> entry = (Map.Entry<String, String>) iter
- .next();
- assertTrue(map.containsKey(entry.getKey()));
- assertTrue(map.containsValue(entry.getValue()));
- size++;
- }
- assertEquals(map.size(), size);
- Set<String> keySet = subMap.keySet();
- iter = keySet.iterator();
- size = 0;
- while (iter.hasNext()) {
- String key = (String) iter.next();
- assertTrue(map.containsKey(key));
- size++;
- }
- assertEquals(map.size(), size);
- }
- /**
- * @tests java.util.TreeMap#SerializationTest()
- */
- // Regression for Harmony-1066
- public void test_SubMap_Serializable() throws Exception {
- TreeMap<Integer, Double> map = new TreeMap<Integer, Double>();
- map.put(1, 2.1);
- map.put(2, 3.1);
- map.put(3, 4.5);
- map.put(7, 21.3);
- SortedMap<Integer, Double> headMap = map.headMap(3);
- assertTrue(headMap instanceof Serializable);
- assertFalse(headMap instanceof TreeMap);
- assertTrue(headMap instanceof SortedMap);
- assertFalse(headMap.entrySet() instanceof Serializable);
- assertFalse(headMap.keySet() instanceof Serializable);
- assertFalse(headMap.values() instanceof Serializable);
- // This assertion will fail on RI. This is a bug of RI.
- SerializationTest.verifySelf(headMap);
- }
-
- /**
- * @tests {@link java.util.TreeMap#firstEntry()}
- */
- public void test_firstEntry() throws Exception {
- Integer testint = new Integer(-1);
- Integer testint10000 = new Integer(-10000);
- Integer testint9999 = new Integer(-9999);
- assertEquals(objArray[0].toString(), tm.firstEntry().getKey());
- assertEquals(objArray[0], tm.firstEntry().getValue());
- tm.put(testint.toString(), testint);
- assertEquals(testint.toString(), tm.firstEntry().getKey());
- assertEquals(testint, tm.firstEntry().getValue());
- tm.put(testint10000.toString(), testint10000);
- assertEquals(testint.toString(), tm.firstEntry().getKey());
- assertEquals(testint, tm.firstEntry().getValue());
- tm.put(testint9999.toString(), testint9999);
- assertEquals(testint.toString(), tm.firstEntry().getKey());
- Entry entry = tm.firstEntry();
- assertEquals(testint, entry.getValue());
- assertEntry(entry);
- tm.clear();
- assertNull(tm.firstEntry());
- }
- /**
- * @tests {@link java.util.TreeMap#lastEntry()
- */
- public void test_lastEntry() throws Exception {
- Integer testint10000 = new Integer(10000);
- Integer testint9999 = new Integer(9999);
- assertEquals(objArray[999].toString(), tm.lastEntry().getKey());
- assertEquals(objArray[999], tm.lastEntry().getValue());
- tm.put(testint10000.toString(), testint10000);
- assertEquals(objArray[999].toString(), tm.lastEntry().getKey());
- assertEquals(objArray[999], tm.lastEntry().getValue());
- tm.put(testint9999.toString(), testint9999);
- assertEquals(testint9999.toString(), tm.lastEntry().getKey());
- Entry entry = tm.lastEntry();
- assertEquals(testint9999, entry.getValue());
- assertEntry(entry);
- tm.clear();
- assertNull(tm.lastEntry());
- }
- /**
- * @tests {@link java.util.TreeMap#pollFirstEntry()
- */
- public void test_pollFirstEntry() throws Exception {
- Integer testint = new Integer(-1);
- Integer testint10000 = new Integer(-10000);
- Integer testint9999 = new Integer(-9999);
- assertEquals(objArray[0].toString(), tm.pollFirstEntry().getKey());
- assertEquals(objArray[1], tm.pollFirstEntry().getValue());
- assertEquals(objArray[10], tm.pollFirstEntry().getValue());
- tm.put(testint.toString(), testint);
- tm.put(testint10000.toString(), testint10000);
- assertEquals(testint.toString(), tm.pollFirstEntry().getKey());
- assertEquals(testint10000, tm.pollFirstEntry().getValue());
- tm.put(testint9999.toString(), testint9999);
- assertEquals(testint9999.toString(), tm.pollFirstEntry().getKey());
- Entry entry = tm.pollFirstEntry();
- assertEntry(entry);
- assertEquals(objArray[100], entry.getValue());
- tm.clear();
- assertNull(tm.pollFirstEntry());
- }
- /**
- * @tests {@link java.util.TreeMap#pollLastEntry()
- */
- public void test_pollLastEntry() throws Exception {
- Integer testint10000 = new Integer(10000);
- Integer testint9999 = new Integer(9999);
- assertEquals(objArray[999].toString(), tm.pollLastEntry().getKey());
- assertEquals(objArray[998], tm.pollLastEntry().getValue());
- assertEquals(objArray[997], tm.pollLastEntry().getValue());
- tm.put(testint10000.toString(), testint10000);
- assertEquals(objArray[996], tm.pollLastEntry().getValue());
- tm.put(testint9999.toString(), testint9999);
- assertEquals(testint9999.toString(), tm.pollLastEntry().getKey());
- Entry entry = tm.pollLastEntry();
- assertEquals(objArray[995], entry.getValue());
- assertEntry(entry);
- tm.clear();
- assertNull(tm.pollLastEntry());
- }
- /**
- * @tests {@link java.util.TreeMap#lowerEntry(Object)
- */
- public void test_lowerEntry() throws Exception {
- Integer testint10000 = new Integer(10000);
- Integer testint9999 = new Integer(9999);
- assertEquals(objArray[999], tm.lowerEntry(testint9999.toString())
- .getValue());
- assertEquals(objArray[100], tm.lowerEntry(testint10000.toString())
- .getValue());
- tm.put(testint10000.toString(), testint10000);
- tm.put(testint9999.toString(), testint9999);
- assertEquals(objArray[999], tm.lowerEntry(testint9999.toString())
- .getValue());
- Entry entry = tm.lowerEntry(testint10000.toString());
- assertEquals(objArray[100], entry.getValue());
- assertEntry(entry);
- try {
- tm.lowerEntry(testint10000);
- fail("should throw ClassCastException");
- } catch (ClassCastException e) {
- // expected
- }
- try {
- tm.lowerEntry(null);
- fail("should throw NullPointerException");
- } catch (NullPointerException e) {
- // expected
- }
- tm.clear();
- assertNull(tm.lowerEntry(testint9999.toString()));
- assertNull(tm.lowerEntry(null));
- }
- /**
- * @tests {@link java.util.TreeMap#lowerKey(Object)
- */
- public void test_lowerKey() throws Exception {
- Integer testint10000 = new Integer(10000);
- Integer testint9999 = new Integer(9999);
- assertEquals(objArray[999].toString(), tm.lowerKey(testint9999
- .toString()));
- assertEquals(objArray[100].toString(), tm.lowerKey(testint10000
- .toString()));
- tm.put(testint10000.toString(), testint10000);
- tm.put(testint9999.toString(), testint9999);
- assertEquals(objArray[999].toString(), tm.lowerKey(testint9999
- .toString()));
- assertEquals(objArray[100].toString(), tm.lowerKey(testint10000
- .toString()));
- try {
- tm.lowerKey(testint10000);
- fail("should throw ClassCastException");
- } catch (ClassCastException e) {
- // expected
- }
- try {
- tm.lowerKey(null);
- fail("should throw NullPointerException");
- } catch (NullPointerException e) {
- // expected
- }
- tm.clear();
- assertNull(tm.lowerKey(testint9999.toString()));
- assertNull(tm.lowerKey(null));
- }
- /**
- * @tests {@link java.util.TreeMap#floorEntry(Object)
- */
- public void test_floorEntry() throws Exception {
- Integer testint10000 = new Integer(10000);
- Integer testint9999 = new Integer(9999);
- assertEquals(objArray[999], tm.floorEntry(testint9999.toString())
- .getValue());
- assertEquals(objArray[100], tm.floorEntry(testint10000.toString())
- .getValue());
- tm.put(testint10000.toString(), testint10000);
- tm.put(testint9999.toString(), testint9999);
- assertEquals(testint9999, tm.floorEntry(testint9999.toString())
- .getValue());
- Entry entry = tm.floorEntry(testint10000.toString());
- assertEquals(testint10000, entry.getValue());
- assertEntry(entry);
- try {
- tm.floorEntry(testint10000);
- fail("should throw ClassCastException");
- } catch (ClassCastException e) {
- // expected
- }
- try {
- tm.floorEntry(null);
- fail("should throw NullPointerException");
- } catch (NullPointerException e) {
- // expected
- }
- tm.clear();
- assertNull(tm.floorEntry(testint9999.toString()));
- assertNull(tm.floorEntry(null));
- }
- /**
- * @tests {@link java.util.TreeMap#floorKey(Object)
- */
- public void test_floorKey() throws Exception {
- Integer testint10000 = new Integer(10000);
- Integer testint9999 = new Integer(9999);
- assertEquals(objArray[999].toString(), tm.floorKey(testint9999
- .toString()));
- assertEquals(objArray[100].toString(), tm.floorKey(testint10000
- .toString()));
- tm.put(testint10000.toString(), testint10000);
- tm.put(testint9999.toString(), testint9999);
- assertEquals(testint9999.toString(), tm
- .floorKey(testint9999.toString()));
- assertEquals(testint10000.toString(), tm.floorKey(testint10000
- .toString()));
- try {
- tm.floorKey(testint10000);
- fail("should throw ClassCastException");
- } catch (ClassCastException e) {
- // expected
- }
- try {
- tm.floorKey(null);
- fail("should throw NullPointerException");
- } catch (NullPointerException e) {
- // expected
- }
- tm.clear();
- assertNull(tm.floorKey(testint9999.toString()));
- assertNull(tm.floorKey(null));
- }
- /**
- * @tests {@link java.util.TreeMap#ceilingEntry(Object)
- */
- public void test_ceilingEntry() throws Exception {
- Integer testint100 = new Integer(100);
- Integer testint = new Integer(-1);
- assertEquals(objArray[0], tm.ceilingEntry(testint.toString())
- .getValue());
- assertEquals(objArray[100], tm.ceilingEntry(testint100.toString())
- .getValue());
- tm.put(testint.toString(), testint);
- tm.put(testint100.toString(), testint);
- assertEquals(testint, tm.ceilingEntry(testint.toString()).getValue());
- Entry entry = tm.ceilingEntry(testint100.toString());
- assertEquals(testint, entry.getValue());
- assertEntry(entry);
- try {
- tm.ceilingEntry(testint100);
- fail("should throw ClassCastException");
- } catch (ClassCastException e) {
- // expected
- }
- try {
- tm.ceilingEntry(null);
- fail("should throw NullPointerException");
- } catch (NullPointerException e) {
- // expected
- }
- tm.clear();
- assertNull(tm.ceilingEntry(testint.toString()));
- assertNull(tm.ceilingEntry(null));
- }
- /**
- * @tests {@link java.util.TreeMap#ceilingKey(Object)
- */
- public void test_ceilingKey() throws Exception {
- Integer testint100 = new Integer(100);
- Integer testint = new Integer(-1);
- assertEquals(objArray[0].toString(), tm.ceilingKey(testint.toString()));
- assertEquals(objArray[100].toString(), tm.ceilingKey(testint100
- .toString()));
- tm.put(testint.toString(), testint);
- tm.put(testint100.toString(), testint);
- assertEquals(testint.toString(), tm.ceilingKey(testint.toString()));
- assertEquals(testint100.toString(), tm
- .ceilingKey(testint100.toString()));
- try {
- tm.ceilingKey(testint100);
- fail("should throw ClassCastException");
- } catch (ClassCastException e) {
- // expected
- }
- try {
- tm.ceilingKey(null);
- fail("should throw NullPointerException");
- } catch (NullPointerException e) {
- // expected
- }
- tm.clear();
- assertNull(tm.ceilingKey(testint.toString()));
- assertNull(tm.ceilingKey(null));
- }
- /**
- * @tests {@link java.util.TreeMap#higherEntry(Object)
- */
- public void test_higherEntry() throws Exception {
- Integer testint9999 = new Integer(9999);
- Integer testint10000 = new Integer(10000);
- Integer testint100 = new Integer(100);
- Integer testint = new Integer(-1);
- assertEquals(objArray[0], tm.higherEntry(testint.toString()).getValue());
- assertEquals(objArray[101], tm.higherEntry(testint100.toString())
- .getValue());
- assertEquals(objArray[101], tm.higherEntry(testint10000.toString())
- .getValue());
- tm.put(testint9999.toString(), testint);
- tm.put(testint100.toString(), testint);
- tm.put(testint10000.toString(), testint);
- assertEquals(objArray[0], tm.higherEntry(testint.toString()).getValue());
- assertEquals(testint, tm.higherEntry(testint100.toString()).getValue());
- Entry entry = tm.higherEntry(testint10000.toString());
- assertEquals(objArray[101], entry.getValue());
- assertEntry(entry);
- assertNull(tm.higherEntry(testint9999.toString()));
- try {
- tm.higherEntry(testint100);
- fail("should throw ClassCastException");
- } catch (ClassCastException e) {
- // expected
- }
- try {
- tm.higherEntry(null);
- fail("should throw NullPointerException");
- } catch (NullPointerException e) {
- // expected
- }
- tm.clear();
- assertNull(tm.higherEntry(testint.toString()));
- assertNull(tm.higherEntry(null));
- }
- /**
- * @tests {@link java.util.TreeMap#higherKey(Object)
- */
- public void test_higherKey() throws Exception {
- Integer testint9999 = new Integer(9999);
- Integer testint10000 = new Integer(10000);
- Integer testint100 = new Integer(100);
- Integer testint = new Integer(-1);
- assertEquals(objArray[0].toString(), tm.higherKey(testint.toString()));
- assertEquals(objArray[101].toString(), tm.higherKey(testint100
- .toString()));
- assertEquals(objArray[101].toString(), tm.higherKey(testint10000
- .toString()));
- tm.put(testint9999.toString(), testint);
- tm.put(testint100.toString(), testint);
- tm.put(testint10000.toString(), testint);
- assertEquals(objArray[0].toString(), tm.higherKey(testint.toString()));
- assertEquals(testint10000.toString(), tm.higherKey(testint100
- .toString()));
- assertEquals(objArray[101].toString(), tm.higherKey(testint10000
- .toString()));
- assertNull(tm.higherKey(testint9999.toString()));
- try {
- tm.higherKey(testint100);
- fail("should throw ClassCastException");
- } catch (ClassCastException e) {
- // expected
- }
- try {
- tm.higherKey(null);
- fail("should throw NullPointerException");
- } catch (NullPointerException e) {
- // expected
- }
- tm.clear();
- assertNull(tm.higherKey(testint.toString()));
- assertNull(tm.higherKey(null));
- }
- public void test_navigableKeySet() throws Exception {
- Integer testint9999 = new Integer(9999);
- Integer testint10000 = new Integer(10000);
- Integer testint100 = new Integer(100);
- Integer testint0 = new Integer(0);
- NavigableSet set = tm.navigableKeySet();
- assertFalse(set.contains(testint9999.toString()));
- tm.put(testint9999.toString(), testint9999);
- assertTrue(set.contains(testint9999.toString()));
- tm.remove(testint9999.toString());
- assertFalse(set.contains(testint9999.toString()));
- try {
- set.add(new Object());
- fail("should throw UnsupportedOperationException");
- } catch (UnsupportedOperationException e) {
- // expected
- }
- try {
- set.add(null);
- fail("should throw UnsupportedOperationException");
- } catch (UnsupportedOperationException e) {
- // expected
- }
- try {
- set.addAll(null);
- fail("should throw UnsupportedOperationException");
- } catch (NullPointerException e) {
- // expected
- }
- Collection collection = new LinkedList();
- set.addAll(collection);
- try {
- collection.add(new Object());
- set.addAll(collection);
- fail("should throw UnsupportedOperationException");
- } catch (UnsupportedOperationException e) {
- // expected
- }
- set.remove(testint100.toString());
- assertFalse(tm.containsKey(testint100.toString()));
- assertTrue(tm.containsKey(testint0.toString()));
- Iterator iter = set.iterator();
- iter.next();
- iter.remove();
- assertFalse(tm.containsKey(testint0.toString()));
- collection.add(new Integer(200).toString());
- set.retainAll(collection);
- assertEquals(1, tm.size());
- set.removeAll(collectio…
Large files files are truncated, but you can click here to view the full file