diff --git a/.classpath b/.classpath

index 058b340..c48898b 100644

--- a/.classpath

+++ b/.classpath

@@ -7,7 +7,5 @@

 	<classpathentry kind="src" path="src/test"/>

 	<classpathentry kind="con" path="org.eclipse.jdt.launching.JRE_CONTAINER"/>

 	<classpathentry kind="lib" path="lib/hamcrest-core-1.1.jar"/>

-	<classpathentry kind="lib" path="lib/junit-4.10.jar"/>

-	<classpathentry kind="lib" path="lib/randomizedtesting-runner-2.0.9.jar"/>

 	<classpathentry kind="output" path="bin"/>

 </classpath>

diff --git a/build.xml b/build.xml

index 1bdc702..919386f 100644

--- a/build.xml

+++ b/build.xml

@@ -14,7 +14,6 @@

     xmlns:ivy="antlib:org.apache.ivy.ant"

-    xmlns:junit4="antlib:com.carrotsearch.junit4"

     xmlns:mvn="antlib:org.apache.maven.artifact.ant">

   <property name="src" location="src"/>

@@ -105,15 +104,6 @@

     <ivy:retrieve />

   </target>

-  <target name="install-junit4" depends="init" unless="junit4.available">

-    <taskdef uri="antlib:com.carrotsearch.junit4">

-      <classpath>

-        <fileset dir="${lib}" includes="*.jar" />

-      </classpath>

-    </taskdef>

-    <property name="junit4.available" value="true" />

-  </target>

-

   <target name="generate-sources" depends="init">

       inline="true" conf="default" transitive="true" pathid="mvel.classpath"/>

@@ -236,37 +226,14 @@

     <antcall target="-test" />

   </target>

-  <target name="-test" depends="compile-tests, install-junit4">

-    <mkdir dir="${build}/tests" />

-    

-      dir="${java.io.tmpdir}"

-      maxmemory="300m"

-      parallelism="auto">

-      <assertions>

-        <enable package="net.jpountz.lz4"/>

-      </assertions>

+  <target name="-test" depends="compile-tests">

+    <junit printsummary="on" showoutput="true" failureProperty="test.failure">

       <classpath refid="${prop.test.classpath}" />

-      <fileset dir="${build}/test-classes/">

-        <include name="**/*Test.class" />

-        <exclude name="**/*$*" />

-        <exclude name="**/Abstract*" />

-      </fileset>

-      <listeners>

-        

-        showThrowable="true"

-        showStackTraces="true"

-        showOutput="never"

-

-        showStatusOk="true"

-        showStatusError="true"

-        showStatusFailure="true"

-        showStatusIgnored="true"

-

-        showSuiteSummary="false" />

-        

-        <junit4:report-ant-xml dir="${build}/tests" />

-      </listeners>

-    </junit4:junit4>

+      <test name="net.jpountz.lz4.LZ4FrameIOStreamTest" />

+      <test name="net.jpountz.lz4.LZ4FactoryTest" />

+      <test name="net.jpountz.xxhash.XXHashFactoryTest" />

+    </junit>

+    <fail message="tests failed" if="test.failure" />

   </target>

   <target name="test-skip-jni" description="run tests without building JNI">

diff --git a/ivy-pure-java.xml b/ivy-pure-java.xml

index 6e99e19..9c1c99b 100644

--- a/ivy-pure-java.xml

+++ b/ivy-pure-java.xml

@@ -21,6 +21,6 @@

   </configurations>

   <dependencies>

-    <dependency org="com.carrotsearch.randomizedtesting" name="junit4-ant" rev="2.7.3" transitive="true" conf="test->*,!sources,!javadoc" />

+    <dependency org="junit" name="junit" rev="4.12" conf="test->default" />

   </dependencies>

 </ivy-module>

diff --git a/ivy.xml b/ivy.xml

index 6643da7..e5a9620 100644

--- a/ivy.xml

+++ b/ivy.xml

@@ -21,6 +21,6 @@

   </configurations>

   <dependencies>

-    <dependency org="com.carrotsearch.randomizedtesting" name="junit4-ant" rev="2.7.3" transitive="true" conf="test->*,!sources,!javadoc" />

