This is an automated email from the ASF dual-hosted git repository.
ggregory pushed a commit to branch master
in repository https://gitbox.apache.org/repos/asf/commons-compress.git
commit b03f5c515c2f1fbddd30bd201239e1bf13b6ddda
Author: Gary Gregory <garydgreg...@gmail.com>
AuthorDate: Fri Nov 10 15:44:14 2023 -0500
Use final
Sort members
---
.../compressors/CompressorStreamFactory.java | 4 +-
.../compress/compressors/DetectCompressorTest.java | 190 ++++++++++-----------
2 files changed, 97 insertions(+), 97 deletions(-)
diff --git
a/src/main/java/org/apache/commons/compress/compressors/CompressorStreamFactory.java
b/src/main/java/org/apache/commons/compress/compressors/CompressorStreamFactory.java
index 5bc2e786d..4629633cd 100644
---
a/src/main/java/org/apache/commons/compress/compressors/CompressorStreamFactory.java
+++
b/src/main/java/org/apache/commons/compress/compressors/CompressorStreamFactory.java
@@ -208,6 +208,8 @@ public class CompressorStreamFactory implements
CompressorStreamProvider {
private static final String YOU_NEED_XZ_JAVA = youNeed("XZ for Java",
"https://tukaani.org/xz/java.html";);
private static final String YOU_NEED_ZSTD_JNI = youNeed("Zstd JNI",
"https://github.com/luben/zstd-jni";);
+ private static final Set<String> ALL_NAMES = Sets.newHashSet(BZIP2, GZIP,
PACK200, SNAPPY_FRAMED, Z, DEFLATE, XZ, LZMA, LZ4_FRAMED, ZSTANDARD);
+
private static Iterable<CompressorStreamProvider>
archiveStreamProviderIterable() {
return ServiceLoader.load(CompressorStreamProvider.class,
ClassLoader.getSystemClassLoader());
}
@@ -476,8 +478,6 @@ public class CompressorStreamFactory implements
CompressorStreamProvider {
private final int memoryLimitInKb;
- private static final Set<String> ALL_NAMES = Sets.newHashSet(BZIP2, GZIP,
PACK200, SNAPPY_FRAMED, Z, DEFLATE, XZ, LZMA, LZ4_FRAMED, ZSTANDARD);
-
/**
* Constructs an instance with the decompress Concatenated option set to
false.
*/
diff --git
a/src/test/java/org/apache/commons/compress/compressors/DetectCompressorTest.java
b/src/test/java/org/apache/commons/compress/compressors/DetectCompressorTest.java
index c8970294a..4acda7b5f 100644
---
a/src/test/java/org/apache/commons/compress/compressors/DetectCompressorTest.java
+++
b/src/test/java/org/apache/commons/compress/compressors/DetectCompressorTest.java
@@ -80,6 +80,21 @@ public final class DetectCompressorTest {
factorySetFalse.setDecompressConcatenated(false);
}
+ public static Stream<Arguments> getDetectLimitedByNameParams() {
+ return Stream.of(
+ Arguments.of("bla.txt.bz2", CompressorStreamFactory.BZIP2),
+ Arguments.of("bla.tgz", CompressorStreamFactory.GZIP),
+ Arguments.of("bla.pack", CompressorStreamFactory.PACK200),
+ Arguments.of("bla.tar.xz", CompressorStreamFactory.XZ),
+ Arguments.of("bla.tar.deflatez",
CompressorStreamFactory.DEFLATE),
+ Arguments.of("bla.tar.lz4",
CompressorStreamFactory.LZ4_FRAMED),
+ Arguments.of("bla.tar.lzma", CompressorStreamFactory.LZMA),
+ Arguments.of("bla.tar.sz",
CompressorStreamFactory.SNAPPY_FRAMED),
+ Arguments.of("bla.tar.Z", CompressorStreamFactory.Z),
+ Arguments.of("bla.tar.zst", CompressorStreamFactory.ZSTANDARD)
+ );
+ }
+
final CompressorStreamFactory factory = new CompressorStreamFactory();
private final TestData[] tests = {
@@ -109,11 +124,6 @@ public final class DetectCompressorTest {
getFile(resource).toPath())));
}
- @SuppressWarnings("resource") // Caller closes.
- private CompressorInputStream createStreamFor(final String resource, final
Set<String> compressorNames) throws CompressorException, IOException {
- return factory.createCompressorInputStream(new
BufferedInputStream(Files.newInputStream(getFile(resource).toPath())),
compressorNames);
- }
-
@SuppressWarnings("resource") // Caller closes.
private CompressorInputStream createStreamFor(final String resource, final
CompressorStreamFactory factory) throws CompressorException, IOException {
return factory.createCompressorInputStream(new
BufferedInputStream(Files.newInputStream(getFile(resource).toPath())));
@@ -134,6 +144,11 @@ public final class DetectCompressorTest {
}
+ @SuppressWarnings("resource") // Caller closes.
+ private CompressorInputStream createStreamFor(final String resource, final
Set<String> compressorNames) throws CompressorException, IOException {
+ return factory.createCompressorInputStream(new
BufferedInputStream(Files.newInputStream(getFile(resource).toPath())),
compressorNames);
+ }
+
private String detect(final String testFileName) throws IOException,
CompressorException {
return detect(testFileName, null);
}
@@ -145,72 +160,46 @@ public final class DetectCompressorTest {
}
@Test
- public void testDetect() throws Exception {
- assertEquals(CompressorStreamFactory.BZIP2, detect("bla.txt.bz2"));
- assertEquals(CompressorStreamFactory.GZIP, detect("bla.tgz"));
- assertEquals(CompressorStreamFactory.PACK200, detect("bla.pack"));
- assertEquals(CompressorStreamFactory.XZ, detect("bla.tar.xz"));
- assertEquals(CompressorStreamFactory.DEFLATE,
detect("bla.tar.deflatez"));
- assertEquals(CompressorStreamFactory.LZ4_FRAMED,
detect("bla.tar.lz4"));
- assertEquals(CompressorStreamFactory.LZMA, detect("bla.tar.lzma"));
- assertEquals(CompressorStreamFactory.SNAPPY_FRAMED,
detect("bla.tar.sz"));
- assertEquals(CompressorStreamFactory.Z, detect("bla.tar.Z"));
- assertEquals(CompressorStreamFactory.ZSTANDARD, detect("bla.tar.zst"));
-
- //make sure we don't oom on detect
- assertEquals(CompressorStreamFactory.Z, detect("COMPRESS-386"));
- assertEquals(CompressorStreamFactory.LZMA, detect("COMPRESS-382"));
-
- assertThrows(CompressorException.class, () ->
CompressorStreamFactory.detect(new BufferedInputStream(new
ByteArrayInputStream(ByteUtils.EMPTY_BYTE_ARRAY))));
+ public void testCreateLimitedByName() throws Exception {
+ try (CompressorInputStream bzip2 = createStreamFor("bla.txt.bz2",
Collections.singleton(CompressorStreamFactory.BZIP2))) {
+ assertNotNull(bzip2);
+ assertTrue(bzip2 instanceof BZip2CompressorInputStream);
+ }
- final IllegalArgumentException e =
assertThrows(IllegalArgumentException.class, () ->
CompressorStreamFactory.detect(null), "shouldn't be able to detect null
stream");
- assertEquals("Stream must not be null.", e.getMessage());
+ try (CompressorInputStream gzip = createStreamFor("bla.tgz",
Collections.singleton(CompressorStreamFactory.GZIP))) {
+ assertNotNull(gzip);
+ assertTrue(gzip instanceof GzipCompressorInputStream);
+ }
- final CompressorException ce = assertThrows(CompressorException.class,
() -> CompressorStreamFactory.detect(new BufferedInputStream(new
BrokenInputStream())), "Expected IOException");
- assertEquals("IOException while reading signature.", ce.getMessage());
- }
+ try (CompressorInputStream pack200 = createStreamFor("bla.pack",
Collections.singleton(CompressorStreamFactory.PACK200))) {
+ assertNotNull(pack200);
+ assertTrue(pack200 instanceof Pack200CompressorInputStream);
+ }
- @Test
- public void testDetectNullOrEmptyCompressorNames() throws Exception {
- assertThrows(IllegalArgumentException.class, () ->
CompressorStreamFactory.detect(createStreamFor("bla.txt.bz2"), (Set<String>)
null));
- assertThrows(IllegalArgumentException.class, () ->
CompressorStreamFactory.detect(createStreamFor("bla.tgz"), new HashSet<>()));
- }
+ try (CompressorInputStream xz = createStreamFor("bla.tar.xz",
Collections.singleton(CompressorStreamFactory.XZ))) {
+ assertNotNull(xz);
+ assertTrue(xz instanceof XZCompressorInputStream);
+ }
- public static Stream<Arguments> limitedByNameData() {
- return Stream.of(
- Arguments.of("bla.txt.bz2", CompressorStreamFactory.BZIP2),
- Arguments.of("bla.tgz", CompressorStreamFactory.GZIP),
- Arguments.of("bla.pack", CompressorStreamFactory.PACK200),
- Arguments.of("bla.tar.xz", CompressorStreamFactory.XZ),
- Arguments.of("bla.tar.deflatez",
CompressorStreamFactory.DEFLATE),
- Arguments.of("bla.tar.lz4",
CompressorStreamFactory.LZ4_FRAMED),
- Arguments.of("bla.tar.lzma", CompressorStreamFactory.LZMA),
- Arguments.of("bla.tar.sz",
CompressorStreamFactory.SNAPPY_FRAMED),
- Arguments.of("bla.tar.Z", CompressorStreamFactory.Z),
- Arguments.of("bla.tar.zst", CompressorStreamFactory.ZSTANDARD)
- );
- }
+ try (CompressorInputStream zlib = createStreamFor("bla.tar.deflatez",
Collections.singleton(CompressorStreamFactory.DEFLATE))) {
+ assertNotNull(zlib);
+ assertTrue(zlib instanceof DeflateCompressorInputStream);
+ }
- @ParameterizedTest
- @MethodSource("limitedByNameData")
- public void testDetectLimitedByName(final String filename, final String
compressorName) throws Exception {
- assertEquals(compressorName, detect(filename,
Collections.singleton(compressorName)));
+ try (CompressorInputStream zstd = createStreamFor("bla.tar.zst",
Collections.singleton(CompressorStreamFactory.ZSTANDARD))) {
+ assertNotNull(zstd);
+ assertTrue(zstd instanceof ZstdCompressorInputStream);
+ }
}
@Test
- public void testDetectLimitedByNameNotFound() throws Exception {
- Set<String> compressorNames =
Collections.singleton(CompressorStreamFactory.DEFLATE);
-
- assertThrows(CompressorException.class, () -> detect("bla.txt.bz2",
compressorNames));
- assertThrows(CompressorException.class, () -> detect("bla.tgz",
compressorNames));
- assertThrows(CompressorException.class, () -> detect("bla.pack",
compressorNames));
- assertThrows(CompressorException.class, () -> detect("bla.tar.xz",
compressorNames));
- assertThrows(CompressorException.class, () ->
detect("bla.tar.deflatez",
Collections.singleton(CompressorStreamFactory.BZIP2)));
- assertThrows(CompressorException.class, () -> detect("bla.tar.lz4",
compressorNames));
- assertThrows(CompressorException.class, () -> detect("bla.tar.lzma",
compressorNames));
- assertThrows(CompressorException.class, () -> detect("bla.tar.sz",
compressorNames));
- assertThrows(CompressorException.class, () -> detect("bla.tar.Z",
compressorNames));
- assertThrows(CompressorException.class, () -> detect("bla.tar.zst",
compressorNames));
+ public void testCreateLimitedByNameNotFound() throws Exception {
+ assertThrows(CompressorException.class, () ->
createStreamFor("bla.txt.bz2",
Collections.singleton(CompressorStreamFactory.BROTLI)));
+ assertThrows(CompressorException.class, () ->
createStreamFor("bla.tgz", Collections.singleton(CompressorStreamFactory.Z)));
+ assertThrows(CompressorException.class, () ->
createStreamFor("bla.pack",
Collections.singleton(CompressorStreamFactory.SNAPPY_FRAMED)));
+ assertThrows(CompressorException.class, () ->
createStreamFor("bla.tar.xz",
Collections.singleton(CompressorStreamFactory.GZIP)));
+ assertThrows(CompressorException.class, () ->
createStreamFor("bla.tar.deflatez",
Collections.singleton(CompressorStreamFactory.PACK200)));
+ assertThrows(CompressorException.class, () ->
createStreamFor("bla.tar.zst",
Collections.singleton(CompressorStreamFactory.LZ4_FRAMED)));
}
@Test
@@ -249,46 +238,57 @@ public final class DetectCompressorTest {
}
@Test
- public void testCreateLimitedByName() throws Exception {
- try (CompressorInputStream bzip2 = createStreamFor("bla.txt.bz2",
Collections.singleton(CompressorStreamFactory.BZIP2))) {
- assertNotNull(bzip2);
- assertTrue(bzip2 instanceof BZip2CompressorInputStream);
- }
+ public void testDetect() throws Exception {
+ assertEquals(CompressorStreamFactory.BZIP2, detect("bla.txt.bz2"));
+ assertEquals(CompressorStreamFactory.GZIP, detect("bla.tgz"));
+ assertEquals(CompressorStreamFactory.PACK200, detect("bla.pack"));
+ assertEquals(CompressorStreamFactory.XZ, detect("bla.tar.xz"));
+ assertEquals(CompressorStreamFactory.DEFLATE,
detect("bla.tar.deflatez"));
+ assertEquals(CompressorStreamFactory.LZ4_FRAMED,
detect("bla.tar.lz4"));
+ assertEquals(CompressorStreamFactory.LZMA, detect("bla.tar.lzma"));
+ assertEquals(CompressorStreamFactory.SNAPPY_FRAMED,
detect("bla.tar.sz"));
+ assertEquals(CompressorStreamFactory.Z, detect("bla.tar.Z"));
+ assertEquals(CompressorStreamFactory.ZSTANDARD, detect("bla.tar.zst"));
- try (CompressorInputStream gzip = createStreamFor("bla.tgz",
Collections.singleton(CompressorStreamFactory.GZIP))) {
- assertNotNull(gzip);
- assertTrue(gzip instanceof GzipCompressorInputStream);
- }
+ //make sure we don't oom on detect
+ assertEquals(CompressorStreamFactory.Z, detect("COMPRESS-386"));
+ assertEquals(CompressorStreamFactory.LZMA, detect("COMPRESS-382"));
- try (CompressorInputStream pack200 = createStreamFor("bla.pack",
Collections.singleton(CompressorStreamFactory.PACK200))) {
- assertNotNull(pack200);
- assertTrue(pack200 instanceof Pack200CompressorInputStream);
- }
+ assertThrows(CompressorException.class, () ->
CompressorStreamFactory.detect(new BufferedInputStream(new
ByteArrayInputStream(ByteUtils.EMPTY_BYTE_ARRAY))));
- try (CompressorInputStream xz = createStreamFor("bla.tar.xz",
Collections.singleton(CompressorStreamFactory.XZ))) {
- assertNotNull(xz);
- assertTrue(xz instanceof XZCompressorInputStream);
- }
+ final IllegalArgumentException e =
assertThrows(IllegalArgumentException.class, () ->
CompressorStreamFactory.detect(null), "shouldn't be able to detect null
stream");
+ assertEquals("Stream must not be null.", e.getMessage());
- try (CompressorInputStream zlib = createStreamFor("bla.tar.deflatez",
Collections.singleton(CompressorStreamFactory.DEFLATE))) {
- assertNotNull(zlib);
- assertTrue(zlib instanceof DeflateCompressorInputStream);
- }
+ final CompressorException ce = assertThrows(CompressorException.class,
() -> CompressorStreamFactory.detect(new BufferedInputStream(new
BrokenInputStream())), "Expected IOException");
+ assertEquals("IOException while reading signature.", ce.getMessage());
+ }
- try (CompressorInputStream zstd = createStreamFor("bla.tar.zst",
Collections.singleton(CompressorStreamFactory.ZSTANDARD))) {
- assertNotNull(zstd);
- assertTrue(zstd instanceof ZstdCompressorInputStream);
- }
+ @ParameterizedTest
+ @MethodSource("getDetectLimitedByNameParams")
+ public void testDetectLimitedByName(final String filename, final String
compressorName) throws Exception {
+ assertEquals(compressorName, detect(filename,
Collections.singleton(compressorName)));
}
@Test
- public void testCreateLimitedByNameNotFound() throws Exception {
- assertThrows(CompressorException.class, () ->
createStreamFor("bla.txt.bz2",
Collections.singleton(CompressorStreamFactory.BROTLI)));
- assertThrows(CompressorException.class, () ->
createStreamFor("bla.tgz", Collections.singleton(CompressorStreamFactory.Z)));
- assertThrows(CompressorException.class, () ->
createStreamFor("bla.pack",
Collections.singleton(CompressorStreamFactory.SNAPPY_FRAMED)));
- assertThrows(CompressorException.class, () ->
createStreamFor("bla.tar.xz",
Collections.singleton(CompressorStreamFactory.GZIP)));
- assertThrows(CompressorException.class, () ->
createStreamFor("bla.tar.deflatez",
Collections.singleton(CompressorStreamFactory.PACK200)));
- assertThrows(CompressorException.class, () ->
createStreamFor("bla.tar.zst",
Collections.singleton(CompressorStreamFactory.LZ4_FRAMED)));
+ public void testDetectLimitedByNameNotFound() throws Exception {
+ final Set<String> compressorNames =
Collections.singleton(CompressorStreamFactory.DEFLATE);
+
+ assertThrows(CompressorException.class, () -> detect("bla.txt.bz2",
compressorNames));
+ assertThrows(CompressorException.class, () -> detect("bla.tgz",
compressorNames));
+ assertThrows(CompressorException.class, () -> detect("bla.pack",
compressorNames));
+ assertThrows(CompressorException.class, () -> detect("bla.tar.xz",
compressorNames));
+ assertThrows(CompressorException.class, () ->
detect("bla.tar.deflatez",
Collections.singleton(CompressorStreamFactory.BZIP2)));
+ assertThrows(CompressorException.class, () -> detect("bla.tar.lz4",
compressorNames));
+ assertThrows(CompressorException.class, () -> detect("bla.tar.lzma",
compressorNames));
+ assertThrows(CompressorException.class, () -> detect("bla.tar.sz",
compressorNames));
+ assertThrows(CompressorException.class, () -> detect("bla.tar.Z",
compressorNames));
+ assertThrows(CompressorException.class, () -> detect("bla.tar.zst",
compressorNames));
+ }
+
+ @Test
+ public void testDetectNullOrEmptyCompressorNames() throws Exception {
+ assertThrows(IllegalArgumentException.class, () ->
CompressorStreamFactory.detect(createStreamFor("bla.txt.bz2"), (Set<String>)
null));
+ assertThrows(IllegalArgumentException.class, () ->
CompressorStreamFactory.detect(createStreamFor("bla.tgz"), new HashSet<>()));
}
@Test
