private void readCeiling(SortedIndex<TestEntry> rbt, int count) { for (int i = 0; i < count; i++) { rbt.getCeiling(i); } }
/** * Returns the length from the given offset until the beginning of the next index entry. If no such entry exists, or * if the length is greater than maxLength, then maxLength is returned. * * @param startOffset The offset to search from. * @param maxLength The maximum allowed length. * @return The result. */ @GuardedBy("lock") private int getLengthUntilNextEntry(long startOffset, int maxLength) { ReadIndexEntry ceilingEntry = this.indexEntries.getCeiling(startOffset); if (ceilingEntry != null) { maxLength = (int) Math.min(maxLength, ceilingEntry.getStreamSegmentOffset() - startOffset); } return maxLength; }
/** * Tests the getCeiling() method. */ @Test public void testGetCeiling() { final int itemCount = 1000; final int maxKey = itemCount * 10; // Create an index and populate sparsely. val index = createIndex(); val validKeys = populate(index, itemCount, maxKey); validKeys.sort(KEY_COMPARATOR); val validKeysIterator = validKeys.iterator(); Long expectedValue = -1L; for (long testKey = 0; testKey < maxKey; testKey++) { // Since both testKey and validKeysIterator increase with natural ordering, finding the next expected value // is a straightforward call to the iterator next() method. while (expectedValue != null && testKey > expectedValue) { if (validKeysIterator.hasNext()) { expectedValue = validKeysIterator.next(); } else { expectedValue = null; } } val ceilingEntry = index.getCeiling(testKey); Long actualValue = ceilingEntry != null ? ceilingEntry.key() : null; Assert.assertEquals("Unexpected value for getCeiling for key " + testKey, expectedValue, actualValue); } }
/** * Tests various operations on already sorted input. */ @Test public void testSortedInput() { val index = createIndex(); for (int key = 0; key < ITEM_COUNT; key++) { index.put(new TestEntry(key)); } //Get + GetCeiling. for (int key = 0; key < ITEM_COUNT; key++) { Assert.assertEquals("Unexpected value from get() for key " + key, key, (long) index.get(key).key()); Assert.assertEquals("Unexpected value from getCeiling() for key " + key, key, (long) index.getCeiling(key).key()); } // Remove + get. for (long key = 0; key < ITEM_COUNT; key++) { long removedKey = index.remove(key).key(); Assert.assertEquals("Unexpected value from remove(). ", key, removedKey); Assert.assertNull("Unexpected value from get() for removed key " + key, index.get(key)); if (key == ITEM_COUNT - 1) { Assert.assertNull("Unexpected value from getCeiling() for removed key " + key, index.getCeiling(key)); } else { Assert.assertEquals("Unexpected value from getCeiling() for removed key " + key, key + 1, (long) index.getCeiling(key).key()); } } }
/** * Tests the clear() method. */ @Test public void testClear() { val index = createIndex(); val keys = populate(index); Assert.assertNotNull("Unexpected return value for getFirst() on non-empty index.", index.getFirst()); Assert.assertNotNull("Unexpected return value for getLast() on non-empty index.", index.getLast()); index.clear(); Assert.assertEquals("Unexpected size of empty index.", 0, index.size()); Assert.assertNull("Unexpected return value for getFirst() on empty index.", index.getFirst()); Assert.assertNull("Unexpected return value for getLast() on empty index.", index.getLast()); for (long key : keys) { Assert.assertNull("Unexpected value for get() on empty index.", index.get(key)); Assert.assertNull("Unexpected value for getCeiling() on empty index.", index.getCeiling(key)); } }