+    <dependency org="junit" name="junit" rev="4.12" conf="test->default" />

   </dependencies>

 </ivy-module>

diff --git a/src/test/net/jpountz/lz4/AbstractLZ4Test.java b/src/test/net/jpountz/lz4/AbstractLZ4Test.java

deleted file mode 100644

index 8c5cd38..0000000

--- a/src/test/net/jpountz/lz4/AbstractLZ4Test.java

+++ /dev/null

@@ -1,257 +0,0 @@

-package net.jpountz.lz4;

-

-/*

- * Licensed 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.

- */

-

-import java.io.ByteArrayOutputStream;

-import java.io.IOException;

-import java.io.InputStream;

-import java.nio.ByteBuffer;

-import java.nio.ByteOrder;

-import java.util.Arrays;

-

-import com.carrotsearch.randomizedtesting.RandomizedTest;

-

-public abstract class AbstractLZ4Test extends RandomizedTest {

-

-  public interface Tester<T> {

-

-    T allocate(int length);

-    T copyOf(byte[] array);

-    byte[] copyOf(T data, int off, int len);

-    int maxCompressedLength(int len);

-    int compress(LZ4Compressor compressor, T src, int srcOff, int srcLen, T dest, int destOff, int maxDestLen);

-    int decompress(LZ4FastDecompressor decompressor, T src, int srcOff, T dest, int destOff, int destLen);

-    int decompress(LZ4SafeDecompressor decompressor, T src, int srcOff, int srcLen, T dest, int destOff, int maxDestLen);

-    void fill(T instance, byte b);

-

-    public static class ByteArrayTester implements Tester<byte[]> {

-

-      @Override

-      public byte[] allocate(int length) {

-        return new byte[length];

-      }

-

-      @Override

-      public byte[] copyOf(byte[] array) {

-        return Arrays.copyOf(array, array.length);

-      }

-

-      @Override

-      public byte[] copyOf(byte[] data, int off, int len) {

-        return Arrays.copyOfRange(data, off, off + len);

-      }

-

-      @Override

-      public int maxCompressedLength(int len) {

-	return LZ4Utils.maxCompressedLength(len);

-      }

-

-      @Override

-      public int compress(LZ4Compressor compressor, byte[] src, int srcOff,

-          int srcLen, byte[] dest, int destOff, int maxDestLen) {

-        return compressor.compress(src, srcOff, srcLen, dest, destOff, maxDestLen);

-      }

-      

-      @Override

-      public int decompress(LZ4FastDecompressor decompressor,

-          byte[] src, int srcOff, byte[] dest, int destOff, int destLen) {

-        return decompressor.decompress(src, srcOff, dest, destOff, destLen);

-      }

-

-      @Override

-      public int decompress(LZ4SafeDecompressor decompressor,

-          byte[] src, int srcOff, int srcLen, byte[] dest, int destOff, int maxDestLen) {

-        return decompressor.decompress(src, srcOff, srcLen, dest, destOff, maxDestLen);

-      }

-

-      @Override

-      public void fill(byte[] instance, byte b) {

-        Arrays.fill(instance, b);

-      }

-    }

-    public static final Tester<byte[]> BYTE_ARRAY = new ByteArrayTester();

-    public static final Tester<byte[]> BYTE_ARRAY_WITH_LENGTH = new ByteArrayTester() {

-      @Override

-      public int compress(LZ4Compressor compressor, byte[] src, int srcOff,

-          int srcLen, byte[] dest, int destOff, int maxDestLen) {

-        return new LZ4CompressorWithLength(compressor).compress(src, srcOff, srcLen, dest, destOff, maxDestLen);

-      }

-

-      @Override

-      public int decompress(LZ4FastDecompressor decompressor,

-          byte[] src, int srcOff, byte[] dest, int destOff, int destLen) {

-        return new LZ4DecompressorWithLength(decompressor).decompress(src, srcOff, dest, destOff);

-      }

-

-      @Override

-      public int decompress(LZ4SafeDecompressor decompressor,

-          byte[] src, int srcOff, int srcLen, byte[] dest, int destOff, int maxDestLen) {

-        return -1;

-      }

-    };

-

-    public static class ByteBufferTester implements Tester<ByteBuffer> {

-

-      @Override

-      public ByteBuffer allocate(int length) {

-        ByteBuffer bb;

-        int slice = randomInt(5);

-        if (randomBoolean()) {

-          bb = ByteBuffer.allocate(length + slice);

-        } else {

-          bb = ByteBuffer.allocateDirect(length + slice);

-        }

-        bb.position(slice);

-        bb = bb.slice();

-        if (randomBoolean()) {

-          bb.order(ByteOrder.LITTLE_ENDIAN);

-        } else {

-          bb.order(ByteOrder.BIG_ENDIAN);

-        }

-        return bb;

-      }

-

-      @Override

-      public ByteBuffer copyOf(byte[] array) {

-        ByteBuffer bb = allocate(array.length).put(array);

-        if (randomBoolean()) {

-          bb = bb.asReadOnlyBuffer();

-        }

-        bb.position(0);

-        return bb;

-      }

-

-      @Override

-      public byte[] copyOf(ByteBuffer data, int off, int len) {

-        byte[] copy = new byte[len];

-        data.position(off);

-        data.get(copy);

-        return copy;

-      }

-

-      @Override

-      public int maxCompressedLength(int len) {

-	return LZ4Utils.maxCompressedLength(len);

-      }

-

-      @Override

-      public int compress(LZ4Compressor compressor, ByteBuffer src, int srcOff,

-          int srcLen, ByteBuffer dest, int destOff, int maxDestLen) {

-        return compressor.compress(src, srcOff, srcLen, dest, destOff, maxDestLen);

-      }

-

-      @Override

-      public int decompress(LZ4FastDecompressor decompressor, ByteBuffer src,

-          int srcOff, ByteBuffer dest, int destOff, int destLen) {

-        return decompressor.decompress(src, srcOff, dest, destOff, destLen);

-      }

-

-      @Override

-      public int decompress(LZ4SafeDecompressor decompressor, ByteBuffer src,

-          int srcOff, int srcLen, ByteBuffer dest, int destOff, int maxDestLen) {

-        return decompressor.decompress(src, srcOff, srcLen, dest, destOff, maxDestLen);

-      }

-

-      @Override

-      public void fill(ByteBuffer instance, byte b) {

-        for (int i = 0; i < instance.capacity(); ++i) {

-          instance.put(i, b);

-        }

-      }

-    }

-    public static final Tester<ByteBuffer> BYTE_BUFFER = new ByteBufferTester();

-    public static final Tester<ByteBuffer> BYTE_BUFFER_WITH_LENGTH = new ByteBufferTester() {

-      @Override

-      public int compress(LZ4Compressor compressor, ByteBuffer src, int srcOff,

-          int srcLen, ByteBuffer dest, int destOff, int maxDestLen) {

-        return new LZ4CompressorWithLength(compressor).compress(src, srcOff, srcLen, dest, destOff, maxDestLen);

-      }

-

-      @Override

-      public int decompress(LZ4FastDecompressor decompressor, ByteBuffer src,

-          int srcOff, ByteBuffer dest, int destOff, int destLen) {

-        return new LZ4DecompressorWithLength(decompressor).decompress(src, srcOff, dest, destOff);

-      }

-

-      @Override

-      public int decompress(LZ4SafeDecompressor decompressor, ByteBuffer src,

-          int srcOff, int srcLen, ByteBuffer dest, int destOff, int maxDestLen) {

-        return -1;

-      }

-    };

-  }

-

-  protected class RandomBytes {

-    private final byte[] bytes;

-    RandomBytes(int n) {

-      assert n > 0 && n <= 256;

-      bytes = new byte[n];

-      for (int i = 0; i < n; ++i) {

-        bytes[i] = (byte) randomInt(255);

-      }

-    }

-    byte next() {

-      final int i = randomInt(bytes.length - 1);

-      return bytes[i];

-    }

-  }

-

-  protected static byte[] readResource(String resource) throws IOException {

-    InputStream is = LZ4Test.class.getResourceAsStream(resource);

-    if (is == null) {

-      throw new IllegalStateException("Cannot find " + resource);

-    }

-    byte[] buf = new byte[4096];

-    ByteArrayOutputStream baos = new ByteArrayOutputStream();

-    try {

-      while (true) {

-        final int read = is.read(buf);

-        if (read == -1) {

-          break;

-        }

-        baos.write(buf, 0, read);

-      }

-    } finally {

-      is.close();

-    }

-    return baos.toByteArray();

-  }

-

-  protected byte[] randomArray(int len, int n) {

-    byte[] result = new byte[len];

-    RandomBytes randomBytes = new RandomBytes(n);

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

-      result[i] = randomBytes.next();

-    }

-    return result;

-  }

