protected <T> void assertBlockFilteredPositions(T[] expectedValues, Block block, Supplier<BlockBuilder> newBlockBuilder, int... positions) { Block filteredBlock = block.copyPositions(positions, 0, positions.length); T[] filteredExpectedValues = filter(expectedValues, positions); assertEquals(filteredBlock.getPositionCount(), positions.length); assertBlock(filteredBlock, newBlockBuilder, filteredExpectedValues); }
private <T> void assertBlockPositions(Block block, Supplier<BlockBuilder> newBlockBuilder, T[] expectedValues) { assertEquals(block.getPositionCount(), expectedValues.length); for (int position = 0; position < block.getPositionCount(); position++) { assertBlockPosition(block, newBlockBuilder, position, expectedValues[position], expectedValues.getClass().getComponentType()); } }
protected <T> void assertBlock(Block block, Supplier<BlockBuilder> newBlockBuilder, T[] expectedValues) { assertBlockPositions(block, newBlockBuilder, expectedValues); assertBlockPositions(copyBlockViaBlockSerde(block), newBlockBuilder, expectedValues); assertBlockPositions(copyBlockViaWritePositionTo(block, newBlockBuilder), newBlockBuilder, expectedValues); if (expectedValues.getClass().getComponentType().isArray() || expectedValues.getClass().getComponentType() == List.class || expectedValues.getClass().getComponentType() == Map.class) { assertBlockPositions(copyBlockViaWriteStructure(block, newBlockBuilder), newBlockBuilder, expectedValues); } assertBlockSize(block); assertRetainedSize(block); try { block.isNull(-1); fail("expected IllegalArgumentException"); } catch (IllegalArgumentException expected) { } try { block.isNull(block.getPositionCount()); fail("expected IllegalArgumentException"); } catch (IllegalArgumentException expected) { } }
protected static void testCompactBlock(Block block) { assertCompact(block); testCopyRegionCompactness(block); }
Slice expectedSliceValue = (Slice) expectedValue; if (isByteAccessSupported()) { for (int offset = 0; offset <= expectedSliceValue.length() - SIZE_OF_BYTE; offset++) { assertEquals(block.getByte(position, offset), expectedSliceValue.getByte(offset)); if (isShortAccessSupported()) { for (int offset = 0; offset <= expectedSliceValue.length() - SIZE_OF_SHORT; offset++) { assertEquals(block.getShort(position, offset), expectedSliceValue.getShort(offset)); if (isIntAccessSupported()) { for (int offset = 0; offset <= expectedSliceValue.length() - SIZE_OF_INT; offset++) { assertEquals(block.getInt(position, offset), expectedSliceValue.getInt(offset)); if (isLongAccessSupported()) { for (int offset = 0; offset <= expectedSliceValue.length() - SIZE_OF_LONG; offset++) { assertEquals(block.getLong(position, offset), expectedSliceValue.getLong(offset)); if (isSliceAccessSupported()) { assertEquals(block.getSliceLength(position), expectedSliceValue.length()); assertSlicePosition(block, position, expectedSliceValue); assertEquals(actual.getPositionCount(), expected.length); for (int i = 0; i < expected.length; i++) { assertPositionValue(actual, i, expected[i]);
Block expectedBlock = toSingeValuedBlock(expectedSliceValue); Slice greaterSlice = createGreaterValue(expectedSliceValue, offset, 3); assertTrue(block.bytesCompare(position, offset, 3, greaterSlice, 0, greaterSlice.length()) < 0); assertEquals(actual.getPositionCount(), expected.length); for (int i = 0; i < expected.length; i++) { assertPositionValue(actual, i, expected[i]);
protected <T> void assertBlockPosition(Block block, Supplier<BlockBuilder> newBlockBuilder, int position, T expectedValue, Class<?> expectedValueType) { assertPositionValue(block, position, expectedValue); assertPositionValue(block.getSingleValueBlock(position), 0, expectedValue); assertPositionValue(block.getRegion(position, 1), 0, expectedValue); assertPositionValue(block.getRegion(0, position + 1), position, expectedValue); assertPositionValue(block.getRegion(position, block.getPositionCount() - position), 0, expectedValue); assertPositionValue(copyBlockViaBlockSerde(block.getRegion(position, 1)), 0, expectedValue); assertPositionValue(copyBlockViaBlockSerde(block.getRegion(0, position + 1)), position, expectedValue); assertPositionValue(copyBlockViaBlockSerde(block.getRegion(position, block.getPositionCount() - position)), 0, expectedValue); assertPositionValue(copyBlockViaWritePositionTo(block.getRegion(position, 1), newBlockBuilder), 0, expectedValue); assertPositionValue(copyBlockViaWritePositionTo(block.getRegion(0, position + 1), newBlockBuilder), position, expectedValue); assertPositionValue(copyBlockViaWritePositionTo(block.getRegion(position, block.getPositionCount() - position), newBlockBuilder), 0, expectedValue); if (expectedValueType.isArray() || expectedValueType == List.class || expectedValueType == Map.class) { assertPositionValue(copyBlockViaWriteStructure(block.getRegion(position, 1), newBlockBuilder), 0, expectedValue); assertPositionValue(copyBlockViaWriteStructure(block.getRegion(0, position + 1), newBlockBuilder), position, expectedValue); assertPositionValue(copyBlockViaWriteStructure(block.getRegion(position, block.getPositionCount() - position), newBlockBuilder), 0, expectedValue); } assertPositionValue(block.copyRegion(position, 1), 0, expectedValue); assertPositionValue(block.copyRegion(0, position + 1), position, expectedValue); assertPositionValue(block.copyRegion(position, block.getPositionCount() - position), 0, expectedValue); assertPositionValue(block.copyPositions(new int[] {position}, 0, 1), 0, expectedValue); }
protected void assertSlicePosition(Block block, int position, Slice expectedSliceValue) { int length = block.getSliceLength(position); assertEquals(length, expectedSliceValue.length()); Block expectedBlock = toSingeValuedBlock(expectedSliceValue); for (int offset = 0; offset < length - 3; offset++) { assertEquals(block.getSlice(position, offset, 3), expectedSliceValue.slice(offset, 3)); assertTrue(block.bytesEqual(position, offset, expectedSliceValue, offset, 3)); // if your tests fail here, please change your test to not use this value assertFalse(block.bytesEqual(position, offset, Slices.utf8Slice("XXX"), 0, 3)); assertEquals(block.bytesCompare(position, offset, 3, expectedSliceValue, offset, 3), 0); assertTrue(block.bytesCompare(position, offset, 3, expectedSliceValue, offset, 2) > 0); Slice greaterSlice = createGreaterValue(expectedSliceValue, offset, 3); assertTrue(block.bytesCompare(position, offset, 3, greaterSlice, 0, greaterSlice.length()) < 0); assertTrue(block.equals(position, offset, expectedBlock, 0, offset, 3)); assertEquals(block.compareTo(position, offset, 3, expectedBlock, 0, offset, 3), 0); BlockBuilder blockBuilder = VARBINARY.createBlockBuilder(null, 1); block.writeBytesTo(position, offset, 3, blockBuilder); blockBuilder.closeEntry(); Block segment = blockBuilder.build(); assertTrue(block.equals(position, offset, segment, 0, 0, 3)); } }
protected static Slice[] createExpectedValues(int positionCount) { Slice[] expectedValues = new Slice[positionCount]; for (int position = 0; position < positionCount; position++) { expectedValues[position] = createExpectedValue(position); } return expectedValues; }
@Override protected <T> void assertPositionValue(Block block, int position, T expectedValue) { if (expectedValue instanceof Map) { assertValue(block, position, (Map<String, Long>) expectedValue); return; } super.assertPositionValue(block, position, expectedValue); }
protected <T> void assertBlock(Block block, T[] expectedValues) { assertBlockPositions(block, expectedValues); assertBlockPositions(copyBlock(block), expectedValues); try { block.isNull(-1); fail("expected IllegalArgumentException"); } catch (IllegalArgumentException expected) { } try { block.isNull(block.getPositionCount()); fail("expected IllegalArgumentException"); } catch (IllegalArgumentException expected) { } }
protected static void testCopyRegionCompactness(Block block) { assertCompact(block.copyRegion(0, block.getPositionCount())); if (block.getPositionCount() > 0) { assertCompact(block.copyRegion(0, block.getPositionCount() - 1)); assertCompact(block.copyRegion(1, block.getPositionCount() - 1)); } }
protected static Slice[] createExpectedUniqueValues(int positionCount) { Slice[] expectedValues = new Slice[positionCount]; for (int position = 0; position < positionCount; position++) { expectedValues[position] = Slices.copyOf(createExpectedValue(position)); } return expectedValues; }
@Override protected <T> void assertPositionValue(Block block, int position, T expectedValue) { if (expectedValue instanceof List) { assertValue(block, position, (List<Object>) expectedValue); return; } super.assertPositionValue(block, position, expectedValue); }
protected <T> void assertBlockFilteredPositions(T[] expectedValues, Block block, List<Integer> positions) { Block filteredBlock = block.copyPositions(positions); T[] filteredExpectedValues = filter(expectedValues, positions); assertEquals(filteredBlock.getPositionCount(), positions.size()); assertBlock(filteredBlock, filteredExpectedValues); }
protected static Slice[] createExpectedValues(int positionCount) { Slice[] expectedValues = new Slice[positionCount]; for (int position = 0; position < positionCount; position++) { expectedValues[position] = createExpectedValue(position); } return expectedValues; }
protected <T> void assertBlockPosition(Block block, int position, T expectedValue) { assertPositionValue(block, position, expectedValue); assertPositionValue(block.getSingleValueBlock(position), 0, expectedValue); assertPositionValue(block.getRegion(position, 1), 0, expectedValue); assertPositionValue(block.getRegion(0, position + 1), position, expectedValue); assertPositionValue(block.getRegion(position, block.getPositionCount() - position), 0, expectedValue); assertPositionValue(block.copyRegion(position, 1), 0, expectedValue); assertPositionValue(block.copyRegion(0, position + 1), position, expectedValue); assertPositionValue(block.copyRegion(position, block.getPositionCount() - position), 0, expectedValue); assertPositionValue(block.copyPositions(Ints.asList(position)), 0, expectedValue); }
private <T> void assertBlockPositions(Block block, T[] expectedValues) { assertEquals(block.getPositionCount(), expectedValues.length); for (int position = 0; position < block.getPositionCount(); position++) { assertBlockPosition(block, position, expectedValues[position]); } }