Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package org.mapdb;
  
  import java.util.*;
This code comes from GoogleCollections, was modified for JDBM by Jan Kotek Tests representing the contract of java.util.SortedMap. Concrete subclasses of this base class test conformance of concrete java.util.SortedMap subclasses to that contract.

Author(s):
Jared Levy
 
 public class BTreeMapTest3
         extends ConcurrentMapInterfaceTest<IntegerString> {
 
     public BTreeMapTest3() {
         super(falsefalsetruetruetruetruefalse);
     }
 
 
     @Override
         return -100;
     }
 
     @Override
         return "XYZ";
     }
 
     @Override
         return "ASD";
     }
 
     @Override
         return DBMaker.newMemoryDB().make().getTreeMap("test");
     }
 
     @Override
         ConcurrentNavigableMap<IntegerStringmap = makeEmptyMap();
         for (int i = 0; i < 100; i++){
             if(i%11==0||i%7==0) continue;
 
             map.put(i"aa" + i);
         }
         return map;
     }
     @Override
         try {
             return makePopulatedMap();
         } catch (UnsupportedOperationException e) {
             return makeEmptyMap();
         }
     }
 
     @SuppressWarnings({ "unchecked""rawtypes" }) // Needed for null comparator
     public void testOrdering() {
         final SortedMap<IntegerStringmap;
         try {
             map = makePopulatedMap();
         } catch (UnsupportedOperationException e) {
             return;
         }
         Iterator<Integeriterator = map.keySet().iterator();
         Integer prior = iterator.next();
         Comparator<? super Integercomparator = map.comparator();
         while (iterator.hasNext()) {
             Integer current = iterator.next();
             if (comparator == null) {
                 Comparable comparable = (Comparableprior;
                 assertTrue(comparable.compareTo(current) < 0);
             } else {
                 assertTrue(map.comparator().compare(priorcurrent) < 0);
             }
             current = prior;
         }
     }
 
 
 
     public void testFirstKeyNonEmpty() {
         final SortedMap<IntegerStringmap;
         try {
             map = makePopulatedMap();
         } catch (UnsupportedOperationException e) {
             return;
         }
         Integer expected = map.keySet().iterator().next();
         assertEquals(expectedmap.firstKey());
         assertInvariants(map);
     }
 
    public void testLastKeyNonEmpty() {
        final SortedMap<IntegerStringmap;
        try {
            map = makePopulatedMap();
        } catch (UnsupportedOperationException e) {
            return;
        }
        Integer expected = null;
        for (Integer key : map.keySet()) {
            expected = key;
        }
        assertEquals(expectedmap.lastKey());
        assertInvariants(map);
    }
    private static <E> List<E> toList(Collection<E> collection) {
        return new ArrayList<E>(collection);
    }
    private static <E> List<E> subListSnapshot(
            List<E> listint fromIndexint toIndex) {
        List<E> subList = new ArrayList<E>();
        for (int i = fromIndexi < toIndexi++) {
            subList.add(list.get(i));
        }
        return Collections.unmodifiableList(subList);
    }
    public void testHeadMap() {
        final NavigableMap<IntegerStringmap;
        try {
            map = makeEitherMap();
        } catch (UnsupportedOperationException e) {
            return;
        }
        List<Map.Entry<IntegerString>> list = toList(map.entrySet());
        for (int i = 0; i < list.size(); i++) {
            List<Map.Entry<IntegerString>> expected = subListSnapshot(list, 0, i);
            SortedMap<IntegerStringheadMap = map.headMap(list.get(i).getKey());
            assertEquals(expectedtoList(headMap.entrySet()));
        }
        for (int i = 0; i < list.size(); i++) {
            List<Map.Entry<IntegerString>> expected = subListSnapshot(list, 0, i+1);
            SortedMap<IntegerStringheadMap = map.headMap(list.get(i).getKey(),true);
            assertEquals(expectedtoList(headMap.entrySet()));
        }
        for (int i = 0; i < list.size(); i++) {
            List<Map.Entry<IntegerString>> expected = subListSnapshot(list, 0, i);
            SortedMap<IntegerStringheadMap = map.headMap(list.get(i).getKey(),false);
            assertEquals(expectedtoList(headMap.entrySet()));
        }
    }
    public void testTailMap() {
        final NavigableMap<IntegerStringmap;
        try {
            map = makeEitherMap();
        } catch (UnsupportedOperationException e) {
            return;
        }
        List<Map.Entry<IntegerString>> list = toList(map.entrySet());
        for (int i = 0; i < list.size(); i++) {
            List<Map.Entry<IntegerString>> expected = subListSnapshot(listilist.size());
            SortedMap<IntegerStringtailMap = map.tailMap(list.get(i).getKey());
            assertEquals(expectedtoList(tailMap.entrySet()));
        }
        for (int i = 0; i < list.size(); i++) {
            List<Map.Entry<IntegerString>> expected = subListSnapshot(listilist.size());
            SortedMap<IntegerStringtailMap = map.tailMap(list.get(i).getKey(),true);
            assertEquals(expectedtoList(tailMap.entrySet()));
        }
        for (int i = 0; i < list.size(); i++) {
            List<Map.Entry<IntegerString>> expected = subListSnapshot(listi+1, list.size());
            SortedMap<IntegerStringtailMap = map.tailMap(list.get(i).getKey(),false);
            assertEquals(expectedtoList(tailMap.entrySet()));
        }
    }
    public void testSubMap() {
        final NavigableMap<IntegerStringmap;
        try {
            map = makeEitherMap();
        } catch (UnsupportedOperationException e) {
            return;
        }
        List<Map.Entry<IntegerString>> list = toList(map.entrySet());
        for (int i = 0; i < list.size(); i++) {
            for (int j = ij < list.size(); j++) {
                List<Map.Entry<IntegerString>> expected = subListSnapshot(listij);
                SortedMap<IntegerStringsubMap
                        = map.subMap(list.get(i).getKey(), list.get(j).getKey());
                assertEquals(expectedtoList(subMap.entrySet()));
                assertEquals(expected.size(), subMap.size());
                assertEquals(expected.size(), subMap.keySet().size());
                assertEquals(expected.size(), subMap.entrySet().size());
                assertEquals(expected.size(), subMap.values().size());
            }
        }
        for (int i = 0; i < list.size(); i++) {
            for (int j = ij < list.size(); j++) {
                List<Map.Entry<IntegerString>> expected = subListSnapshot(listij+1);
                SortedMap<IntegerStringsubMap
                        = map.subMap(list.get(i).getKey(), truelist.get(j).getKey(), true);
                assertEquals(expectedtoList(subMap.entrySet()));
                assertEquals(expected.size(), subMap.size());
                assertEquals(expected.size(), subMap.keySet().size());
                assertEquals(expected.size(), subMap.entrySet().size());
                assertEquals(expected.size(), subMap.values().size());
            }
        }
        for (int i = 0; i < list.size(); i++) {
            for (int j = ij < list.size(); j++) {
                List<Map.Entry<IntegerString>> expected = subListSnapshot(listi+1, j);
                SortedMap<IntegerStringsubMap
                        = map.subMap(list.get(i).getKey(), falselist.get(j).getKey(), false);
                assertEquals(expectedtoList(subMap.entrySet()));
                assertEquals(expected.size(), subMap.size());
                assertEquals(expected.size(), subMap.keySet().size());
                assertEquals(expected.size(), subMap.entrySet().size());
                assertEquals(expected.size(), subMap.values().size());
            }
        }
    }
    public void testSubMapIllegal() {
        final SortedMap<IntegerStringmap;
        try {
            map = makePopulatedMap();
        } catch (UnsupportedOperationException e) {
            return;
        }
        if (map.size() < 2) {
            return;
        }
        Iterator<Integeriterator = map.keySet().iterator();
        Integer first = iterator.next();
        Integer second = iterator.next();
        try {
            map.subMap(secondfirst);
            fail("Expected IllegalArgumentException");
        } catch (IllegalArgumentException expected) {
        }
    }
New to GrepCode? Check out our FAQ X