-

-  protected ByteBuffer copyOf(byte[] bytes, int offset, int len) {

-    ByteBuffer buffer;

-    if (randomBoolean()) {

-      buffer = ByteBuffer.allocate(bytes.length);

-    } else {

-      buffer = ByteBuffer.allocateDirect(bytes.length);

-    }

-    buffer.put(bytes);

-    buffer.position(offset);

-    buffer.limit(offset + len);

-    if (randomBoolean()) {

-      buffer = buffer.asReadOnlyBuffer();

-    }

-    return buffer;

-  }

-

-}

diff --git a/src/test/net/jpountz/lz4/LZ4BlockStreamingTest.java b/src/test/net/jpountz/lz4/LZ4BlockStreamingTest.java

deleted file mode 100644

index 9d6fc5b..0000000

--- a/src/test/net/jpountz/lz4/LZ4BlockStreamingTest.java

+++ /dev/null

@@ -1,347 +0,0 @@

-package net.jpountz.lz4;

-

-/*

- * Licensed 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.

- */

-

-import java.io.ByteArrayInputStream;

-import java.io.ByteArrayOutputStream;

-import java.io.FilterInputStream;

-import java.io.FilterOutputStream;

-import java.io.IOException;

-import java.io.InputStream;

-import java.io.OutputStream;

