~pbeaman/akiban-persistit/buffer-pool-warmup-sorted

                + 74);

 

        source = newArray(TYPE_MVV, 0, 0, 0, 0, 0, 0, 0, 1, 0, 2, 0x1, 0x2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 1, 0xA, /* extra */

        final int usedLength = source.length - 5;

        // new version (-1 = MVV type ID)

        assertEquals(MVV.exactRequiredLength(source, 0, usedLength, 3, 3), usedLength + MVV.overheadLength(1) + 3 - 1);

        final int storedLength = storeVersion(target, 0, vh, source, source.length);

 

        assertEquals(source.length + MVV.overheadLength(2), storedLength);

    }

 

    @Test

        final int storedLength = storeVersion(target, targetLength, vh, source, source.length);

 

        assertEquals(targetLength + source.length + MVV.overheadLength(2), storedLength);

    }

 

    @Test

        final int storedLength = storeVersion(target, targetLength, vh2, source, source.length);

 

        assertEquals(targetContentsLength + source.length + MVV.overheadLength(2), storedLength);

    }

 

    @Test

        final byte[] source = { 0xD, 0xE, 0xF };

        final int storedLength = storeVersion(target, targetLength, vh2, source, source.length);

        assertTrue("version existed", (storedLength & STORE_EXISTED_MASK) != 0);

    }

 

    @Test

 

        storedLength &= STORE_LENGTH_MASK;

        assertEquals(targetLength - 1, storedLength);

    }

 

    @Test

        storedLength &= STORE_LENGTH_MASK;

 

        assertEquals(targetLength + 1, storedLength);

    }

 

    @Test

        targetLength = storeVersion(target, targetLength, vh1, source1, source1.length);

        targetLength = storeVersion(target, targetLength, vh2, source2, source2.length);

 

    }

 

    @Test

        int targetLength = 0;

        try {

            targetLength = storeVersion(target, targetLength, vh1, source1, source1.length);

            Assert.fail("Expected success on first store");

        }

 

        int targetLength = 0;

        try {

            targetLength = storeVersion(target, targetLength, vh, source, source.length - 1);

            Assert.fail("Expected success on first store");

        }

 

    @Test

    public void visitUnused() throws PersistitException {

        final byte[] source = {};

        MVV.visitAllVersions(visitor, source, 0, -1);

        assertTrue(visitor.initCalled);

        assertEquals(newVisitorMap(), visitor.versions);

    @Test

    public void visitUndefined() throws PersistitException {

        final byte[] source = {};

        MVV.visitAllVersions(visitor, source, 0, source.length);

        assertTrue(visitor.initCalled);

        assertEquals(newVisitorMap(0, 0, 0), visitor.versions);

    @Test

    public void visitAndFetchByOffsetPrimordial() throws PersistitException {

        final byte[] source = { 0xA, 0xB, 0xC };

        MVV.visitAllVersions(visitor, source, 0, source.length);

        assertTrue(visitor.initCalled);

        assertEquals(newVisitorMap(0, 3, 0), visitor.versions);

                0, 2, 0xD, 0xE, 0, 0, 0, 0, 0, 0, 0, 11, 0, 5, 0x1, 0x2, 0x3, 0x4, 0x5, 0, 0, 0, 0, 0, 0, 0, 127, 0, 0,

                0, 0, 0, 0, 0, 0, 0, 9, 0, 1, 0xA, 0, 1, 2, 3, 4, 5, 6, 7, 0, 3, 0xB, 0xC, 0xD, 0, 0, 0, 0, 0, 0, 0, 3,

                0, 0 };

        MVV.visitAllVersions(visitor, source, 0, source.length);

        assertTrue(visitor.initCalled);

 

            MVV.fetchVersionByOffset(source, source.length, offset, target);

            assertArrayEqualsLen(source, offset, target, length);

        }

 

        final byte fetchtarget[] = new byte[50];

        for (int i = 0; i < VERSION_COUNT; ++i) {

            assertEquals(sources[i].length, fetchedLen);

            assertArrayEqualsLen(sources[i], fetchtarget, sources[i].length);

        }

    // Test helper methods

    //

 

        assert contents.length <= array.length : "Too many values for array";

        for (int i = 0; i < contents.length; ++i) {

            assert value >= 0 && value <= 255 : "Value " + value + " out of byte range at index " + i;

            array[i] = (byte) value;

        }

        return contents.length;

    }

 

        writeArray(array, contents);

        return array;

    }

 

        assertArrayEqualsLen(expected, 0, actual, length);

    }

 

        if (expected.length < length) {

            throw new AssertionError(String.format("Expected array is too short: %d vs %d", actual.length, length));

        }

            throw new AssertionError(String.format("Actual array is too short: %d vs %d", actual.length, length));

        }

        for (int i = 0; i < length; ++i) {

            if (bE != bA) {

                throw new AssertionError(String.format("Arrays differed at element [%d]: expected <%d> but was <%d>",

                        i, bE, bA));

        long length;

        long offset;

 

            this.length = length;

            this.offset = offset;

        }

        }

 

        @Override

            if (this == o)

                return true;

            if (!(o instanceof LengthAndOffset))

                return false;

            return length == that.length && offset == that.offset;

        }

    }

        }

 

        @Override

            versions.put(version, new LengthAndOffset(valueLength, offset));

        }

    }

 

        assertTrue("must be (version,length,offset) triplets", (vals.length % 3) == 0);

        for (int i = 0; i < vals.length; i += 3) {

            outMap.put(vals[i], new LengthAndOffset(vals[i + 1], vals[i + 2]));

        }

     * storeVersion and is likely to get an ArrayIndexOutOfBounds or other

     * undefined behavior if it fails to do so.

     */

        return MVV.storeVersion(target, 0, targetLength, target.length, versionHandle, source, 0, sourceLength);

    }