@Test(dataProvider = "data") public void testDecompress(DataSet dataSet) throws Exception { byte[] uncompressedOriginal = dataSet.getUncompressed(); byte[] compressed = prepareCompressedData(uncompressedOriginal); byte[] uncompressed = new byte[uncompressedOriginal.length]; Decompressor decompressor = getDecompressor(); int uncompressedSize = decompressor.decompress( compressed, 0, compressed.length, uncompressed, 0, uncompressed.length); assertByteArraysEqual(uncompressed, 0, uncompressedSize, uncompressedOriginal, 0, uncompressedOriginal.length); }
@Test(dataProvider = "data") public void testDecompressByteBufferDirectToDirect(DataSet dataSet) throws Exception { if (!isByteBufferSupported()) { return; } byte[] uncompressedOriginal = dataSet.getUncompressed(); ByteBuffer compressed = toDirectBuffer(prepareCompressedData(uncompressedOriginal)); ByteBuffer uncompressed = ByteBuffer.allocateDirect(uncompressedOriginal.length); getDecompressor().decompress(compressed, uncompressed); uncompressed.flip(); assertByteBufferEqual(ByteBuffer.wrap(uncompressedOriginal), uncompressed); }
@Test(dataProvider = "data") public void testCompressByteBufferDirectToHeap(DataSet dataSet) throws Exception { if (!isByteBufferSupported()) { return; } byte[] uncompressedOriginal = dataSet.getUncompressed(); Compressor compressor = getCompressor(); verifyCompressByteBuffer( compressor, toDirectBuffer(uncompressedOriginal), ByteBuffer.allocate(compressor.maxCompressedLength(uncompressedOriginal.length))); }
private void verifyCompressedData(byte[] originalUncompressed, byte[] compressed, int compressedLength) { byte[] uncompressed = new byte[originalUncompressed.length]; int uncompressedSize = getVerifyDecompressor().decompress(compressed, 0, compressedLength, uncompressed, 0, uncompressed.length); assertByteArraysEqual(uncompressed, 0, uncompressedSize, originalUncompressed, 0, originalUncompressed.length); }
@Test(dataProvider = "data") public void testCompressByteBufferHeapToDirect(DataSet dataSet) throws Exception { if (!isByteBufferSupported()) { return; } byte[] uncompressedOriginal = dataSet.getUncompressed(); Compressor compressor = getCompressor(); verifyCompressByteBuffer( compressor, ByteBuffer.wrap(uncompressedOriginal), ByteBuffer.allocateDirect(compressor.maxCompressedLength(uncompressedOriginal.length))); }
@Test public void testRoundTripSmallLiteral() throws Exception { byte[] data = new byte[256]; for (int i = 0; i < data.length; i++) { data[i] = (byte) i; } Compressor compressor = getCompressor(); byte[] compressed = new byte[compressor.maxCompressedLength(data.length)]; byte[] uncompressed = new byte[data.length]; for (int i = 1; i < data.length; i++) { try { int written = compressor.compress( data, 0, i, compressed, 0, compressed.length); int decompressedSize = getDecompressor().decompress(compressed, 0, written, uncompressed, 0, uncompressed.length); assertByteArraysEqual(data, 0, i, uncompressed, 0, decompressedSize); assertEquals(decompressedSize, i); } catch (MalformedInputException e) { throw new RuntimeException("Failed with " + i + " bytes of input", e); } } }
private void verifyCompressByteBuffer(Compressor compressor, ByteBuffer expected, ByteBuffer compressed) { // attempt to compress slightly different data to ensure the compressor doesn't keep state // between calls that may affect results if (expected.remaining() > 1) { ByteBuffer duplicate = expected.duplicate(); duplicate.get(); // skip one byte compressor.compress(duplicate, ByteBuffer.allocate(compressed.remaining())); } compressor.compress(expected.duplicate(), compressed); compressed.flip(); ByteBuffer uncompressed = ByteBuffer.allocate(expected.remaining()); // TODO: validate with "control" decompressor getDecompressor().decompress(compressed, uncompressed); uncompressed.flip(); assertByteBufferEqual(expected.duplicate(), uncompressed); }
@Test(dataProvider = "data") public void testCompress(DataSet testCase) throws Exception { Compressor compressor = getCompressor(); byte[] originalUncompressed = testCase.getUncompressed(); byte[] compressed = new byte[compressor.maxCompressedLength(originalUncompressed.length)]; // attempt to compress slightly different data to ensure the compressor doesn't keep state // between calls that may affect results if (originalUncompressed.length > 1) { byte[] output = new byte[compressor.maxCompressedLength(originalUncompressed.length - 1)]; compressor.compress(originalUncompressed, 1, originalUncompressed.length - 1, output, 0, output.length); } int compressedLength = compressor.compress( originalUncompressed, 0, originalUncompressed.length, compressed, 0, compressed.length); verifyCompressedData(originalUncompressed, compressed, compressedLength); }
private byte[] prepareCompressedData(byte[] uncompressed) { Compressor compressor = getVerifyCompressor(); byte[] compressed = new byte[compressor.maxCompressedLength(uncompressed.length)]; int compressedLength = compressor.compress( uncompressed, 0, uncompressed.length, compressed, 0, compressed.length); return Arrays.copyOf(compressed, compressedLength); } }
@Test(dataProvider = "data") public void testCompressByteBufferHeapToHeap(DataSet dataSet) throws Exception { if (!isByteBufferSupported()) { return; } byte[] uncompressedOriginal = dataSet.getUncompressed(); Compressor compressor = getCompressor(); verifyCompressByteBuffer( compressor, ByteBuffer.wrap(uncompressedOriginal), ByteBuffer.allocate(compressor.maxCompressedLength(uncompressedOriginal.length))); }
@Test(dataProvider = "data") public void testDecompressByteBufferDirectToHeap(DataSet dataSet) throws Exception { if (!isByteBufferSupported()) { return; } byte[] uncompressedOriginal = dataSet.getUncompressed(); ByteBuffer compressed = toDirectBuffer(prepareCompressedData(uncompressedOriginal)); ByteBuffer uncompressed = ByteBuffer.allocate(uncompressedOriginal.length); getDecompressor().decompress(compressed, uncompressed); uncompressed.flip(); assertByteBufferEqual(ByteBuffer.wrap(uncompressedOriginal), uncompressed); }
@Test(dataProvider = "data") public void testCompressByteBufferDirectToDirect(DataSet dataSet) throws Exception { if (!isByteBufferSupported()) { return; } byte[] uncompressedOriginal = dataSet.getUncompressed(); Compressor compressor = getCompressor(); verifyCompressByteBuffer( compressor, toDirectBuffer(uncompressedOriginal), ByteBuffer.allocateDirect(compressor.maxCompressedLength(uncompressedOriginal.length))); }
@Test(dataProvider = "data") public void testDecompressWithOutputPadding(DataSet dataSet) { int padding = 1021; byte[] uncompressedOriginal = dataSet.getUncompressed(); byte[] compressed = prepareCompressedData(uncompressedOriginal); byte[] uncompressed = new byte[uncompressedOriginal.length + 2 * padding]; // pre + post padding Decompressor decompressor = getDecompressor(); int uncompressedSize = decompressor.decompress( compressed, 0, compressed.length, uncompressed, padding, uncompressedOriginal.length + padding); assertByteArraysEqual(uncompressed, padding, uncompressedSize, uncompressedOriginal, 0, uncompressedOriginal.length); }
@Test(dataProvider = "data") public void testDecompressByteBufferHeapToHeap(DataSet dataSet) throws Exception { if (!isByteBufferSupported()) { return; } byte[] uncompressedOriginal = dataSet.getUncompressed(); ByteBuffer compressed = ByteBuffer.wrap(prepareCompressedData(uncompressedOriginal)); ByteBuffer uncompressed = ByteBuffer.allocate(uncompressedOriginal.length); getDecompressor().decompress(compressed, uncompressed); uncompressed.flip(); assertByteBufferEqual(ByteBuffer.wrap(uncompressedOriginal), uncompressed); }
@Test(dataProvider = "data") public void testDecompressionBufferOverrun(DataSet dataSet) { byte[] uncompressedOriginal = dataSet.getUncompressed(); byte[] compressed = prepareCompressedData(uncompressedOriginal); // add padding with random bytes that we can verify later byte[] padding = new byte[100]; ThreadLocalRandom.current().nextBytes(padding); byte[] uncompressed = Bytes.concat(new byte[uncompressedOriginal.length], padding); Decompressor decompressor = getDecompressor(); int uncompressedSize = decompressor.decompress( compressed, 0, compressed.length, uncompressed, 0, uncompressedOriginal.length); assertByteArraysEqual(uncompressed, 0, uncompressedSize, uncompressedOriginal, 0, uncompressedOriginal.length); // verify padding is intact assertByteArraysEqual(padding, 0, padding.length, uncompressed, uncompressed.length - padding.length, padding.length); }
@Test(dataProvider = "data") public void testDecompressByteBufferHeapToDirect(DataSet dataSet) throws Exception { if (!isByteBufferSupported()) { return; } byte[] uncompressedOriginal = dataSet.getUncompressed(); ByteBuffer compressed = ByteBuffer.wrap(prepareCompressedData(uncompressedOriginal)); ByteBuffer uncompressed = ByteBuffer.allocateDirect(uncompressedOriginal.length); getDecompressor().decompress(compressed, uncompressed); uncompressed.flip(); assertByteBufferEqual(ByteBuffer.wrap(uncompressedOriginal), uncompressed); }