shared/src/test/java/com/google/archivepatcher/shared/DeflateCompressorTest.java - platform/external/archive-patcher - Git at Google

 // Copyright 2015 Google Inc. All rights reserved.
 //
 // 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.

 package com.google.archivepatcher.shared;

 import org.junit.Assert;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;

 import java.io.ByteArrayInputStream;
 import java.io.ByteArrayOutputStream;
 import java.io.IOException;
 import java.util.Arrays;
 import java.util.zip.Deflater;
 import java.util.zip.Inflater;
 import java.util.zip.InflaterInputStream;

 /**
  * Tests for {@link DeflateCompressor}.
  */
 @RunWith(JUnit4.class)
 @SuppressWarnings("javadoc")
 public class DeflateCompressorTest {
   /**
    * Test data for compression. Uses the {@link DefaultDeflateCompatibilityWindow}'s corpus because
    * it is already set up to produce different outputs for each compression level.
    */
   private final static byte[] CONTENT = new DefaultDeflateCompatibilityWindow().getCorpus();

   /**
    * Helper class for storing the compressed and uncompressed form of something together.
    */
   private static class Content {
     public byte[] compressed;
     public byte[] uncompressed;
   }

   private DeflateCompressor compressor;
   private ByteArrayInputStream rawContentIn;
   private ByteArrayOutputStream compressedContentOut;

   /**
    * Uncompress some content with Java's built-in {@link Inflater} as a sanity check against our own
    * code.
    * @param nowrap value to set for the nowrap parameter for the {@link Inflater}
    * @param compressedData
    * @return the uncompressed data as a byte array
    * @throws IOException if anything goes wrong
    */
   private byte[] uncompressWithJavaInflater(boolean nowrap, byte[] compressedData)
       throws IOException {
     Inflater inflater = new Inflater(nowrap);
     InflaterInputStream inflaterIn =
         new InflaterInputStream(new ByteArrayInputStream(compressedData), inflater);
     byte[] buffer = new byte[32768];
     ByteArrayOutputStream uncompressedOut = new ByteArrayOutputStream();
     int numRead = 0;
     while ((numRead = inflaterIn.read(buffer)) >= 0) {
       uncompressedOut.write(buffer, 0, numRead);
     }
     return uncompressedOut.toByteArray();
   }

   @Before
   public void setUp() {
     compressor = new DeflateCompressor();
     rawContentIn = new ByteArrayInputStream(CONTENT);
     compressedContentOut = new ByteArrayOutputStream();
   }

   @Test
   public void testCompress() throws IOException {
     compressor.compress(rawContentIn, compressedContentOut);
     Assert.assertTrue(compressedContentOut.size() > 0);
     Assert.assertTrue(compressedContentOut.size() < CONTENT.length);
     byte[] uncompressed =
         uncompressWithJavaInflater(compressor.isNowrap(), compressedContentOut.toByteArray());
     Assert.assertArrayEquals(CONTENT, uncompressed);
   }

   @Test
   public void testCorrectDefaults() {
     // Sanity check to ensure that defaults are as we want them to be. Arguably crufty but nobody
     // should change these without some thought, particularly the wrapping choice should not be
     // changed in the compressor without also changing it in the *un*compressor.
     Assert.assertTrue(compressor.isNowrap());
     Assert.assertEquals(Deflater.DEFAULT_COMPRESSION, compressor.getCompressionLevel());
     Assert.assertEquals(Deflater.DEFAULT_STRATEGY, compressor.getStrategy());
   }

   @Test
   public void testNowrap() throws IOException {
     // Start with nowrap 'on' (should be the default)
     Assert.assertTrue(compressor.isNowrap());
     compressor.compress(rawContentIn, compressedContentOut);
     byte[] compressedWithNowrapOn = compressedContentOut.toByteArray();
     byte[] uncompressedWithNowrapOn =
         uncompressWithJavaInflater(compressor.isNowrap(), compressedWithNowrapOn);
     Assert.assertArrayEquals(CONTENT, uncompressedWithNowrapOn);

     // Now twiddle nowrap to 'off' and do it again.
     compressor.setNowrap(false);
     Assert.assertFalse(compressor.isNowrap());
     rawContentIn = new ByteArrayInputStream(CONTENT);
     compressedContentOut = new ByteArrayOutputStream();
     compressor.compress(rawContentIn, compressedContentOut);
     byte[] compressedWithNowrapOff = compressedContentOut.toByteArray();
     Assert.assertFalse(compressedWithNowrapOn.length == compressedWithNowrapOff.length);
     byte[] uncompressedWithNowrapOff =
         uncompressWithJavaInflater(compressor.isNowrap(), compressedWithNowrapOff);
     Assert.assertArrayEquals(CONTENT, uncompressedWithNowrapOff);
   }

   @Test
   public void testStrategy() throws IOException {
     // Compression level has to be > 2 to get different output out of strategies 0 and 1.
     compressor.setCompressionLevel(9);

     // Compress with all valid strategies to ensure they all work.
     Content[] content = new Content[3];
     for (int strategy = 0; strategy <= 2; strategy++) {
       rawContentIn = new ByteArrayInputStream(CONTENT);
       compressedContentOut = new ByteArrayOutputStream();
       compressor.setStrategy(strategy);
       Assert.assertEquals(strategy, compressor.getStrategy());
       compressor.compress(rawContentIn, compressedContentOut);
       content[strategy] = new Content();
       content[strategy].compressed = compressedContentOut.toByteArray();
       content[strategy].uncompressed =
           uncompressWithJavaInflater(compressor.isNowrap(), content[strategy].compressed);
       Assert.assertArrayEquals(CONTENT, content[strategy].uncompressed);
     }

     // No two outputs should be the same.
     for (int outer = 0; outer < content.length; outer++) {
       for (int inner = 0; inner < content.length; inner++) {
         if (inner != outer) {
           Assert.assertFalse(
               "strategy " + outer + " == " + inner,
               Arrays.equals(content[outer].compressed, content[inner].compressed));
         }
       }
     }
   }

   @Test
   public void testCompressionLevel() throws IOException {
     // Compress at all levels to ensure they all work.
     Content[] content = new Content[10]; // Note that level 0 (store) is not used.
     for (int level = 1; level <= 9; level++) {
       rawContentIn = new ByteArrayInputStream(CONTENT);
       compressedContentOut = new ByteArrayOutputStream();
       compressor.setCompressionLevel(level);
       Assert.assertEquals(level, compressor.getCompressionLevel());
       compressor.compress(rawContentIn, compressedContentOut);
       content[level] = new Content();
       content[level].compressed = compressedContentOut.toByteArray();
       content[level].uncompressed =
           uncompressWithJavaInflater(compressor.isNowrap(), content[level].compressed);
       Assert.assertArrayEquals(CONTENT, content[level].uncompressed);
     }

     // No two outputs should be the same. Again note that level 0 (store) is unused, so start at 1.
     for (int outer = 1; outer < content.length; outer++) {
       for (int inner = 1; inner < content.length; inner++) {
         if (inner != outer) {
           Assert.assertFalse(
               "strategy " + outer + " == " + inner,
               Arrays.equals(content[outer].compressed, content[inner].compressed));
         }
       }
     }
   }

   @Test
   public void testSetInputBufferSize() throws IOException {
     Assert.assertNotEquals(17, compressor.getInputBufferSize()); // Ensure test is valid
     compressor.setInputBufferSize(17); // Arbitrary non-default value
     Assert.assertEquals(17, compressor.getInputBufferSize());
     compressor.compress(rawContentIn, compressedContentOut);
     byte[] uncompressed =
         uncompressWithJavaInflater(compressor.isNowrap(), compressedContentOut.toByteArray());
     Assert.assertArrayEquals(CONTENT, uncompressed);
   }

   @Test
   public void testSetOutputBufferSize() throws IOException {
     Assert.assertNotEquals(17, compressor.getOutputBufferSize()); // Ensure test is valid
     compressor.setOutputBufferSize(17); // Arbitrary non-default value
     Assert.assertEquals(17, compressor.getOutputBufferSize());
     compressor.compress(rawContentIn, compressedContentOut);
     byte[] uncompressed =
         uncompressWithJavaInflater(compressor.isNowrap(), compressedContentOut.toByteArray());
     Assert.assertArrayEquals(CONTENT, uncompressed);
   }

   @Test
   public void testCreateOrResetDeflater_Uncached() {
     compressor.setCaching(false);
     Deflater deflater1 = compressor.createOrResetDeflater();
     Deflater deflater2 = compressor.createOrResetDeflater();
     Assert.assertNotSame(deflater1, deflater2);
   }

   @Test
   public void testCreateOrResetDeflater_Cached() {
     compressor.setCaching(true);
     Deflater deflater1 = compressor.createOrResetDeflater();
     Deflater deflater2 = compressor.createOrResetDeflater();
     Assert.assertSame(deflater1, deflater2);
   }

   @Test
   public void testRelease() {
     compressor.setCaching(true);
     Deflater deflater1 = compressor.createOrResetDeflater();
     compressor.release();
     Deflater deflater2 = compressor.createOrResetDeflater();
     Assert.assertNotSame(deflater1, deflater2);
   }

   @Test
   public void testReusability() throws IOException {
     // Checks that the compressor produces correct output when cached, i.e. that it is being
     // properly reset between runs.
     compressor.setCaching(true);
     compressor.compress(rawContentIn, compressedContentOut);
     byte[] uncompressed =
         uncompressWithJavaInflater(compressor.isNowrap(), compressedContentOut.toByteArray());
     Assert.assertArrayEquals(CONTENT, uncompressed);

     // Caching is on, try to reuse it without any changes.
     rawContentIn = new ByteArrayInputStream(CONTENT);
     compressedContentOut = new ByteArrayOutputStream();
     compressor.compress(rawContentIn, compressedContentOut);
     uncompressed =
         uncompressWithJavaInflater(compressor.isNowrap(), compressedContentOut.toByteArray());
     Assert.assertArrayEquals(CONTENT, uncompressed);

     // Caching is still on, tweak the compression level and try again.
     Assert.assertNotEquals(7, compressor.getCompressionLevel()); // Ensure test is valid
     compressor.setCompressionLevel(7);
     rawContentIn = new ByteArrayInputStream(CONTENT);
     compressedContentOut = new ByteArrayOutputStream();
     compressor.compress(rawContentIn, compressedContentOut);
     uncompressed =
         uncompressWithJavaInflater(compressor.isNowrap(), compressedContentOut.toByteArray());
     Assert.assertArrayEquals(CONTENT, uncompressed);

     // Caching is still on, tweak the strategy and try again.
     Assert.assertNotEquals(1, compressor.getStrategy()); // Ensure test is valid
     compressor.setStrategy(Deflater.FILTERED);
     rawContentIn = new ByteArrayInputStream(CONTENT);
     compressedContentOut = new ByteArrayOutputStream();
     compressor.compress(rawContentIn, compressedContentOut);
     uncompressed =
         uncompressWithJavaInflater(compressor.isNowrap(), compressedContentOut.toByteArray());
     Assert.assertArrayEquals(CONTENT, uncompressed);

     // Caching is still on, reverse the wrapping style and try again. Changing the wrapping style
     // invalidates the cached compressor because the wrapping style cannot be changed, this is a
     // special code path we need to exercise.
     compressor.setNowrap(!compressor.isNowrap());
     rawContentIn = new ByteArrayInputStream(CONTENT);
     compressedContentOut = new ByteArrayOutputStream();
     compressor.compress(rawContentIn, compressedContentOut);
     uncompressed =
         uncompressWithJavaInflater(compressor.isNowrap(), compressedContentOut.toByteArray());
     Assert.assertArrayEquals(CONTENT, uncompressed);
   }
 }
	// Copyright 2015 Google Inc. All rights reserved.
	//
	// 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.

	package com.google.archivepatcher.shared;

	import org.junit.Assert;
	import org.junit.Before;
	import org.junit.Test;
	import org.junit.runner.RunWith;
	import org.junit.runners.JUnit4;

	import java.io.ByteArrayInputStream;
	import java.io.ByteArrayOutputStream;
	import java.io.IOException;
	import java.util.Arrays;
	import java.util.zip.Deflater;
	import java.util.zip.Inflater;
	import java.util.zip.InflaterInputStream;

	/**
	* Tests for {@link DeflateCompressor}.
	*/
	@RunWith(JUnit4.class)
	@SuppressWarnings("javadoc")
	public class DeflateCompressorTest {
	/**
	* Test data for compression. Uses the {@link DefaultDeflateCompatibilityWindow}'s corpus because
	* it is already set up to produce different outputs for each compression level.
	*/
	private final static byte[] CONTENT = new DefaultDeflateCompatibilityWindow().getCorpus();

	/**
	* Helper class for storing the compressed and uncompressed form of something together.
	*/
	private static class Content {
	public byte[] compressed;
	public byte[] uncompressed;
	}

	private DeflateCompressor compressor;
	private ByteArrayInputStream rawContentIn;
	private ByteArrayOutputStream compressedContentOut;

	/**
	* Uncompress some content with Java's built-in {@link Inflater} as a sanity check against our own
	* code.
	* @param nowrap value to set for the nowrap parameter for the {@link Inflater}
	* @param compressedData
	* @return the uncompressed data as a byte array
	* @throws IOException if anything goes wrong
	*/
	private byte[] uncompressWithJavaInflater(boolean nowrap, byte[] compressedData)
	throws IOException {
	Inflater inflater = new Inflater(nowrap);
	InflaterInputStream inflaterIn =
	new InflaterInputStream(new ByteArrayInputStream(compressedData), inflater);
	byte[] buffer = new byte[32768];
	ByteArrayOutputStream uncompressedOut = new ByteArrayOutputStream();
	int numRead = 0;
	while ((numRead = inflaterIn.read(buffer)) >= 0) {
	uncompressedOut.write(buffer, 0, numRead);
	}
	return uncompressedOut.toByteArray();
	}

	@Before
	public void setUp() {
	compressor = new DeflateCompressor();
	rawContentIn = new ByteArrayInputStream(CONTENT);
	compressedContentOut = new ByteArrayOutputStream();
	}

	@Test
	public void testCompress() throws IOException {
	compressor.compress(rawContentIn, compressedContentOut);
	Assert.assertTrue(compressedContentOut.size() > 0);
	Assert.assertTrue(compressedContentOut.size() < CONTENT.length);
	byte[] uncompressed =
	uncompressWithJavaInflater(compressor.isNowrap(), compressedContentOut.toByteArray());
	Assert.assertArrayEquals(CONTENT, uncompressed);
	}

	@Test
	public void testCorrectDefaults() {
	// Sanity check to ensure that defaults are as we want them to be. Arguably crufty but nobody
	// should change these without some thought, particularly the wrapping choice should not be
	// changed in the compressor without also changing it in the uncompressor.
	Assert.assertTrue(compressor.isNowrap());
	Assert.assertEquals(Deflater.DEFAULT_COMPRESSION, compressor.getCompressionLevel());
	Assert.assertEquals(Deflater.DEFAULT_STRATEGY, compressor.getStrategy());
	}

	@Test
	public void testNowrap() throws IOException {
	// Start with nowrap 'on' (should be the default)
	Assert.assertTrue(compressor.isNowrap());
	compressor.compress(rawContentIn, compressedContentOut);
	byte[] compressedWithNowrapOn = compressedContentOut.toByteArray();
	byte[] uncompressedWithNowrapOn =
	uncompressWithJavaInflater(compressor.isNowrap(), compressedWithNowrapOn);
	Assert.assertArrayEquals(CONTENT, uncompressedWithNowrapOn);

	// Now twiddle nowrap to 'off' and do it again.
	compressor.setNowrap(false);
	Assert.assertFalse(compressor.isNowrap());
	rawContentIn = new ByteArrayInputStream(CONTENT);
	compressedContentOut = new ByteArrayOutputStream();
	compressor.compress(rawContentIn, compressedContentOut);
	byte[] compressedWithNowrapOff = compressedContentOut.toByteArray();
	Assert.assertFalse(compressedWithNowrapOn.length == compressedWithNowrapOff.length);
	byte[] uncompressedWithNowrapOff =
	uncompressWithJavaInflater(compressor.isNowrap(), compressedWithNowrapOff);
	Assert.assertArrayEquals(CONTENT, uncompressedWithNowrapOff);
	}

	@Test
	public void testStrategy() throws IOException {
	// Compression level has to be > 2 to get different output out of strategies 0 and 1.
	compressor.setCompressionLevel(9);

	// Compress with all valid strategies to ensure they all work.
	Content[] content = new Content[3];
	for (int strategy = 0; strategy <= 2; strategy++) {
	rawContentIn = new ByteArrayInputStream(CONTENT);
	compressedContentOut = new ByteArrayOutputStream();
	compressor.setStrategy(strategy);
	Assert.assertEquals(strategy, compressor.getStrategy());
	compressor.compress(rawContentIn, compressedContentOut);
	content[strategy] = new Content();
	content[strategy].compressed = compressedContentOut.toByteArray();
	content[strategy].uncompressed =
	uncompressWithJavaInflater(compressor.isNowrap(), content[strategy].compressed);
	Assert.assertArrayEquals(CONTENT, content[strategy].uncompressed);
	}

	// No two outputs should be the same.
	for (int outer = 0; outer < content.length; outer++) {
	for (int inner = 0; inner < content.length; inner++) {
	if (inner != outer) {
	Assert.assertFalse(
	"strategy " + outer + " == " + inner,
	Arrays.equals(content[outer].compressed, content[inner].compressed));
	}
	}
	}
	}

	@Test
	public void testCompressionLevel() throws IOException {
	// Compress at all levels to ensure they all work.
	Content[] content = new Content[10]; // Note that level 0 (store) is not used.
	for (int level = 1; level <= 9; level++) {
	rawContentIn = new ByteArrayInputStream(CONTENT);
	compressedContentOut = new ByteArrayOutputStream();
	compressor.setCompressionLevel(level);
	Assert.assertEquals(level, compressor.getCompressionLevel());
	compressor.compress(rawContentIn, compressedContentOut);
	content[level] = new Content();
	content[level].compressed = compressedContentOut.toByteArray();
	content[level].uncompressed =
	uncompressWithJavaInflater(compressor.isNowrap(), content[level].compressed);
	Assert.assertArrayEquals(CONTENT, content[level].uncompressed);
	}

	// No two outputs should be the same. Again note that level 0 (store) is unused, so start at 1.
	for (int outer = 1; outer < content.length; outer++) {
	for (int inner = 1; inner < content.length; inner++) {
	if (inner != outer) {
	Assert.assertFalse(
	"strategy " + outer + " == " + inner,
	Arrays.equals(content[outer].compressed, content[inner].compressed));
	}
	}
	}
	}

	@Test
	public void testSetInputBufferSize() throws IOException {
	Assert.assertNotEquals(17, compressor.getInputBufferSize()); // Ensure test is valid
	compressor.setInputBufferSize(17); // Arbitrary non-default value
	Assert.assertEquals(17, compressor.getInputBufferSize());
	compressor.compress(rawContentIn, compressedContentOut);
	byte[] uncompressed =
	uncompressWithJavaInflater(compressor.isNowrap(), compressedContentOut.toByteArray());
	Assert.assertArrayEquals(CONTENT, uncompressed);
	}

	@Test
	public void testSetOutputBufferSize() throws IOException {
	Assert.assertNotEquals(17, compressor.getOutputBufferSize()); // Ensure test is valid
	compressor.setOutputBufferSize(17); // Arbitrary non-default value
	Assert.assertEquals(17, compressor.getOutputBufferSize());
	compressor.compress(rawContentIn, compressedContentOut);
	byte[] uncompressed =
	uncompressWithJavaInflater(compressor.isNowrap(), compressedContentOut.toByteArray());
	Assert.assertArrayEquals(CONTENT, uncompressed);
	}

	@Test
	public void testCreateOrResetDeflater_Uncached() {
	compressor.setCaching(false);
	Deflater deflater1 = compressor.createOrResetDeflater();
	Deflater deflater2 = compressor.createOrResetDeflater();
	Assert.assertNotSame(deflater1, deflater2);
	}

	@Test
	public void testCreateOrResetDeflater_Cached() {
	compressor.setCaching(true);
	Deflater deflater1 = compressor.createOrResetDeflater();
	Deflater deflater2 = compressor.createOrResetDeflater();
	Assert.assertSame(deflater1, deflater2);
	}

	@Test
	public void testRelease() {
	compressor.setCaching(true);
	Deflater deflater1 = compressor.createOrResetDeflater();
	compressor.release();
	Deflater deflater2 = compressor.createOrResetDeflater();
	Assert.assertNotSame(deflater1, deflater2);
	}

	@Test
	public void testReusability() throws IOException {
	// Checks that the compressor produces correct output when cached, i.e. that it is being
	// properly reset between runs.
	compressor.setCaching(true);
	compressor.compress(rawContentIn, compressedContentOut);
	byte[] uncompressed =
	uncompressWithJavaInflater(compressor.isNowrap(), compressedContentOut.toByteArray());
	Assert.assertArrayEquals(CONTENT, uncompressed);

	// Caching is on, try to reuse it without any changes.
	rawContentIn = new ByteArrayInputStream(CONTENT);
	compressedContentOut = new ByteArrayOutputStream();
	compressor.compress(rawContentIn, compressedContentOut);
	uncompressed =
	uncompressWithJavaInflater(compressor.isNowrap(), compressedContentOut.toByteArray());
	Assert.assertArrayEquals(CONTENT, uncompressed);

	// Caching is still on, tweak the compression level and try again.
	Assert.assertNotEquals(7, compressor.getCompressionLevel()); // Ensure test is valid
	compressor.setCompressionLevel(7);
	rawContentIn = new ByteArrayInputStream(CONTENT);
	compressedContentOut = new ByteArrayOutputStream();
	compressor.compress(rawContentIn, compressedContentOut);
	uncompressed =
	uncompressWithJavaInflater(compressor.isNowrap(), compressedContentOut.toByteArray());
	Assert.assertArrayEquals(CONTENT, uncompressed);

	// Caching is still on, tweak the strategy and try again.
	Assert.assertNotEquals(1, compressor.getStrategy()); // Ensure test is valid
	compressor.setStrategy(Deflater.FILTERED);
	rawContentIn = new ByteArrayInputStream(CONTENT);
	compressedContentOut = new ByteArrayOutputStream();
	compressor.compress(rawContentIn, compressedContentOut);
	uncompressed =
	uncompressWithJavaInflater(compressor.isNowrap(), compressedContentOut.toByteArray());
	Assert.assertArrayEquals(CONTENT, uncompressed);

	// Caching is still on, reverse the wrapping style and try again. Changing the wrapping style
	// invalidates the cached compressor because the wrapping style cannot be changed, this is a
	// special code path we need to exercise.
	compressor.setNowrap(!compressor.isNowrap());
	rawContentIn = new ByteArrayInputStream(CONTENT);
	compressedContentOut = new ByteArrayOutputStream();
	compressor.compress(rawContentIn, compressedContentOut);
	uncompressed =
	uncompressWithJavaInflater(compressor.isNowrap(), compressedContentOut.toByteArray());
	Assert.assertArrayEquals(CONTENT, uncompressed);
	}
	}