コード例 #1
0
  /**
   * This case results in a single root leaf filled to capacity.
   *
   * @throws IOException
   */
  public void test_buildOrder10() throws Exception {

    final BTree btree = getProblem1();

    doBuildAndDiscardCache(btree, 10 /* m */);

    /*
     * Verify that we can load the index file and that the metadata
     * associated with the index file is correct (we are only checking those
     * aspects that are easily defined by the test case and not, for
     * example, those aspects that depend on the specifics of the length of
     * serialized nodes or leaves).
     */

    final IndexSegmentStore segStore = new IndexSegmentStore(outFile);

    assertEquals("#nodes", 0, segStore.getCheckpoint().nnodes);
    assertEquals("#leaves", 1, segStore.getCheckpoint().nleaves);
    assertEquals("#entries", 10, segStore.getCheckpoint().nentries);
    assertEquals("height", 0, segStore.getCheckpoint().height);
    assertEquals(segStore.getCheckpoint().addrRoot, segStore.getCheckpoint().addrFirstLeaf);
    assertEquals(segStore.getCheckpoint().addrFirstLeaf, segStore.getCheckpoint().addrLastLeaf);

    final IndexSegment seg = segStore.loadIndexSegment();

    try {

      assertEquals(10, seg.getBranchingFactor());
      assertEquals(0, seg.getHeight());
      assertEquals(1, seg.getLeafCount());
      assertEquals(0, seg.getNodeCount());
      assertEquals(10, seg.getEntryCount());

      final ImmutableLeaf leaf = seg.readLeaf(segStore.getCheckpoint().addrRoot);
      assertEquals("priorAddr", 0L, leaf.getPriorAddr());
      assertEquals("nextAddr", 0L, leaf.getNextAddr());

      final ImmutableLeafCursor itr = seg.newLeafCursor(SeekEnum.First);
      //        if(LRUNexus.INSTANCE!=null)
      //        assertTrue(leaf.getDelegate() == itr.leaf().getDelegate()); // Note: test depends on
      // cache.
      assertNull(itr.prior());
      assertNull(itr.next());

      // test index segment structure.
      dumpIndexSegment(seg);

      /*
       * verify the right keys in the right leaves.
       */
      {
        Leaf root = (Leaf) seg.getRoot();
        assertKeys(new int[] {1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, root);
      }

      /*
       * Verify the total index order.
       */
      assertSameBTree(btree, seg);

    } finally {

      // close so we can delete the backing store.
      seg.close();
    }
  }
コード例 #2
0
  /**
   * This case results in a root node and two leaves. Each leaf is at its minimum capacity (5). This
   * tests an edge case for the algorithm that distributes the keys among the leaves when there
   * would otherwise be an underflow in the last leaf.
   *
   * @throws IOException
   */
  public void test_buildOrder9() throws Exception {

    final BTree btree = getProblem1();

    doBuildAndDiscardCache(btree, 9 /*m*/);

    //        final long commitTime = System.currentTimeMillis();
    //
    //        IndexSegmentBuilder.newInstance(outFile, tmpDir, btree.getEntryCount(), btree
    //                .rangeIterator(), 9/* m */, btree.getIndexMetadata(), commitTime,
    //                true/*compactingMerge*/,bufferNodes).call();

    /*
     * Verify that we can load the index file and that the metadata
     * associated with the index file is correct (we are only checking those
     * aspects that are easily defined by the test case and not, for
     * example, those aspects that depend on the specifics of the length of
     * serialized nodes or leaves).
     */
    final IndexSegmentStore segStore = new IndexSegmentStore(outFile);

    assertEquals("#nodes", 1, segStore.getCheckpoint().nnodes);
    assertEquals("#leaves", 2, segStore.getCheckpoint().nleaves);
    assertEquals("#entries", 10, segStore.getCheckpoint().nentries);
    assertEquals("height", 1, segStore.getCheckpoint().height);
    assertNotSame(segStore.getCheckpoint().addrRoot, segStore.getCheckpoint().addrFirstLeaf);
    assertNotSame(segStore.getCheckpoint().addrFirstLeaf, segStore.getCheckpoint().addrLastLeaf);

    final IndexSegment seg = segStore.loadIndexSegment();

    try {

      assertEquals(9, seg.getBranchingFactor());
      assertEquals(1, seg.getHeight());
      assertEquals(2, seg.getLeafCount());
      assertEquals(1, seg.getNodeCount());
      assertEquals(10, seg.getEntryCount());

      final ImmutableLeaf firstLeaf = seg.readLeaf(segStore.getCheckpoint().addrFirstLeaf);

      assertEquals("priorAddr", 0L, firstLeaf.getPriorAddr());

      assertEquals("nextAddr", segStore.getCheckpoint().addrLastLeaf, firstLeaf.getNextAddr());

      final ImmutableLeaf lastLeaf = seg.readLeaf(segStore.getCheckpoint().addrLastLeaf);

      assertEquals("priorAddr", segStore.getCheckpoint().addrFirstLeaf, lastLeaf.getPriorAddr());

      assertEquals("nextAddr", 0L, lastLeaf.getNextAddr());

      // test forward scan
      {
        final ImmutableLeafCursor itr = seg.newLeafCursor(SeekEnum.First);

        //            if(LRUNexus.INSTANCE!=null)
        //            assertTrue(firstLeaf.getDelegate() == itr.leaf().getDelegate()); // Note: test
        // depends on cache!
        assertNull(itr.prior());

        //            if(LRUNexus.INSTANCE!=null)
        //            assertTrue(lastLeaf.getDelegate() == itr.next().getDelegate()); // Note: test
        // depends on cache!

        //            if(LRUNexus.INSTANCE!=null)
        //            assertTrue(lastLeaf.getDelegate() == itr.leaf().getDelegate()); // Note: test
        // depends on cache!

      }

      /*
       * test reverse scan
       *
       * Note: the scan starts with the last leaf in the key order and then
       * proceeds in reverse key order.
       */
      {
        final ImmutableLeafCursor itr = seg.newLeafCursor(SeekEnum.Last);

        //            if(LRUNexus.INSTANCE!=null)
        //            assertTrue(lastLeaf.getDelegate() == itr.leaf().getDelegate()); // Note: test
        // depends on cache!
        assertNull(itr.next());

        //            if(LRUNexus.INSTANCE!=null)
        //            assertTrue(firstLeaf.getDelegate() == itr.prior().getDelegate()); // Note:
        // test depends on cache!
        //            if(LRUNexus.INSTANCE!=null)
        //            assertTrue(firstLeaf.getDelegate() == itr.leaf().getDelegate()); // Note: test
        // depends on cache!

      }

      // test index segment structure.
      dumpIndexSegment(seg);

      /*
       * Test the tree in detail.
       */
      {
        final Node A = (Node) seg.getRoot();
        final Leaf a = (Leaf) A.getChild(0);
        final Leaf b = (Leaf) A.getChild(1);

        assertKeys(new int[] {6}, A);
        assertEntryCounts(new int[] {5, 5}, A);

        assertKeys(new int[] {1, 2, 3, 4, 5}, a);
        assertKeys(new int[] {6, 7, 8, 9, 10}, b);

        // Note: values are verified by testing the total order.

      }

      /*
       * Verify the total index order.
       */
      assertSameBTree(btree, seg);

    } finally {

      // close so we can delete the backing store.
      seg.close();
    }
  }