From 6c2277ef90dac84fa66536abc16d6dcd14f8400d Mon Sep 17 00:00:00 2001 From: Simon Spero Date: Sat, 24 Jun 2017 16:53:26 -0400 Subject: [PATCH 1/5] Random coveralls bait. Signed-off-by: Simon Spero --- .../compress/archivers/sevenz/CLI.java | 2 +- .../compress/archivers/zip/AsiExtraField.java | 16 ++++---- .../compress/archivers/arj/CoverageTest.java | 23 +++++++++++ .../compress/archivers/jar/JarMarkerTest.java | 39 ++++++++++++++++++ .../archivers/sevenz/CoverageTest.java | 24 +++++++++++ .../archivers/zip/BinaryTreeTest.java | 24 +++++++++++ .../archivers/zip/ExplodeSupportTest.java | 18 ++++++++ .../archivers/zip/ExtraFieldUtilsTest.java | 12 ++++++ .../archivers/zip/PkWareExtraHeaderTest.java | 28 +++++++++++++ .../archivers/zip/StreamCompressorTest.java | 23 ++++++++--- .../archivers/zip/ZipClassCoverageTest.java | 41 +++++++++++++++++++ 11 files changed, 236 insertions(+), 14 deletions(-) create mode 100644 src/test/java/org/apache/commons/compress/archivers/arj/CoverageTest.java create mode 100644 src/test/java/org/apache/commons/compress/archivers/jar/JarMarkerTest.java create mode 100644 src/test/java/org/apache/commons/compress/archivers/sevenz/CoverageTest.java create mode 100644 src/test/java/org/apache/commons/compress/archivers/zip/PkWareExtraHeaderTest.java create mode 100644 src/test/java/org/apache/commons/compress/archivers/zip/ZipClassCoverageTest.java diff --git a/src/main/java/org/apache/commons/compress/archivers/sevenz/CLI.java b/src/main/java/org/apache/commons/compress/archivers/sevenz/CLI.java index 58e52eef24..0db5a42d81 100644 --- a/src/main/java/org/apache/commons/compress/archivers/sevenz/CLI.java +++ b/src/main/java/org/apache/commons/compress/archivers/sevenz/CLI.java @@ -23,7 +23,6 @@ public class CLI { - private static final byte[] BUF = new byte[8192]; private static enum Mode { LIST("Analysing") { @@ -65,6 +64,7 @@ private String getContentMethods(final SevenZArchiveEntry entry) { } }, EXTRACT("Extracting") { + private final byte[] BUF = new byte[8192]; @Override public void takeAction(final SevenZFile archive, final SevenZArchiveEntry entry) throws IOException { diff --git a/src/main/java/org/apache/commons/compress/archivers/zip/AsiExtraField.java b/src/main/java/org/apache/commons/compress/archivers/zip/AsiExtraField.java index e4afa95cdb..4d8b65c4a0 100644 --- a/src/main/java/org/apache/commons/compress/archivers/zip/AsiExtraField.java +++ b/src/main/java/org/apache/commons/compress/archivers/zip/AsiExtraField.java @@ -325,13 +325,13 @@ protected int getMode(final int mode) { @Override public Object clone() { - try { - final AsiExtraField cloned = (AsiExtraField) super.clone(); - cloned.crc = new CRC32(); - return cloned; - } catch (final CloneNotSupportedException cnfe) { - // impossible - throw new RuntimeException(cnfe); //NOSONAR - } + AsiExtraField cloned = new AsiExtraField(); + cloned.mode = mode; + cloned.uid = uid; + cloned.gid =gid; + cloned.link = link; + cloned.dirFlag = dirFlag; + cloned.crc = new CRC32(); + return cloned; } } diff --git a/src/test/java/org/apache/commons/compress/archivers/arj/CoverageTest.java b/src/test/java/org/apache/commons/compress/archivers/arj/CoverageTest.java new file mode 100644 index 0000000000..bd394f719e --- /dev/null +++ b/src/test/java/org/apache/commons/compress/archivers/arj/CoverageTest.java @@ -0,0 +1,23 @@ +package org.apache.commons.compress.archivers.arj; + +import static org.junit.Assert.assertNotNull; + +import org.apache.commons.compress.archivers.arj.ArjArchiveEntry.HostOs; +import org.junit.Test; + +public class CoverageTest { + + @Test + public void testHostOsInstance() { + HostOs hostOs = new HostOs(); + assertNotNull(hostOs); + } + @Test + public void testHeaderInstances() { + assertNotNull(new LocalFileHeader.FileTypes()); + assertNotNull(new LocalFileHeader.Methods()); + assertNotNull(new LocalFileHeader.Flags()); + assertNotNull(new MainHeader.Flags()); + } + +} diff --git a/src/test/java/org/apache/commons/compress/archivers/jar/JarMarkerTest.java b/src/test/java/org/apache/commons/compress/archivers/jar/JarMarkerTest.java new file mode 100644 index 0000000000..507a814e90 --- /dev/null +++ b/src/test/java/org/apache/commons/compress/archivers/jar/JarMarkerTest.java @@ -0,0 +1,39 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one + * or more contributor license agreements. See the NOTICE file + * distributed with this work for additional information + * regarding copyright ownership. The ASF 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 org.apache.commons.compress.archivers.jar; + +import static org.junit.Assert.fail; + +import java.util.zip.ZipException; +import org.apache.commons.compress.archivers.zip.JarMarker; +import org.junit.Test; + +public class JarMarkerTest { + + @Test public void testJarMarkerLengthCheck() { + JarMarker jarMarker = JarMarker.getInstance(); + try { + jarMarker.parseFromLocalFileData(null,0,1); + fail("should have thrown exception due to length of 1"); + } catch (ZipException e) { + + } + } + +} diff --git a/src/test/java/org/apache/commons/compress/archivers/sevenz/CoverageTest.java b/src/test/java/org/apache/commons/compress/archivers/sevenz/CoverageTest.java new file mode 100644 index 0000000000..c6801aed71 --- /dev/null +++ b/src/test/java/org/apache/commons/compress/archivers/sevenz/CoverageTest.java @@ -0,0 +1,24 @@ +package org.apache.commons.compress.archivers.sevenz; + +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.fail; + +import org.junit.Test; + +public class CoverageTest { + + @Test public void testNidInstance() { + assertNotNull(new NID()); + } + + @Test public void testCLIInstance() { + CLI foo = new CLI(); + assertNotNull(foo); + try { + CLI.main(new String[]{"/dev/null/not-there"}); + fail("shouldn't be able to list contents of a file that isn't there"); + } catch (Exception ignored) { + + } + } +} diff --git a/src/test/java/org/apache/commons/compress/archivers/zip/BinaryTreeTest.java b/src/test/java/org/apache/commons/compress/archivers/zip/BinaryTreeTest.java index 930df01acf..fc0e94a13a 100644 --- a/src/test/java/org/apache/commons/compress/archivers/zip/BinaryTreeTest.java +++ b/src/test/java/org/apache/commons/compress/archivers/zip/BinaryTreeTest.java @@ -47,4 +47,28 @@ public void testDecode() throws IOException { assertEquals(6, tree.read(stream)); assertEquals(7, tree.read(stream)); } + @Test + public void testExceptions() { + BinaryTree binaryFinary = new BinaryTree(4); + binaryFinary.addLeaf(0,0,0,1); + try { + binaryFinary.addLeaf(0,0,0,1); + fail("should have thrown illegalArgumentException"); + } catch (IllegalArgumentException e) { + } + + InputStream is = new ByteArrayInputStream(new byte[]{}); + try { + BinaryTree.decode(is,0); + fail("should have thrown IOException"); + } catch (IOException e) { + + } + binaryFinary = new BinaryTree(4); + try { + binaryFinary.read(new BitStream(new ByteArrayInputStream(new byte[] {0}))); + fail("expected read fail"); + } catch (IOException e) { + } + } } diff --git a/src/test/java/org/apache/commons/compress/archivers/zip/ExplodeSupportTest.java b/src/test/java/org/apache/commons/compress/archivers/zip/ExplodeSupportTest.java index 5716fd7ffc..13bdb53741 100644 --- a/src/test/java/org/apache/commons/compress/archivers/zip/ExplodeSupportTest.java +++ b/src/test/java/org/apache/commons/compress/archivers/zip/ExplodeSupportTest.java @@ -20,6 +20,8 @@ package org.apache.commons.compress.archivers.zip; import static org.junit.Assert.*; + +import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileInputStream; @@ -99,4 +101,20 @@ public void testTikaTestStream() throws IOException { testZipStreamWithImplodeCompression("target/test-classes/moby-imploded.zip", "README"); } + @Test + public void testConstructorThrowsExceptions() { + try { + ExplodingInputStream eis = new ExplodingInputStream(4095,2,new ByteArrayInputStream(new byte[] {})); + fail("should have failed with illegal argument exception"); + } catch (IllegalArgumentException e) { + } + + try { + ExplodingInputStream eis = new ExplodingInputStream(4096,4,new ByteArrayInputStream(new byte[] {})); + fail("should have failed with illegal argument exception"); + } catch (IllegalArgumentException e) { + } + + } + } diff --git a/src/test/java/org/apache/commons/compress/archivers/zip/ExtraFieldUtilsTest.java b/src/test/java/org/apache/commons/compress/archivers/zip/ExtraFieldUtilsTest.java index afa122e4a2..3803817b9d 100644 --- a/src/test/java/org/apache/commons/compress/archivers/zip/ExtraFieldUtilsTest.java +++ b/src/test/java/org/apache/commons/compress/archivers/zip/ExtraFieldUtilsTest.java @@ -93,6 +93,18 @@ public void testParse() throws Exception { e.getMessage()); } } + @Test + public void testParseCentral() throws Exception { + final ZipExtraField[] ze = ExtraFieldUtils.parse(data,false); + assertEquals("number of fields", 2, ze.length); + assertTrue("type field 1", ze[0] instanceof AsiExtraField); + assertEquals("mode field 1", 040755, + ((AsiExtraField) ze[0]).getMode()); + assertTrue("type field 2", ze[1] instanceof UnrecognizedExtraField); + assertEquals("data length field 2", 1, + ze[1].getCentralDirectoryLength().getValue()); + + } @Test public void testParseWithRead() throws Exception { diff --git a/src/test/java/org/apache/commons/compress/archivers/zip/PkWareExtraHeaderTest.java b/src/test/java/org/apache/commons/compress/archivers/zip/PkWareExtraHeaderTest.java new file mode 100644 index 0000000000..315a189536 --- /dev/null +++ b/src/test/java/org/apache/commons/compress/archivers/zip/PkWareExtraHeaderTest.java @@ -0,0 +1,28 @@ +package org.apache.commons.compress.archivers.zip; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; + +import org.apache.commons.compress.archivers.zip.PKWareExtraHeader.EncryptionAlgorithm; +import org.apache.commons.compress.archivers.zip.PKWareExtraHeader.HashAlgorithm; +import org.junit.Test; + +public class PkWareExtraHeaderTest { + + @Test public void testEncryptionAlgorithm() { + String name = "AES256"; + int code = EncryptionAlgorithm.AES256.getCode(); + EncryptionAlgorithm e = EncryptionAlgorithm.valueOf(name); + assertEquals(code,e.getCode()); + assertNotNull(e); + } + + @Test public void testHashAlgorithm() { + String name = "SHA256"; + int code = HashAlgorithm.SHA256.getCode(); + HashAlgorithm e = HashAlgorithm.valueOf(name); + assertEquals(code,e.getCode()); + assertNotNull(e); + } + +} diff --git a/src/test/java/org/apache/commons/compress/archivers/zip/StreamCompressorTest.java b/src/test/java/org/apache/commons/compress/archivers/zip/StreamCompressorTest.java index 27505c48ac..38ed531c79 100644 --- a/src/test/java/org/apache/commons/compress/archivers/zip/StreamCompressorTest.java +++ b/src/test/java/org/apache/commons/compress/archivers/zip/StreamCompressorTest.java @@ -17,14 +17,18 @@ */ package org.apache.commons.compress.archivers.zip; -import org.junit.Test; +import static org.junit.Assert.assertArrayEquals; +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertNotNull; import java.io.ByteArrayInputStream; import java.io.ByteArrayOutputStream; +import java.io.DataOutput; +import java.io.DataOutputStream; +import java.io.IOException; +import java.util.zip.Deflater; import java.util.zip.ZipEntry; - -import static org.junit.Assert.assertArrayEquals; -import static org.junit.Assert.assertEquals; +import org.junit.Test; public class StreamCompressorTest { @@ -55,4 +59,13 @@ public void deflatedEntries() throws Exception { // Note that this test really asserts stuff about the java Deflater, which might be a little bit brittle assertArrayEquals(expected, actuals); } -} \ No newline at end of file + + @Test + public void testCreateDataOutputCompressor() throws IOException { + DataOutput dataOutputStream = new DataOutputStream(new ByteArrayOutputStream()); + try (StreamCompressor streamCompressor = StreamCompressor + .create(dataOutputStream, new Deflater(9))) { + assertNotNull(streamCompressor); + } + } +} diff --git a/src/test/java/org/apache/commons/compress/archivers/zip/ZipClassCoverageTest.java b/src/test/java/org/apache/commons/compress/archivers/zip/ZipClassCoverageTest.java new file mode 100644 index 0000000000..3387b63bc7 --- /dev/null +++ b/src/test/java/org/apache/commons/compress/archivers/zip/ZipClassCoverageTest.java @@ -0,0 +1,41 @@ +package org.apache.commons.compress.archivers.zip; + +import static org.junit.Assert.assertEquals; +import static org.junit.Assert.assertFalse; +import static org.junit.Assert.assertNotNull; +import static org.junit.Assert.assertThat; + +import java.lang.reflect.Constructor; +import java.lang.reflect.InvocationTargetException; +import org.hamcrest.core.IsInstanceOf; +import org.junit.Test; + +public class ZipClassCoverageTest { + + @Test + public void testConstructZip64RequiredException() { + Zip64RequiredException e = new Zip64RequiredException("critique of pure"); + assertNotNull(e); + } + @Test + public void testMessageException() { + ZipArchiveEntry ze = new ZipArchiveEntry("hello"); + String entryTooBigMessage = Zip64RequiredException.getEntryTooBigMessage(ze); + assertEquals("hello's size exceeds the limit of 4GByte.", + entryTooBigMessage); + } + + @Test + public void testConstantConstructor() + throws NoSuchMethodException, IllegalAccessException, InvocationTargetException, InstantiationException { + Class clazz = ZipConstants.class; + Constructor constructor = clazz.getDeclaredConstructor(); + assertFalse(constructor.isAccessible()); + constructor.setAccessible(true); + Object o = constructor.newInstance(); + assertThat(o, IsInstanceOf.instanceOf(clazz)); + constructor.setAccessible(false); + + } + +} From b9d2949fa9e9bcfed8a7b69699224a101beb6554 Mon Sep 17 00:00:00 2001 From: Simon Spero Date: Sun, 25 Jun 2017 16:54:45 -0400 Subject: [PATCH 2/5] Increase test coverage Signed-off-by: Simon Spero --- .../apache/commons/compress/archivers/arj/CoverageTest.java | 5 +++++ 1 file changed, 5 insertions(+) diff --git a/src/test/java/org/apache/commons/compress/archivers/arj/CoverageTest.java b/src/test/java/org/apache/commons/compress/archivers/arj/CoverageTest.java index bd394f719e..8372e6ae89 100644 --- a/src/test/java/org/apache/commons/compress/archivers/arj/CoverageTest.java +++ b/src/test/java/org/apache/commons/compress/archivers/arj/CoverageTest.java @@ -19,5 +19,10 @@ public void testHeaderInstances() { assertNotNull(new LocalFileHeader.Flags()); assertNotNull(new MainHeader.Flags()); } + @Test + public void testCallLFHToString() { + LocalFileHeader lfh = new LocalFileHeader(); + assertNotNull(lfh.toString()); + } } From 6a9af034469475ee34538ed321f09a181a854dd3 Mon Sep 17 00:00:00 2001 From: Simon Spero Date: Sun, 25 Jun 2017 16:56:54 -0400 Subject: [PATCH 3/5] Avoid NPE when running against pre-release xz's (which are by definition not 1.4) Signed-off-by: Simon Spero --- .../compress/archivers/sevenz/SevenZOutputFileTest.java | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/src/test/java/org/apache/commons/compress/archivers/sevenz/SevenZOutputFileTest.java b/src/test/java/org/apache/commons/compress/archivers/sevenz/SevenZOutputFileTest.java index feb988a240..058c9e3382 100644 --- a/src/test/java/org/apache/commons/compress/archivers/sevenz/SevenZOutputFileTest.java +++ b/src/test/java/org/apache/commons/compress/archivers/sevenz/SevenZOutputFileTest.java @@ -38,7 +38,8 @@ public class SevenZOutputFileTest extends AbstractTestCase { static { final String version = org.tukaani.xz.XZ.class.getPackage().getImplementationVersion(); - XZ_BCJ_IS_BUGGY=version.equals("1.4"); + + XZ_BCJ_IS_BUGGY= version != null && version.equals("1.4"); if (XZ_BCJ_IS_BUGGY) { System.out.println("XZ version is " + version + " - skipping BCJ tests"); } From 5646aa5198dc457356642d0a65cb337ed261b6b5 Mon Sep 17 00:00:00 2001 From: Simon Spero Date: Sun, 25 Jun 2017 16:57:16 -0400 Subject: [PATCH 4/5] Slight speed up by avoiding writing to disk Signed-off-by: Simon Spero --- .../lz4/FramedLZ4CompressorRoundtripTest.java | 24 +++++++++++-------- 1 file changed, 14 insertions(+), 10 deletions(-) diff --git a/src/test/java/org/apache/commons/compress/compressors/lz4/FramedLZ4CompressorRoundtripTest.java b/src/test/java/org/apache/commons/compress/compressors/lz4/FramedLZ4CompressorRoundtripTest.java index ea63c1d18d..29e4443914 100644 --- a/src/test/java/org/apache/commons/compress/compressors/lz4/FramedLZ4CompressorRoundtripTest.java +++ b/src/test/java/org/apache/commons/compress/compressors/lz4/FramedLZ4CompressorRoundtripTest.java @@ -18,20 +18,20 @@ */ package org.apache.commons.compress.compressors.lz4; +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileInputStream; -import java.io.FileOutputStream; import java.io.IOException; import java.util.Arrays; import java.util.Collection; - import org.apache.commons.compress.AbstractTestCase; import org.apache.commons.compress.utils.IOUtils; import org.junit.Assert; import org.junit.Test; +import org.junit.runner.RunWith; import org.junit.runners.Parameterized; import org.junit.runners.Parameterized.Parameters; -import org.junit.runner.RunWith; @RunWith(Parameterized.class) public final class FramedLZ4CompressorRoundtripTest extends AbstractTestCase { @@ -69,20 +69,24 @@ private void roundTripTest(String testFile) throws IOException { File input = getFile(testFile); long start = System.currentTimeMillis(); final File outputSz = new File(dir, input.getName() + ".framed.lz4"); - try (FileInputStream is = new FileInputStream(input); - FileOutputStream os = new FileOutputStream(outputSz); - FramedLZ4CompressorOutputStream los = new FramedLZ4CompressorOutputStream(os, params)) { - IOUtils.copy(is, los); + byte[] expected; + try (FileInputStream is = new FileInputStream(input)) { + expected = IOUtils.toByteArray(is); + } + ByteArrayOutputStream bos = new ByteArrayOutputStream(); + try (FramedLZ4CompressorOutputStream los = new FramedLZ4CompressorOutputStream(bos, + params)) { + IOUtils.copy(new ByteArrayInputStream(expected), los); } System.err.println(input.getName() + " written, uncompressed bytes: " + input.length() + ", compressed bytes: " + outputSz.length() + " after " + (System.currentTimeMillis() - start) + "ms"); start = System.currentTimeMillis(); - try (FileInputStream is = new FileInputStream(input); - FramedLZ4CompressorInputStream sis = new FramedLZ4CompressorInputStream(new FileInputStream(outputSz))) { - byte[] expected = IOUtils.toByteArray(is); + try (FramedLZ4CompressorInputStream sis = new FramedLZ4CompressorInputStream( + new ByteArrayInputStream(bos.toByteArray()))) { byte[] actual = IOUtils.toByteArray(sis); Assert.assertArrayEquals(expected, actual); } + System.err.println(outputSz.getName() + " read after " + (System.currentTimeMillis() - start) + "ms"); } From a864cc8be49778cc9c3d549f8daf69f616a732f1 Mon Sep 17 00:00:00 2001 From: Simon Spero Date: Sun, 25 Jun 2017 16:57:23 -0400 Subject: [PATCH 5/5] Slight test speed up by avoiding more writing to disk Signed-off-by: Simon Spero --- .../snappy/SnappyRoundtripTest.java | 27 ++++++++++++++++--- 1 file changed, 24 insertions(+), 3 deletions(-) diff --git a/src/test/java/org/apache/commons/compress/compressors/snappy/SnappyRoundtripTest.java b/src/test/java/org/apache/commons/compress/compressors/snappy/SnappyRoundtripTest.java index 8b96309139..350ef4ee76 100644 --- a/src/test/java/org/apache/commons/compress/compressors/snappy/SnappyRoundtripTest.java +++ b/src/test/java/org/apache/commons/compress/compressors/snappy/SnappyRoundtripTest.java @@ -18,6 +18,8 @@ */ package org.apache.commons.compress.compressors.snappy; +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; import java.io.File; import java.io.FileInputStream; import java.io.FileOutputStream; @@ -57,6 +59,25 @@ private void roundTripTest(final File input, Parameters params) throws IOExcepti } System.err.println(outputSz.getName() + " read after " + (System.currentTimeMillis() - start) + "ms"); } + private void roundTripTest(final byte[] input, Parameters params) throws IOException { + long start = System.currentTimeMillis(); + ByteArrayOutputStream os = new ByteArrayOutputStream(); + try ( + SnappyCompressorOutputStream sos = new SnappyCompressorOutputStream(os, input.length, params)) { + sos.write(input); + } + System.err.println("byte array" + " written, uncompressed bytes: " + input.length + + ", compressed bytes: " + os.size() + " after " + (System.currentTimeMillis() - start) + "ms"); + start = System.currentTimeMillis(); + try ( + SnappyCompressorInputStream sis = new SnappyCompressorInputStream(new ByteArrayInputStream(os.toByteArray()), + params.getWindowSize())) { + byte[] expected = input; + byte[] actual = IOUtils.toByteArray(sis); + Assert.assertArrayEquals(expected, actual); + } + System.err.println("byte array" + " read after " + (System.currentTimeMillis() - start) + "ms"); + } // should yield decent compression @Test @@ -108,7 +129,7 @@ public void tryReallyBigOffset() throws IOException { // of random noise that doesn't contain any 0000 at all, then // add 0000. File f = new File(dir, "reallyBigOffsetTest"); - try (FileOutputStream fs = new FileOutputStream(f)) { + ByteArrayOutputStream fs = new ByteArrayOutputStream((1<<16) + 1024); fs.write(0); fs.write(0); fs.write(0); @@ -122,8 +143,8 @@ public void tryReallyBigOffset() throws IOException { fs.write(0); fs.write(0); fs.write(0); - } - roundTripTest(f, newParameters(1 << 17, 4, 64, 1 << 17 - 1, 1 << 17 - 1)); + + roundTripTest(fs.toByteArray(), newParameters(1 << 17, 4, 64, 1 << 17 - 1, 1 << 17 - 1)); } @Test