-import java.nio.charset.Charset;

-import java.util.Arrays;

-import java.util.zip.Adler32;

-import java.util.zip.CRC32;

-import java.util.zip.Checksum;

-

-import net.jpountz.xxhash.XXHashFactory;

-

-import org.junit.Test;

-import static org.junit.Assert.*;

-

-import com.carrotsearch.randomizedtesting.annotations.Repeat;

-

-public class LZ4BlockStreamingTest extends AbstractLZ4Test {

-

-  // An input stream that might read less data than it is able to

-  class MockInputStream extends FilterInputStream {

-

-    MockInputStream(InputStream in) {

-      super(in);

-    }

-

-    @Override

-    public int read(byte[] b, int off, int len) throws IOException {

-      return super.read(b, off, randomIntBetween(0, len));

-    }

-

-    @Override

-    public long skip(long n) throws IOException {

-      return super.skip(randomInt((int) Math.min(n, Integer.MAX_VALUE)));

-    }

-

-  }

-

-  // an output stream that delays the actual writes

-  class MockOutputStream extends FilterOutputStream {

-

-    private final byte[] buffer;

-    private int delayedBytes;

-

-    MockOutputStream(OutputStream out) {

-      super(out);

-      buffer = new byte[randomIntBetween(10, 1000)];

-      delayedBytes = 0;

-    }

-

-    private void flushIfNecessary() throws IOException {

-      if (delayedBytes == buffer.length) {

-        flushPendingData();

-      }

-    }

-

-    private void flushPendingData() throws IOException {

-      out.write(buffer, 0, delayedBytes);

-      delayedBytes = 0;

-    }

-

-    @Override

-    public void write(int b) throws IOException {

-      if (rarely()) {

-        flushPendingData();

-      } else {

-        flushIfNecessary();

-      }

-      buffer[delayedBytes++] = (byte) b;

-    }

-

-    @Override

-    public void write(byte[] b, int off, int len) throws IOException {

-      if (rarely()) {

-        flushPendingData();

-      }

-      if (len + delayedBytes > buffer.length) {

-        flushPendingData();

-        delayedBytes = randomInt(Math.min(len, buffer.length));

-        out.write(b, off, len - delayedBytes);

-        System.arraycopy(b, off + len - delayedBytes, buffer, 0, delayedBytes);

-      } else {

-        System.arraycopy(b, off, buffer, delayedBytes, len);

-        delayedBytes += len;

-      }

-    }

-

-    @Override

-    public void write(byte[] b) throws IOException {

-      write(b, 0, b.length);

-    }

-

-    @Override

-    public void flush() throws IOException {

-      // no-op

-    }

-

-    @Override

-    public void close() throws IOException {

-      flushPendingData();

-      out.close();

-    }

-

-  }

-

-  private InputStream open(byte[] data) {

-    return new MockInputStream(new ByteArrayInputStream(data));

-  }

-

-  private OutputStream wrap(OutputStream other) {

-    return new MockOutputStream(other);

-  }

-

-  @Test

-  @Repeat(iterations=5)

-  public void testRoundtripGeo() throws IOException {

-    testRoundTrip("/calgary/geo");

-  }

-

-  @Test

-  @Repeat(iterations=5)

-  public void testRoundtripBook1() throws IOException {

-    testRoundTrip("/calgary/book1");

-  }

-

-  @Test

-  @Repeat(iterations=5)

-  public void testRoundtripPic() throws IOException {

-    testRoundTrip("/calgary/pic");

-  }

-

-  public void testRoundTrip(String resource) throws IOException {

-    testRoundTrip(readResource(resource));

-  }

-

-  public void testRoundTrip(byte[] data) throws IOException {

-    final ByteArrayOutputStream compressed = new ByteArrayOutputStream();

-    final int blockSize;

-    switch (randomInt(2)) {

-    case 0:

-      blockSize = LZ4BlockOutputStream.MIN_BLOCK_SIZE;

-      break;

-    case 1:

-      blockSize = LZ4BlockOutputStream.MAX_BLOCK_SIZE;

-      break;

-    default:

-      blockSize = randomIntBetween(LZ4BlockOutputStream.MIN_BLOCK_SIZE, LZ4BlockOutputStream.MAX_BLOCK_SIZE);

-      break;

-    }

-    final LZ4Compressor compressor = randomBoolean()

-        ? LZ4Factory.fastestInstance().fastCompressor()

-        : LZ4Factory.fastestInstance().highCompressor();

-    final Checksum checksum;

-    switch (randomInt(2)) {

-    case 0:

-      checksum = new Adler32();

-      break;

-    case 1:

-      checksum = new CRC32();

-      break;

-    default:

-      checksum = XXHashFactory.fastestInstance().newStreamingHash32(randomInt()).asChecksum();

-      break;

-    }

-    final boolean syncFlush = randomBoolean();

-    final LZ4BlockOutputStream os = new LZ4BlockOutputStream(wrap(compressed), blockSize, compressor, checksum, syncFlush);

-    final int half = data.length / 2;

-    switch (randomInt(2)) {

-    case 0:

-      os.write(data, 0, half);

-      for (int i = half; i < data.length; ++i) {

-        os.write(data[i]);

-      }

-      break;

-    case 1:

-      for (int i = 0; i < half; ++i) {

-        os.write(data[i]);

-      }

-      os.write(data, half, data.length - half);

-      break;

-    case 2:

-      os.write(data, 0, data.length);

-      break;

-    }

-    os.close();

-

-    final LZ4FastDecompressor decompressor = LZ4Factory.fastestInstance().fastDecompressor();

-    InputStream is = new LZ4BlockInputStream(open(compressed.toByteArray()), decompressor, checksum);

-    assertFalse(is.markSupported());

-    try {

-      is.mark(1);

-      is.reset();

-      assertFalse(true);

-    } catch (IOException e) {

-      // OK

-    }

-    byte[] restored = new byte[data.length + 1000];

-    int read = 0;

-    while (true) {

-      if (randomFloat() < 0.01f) {

-        final int r = is.read(restored, read, restored.length - read);

-        if (r == -1) {

-          break;

-        } else {

-          read += r;

-        }

-      } else {

-        final int b = is.read();

-        if (b == -1) {

-          break;

-        } else {

-          restored[read++] = (byte) b;

-        }

-      }

-    }

-    is.close();

-    assertEquals(data.length, read);

-    assertArrayEquals(data, Arrays.copyOf(restored, read));

-

-    // test skip

-    final int offset = data.length <= 1 ? 0 : randomInt(data.length - 1);

-    final int length = randomInt(data.length - offset);

-    is = new LZ4BlockInputStream(open(compressed.toByteArray()), decompressor, checksum);

-    restored = new byte[length + 1000];

-    read = 0;

-    while (read < offset) {

-      final long skipped = is.skip(offset - read);

-      assertTrue(skipped >= 0);

-      read += skipped;

-    }

-    read = 0;

-    while (read < length) {

-      final int r = is.read(restored, read, length - read);

-      assertTrue(r >= 0);

-      read += r;

-    }

-    is.close();

-    assertArrayEquals(Arrays.copyOfRange(data, offset, offset + length), Arrays.copyOfRange(restored, 0, length));

-  }

-

-  @Test

-  @Repeat(iterations=20)

-  public void testRoundtripRandom() throws IOException {

-    final int size = randomFloat() < 0.1f ? randomInt(5) : randomInt(1 << 20);

-    final byte[] data = randomArray(size, randomBoolean() ? randomIntBetween(1, 5) : randomIntBetween(6, 100));

-    testRoundTrip(data);

-  }

-

-  @Test

-  public void testRoundtripEmpty() throws IOException {

-    testRoundTrip(new byte[0]);

-  }

-

-  @Test

-  public void testDoubleClose() throws IOException {

-    final byte[] testBytes = "Testing!".getBytes(Charset.forName("UTF-8"));

-

-    ByteArrayOutputStream bytes = new ByteArrayOutputStream();

-    LZ4BlockOutputStream out = new LZ4BlockOutputStream(bytes);

-

-    out.write(testBytes);

-

-    out.close();

-    out.close();

-

-    LZ4BlockInputStream in = new LZ4BlockInputStream(new ByteArrayInputStream(bytes.toByteArray()));

-    byte[] actual = new byte[testBytes.length];

-    in.read(actual);

-

-    assertArrayEquals(testBytes, actual);

-

-    in.close();

-    in.close();

-  }

-

-  private static int readFully(InputStream in, byte[] b) throws IOException {

-    int total;

-    int result;

-    for (total = 0; total < b.length; total += result) {

-      result = in.read(b, total, b.length - total);

-      if(result == -1) {

-        break;

-      }

-    }

-    return total;

-  }

-

-  @Test

-  public void testConcatenationOfSerializedStreams() throws IOException {

-    final byte[] testBytes1 = randomArray(64, 256);

-    final byte[] testBytes2 = randomArray(64, 256);

-    byte[] expected = new byte[128];

-    System.arraycopy(testBytes1, 0, expected, 0, 64);

-    System.arraycopy(testBytes2, 0, expected, 64, 64);

-

-    ByteArrayOutputStream bytes1os = new ByteArrayOutputStream();

-    LZ4BlockOutputStream out1 = new LZ4BlockOutputStream(bytes1os);

-    out1.write(testBytes1);

-    out1.close();

-

-    ByteArrayOutputStream bytes2os = new ByteArrayOutputStream();

-    LZ4BlockOutputStream out2 = new LZ4BlockOutputStream(bytes2os);

-    out2.write(testBytes2);

-    out2.close();

-

-    byte[] bytes1 = bytes1os.toByteArray();

-    byte[] bytes2 = bytes2os.toByteArray();

-    byte[] concatenatedBytes = new byte[bytes1.length + bytes2.length];

-    System.arraycopy(bytes1, 0, concatenatedBytes, 0, bytes1.length);

-    System.arraycopy(bytes2, 0, concatenatedBytes, bytes1.length, bytes2.length);

-

-    // In a default behaviour, we can read the first block of the concatenated bytes only

-    LZ4BlockInputStream in1 = new LZ4BlockInputStream(new ByteArrayInputStream(concatenatedBytes));

-    byte[] actual1 = new byte[128];

-    assertEquals(64, readFully(in1, actual1));

-    assertEquals(-1, in1.read());

-    in1.close();

-

-    // Check if we can read concatenated byte stream

-    LZ4BlockInputStream in2 = new LZ4BlockInputStream(new ByteArrayInputStream(concatenatedBytes), false);

-    byte[] actual2 = new byte[128];

-    assertEquals(128, readFully(in2, actual2));