collectiontest.java

berkeleyDB,强大的嵌入式数据,多个数据库的内核

        throws Exception {

        writeRunner.run(new TransactionWorker() {
            public void doWork() throws Exception {
                // add using Map.put()
                for (int i = beginKey; i <= endKey; i += 2) {
                    Long key = makeKey(i);
                    Object val = makeVal(i);
                    assertNull(imap.get(key));
                    assertNull(imap.put(key, val));
                    assertEquals(val, imap.get(key));
                    assertTrue(imap.duplicates(key).contains(val));
                    checkDupsSize(1, imap.duplicates(key));
                    if (isEntityBinding) {
                        assertTrue(!imap.values().add(val));
                    }
                    if (!imap.areDuplicatesAllowed()) {
                        assertEquals(val, imap.put(key, val));
                    }
                }
            }
        });
    }

    void addOddEntity()
        throws Exception {

        writeRunner.run(new TransactionWorker() {
            public void doWork() throws Exception {
                // add using Map.values().add()
                for (int i = beginKey; i <= endKey; i += 2) {
                    Long key = makeKey(i);
                    Object val = makeVal(i);
                    assertNull(imap.get(key));
                    assertTrue(!imap.values().contains(val));
                    assertTrue(imap.values().add(val));
                    assertEquals(val, imap.get(key));
                    assertTrue(imap.values().contains(val));
                    assertTrue(imap.duplicates(key).contains(val));
                    checkDupsSize(1, imap.duplicates(key));
                    if (isEntityBinding) {
                        assertTrue(!imap.values().add(val));
                    }
                }
            }
        });
    }

    void addOddDup()
        throws Exception {

        writeRunner.run(new TransactionWorker() {
            public void doWork() throws Exception {
                // add using Map.duplicates().add()
                for (int i = beginKey; i <= endKey; i += 2) {
                    Long key = makeKey(i);
                    Object val = makeVal(i);
                    assertNull(imap.get(key));
                    assertTrue(!imap.values().contains(val));
                    assertTrue(imap.duplicates(key).add(val));
                    assertEquals(val, imap.get(key));
                    assertTrue(imap.values().contains(val));
                    assertTrue(imap.duplicates(key).contains(val));
                    checkDupsSize(1, imap.duplicates(key));
                    assertTrue(!imap.duplicates(key).add(val));
                    if (isEntityBinding) {
                        assertTrue(!imap.values().add(val));
                    }
                }
            }
        });
    }

    void addOddList()
        throws Exception {

        writeRunner.run(new TransactionWorker() {
            public void doWork() throws Exception {
                for (int i = beginKey; i <= endKey; i += 2) {
                    int idx = i - beginKey;
                    Object val = makeVal(i);
                    assertTrue(!list.contains(val));
                    assertTrue(!val.equals(list.get(idx)));
                    list.add(idx, val);
                    assertTrue(list.contains(val));
                    assertEquals(val, list.get(idx));
                }
            }
        });
    }

    void addAllList()
        throws Exception {

        writeRunner.run(new TransactionWorker() {
            public void doWork() throws Exception {
                for (int i = beginKey; i <= endKey; i += 1) {
                    int idx = i - beginKey;
                    Object val = makeVal(i);
                    assertTrue(!list.contains(val));
                    assertTrue(list.add(val));
                    assertTrue(list.contains(val));
                    assertEquals(val, list.get(idx));
                }
            }
        });
    }

    void removeAllList()
        throws Exception {

        writeRunner.run(new TransactionWorker() {
            public void doWork() throws Exception {
                assertTrue(!list.isEmpty());
                list.clear();
                assertTrue(list.isEmpty());
                for (int i = beginKey; i <= endKey; i += 1) {
                    int idx = i - beginKey;
                    Object val = makeVal(i);
                    assertNull(list.get(idx));
                }
            }
        });
    }

    void testIterAddList()
        throws Exception {

        writeIterRunner.run(new TransactionWorker() {
            public void doWork() throws Exception {
                ListIterator i = list.listIterator();
                try {
                    assertTrue(!i.hasNext());
                    i.add(makeVal(3));
                    assertTrue(!i.hasNext());
                    assertTrue(i.hasPrevious());
                    assertEquals(3, intVal(i.previous()));

                    i.add(makeVal(1));
                    assertTrue(i.hasPrevious());
                    assertTrue(i.hasNext());
                    assertEquals(1, intVal(i.previous()));
                    assertTrue(i.hasNext());
                    assertEquals(1, intVal(i.next()));
                    assertTrue(i.hasNext());
                    assertEquals(3, intVal(i.next()));
                    assertEquals(3, intVal(i.previous()));

                    assertTrue(i.hasNext());
                    i.add(makeVal(2));
                    assertTrue(i.hasNext());
                    assertTrue(i.hasPrevious());
                    assertEquals(2, intVal(i.previous()));
                    assertTrue(i.hasNext());
                    assertEquals(2, intVal(i.next()));
                    assertTrue(i.hasNext());
                    assertEquals(3, intVal(i.next()));

                    assertTrue(!i.hasNext());
                    i.add(makeVal(4));
                    i.add(makeVal(5));
                    assertTrue(!i.hasNext());
                    assertEquals(5, intVal(i.previous()));
                    assertEquals(4, intVal(i.previous()));
                    assertEquals(3, intVal(i.previous()));
                    assertEquals(2, intVal(i.previous()));
                    assertEquals(1, intVal(i.previous()));
                    assertTrue(!i.hasPrevious());
                } finally {
                    StoredIterator.close(i);
                }
            }
        });
    }

    void testIterAddDuplicates()
        throws Exception {

        writeIterRunner.run(new TransactionWorker() {
            public void doWork() throws Exception {
                assertNull(imap.put(makeKey(1), makeVal(1)));
                ListIterator i =
                    (ListIterator) imap.duplicates(makeKey(1)).iterator();
                try {
                    if (imap.areDuplicatesOrdered()) {
                        i.add(makeVal(1, 4));
                        i.add(makeVal(1, 2));
                        i.add(makeVal(1, 3));
                        while (i.hasPrevious()) i.previous();
                        assertEquals(1, intVal(i.next()));
                        assertEquals(2, intVal(i.next()));
                        assertEquals(3, intVal(i.next()));
                        assertEquals(4, intVal(i.next()));
                        assertTrue(!i.hasNext());
                    } else {
                        assertEquals(1, intVal(i.next()));
                        i.add(makeVal(1, 2));
                        i.add(makeVal(1, 3));
                        assertTrue(!i.hasNext());
                        assertTrue(i.hasPrevious());
                        assertEquals(3, intVal(i.previous()));
                        assertEquals(2, intVal(i.previous()));
                        assertEquals(1, intVal(i.previous()));
                        assertTrue(!i.hasPrevious());
                        i.add(makeVal(1, 4));
                        i.add(makeVal(1, 5));
                        assertTrue(i.hasNext());
                        assertEquals(5, intVal(i.previous()));
                        assertEquals(4, intVal(i.previous()));
                        assertTrue(!i.hasPrevious());
                        assertEquals(4, intVal(i.next()));
                        assertEquals(5, intVal(i.next()));
                        assertEquals(1, intVal(i.next()));
                        assertEquals(2, intVal(i.next()));
                        assertEquals(3, intVal(i.next()));
                        assertTrue(!i.hasNext());
                    }
                } finally {
                    StoredIterator.close(i);
                }
            }
        });
    }

    void readAll()
        throws Exception {

        readRunner.run(new TransactionWorker() {
            public void doWork() throws Exception {
                // map

                assertNotNull(map.toString());
                for (int i = beginKey; i <= endKey; i += 1) {
                    Long key = makeKey(i);
                    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));
                }
                assertNull(map.get(makeKey(-1)));
                assertNull(map.get(makeKey(0)));
                assertNull(map.get(makeKey(beginKey - 1)));
                assertNull(map.get(makeKey(endKey + 1)));
                checkDupsSize(0, map.duplicates(makeKey(-1)));
                checkDupsSize(0, map.duplicates(makeKey(0)));
                checkDupsSize(0, map.duplicates(makeKey(beginKey - 1)));
                checkDupsSize(0, map.duplicates(makeKey(endKey + 1)));

                // entrySet

                Set set = map.entrySet();
                assertNotNull(set.toString());
                assertEquals(beginKey > endKey, set.isEmpty());
                Iterator iter = set.iterator();
                try {
                    for (int i = beginKey; i <= endKey; i += 1) {
                        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);
                }
                Map.Entry[] entries =
                    (Map.Entry[]) set.toArray(new Map.Entry[0]);
                assertNotNull(entries);
                assertEquals(endKey - beginKey + 1, entries.length);
                for (int i = beginKey; i <= endKey; i += 1) {
                    Map.Entry entry = entries[i - beginKey];
                    assertNotNull(entry);
                    if (map instanceof SortedMap) {
                        assertEquals(makeKey(i), entry.getKey());
                        assertEquals(makeVal(i), entry.getValue());
                    }
                }
                readIterator(set, set.iterator(), beginKey, endKey);
                if (smap != null) {
                    SortedSet sset = (SortedSet) set;
                    if (beginKey == 1 && endKey >= 1) {
                        readIterator(sset, sset.subSet(mapEntry(1),
                                                 mapEntry(2))
                                                 .iterator(), 1, 1);
                    }
                    if (beginKey <= 2 && endKey >= 2) {
                        readIterator(sset, sset.subSet(mapEntry(2),
                                                 mapEntry(3))
                                                 .iterator(), 2, 2);
                    }
                    if (beginKey <= endKey) {
                        readIterator(sset, sset.subSet(
                                            mapEntry(endKey),
                                            mapEntry(endKey + 1))
                                            .iterator(),
                                            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, sset.subSet(
                                            mapEntry(endKey + 1),
                                            mapEntry(endKey + 2))
                                            .iterator(),
                                            endKey, endKey - 1);
                        readIterator(sset, sset.subSet(mapEntry(0),
                                                 mapEntry(1))
                                                 .iterator(),
                                                 0, -1);
                    }
                }

                // keySet