582 lines
24 KiB
Java
582 lines
24 KiB
Java
/*
|
|
* Copyright (c) 2021, Oracle and/or its affiliates. All rights reserved.
|
|
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
|
|
*
|
|
* This code is free software; you can redistribute it and/or modify it
|
|
* under the terms of the GNU General Public License version 2 only, as
|
|
* published by the Free Software Foundation.
|
|
*
|
|
* This code is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
* version 2 for more details (a copy is included in the LICENSE file that
|
|
* accompanied this code).
|
|
*
|
|
* You should have received a copy of the GNU General Public License version
|
|
* 2 along with this work; if not, write to the Free Software Foundation,
|
|
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*
|
|
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
|
|
* or visit www.oracle.com if you need additional information or have any
|
|
* questions.
|
|
*
|
|
*/
|
|
|
|
import org.testng.annotations.AfterTest;
|
|
import org.testng.annotations.BeforeTest;
|
|
import org.testng.annotations.DataProvider;
|
|
import org.testng.annotations.Test;
|
|
|
|
import java.io.ByteArrayOutputStream;
|
|
import java.io.FileInputStream;
|
|
import java.io.IOException;
|
|
import java.io.InputStream;
|
|
import java.net.JarURLConnection;
|
|
import java.net.URL;
|
|
import java.nio.charset.StandardCharsets;
|
|
import java.nio.file.Files;
|
|
import java.nio.file.Path;
|
|
import java.nio.file.Paths;
|
|
import java.util.Arrays;
|
|
import java.util.Formatter;
|
|
import java.util.List;
|
|
import java.util.jar.JarEntry;
|
|
import java.util.jar.JarFile;
|
|
import java.util.jar.JarInputStream;
|
|
import java.util.jar.JarOutputStream;
|
|
import java.util.stream.Collectors;
|
|
import java.util.zip.ZipEntry;
|
|
import java.util.zip.ZipFile;
|
|
import java.util.zip.ZipInputStream;
|
|
import java.util.zip.ZipOutputStream;
|
|
|
|
import static org.testng.Assert.*;
|
|
|
|
/**
|
|
* @test
|
|
* @bug 8276123
|
|
* @summary ZipFile::getEntry will not return a file entry when there is a
|
|
* directory entry of the same name within a Zip File
|
|
* @run testng/othervm ZipFileDuplicateEntryTest
|
|
*/
|
|
public class ZipFileDuplicateEntryTest {
|
|
|
|
/**
|
|
* Name to use for creating Zip entries
|
|
*/
|
|
private static final String ENTRY_NAME = "entry";
|
|
|
|
/**
|
|
* Zip and Jar files to be created
|
|
*/
|
|
private static final Path ZIP_FILE = Paths.get("fileDirEntry.zip");
|
|
private static final Path ZIP_FILE2 = Paths.get("OnlyDirEntry.zip");
|
|
private static final Path DUPLICATE_FILE_ENTRY_FILE = Paths.get("DupFIleEntry.zip");
|
|
private static final Path TEST_JAR = Paths.get("fileDirEntry.jar");
|
|
|
|
/**
|
|
* Directory entry added to the Zip File.
|
|
*/
|
|
private static final Entry DIR_ENTRY =
|
|
Entry.of(ENTRY_NAME + "/", ZipEntry.DEFLATED,
|
|
"I am a Directory");
|
|
|
|
/**
|
|
* File entry added to the Zip File.
|
|
*/
|
|
private static final Entry FILE_ENTRY =
|
|
Entry.of(ENTRY_NAME, ZipEntry.DEFLATED, "I am a File");
|
|
|
|
/**
|
|
* Duplicate File entry added to the Zip file. This is the 2nd entry added
|
|
* to the Zip file and is expected to be returned.
|
|
*/
|
|
private static final Entry DUPLICATE_FILE_ENTRY =
|
|
Entry.of(ENTRY_NAME, ZipEntry.DEFLATED, "Yet another File");
|
|
/**
|
|
* Entries expected to be returned via ZipFile::stream
|
|
*/
|
|
private static final List<String> EXPECTED_ENTRIES =
|
|
Arrays.asList(FILE_ENTRY.name, DIR_ENTRY.name);
|
|
|
|
/**
|
|
* Max buffer size for readAllBytes method which can be used when
|
|
* InputStream::readAllBytes is not available
|
|
*/
|
|
private static final int MAX_BUFFER_SIZE = 1024;
|
|
|
|
/**
|
|
* Flag to enable test output
|
|
*/
|
|
private static final boolean DEBUG = false;
|
|
|
|
/**
|
|
* Array representing a Jar File with the entries:
|
|
* Name: entry, contents: "I am a File"
|
|
* Name: entry, contents: "Yet another File"
|
|
* See createByteArray()
|
|
*/
|
|
private static final byte[] DUPLICATE_ENTRY_JAR_BYTES = {
|
|
(byte) 0x50, (byte) 0x4b, (byte) 0x3, (byte) 0x4, (byte) 0x14, (byte) 0x0, (byte) 0x0, (byte) 0x8,
|
|
(byte) 0x8, (byte) 0x0, (byte) 0x60, (byte) 0x59, (byte) 0x55, (byte) 0x53, (byte) 0x8e, (byte) 0x39,
|
|
(byte) 0x14, (byte) 0x49, (byte) 0xd, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0xb, (byte) 0x0,
|
|
(byte) 0x0, (byte) 0x0, (byte) 0x5, (byte) 0x0, (byte) 0x14, (byte) 0x0, (byte) 0x65, (byte) 0x6e,
|
|
(byte) 0x74, (byte) 0x72, (byte) 0x79, (byte) 0x1, (byte) 0x0, (byte) 0x10, (byte) 0x0, (byte) 0xb,
|
|
(byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0xd,
|
|
(byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0xf3,
|
|
(byte) 0x54, (byte) 0x48, (byte) 0xcc, (byte) 0x55, (byte) 0x48, (byte) 0x54, (byte) 0x70, (byte) 0xcb,
|
|
(byte) 0xcc, (byte) 0x49, (byte) 0x5, (byte) 0x0, (byte) 0x50, (byte) 0x4b, (byte) 0x3, (byte) 0x4,
|
|
(byte) 0x14, (byte) 0x0, (byte) 0x0, (byte) 0x8, (byte) 0x8, (byte) 0x0, (byte) 0x60, (byte) 0x59,
|
|
(byte) 0x55, (byte) 0x53, (byte) 0xe1, (byte) 0x4c, (byte) 0x29, (byte) 0xa4, (byte) 0x12, (byte) 0x0,
|
|
(byte) 0x0, (byte) 0x0, (byte) 0x10, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x5, (byte) 0x0,
|
|
(byte) 0x14, (byte) 0x0, (byte) 0x65, (byte) 0x6e, (byte) 0x74, (byte) 0x72, (byte) 0x79, (byte) 0x1,
|
|
(byte) 0x0, (byte) 0x10, (byte) 0x0, (byte) 0x10, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0,
|
|
(byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x12, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0,
|
|
(byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x8b, (byte) 0x4c, (byte) 0x2d, (byte) 0x51, (byte) 0x48,
|
|
(byte) 0xcc, (byte) 0xcb, (byte) 0x2f, (byte) 0xc9, (byte) 0x48, (byte) 0x2d, (byte) 0x52, (byte) 0x70,
|
|
(byte) 0xcb, (byte) 0xcc, (byte) 0x49, (byte) 0x5, (byte) 0x0, (byte) 0x50, (byte) 0x4b, (byte) 0x1,
|
|
(byte) 0x2, (byte) 0x14, (byte) 0x0, (byte) 0x14, (byte) 0x0, (byte) 0x0, (byte) 0x8, (byte) 0x8,
|
|
(byte) 0x0, (byte) 0x60, (byte) 0x59, (byte) 0x55, (byte) 0x53, (byte) 0x8e, (byte) 0x39, (byte) 0x14,
|
|
(byte) 0x49, (byte) 0xd, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0xb, (byte) 0x0, (byte) 0x0,
|
|
(byte) 0x0, (byte) 0x5, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0,
|
|
(byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0,
|
|
(byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x65, (byte) 0x6e, (byte) 0x74, (byte) 0x72, (byte) 0x79,
|
|
(byte) 0x50, (byte) 0x4b, (byte) 0x1, (byte) 0x2, (byte) 0x14, (byte) 0x0, (byte) 0x14, (byte) 0x0,
|
|
(byte) 0x0, (byte) 0x8, (byte) 0x8, (byte) 0x0, (byte) 0x60, (byte) 0x59, (byte) 0x55, (byte) 0x53,
|
|
(byte) 0xe1, (byte) 0x4c, (byte) 0x29, (byte) 0xa4, (byte) 0x12, (byte) 0x0, (byte) 0x0, (byte) 0x0,
|
|
(byte) 0x10, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x5, (byte) 0x0, (byte) 0x0, (byte) 0x0,
|
|
(byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0,
|
|
(byte) 0x0, (byte) 0x0, (byte) 0x44, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x65, (byte) 0x6e,
|
|
(byte) 0x74, (byte) 0x72, (byte) 0x79, (byte) 0x50, (byte) 0x4b, (byte) 0x5, (byte) 0x6, (byte) 0x0,
|
|
(byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x2, (byte) 0x0, (byte) 0x2, (byte) 0x0, (byte) 0x66,
|
|
(byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x8d, (byte) 0x0, (byte) 0x0, (byte) 0x0, (byte) 0x0,
|
|
(byte) 0x0,
|
|
};
|
|
|
|
/**
|
|
* Create Zip files used by the tests.
|
|
*
|
|
* @throws IOException If an error occurs
|
|
*/
|
|
@BeforeTest
|
|
public static void setup() throws IOException {
|
|
|
|
/**
|
|
* Zip contains two entries named "entry" and "entry/"
|
|
*/
|
|
Files.deleteIfExists(ZIP_FILE);
|
|
try (ZipOutputStream zos = new ZipOutputStream(Files.newOutputStream(ZIP_FILE))) {
|
|
zos.putNextEntry(new ZipEntry(FILE_ENTRY.name));
|
|
zos.write(FILE_ENTRY.bytes);
|
|
zos.closeEntry();
|
|
zos.putNextEntry(new ZipEntry(DIR_ENTRY.name));
|
|
zos.write(DIR_ENTRY.bytes);
|
|
zos.closeEntry();
|
|
}
|
|
|
|
/**
|
|
* Jar contains two entries named "entry" and "entry/"
|
|
*/
|
|
Files.deleteIfExists(TEST_JAR);
|
|
try (JarOutputStream jos = new JarOutputStream(Files.newOutputStream(TEST_JAR))) {
|
|
jos.putNextEntry(new JarEntry(FILE_ENTRY.name));
|
|
jos.write(FILE_ENTRY.bytes);
|
|
jos.closeEntry();
|
|
jos.putNextEntry(new JarEntry(DIR_ENTRY.name));
|
|
jos.write(DIR_ENTRY.bytes);
|
|
jos.closeEntry();
|
|
}
|
|
|
|
/**
|
|
* Zip contains the entry "entry/"
|
|
*/
|
|
Files.deleteIfExists(ZIP_FILE2);
|
|
try (ZipOutputStream zos = new ZipOutputStream(Files.newOutputStream(ZIP_FILE2))) {
|
|
zos.putNextEntry(new ZipEntry(DIR_ENTRY.name));
|
|
zos.write(DIR_ENTRY.bytes);
|
|
zos.closeEntry();
|
|
}
|
|
|
|
/**
|
|
* Create a Jar that contains two entries named "entry"
|
|
*/
|
|
Files.deleteIfExists(DUPLICATE_FILE_ENTRY_FILE);
|
|
Files.write(DUPLICATE_FILE_ENTRY_FILE, DUPLICATE_ENTRY_JAR_BYTES);
|
|
}
|
|
|
|
/**
|
|
* Clean up after the test run
|
|
*
|
|
* @throws IOException If an error occurs
|
|
*/
|
|
@AfterTest
|
|
public static void cleanup() throws IOException {
|
|
Files.deleteIfExists(ZIP_FILE);
|
|
Files.deleteIfExists(ZIP_FILE2);
|
|
Files.deleteIfExists(DUPLICATE_FILE_ENTRY_FILE);
|
|
Files.deleteIfExists(TEST_JAR);
|
|
}
|
|
|
|
/**
|
|
* DataProvider used to specify the Zip entries to use
|
|
*
|
|
* @return The Entry to use within the test
|
|
*/
|
|
@DataProvider
|
|
public Object[][] entries() {
|
|
return new Object[][]{
|
|
{FILE_ENTRY},
|
|
{DIR_ENTRY}
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Test whether ZipFile::getEntry can find a directory entry within a Zip
|
|
* file specifying "name" vs "name/"
|
|
*
|
|
* @throws IOException If an error occurs
|
|
*/
|
|
@Test
|
|
public void readDirWithoutSlash() throws IOException {
|
|
System.out.printf("%n%n**** readDirWithoutSlash ***%n");
|
|
try (ZipFile zip = new ZipFile(ZIP_FILE2.toString())) {
|
|
ZipEntry ze = zip.getEntry(ENTRY_NAME);
|
|
if (DEBUG) {
|
|
System.out.printf(" Entry:%s, found:%s%n", ENTRY_NAME, ze != null);
|
|
}
|
|
assertNotNull(ze);
|
|
assertTrue(ze.isDirectory());
|
|
try (InputStream in = zip.getInputStream(ze)) {
|
|
byte[] bytes = in.readAllBytes();
|
|
if (DEBUG) {
|
|
System.out.printf("name: %s, isDirectory: %s, payload= %s%n",
|
|
ze.getName(), ze.isDirectory(), new String(bytes));
|
|
}
|
|
assertEquals(bytes, DIR_ENTRY.bytes,
|
|
String.format("Expected payload: %s",
|
|
new String(DIR_ENTRY.bytes)));
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Validate that ZipFile::getEntry will return the correct entry when a file
|
|
* and directory have the same name
|
|
*
|
|
* @param entry The entry to search for
|
|
* @throws IOException If an error occurs
|
|
*/
|
|
@Test(dataProvider = "entries")
|
|
public void testSameFileDirEntryName(Entry entry) throws IOException {
|
|
System.out.printf("%n%n**** testSameFileDirEntryName ***%n");
|
|
|
|
try (ZipFile zip = new ZipFile(ZIP_FILE.toString())) {
|
|
ZipEntry ze = zip.getEntry(entry.name);
|
|
if (DEBUG) {
|
|
System.out.printf(" Entry:%s, found:%s%n", entry.name, ze != null);
|
|
}
|
|
assertNotNull(ze);
|
|
try (InputStream in = zip.getInputStream(ze)) {
|
|
byte[] bytes = in.readAllBytes();
|
|
if (DEBUG) {
|
|
System.out.printf("name: %s, isDirectory: %s, payload= %s%n",
|
|
ze.getName(), ze.isDirectory(), new String(bytes));
|
|
}
|
|
assertEquals(entry.bytes, bytes,
|
|
String.format("Expected payload: %s", new String(entry.bytes)));
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Validate that ZipFile::getEntry will return the correct entry, which
|
|
* is the second entry, when there are duplicate entries within the Zip file.
|
|
*
|
|
* @throws IOException If an error occurs
|
|
*/
|
|
@Test
|
|
public void DupFileEntryTest() throws IOException {
|
|
System.out.printf("%n%n**** DupFileEntryTest ***%n");
|
|
try (ZipFile zip =
|
|
new ZipFile(DUPLICATE_FILE_ENTRY_FILE.toString())) {
|
|
ZipEntry ze = zip.getEntry(ENTRY_NAME);
|
|
if (DEBUG) {
|
|
System.out.printf(" Entry:%s, found:%s%n", ENTRY_NAME, ze != null);
|
|
}
|
|
assertNotNull(ze);
|
|
try (InputStream in = zip.getInputStream(ze)) {
|
|
byte[] bytes = in.readAllBytes();
|
|
if (DEBUG) {
|
|
System.out.printf("name: %s, isDirectory: %s, payload= %s%n",
|
|
ze.getName(), ze.isDirectory(), new String(bytes));
|
|
}
|
|
assertEquals(bytes, DUPLICATE_FILE_ENTRY.bytes,
|
|
String.format("Expected payload: %s", new String(DUPLICATE_FILE_ENTRY.bytes)));
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Verify that ZipInputStream can be used to read all Zip entries including
|
|
* a file and directory entry with the same name
|
|
*
|
|
* @throws IOException If an error occurs
|
|
*/
|
|
@Test
|
|
public void ZipInputStreamTest() throws IOException {
|
|
System.out.printf("%n%n**** ZipInputStreamTest ***%n");
|
|
try (ZipInputStream zis = new ZipInputStream(
|
|
new FileInputStream(ZIP_FILE.toFile()))) {
|
|
ZipEntry zipEntry = zis.getNextEntry();
|
|
assertNotNull(zipEntry);
|
|
while (zipEntry != null) {
|
|
Entry e;
|
|
if (zipEntry.getName().equals(FILE_ENTRY.name)) {
|
|
e = FILE_ENTRY;
|
|
} else if (zipEntry.getName().equals(DIR_ENTRY.name)) {
|
|
e = DIR_ENTRY;
|
|
} else {
|
|
throw new RuntimeException(
|
|
String.format("Invalid Zip entry: %s", zipEntry.getName()));
|
|
}
|
|
assertEquals(zipEntry.getMethod(), e.method);
|
|
assertEquals(zis.readAllBytes(), e.bytes,
|
|
String.format("Expected payload: %s", new String(e.bytes)));
|
|
zipEntry = zis.getNextEntry();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Verify that ZipFile::stream returns all Zip entries including
|
|
* a file and directory entry with the same name
|
|
*
|
|
* @throws IOException If an error occurs
|
|
*/
|
|
@Test
|
|
public void ZipFileStreamTest() throws IOException {
|
|
System.out.printf("%n%n**** ZipFileStreamTest ***%n");
|
|
try (ZipFile zf = new ZipFile(ZIP_FILE.toFile())) {
|
|
List<? extends ZipEntry> entries = zf.stream().collect(Collectors.toList());
|
|
assertEquals(EXPECTED_ENTRIES.size(), entries.size());
|
|
for (ZipEntry e : entries) {
|
|
assertTrue(EXPECTED_ENTRIES.contains(e.getName()));
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Verify that JarFile can be used to read all the entries including
|
|
* a file and directory entry with the same name
|
|
*
|
|
* @param entry The entry to validate
|
|
* @throws IOException If an error occurs
|
|
*/
|
|
@Test(dataProvider = "entries")
|
|
public static void JarFileInputStreamTest(Entry entry) throws IOException {
|
|
System.out.printf("%n%n**** JarFileInputStreamTest ***%n");
|
|
try (JarFile jarFile = new JarFile(TEST_JAR.toFile())) {
|
|
JarEntry je = jarFile.getJarEntry(entry.name);
|
|
assertNotNull(je);
|
|
if (DEBUG) {
|
|
System.out.printf("Entry Name: %s, method: %s, Expected Method: %s%n",
|
|
entry.name, je.getMethod(), entry.method);
|
|
}
|
|
assertEquals(entry.method, je.getMethod());
|
|
try (InputStream in = jarFile.getInputStream(je)) {
|
|
byte[] bytes = in.readAllBytes();
|
|
if (DEBUG) {
|
|
System.out.printf("bytes= %s, expected=%s%n",
|
|
new String(bytes), new String(entry.bytes));
|
|
}
|
|
assertEquals(bytes, entry.bytes,
|
|
String.format("Expected payload: %s", new String(entry.bytes)));
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Verify that JarInputStream can be used to read all entries including
|
|
* a file and directory entry with the same name
|
|
*
|
|
* @throws IOException If an error occurs
|
|
*/
|
|
@Test
|
|
public void JarInputStreamTest() throws IOException {
|
|
System.out.printf("%n%n**** JarInputStreamTest ***%n");
|
|
try (JarInputStream jis = new JarInputStream(
|
|
new FileInputStream(TEST_JAR.toFile()))) {
|
|
JarEntry jarEntry = jis.getNextJarEntry();
|
|
assertNotNull(jarEntry);
|
|
while (jarEntry != null) {
|
|
Entry e;
|
|
if (jarEntry.getName().equals(FILE_ENTRY.name)) {
|
|
e = FILE_ENTRY;
|
|
} else if (jarEntry.getName().equals(DIR_ENTRY.name)) {
|
|
e = DIR_ENTRY;
|
|
} else {
|
|
throw new RuntimeException(
|
|
String.format("Invalid Jar entry: %s", jarEntry.getName()));
|
|
}
|
|
assertEquals(jarEntry.getMethod(), e.method);
|
|
assertEquals(jis.readAllBytes(), e.bytes,
|
|
String.format("Expected payload: %s", new String(e.bytes)));
|
|
jarEntry = jis.getNextJarEntry();
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Verify that JarURLConnection can be used to access all the entries including
|
|
* a file and directory entry with the same name within a jar file
|
|
*
|
|
* @param entry The entry to validate
|
|
* @throws IOException If an error occurs
|
|
*/
|
|
@Test(dataProvider = "entries")
|
|
public void JarURLConnectionTest(Entry entry) throws Exception {
|
|
System.out.printf("%n%n**** JarURLConnectionTest ***%n");
|
|
URL url = new URL("jar:" + TEST_JAR.toUri().toURL() + "!/" + entry.name);
|
|
if (DEBUG) {
|
|
System.out.printf("URL=%s%n", url);
|
|
}
|
|
JarURLConnection con = (JarURLConnection) url.openConnection();
|
|
con.connect();
|
|
JarEntry je = con.getJarEntry();
|
|
try (JarFile jarFile = con.getJarFile()) {
|
|
assertNotNull(je);
|
|
assertNotNull(jarFile);
|
|
assertNull(con.getAttributes());
|
|
assertNull(con.getMainAttributes());
|
|
assertNull(con.getManifest());
|
|
assertEquals(je.getName(), entry.name);
|
|
assertEquals(con.getEntryName(), entry.name);
|
|
assertEquals(je.getMethod(), entry.method);
|
|
assertEquals(con.getJarFileURL(), TEST_JAR.toUri().toURL());
|
|
if (DEBUG) {
|
|
System.out.printf(" getEntryName: %s, getJarFileURL:%s%n",
|
|
con.getEntryName(), con.getJarFileURL());
|
|
System.out.printf(" Jar Entry= %s, size= %s%n", je.getName(), je.getSize());
|
|
}
|
|
|
|
try (InputStream is = jarFile.getInputStream(je)) {
|
|
byte[] bytes = is.readAllBytes();
|
|
if (DEBUG) {
|
|
System.out.printf(" Bytes read:%s%n", new String(bytes));
|
|
}
|
|
assertEquals(bytes, entry.bytes,
|
|
String.format("Expected payload: %s", new String(entry.bytes)));
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Verify that JarFile::stream returns all entries including
|
|
* a file and directory entry with the same name
|
|
*
|
|
* @throws IOException If an error occurs
|
|
*/
|
|
@Test
|
|
public void JarFileStreamTest() throws IOException {
|
|
System.out.printf("%n%n**** JarFileStreamTest ***%n");
|
|
try (JarFile jf = new JarFile(TEST_JAR.toFile())) {
|
|
List<? extends JarEntry> entries = jf.stream().collect(Collectors.toList());
|
|
assertEquals(EXPECTED_ENTRIES.size(), jf.size());
|
|
for (JarEntry e : entries) {
|
|
assertTrue(EXPECTED_ENTRIES.contains(e.getName()));
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Method used to read the bytes from an InputStream. This method is
|
|
* here so that the test could be backported to JDK 8 if needed as
|
|
* InputStream::readAllBytes() does not exist
|
|
*
|
|
* @param is The InputStream to read from
|
|
* @return The byte array representing bytes read from the InputStream
|
|
* @throws IOException If an error occurs
|
|
*/
|
|
public static byte[] readAllBytes(InputStream is) throws IOException {
|
|
byte[] data = new byte[MAX_BUFFER_SIZE];
|
|
ByteArrayOutputStream buffer = new ByteArrayOutputStream();
|
|
int len;
|
|
while ((len = is.read(data, 0, data.length)) != -1) {
|
|
buffer.write(data, 0, len);
|
|
}
|
|
buffer.flush();
|
|
return buffer.toByteArray();
|
|
}
|
|
|
|
/**
|
|
* Method used to create a byte[] representing a Jar file with
|
|
* duplicate file entries. This uses ZipArchiveOutputStream as ZipOutputStream
|
|
* will fail with a "java.util.zip.ZipException: duplicate entry".
|
|
*/
|
|
// public static void createJarWithDuplicateFileEntries() throws IOException {
|
|
// Files.deleteIfExists(DUPFILE_ENTRY_FILE);
|
|
// try (ZipArchiveOutputStream zos =
|
|
// new ZipArchiveOutputStream(DUPFILE_ENTRY_FILE.toFile())) {
|
|
// zos.putArchiveEntry(new ZipArchiveEntry(FILE_ENTRY.name));
|
|
// zos.write(FILE_ENTRY.bytes);
|
|
// zos.putArchiveEntry(new ZipArchiveEntry(FILE_ENTRY.name));
|
|
// zos.write("Yet another File".getBytes(StandardCharsets.UTF_8));
|
|
// zos.closeArchiveEntry();
|
|
// } catch (IOException e) {
|
|
// e.printStackTrace();
|
|
// }
|
|
// byte[] jarBytes = Files.readAllBytes(DUPFILE_ENTRY_FILE);
|
|
// String result = createByteArray(jarBytes, "DUPLICATE_ENTRY_JAR_BYTES");
|
|
// System.out.println(result);
|
|
// }
|
|
|
|
/**
|
|
* Utility method which takes a byte array and converts to byte array
|
|
* declaration. For example:
|
|
* <pre>
|
|
* {@code
|
|
* var fooJar = Files.readAllBytes(Path.of("foo.jar"));
|
|
* var result = createByteArray(fooJar, "FOOBYTES");
|
|
* }
|
|
* </pre>
|
|
*
|
|
* @param bytes A byte array used to create a byte array declaration
|
|
* @param name Name to be used in the byte array declaration
|
|
* @return The formatted byte array declaration
|
|
*/
|
|
public static String createByteArray(byte[] bytes, String name) {
|
|
StringBuilder sb = new StringBuilder(bytes.length * 5);
|
|
Formatter fmt = new Formatter(sb);
|
|
fmt.format(" public static byte[] %s = {", name);
|
|
final int linelen = 8;
|
|
for (int i = 0; i < bytes.length; i++) {
|
|
if (i % linelen == 0) {
|
|
fmt.format("%n ");
|
|
}
|
|
fmt.format(" (byte) 0x%x,", bytes[i] & 0xff);
|
|
}
|
|
fmt.format("%n };%n");
|
|
return sb.toString();
|
|
}
|
|
|
|
/**
|
|
* Represents an entry in a Zip file. An entry encapsulates a name, a
|
|
* compression method, and its contents/data.
|
|
*/
|
|
public static class Entry {
|
|
public final String name;
|
|
public final int method;
|
|
public final byte[] bytes;
|
|
|
|
public Entry(String name, int method, String contents) {
|
|
this.name = name;
|
|
this.method = method;
|
|
this.bytes = contents.getBytes(StandardCharsets.UTF_8);
|
|
}
|
|
|
|
public static Entry of(String name, int method, String contents) {
|
|
return new Entry(name, method, contents);
|
|
}
|
|
}
|
|
}
|