collectiontest.java

嵌入式数据库Berkeley DB-4.5.20源代码

                readIterator(set, iterator(set), beginKey, endKey);
                if (smap != null) {
                    SortedSet sset = (SortedSet) set;
                    if (beginKey == 1 && endKey >= 1) {
                        readIterator(sset,
                                     iterator(sset.subSet(mapEntry(1),
                                                          mapEntry(2))),
                                     1, 1);
                    }
                    if (beginKey <= 2 && endKey >= 2) {
                        readIterator(sset,
                                     iterator(sset.subSet(mapEntry(2),
                                                          mapEntry(3))),
                                     2, 2);
                    }
                    if (beginKey <= endKey) {
                        readIterator(sset,
                                     iterator(sset.subSet
                                                (mapEntry(endKey),
                                                 mapEntry(endKey + 1))),
                                     endKey, endKey);
                    }
                    if (isSubMap()) {
                        if (beginKey <= endKey) {
                            if (rangeType != TAIL) {
                                try {
                                    sset.subSet(mapEntry(endKey + 1),
                                                mapEntry(endKey + 2));
                                    fail();
                                } catch (IllegalArgumentException e) {}
                            }
                            if (rangeType != HEAD) {
                                try {
                                    sset.subSet(mapEntry(0),
                                                mapEntry(1));
                                    fail();
                                } catch (IllegalArgumentException e) {}
                            }
                        }
                    } else {
                        readIterator(sset,
                                     iterator(sset.subSet
                                                (mapEntry(endKey + 1),
                                                 mapEntry(endKey + 2))),
                                     endKey, endKey - 1);
                        readIterator(sset,
                                     iterator(sset.subSet(mapEntry(0),
                                                          mapEntry(1))),
                                     0, -1);
                    }
                }

                // keySet

                set = map.keySet();
                assertNotNull(set.toString());
                assertEquals(beginKey > endKey, set.isEmpty());
                iter = iterator(set);
                try {
                    for (int i = beginKey; i <= endKey; i += 1) {
                        assertTrue(iter.hasNext());
                        Long key = (Long) iter.next();
                        assertTrue(set.contains(key));
                        Object val = map.get(key);
                        if (map instanceof SortedMap) {
                            assertEquals(key, makeKey(i));
                        }
                        assertEquals(intKey(key), intVal(val));
                    }
                    assertTrue("" + beginKey + ' ' + endKey, !iter.hasNext());
                } finally {
                    StoredIterator.close(iter);
                }
                Long[] keys = (Long[]) set.toArray(new Long[0]);
                assertNotNull(keys);
                assertEquals(endKey - beginKey + 1, keys.length);
                for (int i = beginKey; i <= endKey; i += 1) {
                    Long key = keys[i - beginKey];
                    assertNotNull(key);
                    if (map instanceof SortedMap) {
                        assertEquals(makeKey(i), key);
                    }
                }
                readIterator(set, iterator(set), beginKey, endKey);

                // values

                Collection coll = map.values();
                assertNotNull(coll.toString());
                assertEquals(beginKey > endKey, coll.isEmpty());
                iter = iterator(coll);
                try {
                    for (int i = beginKey; i <= endKey; i += 1) {
                        assertTrue(iter.hasNext());
                        Object val = iter.next();
                        if (map instanceof SortedMap) {
                            assertEquals(makeVal(i), val);
                        }
                    }
                    assertTrue(!iter.hasNext());
                } finally {
                    StoredIterator.close(iter);
                }
                Object[] values = coll.toArray();
                assertNotNull(values);
                assertEquals(endKey - beginKey + 1, values.length);
                for (int i = beginKey; i <= endKey; i += 1) {
                    Object val = values[i - beginKey];
                    assertNotNull(val);
                    if (map instanceof SortedMap) {
                        assertEquals(makeVal(i), val);
                    }
                }
                readIterator(coll, iterator(coll), beginKey, endKey);

                // list

                if (list != null) {
                    assertNotNull(list.toString());
                    assertEquals(beginKey > endKey, list.isEmpty());
                    for (int i = beginKey; i <= endKey; i += 1) {
                        int idx = i - beginKey;
                        Object val = list.get(idx);
                        assertEquals(makeVal(i), val);
                        assertTrue(list.contains(val));
                        assertEquals(idx, list.indexOf(val));
                        assertEquals(idx, list.lastIndexOf(val));
                    }
                    ListIterator li = (ListIterator) iterator(list);
                    try {
                        for (int i = beginKey; i <= endKey; i += 1) {
                            int idx = i - beginKey;
                            assertTrue(li.hasNext());
                            assertEquals(idx, li.nextIndex());
                            Object val = li.next();
                            assertEquals(makeVal(i), val);
                            assertEquals(idx, li.previousIndex());
                        }
                        assertTrue(!li.hasNext());
                    } finally {
                        StoredIterator.close(li);
                    }
                    if (beginKey < endKey) {
                        li = list.listIterator(1);
                        try {
                            for (int i = beginKey + 1; i <= endKey; i += 1) {
                                int idx = i - beginKey;
                                assertTrue(li.hasNext());
                                assertEquals(idx, li.nextIndex());
                                Object val = li.next();
                                assertEquals(makeVal(i), val);
                                assertEquals(idx, li.previousIndex());
                            }
                            assertTrue(!li.hasNext());
                        } finally {
                            StoredIterator.close(li);
                        }
                    }
                    values = list.toArray();
                    assertNotNull(values);
                    assertEquals(endKey - beginKey + 1, values.length);
                    for (int i = beginKey; i <= endKey; i += 1) {
                        Object val = values[i - beginKey];
                        assertNotNull(val);
                        assertEquals(makeVal(i), val);
                    }
                    readIterator(list, iterator(list), beginKey, endKey);
                }

                // first/last

                if (smap != null) {
                    if (beginKey <= endKey &&
                        beginKey >= 1 && beginKey <= maxKey) {
                        assertEquals(makeKey(beginKey),
                                     smap.firstKey());
                        assertEquals(makeKey(beginKey),
                                     ((SortedSet) smap.keySet()).first());
                        Object entry = ((SortedSet) smap.entrySet()).first();
                        assertEquals(makeKey(beginKey),
                                     ((Map.Entry) entry).getKey());
                        if (smap.values() instanceof SortedSet) {
                            assertEquals(makeVal(beginKey),
                                         ((SortedSet) smap.values()).first());
                        }
                    } else {
                        assertNull(smap.firstKey());
                        assertNull(((SortedSet) smap.keySet()).first());
                        assertNull(((SortedSet) smap.entrySet()).first());
                        if (smap.values() instanceof SortedSet) {
                            assertNull(((SortedSet) smap.values()).first());
                        }
                    }
                    if (beginKey <= endKey &&
                        endKey >= 1 && endKey <= maxKey) {
                        assertEquals(makeKey(endKey),
                                     smap.lastKey());
                        assertEquals(makeKey(endKey),
                                     ((SortedSet) smap.keySet()).last());
                        Object entry = ((SortedSet) smap.entrySet()).last();
                        assertEquals(makeKey(endKey),
                                     ((Map.Entry) entry).getKey());
                        if (smap.values() instanceof SortedSet) {
                            assertEquals(makeVal(endKey),
                                         ((SortedSet) smap.values()).last());
                        }
                    } else {
                        assertNull(smap.lastKey());
                        assertNull(((SortedSet) smap.keySet()).last());
                        assertNull(((SortedSet) smap.entrySet()).last());
                        if (smap.values() instanceof SortedSet) {
                            assertNull(((SortedSet) smap.values()).last());
                        }
                    }
                }
            }
        });
    }

    void readEven()
        throws Exception {

        readRunner.run(new TransactionWorker() {
            public void doWork() throws Exception {
                int readBegin = ((beginKey & 1) != 0) ?
                                    (beginKey + 1) : beginKey;
                int readEnd = ((endKey & 1) != 0) ?  (endKey - 1) : endKey;
                int readIncr = 2;

                // map

                for (int i = beginKey; i <= endKey; i += 1) {
                    Long key = makeKey(i);
                    if ((i & 1) == 0) {
                        Object val = map.get(key);
                        assertEquals(makeVal(i), val);
                        assertTrue(map.containsKey(key));
                        assertTrue(map.containsValue(val));
                        assertTrue(map.keySet().contains(key));
                        assertTrue(map.values().contains(val));
                        assertTrue(map.duplicates(key).contains(val));
                        checkDupsSize(1, map.duplicates(key));
                    } else {
                        Object val = makeVal(i);
                        assertTrue(!map.containsKey(key));
                        assertTrue(!map.containsValue(val));
                        assertTrue(!map.keySet().contains(key));
                        assertTrue(!map.values().contains(val));
                        assertTrue(!map.duplicates(key).contains(val));
                        checkDupsSize(0, map.duplicates(key));
                    }
                }

                // entrySet

                Set set = map.entrySet();
                assertEquals(beginKey > endKey, set.isEmpty());
                Iterator iter = iterator(set);
                try {
                    for (int i = readBegin; i <= readEnd; i += readIncr) {
                        assertTrue(iter.hasNext());
                        Map.Entry entry = (Map.Entry) iter.next();
                        Long key = (Long) entry.getKey();
                        Object val = entry.getValue();
                        if (map instanceof SortedMap) {
                            assertEquals(intKey(key), i);
                        }
                        assertEquals(intKey(key), intVal(val));
                        assertTrue(set.contains(entry));
                    }
                    assertTrue(!iter.hasNext());
                } finally {
                    StoredIterator.close(iter);
                }

                // keySet

                set = map.keySet();
                assertEquals(beginKey > endKey, set.isEmpty());
                iter = iterator(set);
                try {
                    for (int i = readBegin; i <= readEnd; i += readIncr) {
                        assertTrue(iter.hasNext());
                        Long key = (Long) iter.next();
                        assertTrue(set.contains(key));
                        Object val = map.get(key);
                        if (map instanceof SortedMap) {
                            assertEquals(key, makeKey(i));
                        }
                        assertEquals(intKey(key), intVal(val));
                    }
                    assertTrue(!iter.hasNext());
                } finally {
                    StoredIterator.close(iter);
                }

                // values

                Collection coll = map.values();
                assertEquals(beginKey > endKey, coll.isEmpty());
                iter = iterator(coll);
                try {
                    for (int i = readBegin; i <= readEnd; i += readIncr) {
                        assertTrue(iter.hasNext());
                        Object val = iter.next();
                        if (map instanceof SortedMap) {
                            assertEquals(makeVal(i), val);
                        }
                    }
                    assertTrue(!iter.hasNext());
                } finally {
                    StoredIterator.close(iter);
                }


                // list not used since keys may not be renumbered for this
                // method to work in general

                // first/last

                if (smap != null) {
                    if (readBegin <= readEnd &&
                        readBegin >= 1 && readBegin <= maxKey) {
                        assertEquals(makeKey(readBegin),
                                     smap.firstKey());
                        assertEquals(makeKey(readBegin),
                                     ((SortedSet) smap.keySet()).first());
                        Object entry = ((SortedSet) smap.entrySet()).first();
                        assertEquals(makeKey(readBegin),
                                     ((Map.Entry) entry).getKey());
                        if (smap.values() instanceof SortedSet) {
                            assertEquals(makeVal(readBegin),
                                         ((SortedSet) smap.values()).first());
                        }
                    } else {
                        assertNull(smap.firstKey());
                        assertNull(((SortedSet) smap.keySet()).first());
                        assertNull(((SortedSet) smap.entrySet()).first());
                        if (smap.values() instanceof SortedSet) {
                            assertNull(((SortedSet) smap.values()).first());