Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   /*
    *  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.mapdb;
  
  import java.util.*;
  
  
  public class BTreeMapTest4 extends junit.framework.TestCase {
  
      protected <K,V> BTreeMap<K,V> newBTreeMap(Map map) {
          BTreeMap ret = DBMaker.newMemoryDB()
                  .cacheDisable()
                  .asyncWriteDisable().transactionDisable().make()
                  .createTreeMap("test").nodeSize(6).make();
          ret.putAll(map);
          return ret;
      }
  
      protected <K,V> BTreeMap<K,V> newBTreeMap(Comparator comp) {
          return DBMaker.newMemoryDB()
                  .cacheDisable()
                  .asyncWriteDisable().transactionDisable().make()
                  .createTreeMap("test").nodeSize(6).comparator(comp).make();
      }
  
      protected static <K,V> BTreeMap<K,V> newBTreeMap() {
          return DBMaker.newMemoryDB()
                  .cacheDisable()
                  .asyncWriteDisable().transactionDisable().make()
                  .getTreeMap("test");
      }
  
      public static class ReversedComparator implements Comparator,Serializable {
          public int compare(Object o1Object o2) {
              return -(((Comparableo1).compareTo(o2));
          }
  
          public boolean equals(Object o1Object o2) {
              return (((Comparableo1).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);
          }
      }
  
  
      BTreeMap tm;
  
      Object objArray[] = new Object[1000];


    

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();
          BTreeMap reversedTreeMap = newBTreeMap(comp);
          assertEquals("TreeMap answered incorrect comparator"reversedTreeMap
                  .comparator().getClass().toString(),comp.getClass().toString());
          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#clear()
 
     public void test_clear() {
         // Test for method void java.util.TreeMap.clear()
         .clear();
         assertEquals("Cleared map returned non-zero size", 0, .size());
     }


    

Tests:
java.util.TreeMap#comparator()
 
     public void test_comparator() {
         // Test for method java.util.Comparator java.util.TreeMap.comparator()\
         Comparator comp = new ReversedComparator();
         BTreeMap reversedTreeMap = newBTreeMap(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".containsKey("95"));
         assertTrue("Returned true for invalid key", !.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"
                 .containsValue([986]));
         assertTrue("Returned true for invalid value", !
                 .containsValue(new Object()));
     }

    

Tests:
java.util.TreeMap#entrySet()
 
     public void test_entrySet() {
         // Test for method java.util.Set java.util.TreeMap.entrySet()
         Set anEntrySet = .entrySet();
         Iterator entrySetIterator = anEntrySet.iterator();
         assertTrue("EntrySet is incorrect size",
                 anEntrySet.size() == .);
         Map.Entry entry;
         while (entrySetIterator.hasNext()) {
             entry = (Map.EntryentrySetIterator.next();
             assertEquals("EntrySet does not contain correct mappings"
                     .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".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 = .;
         .put("Hello"o);
         assertEquals("Failed to get mapping".get("Hello"), o);
         
 		// Test for the same key & same value
 		 = newBTreeMap();
 		Integer key1 = 1;
 		Integer key2 = 2;
 		assertNull(.put(key1o));
 		assertNull(.put(key2o));
 		assertEquals(.get(key1), .get(key2));
 		assertEquals(o.put(key1o2));
 		assertEquals(o2.get(key1));
     }
 
 
     // Regression for ill-behaved collator
     static class IllBehavedCollator extends Collator implements Serializable {
         @Override
         public int compare(String o1String o2) {
             if (o1 == null) {
                 return 0;
             }
             return o1.compareTo(o2);
         }
 
         @Override
         public CollationKey getCollationKey(String string) {
             return null;
         }
 
         @Override
         public int hashCode() {
             return 0;
         }
     }

    

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 = .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
         BTreeMap<IntegerDoublemap = newBTreeMap(
                 new MockComparator());
         map.put(1, 2.1);
         map.put(2, 3.1);
         map.put(3, 4.5);
         map.put(7, 21.3);
 
         SortedMap<IntegerDoublesmap = map.headMap(-1);
         assertEquals(0, smap.size());
 
         Set<IntegerkeySet = smap.keySet();
         assertEquals(0, keySet.size());
 
         Set<Map.Entry<IntegerDouble>> entrySet = smap.entrySet();
         assertEquals(0, entrySet.size());
 
         Collection<DoublevalueCollection = smap.values();
         assertEquals(0, valueCollection.size());
 
 //        // Regression for Harmony-1066
 //        assertTrue(head instanceof Serializable);
 
 
         BTreeMap<StringStringtreemap = newBTreeMap(new IllBehavedCollator());
 //        assertEquals(0, treemap.headMap(null).size());
         
         treemap = newBTreeMap();
 		SortedMap<StringStringheadMap =  treemap.headMap("100");
 		headMap.headMap("100");
 
 	SortedMap<Integer,IntegerintMap,sub;
         int size = 16;
         intMap = newBTreeMap();
         for(int i=0; i<sizei++) {
             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 {
             SortedMap th = t.headMap(null);
             fail("Should throw a NullPointerException");
         } catchNullPointerException npe) {
             // expected
         }
 
         try{
             sub.lastKey();
             fail("java.util.NoSuchElementException should be thrown");
         } catch(java.util.NoSuchElementException e) {
         }
 
         size = 256;
         intMap = newBTreeMap();
         for(int i=0; i<sizei++) {
             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 = .keySet();
         assertTrue("Returned set of incorrect size",
                 ks.size() == .);
         for (int i = 0; i < .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".lastKey().equals(
                 [. - 1].toString()));
         assertNotSame([. - 1].toString(), .lastKey());
 				.headMap("999").lastKey());
 				.tailMap("123").lastKey());
 				"999").lastKey());
     }
 	
 	public void test_lastKey_after_subMap() {
 		tm.put("001""VAL001");
 		tm.put("003""VAL003");
 		tm.put("002""VAL002");
 		SortedMap<StringStringsm = tm;
 		String firstKey = (Stringsm.firstKey();
 		String lastKey="";
 		for (int i = 1; i <= tm.size(); i++) {
 			try{
 				lastKey = (Stringsm.lastKey();
 			}
 			catch(NoSuchElementException excep){
 				fail("NoSuchElementException thrown when there are elements in the map");
 			}
 			sm = sm.subMap(firstKeylastKey);
 		}
 	}

    

Tests:
java.util.TreeMap#put(java.lang.Object, java.lang.Object)
 
         // Test for method java.lang.Object
         // java.util.TreeMap.put(java.lang.Object, java.lang.Object)
         Object o = .;
         .put("Hello"o);
         assertEquals("Failed to put mapping".get("Hello") , o);
 
         // regression for Harmony-780
          = newBTreeMap();
         assertNull(.put(new Object(), new Object()));
         try {
             .put(new Integer(1), new Object());
             fail("should throw ClassCastException");
         } catch (ClassCastException e) {
             // expected
         }
 
          = newBTreeMap();
         assertNull(.put(new Integer(1), new Object()));
         
         try {
 			.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 = newBTreeMap();
 //        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)
         BTreeMap x = newBTreeMap();
         x.putAll();
         assertTrue("Map incorrect size after put"x.size() == .size());
         for (Object element : ) {
             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)
         .remove("990");
         assertTrue("Failed to remove mapping", !.containsKey("990"));
 
     }

    

Tests:
java.util.TreeMap#size()
 
     public void test_size() {
         // Test for method int java.util.TreeMap.size()
         assertEquals("Returned incorrect size", 1000, .size());
 		assertEquals("Returned incorrect size", 447, .headMap("500").size());
 		assertEquals("Returned incorrect size", 1000, .headMap("null").size());
 		assertEquals("Returned incorrect size", 0, .headMap("").size());
 		assertEquals("Returned incorrect size", 448, .headMap("500a").size());
 		assertEquals("Returned incorrect size", 553, .tailMap("500").size());
 		assertEquals("Returned incorrect size", 0, .tailMap("null").size());
 		assertEquals("Returned incorrect size", 1000, .tailMap("").size());
 		assertEquals("Returned incorrect size", 552, .tailMap("500a").size());
 		assertEquals("Returned incorrect size", 111, .subMap("500""600")
 				.size());
 		try {
 			.subMap("null""600");
 			fail("Should throw an IllegalArgumentException");
 		} catch (IllegalArgumentException e) {
 			// expected
 		}
 		assertEquals("Returned incorrect size", 1000, .subMap("""null")
 				.size()); 
     }

    

Tests:
java.util.TreeMap#subMap(java.lang.Object, java.lang.Object)
 
         // Test for method java.util.SortedMap
         // java.util.TreeMap.subMap(java.lang.Object, java.lang.Object)
         SortedMap subMap = .subMap([100].toString(), [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(
                     [counter].toString()).equals([counter]));
         }
 
         try {
             .subMap([9].toString(), [1].toString());
             fail("end key less than start key should throw IllegalArgumentException");
         } catch (IllegalArgumentException e) {
             // Expected
         }
 
         // Regression test for typo in lastKey method
         SortedMap<StringStringmap = newBTreeMap();
         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<StringStringsub = map.subMap("1""3"); //$NON-NLS-1$ //$NON-NLS-2$
         assertEquals("2"sub.lastKey()); //$NON-NLS-1$
         
         BTreeMap t = newBTreeMap();
         try {
 			SortedMap th = t.subMap(null,new Object());
 			fail("Should throw a NullPointerException");
         } catchNullPointerException npe) {
         	// expected
         }
     }
    
    
    

Tests:
java.util.TreeMap#subMap(java.lang.Object, java.lang.Object)
 
     public void test_subMap_Iterator() {
         BTreeMap<StringStringmap = newBTreeMap();
 
         String[] keys = { "1""2""3" };
         String[] values = { "one""two""three" };
         for (int i = 0; i < keys.lengthi++) {
             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<StringStringentry = (Map.Entry<StringString>) iter
                     .next();
             assertTrue(map.containsKey(entry.getKey()));
             assertTrue(map.containsValue(entry.getValue()));
             size++;
         }
         assertEquals(map.size(), size);
 
         Set<StringkeySet = subMap.keySet();
         iter = keySet.iterator();
         size = 0;
         while (iter.hasNext()) {
             String key = (Stringiter.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 = .tailMap([900].toString());
         assertTrue("Returned map of incorrect size : " + tail.size(), tail
                 .size() == (. - 900) + 9);
         for (int i = 900; i < .i++) {
             assertTrue("Map contains incorrect entries"tail
                     .containsValue([i]));
         }
 
 //        // Regression for Harmony-1066
 //        assertTrue(tail instanceof Serializable);
 
 	SortedMap<Integer,IntegerintMap,sub;
         int size = 16;
         intMap = newBTreeMap();
         for(int i=0; i<sizei++) {
             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) {
         }
         
         BTreeMap t = newBTreeMap();
         try {
             SortedMap th = t.tailMap(null);
             fail("Should throw a NullPointerException");
         } catchNullPointerException npe) {
             // expected
         }
 
 
         try{
             sub.lastKey();
             fail("java.util.NoSuchElementException should be thrown");
         } catch(java.util.NoSuchElementException e) {
         }
 
         size = 256;
         intMap = newBTreeMap();
         for(int i=0; i<sizei++) {
             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 = .values();
         vals.iterator();
         assertTrue("Returned collection of incorrect size",
                 vals.size() == .);
         for (Object element : ) {
             assertTrue("Collection contains incorrect elements"vals
                     .contains(element));
         }
         assertEquals(1000, vals.size());
         int j = 0;
         for (Iterator iter = vals.iterator(); iter.hasNext();) {
             Object element = (Objectiter.next();
             j++;
         }
         assertEquals(1000, j);
         
 //        vals = tm.descendingMap().values();
 //        vals.iterator();
         assertTrue("Returned collection of incorrect size",
                 vals.size() == .);
         for (Object element : ) {
             assertTrue("Collection contains incorrect elements"vals
                     .contains(element));
         }
         assertEquals(1000, vals.size());
         j = 0;
         for (Iterator iter = vals.iterator(); iter.hasNext();) {
             Object element = (Objectiter.next();
             j++;
         }
         assertEquals(1000, j);
         
         BTreeMap myTreeMap = newBTreeMap();
         for (int i = 0; i < 100; i++) {
             myTreeMap.put([i], [i]);
         }
         Collection col = myTreeMap.values();
 
         // contains
         assertTrue("UnmodifiableCollectionTest - should contain 0"col
                 .contains(new Integer(0)));
         assertTrue("UnmodifiableCollectionTest - should contain 50"col
                 .contains(new Integer(50)));
         assertTrue("UnmodifiableCollectionTest - should not contain 100", !col
                 .contains(new Integer(100)));
 
         // containsAll
         HashSet<Integerhs = new HashSet<Integer>();
         hs.add(new Integer(0));
         hs.add(new Integer(25));
         hs.add(new Integer(99));
         assertTrue(
                 "UnmodifiableCollectionTest - should contain set of 0, 25, and 99",
                 col.containsAll(hs));
         hs.add(new Integer(100));
         assertTrue(
                 "UnmodifiableCollectionTest - should not contain set of 0, 25, 99 and 100",
                 !col.containsAll(hs));
 
         // isEmpty
         assertTrue("UnmodifiableCollectionTest - should not be empty", !col
                 .isEmpty());
 
         // iterator
         Iterator<Integerit = col.iterator();
         SortedSet<Integerss = new TreeSet<Integer>();
         while (it.hasNext()) {
             ss.add(it.next());
         }
         it = ss.iterator();
         for (int counter = 0; it.hasNext(); counter++) {
             int nextValue = it.next().intValue();
             assertTrue(
                     "UnmodifiableCollectionTest - Iterator returned wrong value.  Wanted: "
                             + counter + " got: " + nextValue,
                     nextValue == counter);
         }
 
         // size
         assertTrue(
                 "UnmodifiableCollectionTest - returned wrong size.  Wanted 100, got: "
                         + col.size(), col.size() == 100);
 
         // toArray
         Object[] objArray;
         objArray = col.toArray();
         for (int counter = 0; it.hasNext(); counter++) {
             assertTrue(
                     "UnmodifiableCollectionTest - toArray returned incorrect array",
                     objArray[counter] == it.next());
         }
 
         // toArray (Object[])
         objArray = new Object[100];
         col.toArray(objArray);
         for (int counter = 0; it.hasNext(); counter++) {
             assertTrue(
                     "UnmodifiableCollectionTest - toArray(Object) filled array incorrectly",
                     objArray[counter] == it.next());
         }
         col.remove(new Integer(0));
         assertTrue(
                 "Removing from the values collection should remove from the original map",
                 !myTreeMap.containsValue(new Integer(0)));
         assertEquals(99, col.size());
         j = 0;
         for (Iterator iter = col.iterator(); iter.hasNext();) {
             Object element = (Objectiter.next();
             j++;
         }
         assertEquals(99, j);
         
     }
    
    

Tests:
java.util.TreeMap the values() method in sub maps
 
     public void test_subMap_values_size() {
         BTreeMap myTreeMap = newBTreeMap();
         for (int i = 0; i < 1000; i++) {
             myTreeMap.put(i[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" + ivals
                     .contains([i]));
         }
         assertEquals(200,vals.toArray().length);
         vals.remove([300]);
         assertTrue(
                 "Removing from the values collection should remove from the original map",
                 !myTreeMap.containsValue([300]));
         assertTrue("Returned collection of incorrect size"vals.size() == 199);
         assertEquals(199,vals.toArray().length);
 
         myTreeMap.put(300, [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 "+ivals
                     .contains([i]));
         }
         assertEquals(400,vals.toArray().length);
         vals.remove([300]);
         assertTrue(
                 "Removing from the values collection should remove from the original map",
                 !myTreeMap.containsValue([300]));
         assertTrue("Returned collection of incorrect size"vals.size() == 399);
         assertEquals(399,vals.toArray().length);
         
         myTreeMap.put(300, [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 "+ivals
                     .contains([i]));
         }
         assertEquals(600,vals.toArray().length);
         vals.remove([600]);
         assertTrue(
                 "Removing from the values collection should remove from the original map",
                 !myTreeMap.containsValue([600]));
         assertTrue("Returned collection of incorrect size"vals.size() == 599);
         assertEquals(599,vals.toArray().length);
         
         
         myTreeMap.put(600, [600]);
         // Test for method values() in subMaps
         vals = myTreeMap.tailMap(401).values();
         assertEquals("Returned collection of incorrect size"vals.size(), 599);
         for (int i = 401; i < 1000; i++) {
             assertTrue("Collection contains incorrect elements "+ivals
                     .contains([i]));
         }
         assertEquals(599,vals.toArray().length);
         vals.remove([600]);
         assertTrue(
                 "Removing from the values collection should remove from the original map",
                 !myTreeMap.containsValue([600]));
         assertTrue("Returned collection of incorrect size"vals.size() == 598);
         assertEquals(598,vals.toArray().length);
         
         myTreeMap.put(600, [600]);
         // Test for method values() in subMaps
         vals = myTreeMap.headMap(401).values();
         assertEquals("Returned collection of incorrect size"vals.size(), 401);
         for (int i = 0; i <= 400; i++) {
             assertTrue("Collection contains incorrect elements "+ivals
                     .contains([i]));
         }
         assertEquals(401,vals.toArray().length);
         vals.remove([300]);
         assertTrue(
                 "Removing from the values collection should remove from the original map",
                 !myTreeMap.containsValue([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() {
         BTreeMap<StringStringmap = newBTreeMap();
 
         String[] keys = { "1""2""3" };
         String[] values = { "one""two""three" };
         for (int i = 0; i < keys.lengthi++) {
             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<StringStringentry = (Map.Entry<StringString>) iter
                     .next();
             assertTrue(map.containsKey(entry.getKey()));
             assertTrue(map.containsValue(entry.getValue()));
             size++;
         }
         assertEquals(map.size(), size);
 
         Set<StringkeySet = subMap.keySet();
         iter = keySet.iterator();
         size = 0;
         while (iter.hasNext()) {
             String key = (Stringiter.next();
             assertTrue(map.containsKey(key));
             size++;
         }
         assertEquals(map.size(), size);
     }


    
 
     public void test_firstEntry() throws Exception {
         Integer testint = new Integer(-1);
         Integer testint10000 = new Integer(-10000);
         Integer testint9999 = new Integer(-9999);
         assertEquals([0].toString(), .firstEntry().getKey());
         assertEquals([0], .firstEntry().getValue());
         .put(testint.toString(), testint);
         assertEquals(testint.toString(), .firstEntry().getKey());
         assertEquals(testint.firstEntry().getValue());
         .put(testint10000.toString(), testint10000);
         assertEquals(testint.toString(), .firstEntry().getKey());
         assertEquals(testint.firstEntry().getValue());
         .put(testint9999.toString(), testint9999);
         assertEquals(testint.toString(), .firstEntry().getKey());
         Entry entry = .firstEntry();
         assertEquals(testintentry.getValue());
         assertEntry(entry);
         .clear();
         assertNull(.firstEntry());
     }

    

Tests:
 
     public void test_lastEntry() throws Exception {
         Integer testint10000 = new Integer(10000);
         Integer testint9999 = new Integer(9999);
         assertEquals([999].toString(), .lastEntry().getKey());
         assertEquals([999], .lastEntry().getValue());
         .put(testint10000.toString(), testint10000);
         assertEquals([999].toString(), .lastEntry().getKey());
         assertEquals([999], .lastEntry().getValue());
         .put(testint9999.toString(), testint9999);
         assertEquals(testint9999.toString(), .lastEntry().getKey());
         Entry entry = .lastEntry();
         assertEquals(testint9999entry.getValue());
         assertEntry(entry);
         .clear();
         assertNull(.lastEntry());
     }

    

Tests:
 
     public void test_pollFirstEntry() throws Exception {
         Integer testint = new Integer(-1);
         Integer testint10000 = new Integer(-10000);
         Integer testint9999 = new Integer(-9999);
         assertEquals([0].toString(), .pollFirstEntry().getKey());
         assertEquals([1], .pollFirstEntry().getValue());
         assertEquals([10], .pollFirstEntry().getValue());
         .put(testint.toString(), testint);
         .put(testint10000.toString(), testint10000);
         assertEquals(testint.toString(), .pollFirstEntry().getKey());
         assertEquals(testint10000.pollFirstEntry().getValue());
         .put(testint9999.toString(), testint9999);
         assertEquals(testint9999.toString(), .pollFirstEntry().getKey());
         Entry entry = .pollFirstEntry();
         assertEntry(entry);
         assertEquals([100], entry.getValue());
         .clear();
         assertNull(.pollFirstEntry());
     }

    

Tests:
 
     public void test_pollLastEntry() throws Exception {
         Integer testint10000 = new Integer(10000);
         Integer testint9999 = new Integer(9999);
         assertEquals([999].toString(), .pollLastEntry().getKey());
         assertEquals([998], .pollLastEntry().getValue());
         assertEquals([997], .pollLastEntry().getValue());
         .put(testint10000.toString(), testint10000);
         assertEquals([996], .pollLastEntry().getValue());
         .put(testint9999.toString(), testint9999);
         assertEquals(testint9999.toString(), .pollLastEntry().getKey());
         Entry entry = .pollLastEntry();
         assertEquals([995], entry.getValue());
         assertEntry(entry);
         .clear();
         assertNull(.pollLastEntry());
     }
 
     public void testLastFirstEntryOnEmpty(){
         .clear();
         assertNull(.firstEntry());
         assertNull(.lastEntry());
     }

    

Tests:
 
     public void test_lowerEntry() throws Exception {
         Integer testint10000 = new Integer(10000);
         Integer testint9999 = new Integer(9999);
         assertEquals([999], .lowerEntry(testint9999.toString())
                 .getValue());
         assertEquals([100], .lowerEntry(testint10000.toString())
                 .getValue());
         .put(testint10000.toString(), testint10000);
         .put(testint9999.toString(), testint9999);
         assertEquals([999], .lowerEntry(testint9999.toString())
                 .getValue());
         Entry entry = .lowerEntry(testint10000.toString());
         assertEquals([100], entry.getValue());
         assertEntry(entry);
         try {
             .lowerEntry(testint10000);
             fail("should throw ClassCastException");
         } catch (ClassCastException e) {
             // expected
         }
         try {
             .lowerEntry(null);
             fail("should throw NullPointerException");
         } catch (NullPointerException e) {
             // expected
         }
         .clear();
         assertNull(.lowerEntry(testint9999.toString()));
 //        assertNull(tm.lowerEntry(null));
     }

    

Tests:
 
     public void test_lowerKey() throws Exception {
         Integer testint10000 = new Integer(10000);
         Integer testint9999 = new Integer(9999);
         assertEquals([999].toString(), .lowerKey(testint9999
                 .toString()));
         assertEquals([100].toString(), .lowerKey(testint10000
                .toString()));
        .put(testint10000.toString(), testint10000);
        .put(testint9999.toString(), testint9999);
        assertEquals([999].toString(), .lowerKey(testint9999
                .toString()));
        assertEquals([100].toString(), .lowerKey(testint10000
                .toString()));
        try {
            .lowerKey(testint10000);
            fail("should throw ClassCastException");
        } catch (ClassCastException e) {
            // expected
        }
        try {
            .lowerKey(null);
            fail("should throw NullPointerException");
        } catch (NullPointerException e) {
            // expected
        }
        .clear();
        assertNull(.lowerKey(testint9999.toString()));
//        assertNull(tm.lowerKey(null));
    }

    

Tests:
    public void test_floorEntry() throws Exception {
        Integer testint10000 = new Integer(10000);
        Integer testint9999 = new Integer(9999);
        assertEquals([999], .floorEntry(testint9999.toString())
                .getValue());
        assertEquals([100], .floorEntry(testint10000.toString())
                .getValue());
        .put(testint10000.toString(), testint10000);
        .put(testint9999.toString(), testint9999);
        assertEquals(testint9999.floorEntry(testint9999.toString())
                .getValue());
        Entry entry = .floorEntry(testint10000.toString());
        assertEquals(testint10000entry.getValue());
        assertEntry(entry);
        try {
            .floorEntry(testint10000);
            fail("should throw ClassCastException");
        } catch (ClassCastException e) {
            // expected
        }
        try {
            .floorEntry(null);
            fail("should throw NullPointerException");
        } catch (NullPointerException e) {
            // expected
        }
        .clear();
        assertNull(.floorEntry(testint9999.toString()));
    }

    

Tests:
    public void test_floorKey() throws Exception {
        Integer testint10000 = new Integer(10000);
        Integer testint9999 = new Integer(9999);
        assertEquals([999].toString(), .floorKey(testint9999
                .toString()));
        assertEquals([100].toString(), .floorKey(testint10000
                .toString()));
        .put(testint10000.toString(), testint10000);
        .put(testint9999.toString(), testint9999);
        assertEquals(testint9999.toString(), 
                .floorKey(testint9999.toString()));
        assertEquals(testint10000.