a0c466a276
Motivation: FastLZ compression codec provides sending and receiving data encoded by fast FastLZ algorithm using block mode. Modifications: - Added part of `jfastlz` library which implements FastLZ algorithm. See FastLz class. - Implemented FastLzFramedEncoder which extends MessageToByteEncoder and provides compression of outgoing messages. - Implemented FastLzFramedDecoder which extends ByteToMessageDecoder and provides uncompression of incoming messages. - Added integration tests for `FastLzFramedEncoder/Decoder`. Result: Full FastLZ compression codec which can compress/uncompress data using FastLZ algorithm.
137 lines
4.9 KiB
Java
137 lines
4.9 KiB
Java
/*
|
|
* Copyright 2014 The Netty Project
|
|
*
|
|
* The Netty Project licenses this file to you under the Apache License,
|
|
* version 2.0 (the "License"); you may not use this file except in compliance
|
|
* with the License. You may obtain a copy of the License at:
|
|
*
|
|
* http://www.apache.org/licenses/LICENSE-2.0
|
|
*
|
|
* Unless required by applicable law or agreed to in writing, software
|
|
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
|
|
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
|
|
* License for the specific language governing permissions and limitations
|
|
* under the License.
|
|
*/
|
|
package io.netty.handler.codec.compression;
|
|
|
|
import io.netty.buffer.ByteBuf;
|
|
import io.netty.buffer.CompositeByteBuf;
|
|
import io.netty.buffer.Unpooled;
|
|
import io.netty.channel.embedded.EmbeddedChannel;
|
|
import io.netty.util.ReferenceCountUtil;
|
|
|
|
import static org.hamcrest.Matchers.*;
|
|
import static org.junit.Assert.*;
|
|
|
|
public class FastLzIntegrationTest extends IntegrationTest {
|
|
|
|
public static class TestWithChecksum extends IntegrationTest {
|
|
|
|
@Override
|
|
protected EmbeddedChannel createEncoderEmbeddedChannel() {
|
|
return new EmbeddedChannel(new FastLzFramedEncoder(true));
|
|
}
|
|
|
|
@Override
|
|
protected EmbeddedChannel createDecoderEmbeddedChannel() {
|
|
return new EmbeddedChannel(new FastLzFramedDecoder(true));
|
|
}
|
|
}
|
|
|
|
public static class TestRandomChecksum extends IntegrationTest {
|
|
|
|
@Override
|
|
protected EmbeddedChannel createEncoderEmbeddedChannel() {
|
|
return new EmbeddedChannel(new FastLzFramedEncoder(rand.nextBoolean()));
|
|
}
|
|
|
|
@Override
|
|
protected EmbeddedChannel createDecoderEmbeddedChannel() {
|
|
return new EmbeddedChannel(new FastLzFramedDecoder(rand.nextBoolean()));
|
|
}
|
|
}
|
|
|
|
@Override
|
|
protected EmbeddedChannel createEncoderEmbeddedChannel() {
|
|
return new EmbeddedChannel(new FastLzFramedEncoder(rand.nextBoolean()));
|
|
}
|
|
|
|
@Override
|
|
protected EmbeddedChannel createDecoderEmbeddedChannel() {
|
|
return new EmbeddedChannel(new FastLzFramedDecoder(rand.nextBoolean()));
|
|
}
|
|
|
|
@Override // test batched flow of data
|
|
protected void testIdentity(final byte[] data) {
|
|
final ByteBuf original = Unpooled.wrappedBuffer(data);
|
|
final EmbeddedChannel encoder = createEncoderEmbeddedChannel();
|
|
final EmbeddedChannel decoder = createDecoderEmbeddedChannel();
|
|
|
|
try {
|
|
int written = 0, length = rand.nextInt(100);
|
|
while (written + length < data.length) {
|
|
ByteBuf in = Unpooled.wrappedBuffer(data, written, length);
|
|
encoder.writeOutbound(in);
|
|
written += length;
|
|
length = rand.nextInt(100);
|
|
}
|
|
ByteBuf in = Unpooled.wrappedBuffer(data, written, data.length - written);
|
|
encoder.writeOutbound(in);
|
|
encoder.finish();
|
|
|
|
ByteBuf msg;
|
|
final CompositeByteBuf compressed = Unpooled.compositeBuffer();
|
|
while ((msg = encoder.readOutbound()) != null) {
|
|
compressed.addComponent(msg);
|
|
compressed.writerIndex(compressed.writerIndex() + msg.readableBytes());
|
|
}
|
|
assertThat(compressed, is(notNullValue()));
|
|
|
|
final byte[] compressedArray = new byte[compressed.readableBytes()];
|
|
compressed.readBytes(compressedArray);
|
|
written = 0;
|
|
length = rand.nextInt(100);
|
|
while (written + length < compressedArray.length) {
|
|
in = Unpooled.wrappedBuffer(compressedArray, written, length);
|
|
decoder.writeInbound(in);
|
|
written += length;
|
|
length = rand.nextInt(100);
|
|
}
|
|
in = Unpooled.wrappedBuffer(compressedArray, written, compressedArray.length - written);
|
|
decoder.writeInbound(in);
|
|
|
|
assertFalse(compressed.isReadable());
|
|
final CompositeByteBuf decompressed = Unpooled.compositeBuffer();
|
|
while ((msg = decoder.readInbound()) != null) {
|
|
decompressed.addComponent(msg);
|
|
decompressed.writerIndex(decompressed.writerIndex() + msg.readableBytes());
|
|
}
|
|
assertEquals(original, decompressed);
|
|
|
|
compressed.release();
|
|
decompressed.release();
|
|
original.release();
|
|
} finally {
|
|
encoder.close();
|
|
decoder.close();
|
|
|
|
for (;;) {
|
|
Object msg = encoder.readOutbound();
|
|
if (msg == null) {
|
|
break;
|
|
}
|
|
ReferenceCountUtil.release(msg);
|
|
}
|
|
|
|
for (;;) {
|
|
Object msg = decoder.readInbound();
|
|
if (msg == null) {
|
|
break;
|
|
}
|
|
ReferenceCountUtil.release(msg);
|
|
}
|
|
}
|
|
}
|
|
}
|