src/test/java/org/apache/commons/compress/archivers/sevenz/SevenZFileTest.java - commons-compress - Git at Google

 /*
  *  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.sevenz;

 import static org.junit.Assert.*;

 import java.io.ByteArrayOutputStream;
 import java.io.File;
 import java.io.IOException;
 import java.security.NoSuchAlgorithmException;
 import java.util.Arrays;
 import java.util.HashMap;
 import java.util.Iterator;
 import java.util.Map;
 import java.util.Random;

 import javax.crypto.Cipher;

 import org.apache.commons.compress.AbstractTestCase;
 import org.apache.commons.compress.PasswordRequiredException;
 import org.junit.Test;

 public class SevenZFileTest extends AbstractTestCase {
     private static final String TEST2_CONTENT = "<?xml version = '1.0'?>\r\n<!DOCTYPE"
         + " connections>\r\n<meinxml>\r\n\t<leer />\r\n</meinxml>\n";

     // https://issues.apache.org/jira/browse/COMPRESS-320
     @Test
     public void testRandomlySkippingEntries() throws Exception {
         // Read sequential reference.
         final Map<String, byte[]> entriesByName = new HashMap<>();
         SevenZFile archive = new SevenZFile(getFile("COMPRESS-320/Copy.7z"));
         SevenZArchiveEntry entry;
         while ((entry = archive.getNextEntry()) != null) {
             if (entry.hasStream()) {
                 entriesByName.put(entry.getName(), readFully(archive));
             }
         }
         archive.close();

         final String[] variants = {
             "BZip2-solid.7z",
             "BZip2.7z",
             "Copy-solid.7z",
             "Copy.7z",
             "Deflate-solid.7z",
             "Deflate.7z",
             "LZMA-solid.7z",
             "LZMA.7z",
             "LZMA2-solid.7z",
             "LZMA2.7z",
             // TODO: unsupported compression method.
             // "PPMd-solid.7z",
             // "PPMd.7z",
         };

         // TODO: use randomizedtesting for predictable, but different, randomness.
         final Random rnd = new Random(0xdeadbeef);
         for (final String fileName : variants) {
             archive = new SevenZFile(getFile("COMPRESS-320/" + fileName));

             while ((entry = archive.getNextEntry()) != null) {
                 // Sometimes skip reading entries.
                 if (rnd.nextBoolean()) {
                     continue;
                 }

                 if (entry.hasStream()) {
                     assertTrue(entriesByName.containsKey(entry.getName()));
                     final byte [] content = readFully(archive);
                     assertTrue("Content mismatch on: " + fileName + "!" + entry.getName(),
                                Arrays.equals(content, entriesByName.get(entry.getName())));
                 }
             }

             archive.close();
         }
     }

     private byte[] readFully(final SevenZFile archive) throws IOException {
         final byte [] buf = new byte [1024];
         final ByteArrayOutputStream baos = new ByteArrayOutputStream();
         for (int len = 0; (len = archive.read(buf)) > 0;) {
             baos.write(buf, 0, len);
         }
         return baos.toByteArray();
     }

     @Test
     public void testAllEmptyFilesArchive() throws Exception {
         try (SevenZFile archive = new SevenZFile(getFile("7z-empty-mhc-off.7z"))) {
             assertNotNull(archive.getNextEntry());
         }
     }

     @Test
     public void testHelloWorldHeaderCompressionOffCopy() throws Exception {
         checkHelloWorld("7z-hello-mhc-off-copy.7z");
     }

     @Test
     public void testHelloWorldHeaderCompressionOffLZMA2() throws Exception {
         checkHelloWorld("7z-hello-mhc-off-lzma2.7z");
     }

     @Test
     public void test7zUnarchive() throws Exception {
         test7zUnarchive(getFile("bla.7z"), SevenZMethod.LZMA);
     }

     @Test
     public void test7zDeflateUnarchive() throws Exception {
         test7zUnarchive(getFile("bla.deflate.7z"), SevenZMethod.DEFLATE);
     }

     @Test
     public void test7zDecryptUnarchive() throws Exception {
         if (isStrongCryptoAvailable()) {
             test7zUnarchive(getFile("bla.encrypted.7z"), SevenZMethod.LZMA, // stack LZMA + AES
                             "foo".getBytes("UTF-16LE"));
         }
     }

     private void test7zUnarchive(final File f, final SevenZMethod m) throws Exception {
         test7zUnarchive(f, m, null);
     }

     @Test
     public void testEncryptedArchiveRequiresPassword() throws Exception {
         try {
             new SevenZFile(getFile("bla.encrypted.7z"));
             fail("shouldn't decrypt without a password");
         } catch (final PasswordRequiredException ex) {
             final String msg = ex.getMessage();
             assertTrue("Should start with whining about being unable to decrypt",
                        msg.startsWith("Cannot read encrypted content from "));
             assertTrue("Should finish the sentence properly",
                        msg.endsWith(" without a password."));
             assertTrue("Should contain archive's name",
                        msg.contains("bla.encrypted.7z"));
         }
     }

     /**
      * @see "https://issues.apache.org/jira/browse/COMPRESS-256"
      */
     @Test
     public void testCompressedHeaderWithNonDefaultDictionarySize() throws Exception {
         try (SevenZFile sevenZFile = new SevenZFile(getFile("COMPRESS-256.7z"))) {
             int count = 0;
             while (sevenZFile.getNextEntry() != null) {
                 count++;
             }
             assertEquals(446, count);
         }
     }

     @Test
     public void testSignatureCheck() {
         assertTrue(SevenZFile.matches(SevenZFile.sevenZSignature,
                                       SevenZFile.sevenZSignature.length));
         assertTrue(SevenZFile.matches(SevenZFile.sevenZSignature,
                                       SevenZFile.sevenZSignature.length + 1));
         assertFalse(SevenZFile.matches(SevenZFile.sevenZSignature,
                                       SevenZFile.sevenZSignature.length - 1));
         assertFalse(SevenZFile.matches(new byte[] { 1, 2, 3, 4, 5, 6 }, 6));
         assertTrue(SevenZFile.matches(new byte[] { '7', 'z', (byte) 0xBC,
                                                    (byte) 0xAF, 0x27, 0x1C}, 6));
         assertFalse(SevenZFile.matches(new byte[] { '7', 'z', (byte) 0xBC,
                                                     (byte) 0xAF, 0x27, 0x1D}, 6));
     }

     @Test
     public void testReadingBackLZMA2DictSize() throws Exception {
         final File output = new File(dir, "lzma2-dictsize.7z");
         try (SevenZOutputFile outArchive = new SevenZOutputFile(output)) {
             outArchive.setContentMethods(Arrays.asList(new SevenZMethodConfiguration(SevenZMethod.LZMA2, 1 << 20)));
             final SevenZArchiveEntry entry = new SevenZArchiveEntry();
             entry.setName("foo.txt");
             outArchive.putArchiveEntry(entry);
             outArchive.write(new byte[] { 'A' });
             outArchive.closeArchiveEntry();
         }

         try (SevenZFile archive = new SevenZFile(output)) {
             final SevenZArchiveEntry entry = archive.getNextEntry();
             final SevenZMethodConfiguration m = entry.getContentMethods().iterator().next();
             assertEquals(SevenZMethod.LZMA2, m.getMethod());
             assertEquals(1 << 20, m.getOptions());
         }
     }

     @Test
     public void testReadingBackDeltaDistance() throws Exception {
         final File output = new File(dir, "delta-distance.7z");
         try (SevenZOutputFile outArchive = new SevenZOutputFile(output)) {
             outArchive.setContentMethods(Arrays.asList(new SevenZMethodConfiguration(SevenZMethod.DELTA_FILTER, 32),
                     new SevenZMethodConfiguration(SevenZMethod.LZMA2)));
             final SevenZArchiveEntry entry = new SevenZArchiveEntry();
             entry.setName("foo.txt");
             outArchive.putArchiveEntry(entry);
             outArchive.write(new byte[] { 'A' });
             outArchive.closeArchiveEntry();
         }

         try (SevenZFile archive = new SevenZFile(output)) {
             final SevenZArchiveEntry entry = archive.getNextEntry();
             final SevenZMethodConfiguration m = entry.getContentMethods().iterator().next();
             assertEquals(SevenZMethod.DELTA_FILTER, m.getMethod());
             assertEquals(32, m.getOptions());
         }
     }

     @Test
     public void getEntriesOfUnarchiveTest() throws IOException {
         try (SevenZFile sevenZFile = new SevenZFile(getFile("bla.7z"))) {
             final Iterable<SevenZArchiveEntry> entries = sevenZFile.getEntries();
             final Iterator<SevenZArchiveEntry> iter = entries.iterator();
             SevenZArchiveEntry entry = iter.next();
             assertEquals("test1.xml", entry.getName());
             entry = iter.next();
             assertEquals("test2.xml", entry.getName());
             assertFalse(iter.hasNext());
         }
     }

     /**
      * @see "https://issues.apache.org/jira/browse/COMPRESS-348"
      */
     @Test
     public void readEntriesOfSize0() throws IOException {
         try (SevenZFile sevenZFile = new SevenZFile(getFile("COMPRESS-348.7z"))) {
             int entries = 0;
             SevenZArchiveEntry entry = sevenZFile.getNextEntry();
             while (entry != null) {
                 entries++;
                 final int b = sevenZFile.read();
                 if ("2.txt".equals(entry.getName()) || "5.txt".equals(entry.getName())) {
                     assertEquals(-1, b);
                 } else {
                     assertNotEquals(-1, b);
                 }
                 entry = sevenZFile.getNextEntry();
             }
             assertEquals(5, entries);
         }
     }

     private void test7zUnarchive(final File f, final SevenZMethod m, final byte[] password) throws Exception {
         try (SevenZFile sevenZFile = new SevenZFile(f, password)) {
             SevenZArchiveEntry entry = sevenZFile.getNextEntry();
             assertEquals("test1.xml", entry.getName());
             assertEquals(m, entry.getContentMethods().iterator().next().getMethod());
             entry = sevenZFile.getNextEntry();
             assertEquals("test2.xml", entry.getName());
             assertEquals(m, entry.getContentMethods().iterator().next().getMethod());
             final byte[] contents = new byte[(int) entry.getSize()];
             int off = 0;
             while ((off < contents.length)) {
                 final int bytesRead = sevenZFile.read(contents, off, contents.length - off);
                 assert (bytesRead >= 0);
                 off += bytesRead;
             }
             assertEquals(TEST2_CONTENT, new String(contents, "UTF-8"));
             assertNull(sevenZFile.getNextEntry());
         }
     }

     private void checkHelloWorld(final String filename) throws Exception {
         try (SevenZFile sevenZFile = new SevenZFile(getFile(filename))) {
             final SevenZArchiveEntry entry = sevenZFile.getNextEntry();
             assertEquals("Hello world.txt", entry.getName());
             final byte[] contents = new byte[(int) entry.getSize()];
             int off = 0;
             while ((off < contents.length)) {
                 final int bytesRead = sevenZFile.read(contents, off, contents.length - off);
                 assert (bytesRead >= 0);
                 off += bytesRead;
             }
             assertEquals("Hello, world!\n", new String(contents, "UTF-8"));
             assertNull(sevenZFile.getNextEntry());
         }
     }

     private static boolean isStrongCryptoAvailable() throws NoSuchAlgorithmException {
         return Cipher.getMaxAllowedKeyLength("AES/ECB/PKCS5Padding") >= 256;
     }
 }
	/*
	* 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.sevenz;

	import static org.junit.Assert.*;

	import java.io.ByteArrayOutputStream;
	import java.io.File;
	import java.io.IOException;
	import java.security.NoSuchAlgorithmException;
	import java.util.Arrays;
	import java.util.HashMap;
	import java.util.Iterator;
	import java.util.Map;
	import java.util.Random;

	import javax.crypto.Cipher;

	import org.apache.commons.compress.AbstractTestCase;
	import org.apache.commons.compress.PasswordRequiredException;
	import org.junit.Test;

	public class SevenZFileTest extends AbstractTestCase {
	private static final String TEST2_CONTENT = "<?xml version = '1.0'?>\r\n<!DOCTYPE"
	+ " connections>\r\n<meinxml>\r\n\t<leer />\r\n</meinxml>\n";

	// https://issues.apache.org/jira/browse/COMPRESS-320
	@Test
	public void testRandomlySkippingEntries() throws Exception {
	// Read sequential reference.
	final Map<String, byte[]> entriesByName = new HashMap<>();
	SevenZFile archive = new SevenZFile(getFile("COMPRESS-320/Copy.7z"));
	SevenZArchiveEntry entry;
	while ((entry = archive.getNextEntry()) != null) {
	if (entry.hasStream()) {
	entriesByName.put(entry.getName(), readFully(archive));
	}
	}
	archive.close();

	final String[] variants = {
	"BZip2-solid.7z",
	"BZip2.7z",
	"Copy-solid.7z",
	"Copy.7z",
	"Deflate-solid.7z",
	"Deflate.7z",
	"LZMA-solid.7z",
	"LZMA.7z",
	"LZMA2-solid.7z",
	"LZMA2.7z",
	// TODO: unsupported compression method.
	// "PPMd-solid.7z",
	// "PPMd.7z",
	};

	// TODO: use randomizedtesting for predictable, but different, randomness.
	final Random rnd = new Random(0xdeadbeef);
	for (final String fileName : variants) {
	archive = new SevenZFile(getFile("COMPRESS-320/" + fileName));

	while ((entry = archive.getNextEntry()) != null) {
	// Sometimes skip reading entries.
	if (rnd.nextBoolean()) {
	continue;
	}

	if (entry.hasStream()) {
	assertTrue(entriesByName.containsKey(entry.getName()));
	final byte [] content = readFully(archive);
	assertTrue("Content mismatch on: " + fileName + "!" + entry.getName(),
	Arrays.equals(content, entriesByName.get(entry.getName())));
	}
	}

	archive.close();
	}
	}

	private byte[] readFully(final SevenZFile archive) throws IOException {
	final byte [] buf = new byte [1024];
	final ByteArrayOutputStream baos = new ByteArrayOutputStream();
	for (int len = 0; (len = archive.read(buf)) > 0;) {
	baos.write(buf, 0, len);
	}
	return baos.toByteArray();
	}

	@Test
	public void testAllEmptyFilesArchive() throws Exception {
	try (SevenZFile archive = new SevenZFile(getFile("7z-empty-mhc-off.7z"))) {
	assertNotNull(archive.getNextEntry());
	}
	}

	@Test
	public void testHelloWorldHeaderCompressionOffCopy() throws Exception {
	checkHelloWorld("7z-hello-mhc-off-copy.7z");
	}

	@Test
	public void testHelloWorldHeaderCompressionOffLZMA2() throws Exception {
	checkHelloWorld("7z-hello-mhc-off-lzma2.7z");
	}

	@Test
	public void test7zUnarchive() throws Exception {
	test7zUnarchive(getFile("bla.7z"), SevenZMethod.LZMA);
	}

	@Test
	public void test7zDeflateUnarchive() throws Exception {
	test7zUnarchive(getFile("bla.deflate.7z"), SevenZMethod.DEFLATE);
	}

	@Test
	public void test7zDecryptUnarchive() throws Exception {
	if (isStrongCryptoAvailable()) {
	test7zUnarchive(getFile("bla.encrypted.7z"), SevenZMethod.LZMA, // stack LZMA + AES
	"foo".getBytes("UTF-16LE"));
	}
	}

	private void test7zUnarchive(final File f, final SevenZMethod m) throws Exception {
	test7zUnarchive(f, m, null);
	}

	@Test
	public void testEncryptedArchiveRequiresPassword() throws Exception {
	try {
	new SevenZFile(getFile("bla.encrypted.7z"));
	fail("shouldn't decrypt without a password");
	} catch (final PasswordRequiredException ex) {
	final String msg = ex.getMessage();
	assertTrue("Should start with whining about being unable to decrypt",
	msg.startsWith("Cannot read encrypted content from "));
	assertTrue("Should finish the sentence properly",
	msg.endsWith(" without a password."));
	assertTrue("Should contain archive's name",
	msg.contains("bla.encrypted.7z"));
	}
	}

	/**
	* @see "https://issues.apache.org/jira/browse/COMPRESS-256"
	*/
	@Test
	public void testCompressedHeaderWithNonDefaultDictionarySize() throws Exception {
	try (SevenZFile sevenZFile = new SevenZFile(getFile("COMPRESS-256.7z"))) {
	int count = 0;
	while (sevenZFile.getNextEntry() != null) {
	count++;
	}
	assertEquals(446, count);
	}
	}

	@Test
	public void testSignatureCheck() {
	assertTrue(SevenZFile.matches(SevenZFile.sevenZSignature,
	SevenZFile.sevenZSignature.length));
	assertTrue(SevenZFile.matches(SevenZFile.sevenZSignature,
	SevenZFile.sevenZSignature.length + 1));
	assertFalse(SevenZFile.matches(SevenZFile.sevenZSignature,
	SevenZFile.sevenZSignature.length - 1));
	assertFalse(SevenZFile.matches(new byte[] { 1, 2, 3, 4, 5, 6 }, 6));
	assertTrue(SevenZFile.matches(new byte[] { '7', 'z', (byte) 0xBC,
	(byte) 0xAF, 0x27, 0x1C}, 6));
	assertFalse(SevenZFile.matches(new byte[] { '7', 'z', (byte) 0xBC,
	(byte) 0xAF, 0x27, 0x1D}, 6));
	}

	@Test
	public void testReadingBackLZMA2DictSize() throws Exception {
	final File output = new File(dir, "lzma2-dictsize.7z");
	try (SevenZOutputFile outArchive = new SevenZOutputFile(output)) {
	outArchive.setContentMethods(Arrays.asList(new SevenZMethodConfiguration(SevenZMethod.LZMA2, 1 << 20)));
	final SevenZArchiveEntry entry = new SevenZArchiveEntry();
	entry.setName("foo.txt");
	outArchive.putArchiveEntry(entry);
	outArchive.write(new byte[] { 'A' });
	outArchive.closeArchiveEntry();
	}

	try (SevenZFile archive = new SevenZFile(output)) {
	final SevenZArchiveEntry entry = archive.getNextEntry();
	final SevenZMethodConfiguration m = entry.getContentMethods().iterator().next();
	assertEquals(SevenZMethod.LZMA2, m.getMethod());
	assertEquals(1 << 20, m.getOptions());
	}
	}

	@Test
	public void testReadingBackDeltaDistance() throws Exception {
	final File output = new File(dir, "delta-distance.7z");
	try (SevenZOutputFile outArchive = new SevenZOutputFile(output)) {
	outArchive.setContentMethods(Arrays.asList(new SevenZMethodConfiguration(SevenZMethod.DELTA_FILTER, 32),
	new SevenZMethodConfiguration(SevenZMethod.LZMA2)));
	final SevenZArchiveEntry entry = new SevenZArchiveEntry();
	entry.setName("foo.txt");
	outArchive.putArchiveEntry(entry);
	outArchive.write(new byte[] { 'A' });
	outArchive.closeArchiveEntry();
	}

	try (SevenZFile archive = new SevenZFile(output)) {
	final SevenZArchiveEntry entry = archive.getNextEntry();
	final SevenZMethodConfiguration m = entry.getContentMethods().iterator().next();
	assertEquals(SevenZMethod.DELTA_FILTER, m.getMethod());
	assertEquals(32, m.getOptions());
	}
	}

	@Test
	public void getEntriesOfUnarchiveTest() throws IOException {
	try (SevenZFile sevenZFile = new SevenZFile(getFile("bla.7z"))) {
	final Iterable<SevenZArchiveEntry> entries = sevenZFile.getEntries();
	final Iterator<SevenZArchiveEntry> iter = entries.iterator();
	SevenZArchiveEntry entry = iter.next();
	assertEquals("test1.xml", entry.getName());
	entry = iter.next();
	assertEquals("test2.xml", entry.getName());
	assertFalse(iter.hasNext());
	}
	}

	/**
	* @see "https://issues.apache.org/jira/browse/COMPRESS-348"
	*/
	@Test
	public void readEntriesOfSize0() throws IOException {
	try (SevenZFile sevenZFile = new SevenZFile(getFile("COMPRESS-348.7z"))) {
	int entries = 0;
	SevenZArchiveEntry entry = sevenZFile.getNextEntry();
	while (entry != null) {
	entries++;
	final int b = sevenZFile.read();
	if ("2.txt".equals(entry.getName()) \|\| "5.txt".equals(entry.getName())) {
	assertEquals(-1, b);
	} else {
	assertNotEquals(-1, b);
	}
	entry = sevenZFile.getNextEntry();
	}
	assertEquals(5, entries);
	}
	}

	private void test7zUnarchive(final File f, final SevenZMethod m, final byte[] password) throws Exception {
	try (SevenZFile sevenZFile = new SevenZFile(f, password)) {
	SevenZArchiveEntry entry = sevenZFile.getNextEntry();
	assertEquals("test1.xml", entry.getName());
	assertEquals(m, entry.getContentMethods().iterator().next().getMethod());
	entry = sevenZFile.getNextEntry();
	assertEquals("test2.xml", entry.getName());
	assertEquals(m, entry.getContentMethods().iterator().next().getMethod());
	final byte[] contents = new byte[(int) entry.getSize()];
	int off = 0;
	while ((off < contents.length)) {
	final int bytesRead = sevenZFile.read(contents, off, contents.length - off);
	assert (bytesRead >= 0);
	off += bytesRead;
	}
	assertEquals(TEST2_CONTENT, new String(contents, "UTF-8"));
	assertNull(sevenZFile.getNextEntry());
	}
	}

	private void checkHelloWorld(final String filename) throws Exception {
	try (SevenZFile sevenZFile = new SevenZFile(getFile(filename))) {
	final SevenZArchiveEntry entry = sevenZFile.getNextEntry();
	assertEquals("Hello world.txt", entry.getName());
	final byte[] contents = new byte[(int) entry.getSize()];
	int off = 0;
	while ((off < contents.length)) {
	final int bytesRead = sevenZFile.read(contents, off, contents.length - off);
	assert (bytesRead >= 0);
	off += bytesRead;
	}
	assertEquals("Hello, world!\n", new String(contents, "UTF-8"));
	assertNull(sevenZFile.getNextEntry());
	}
	}

	private static boolean isStrongCryptoAvailable() throws NoSuchAlgorithmException {
	return Cipher.getMaxAllowedKeyLength("AES/ECB/PKCS5Padding") >= 256;
	}
	}