You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by bo...@apache.org on 2016/04/10 06:18:54 UTC

[38/46] commons-compress git commit: Add final modifier to local variables.

http://git-wip-us.apache.org/repos/asf/commons-compress/blob/3f2c760a/src/test/java/org/apache/commons/compress/archivers/zip/ParallelScatterZipCreatorTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/compress/archivers/zip/ParallelScatterZipCreatorTest.java b/src/test/java/org/apache/commons/compress/archivers/zip/ParallelScatterZipCreatorTest.java
index c4eabeb..0d9cd3e 100644
--- a/src/test/java/org/apache/commons/compress/archivers/zip/ParallelScatterZipCreatorTest.java
+++ b/src/test/java/org/apache/commons/compress/archivers/zip/ParallelScatterZipCreatorTest.java
@@ -57,11 +57,11 @@ public class ParallelScatterZipCreatorTest {
     public void concurrent()
             throws Exception {
         result = File.createTempFile("parallelScatterGather1", "");
-        ZipArchiveOutputStream zos = new ZipArchiveOutputStream(result);
+        final ZipArchiveOutputStream zos = new ZipArchiveOutputStream(result);
         zos.setEncoding("UTF-8");
-        ParallelScatterZipCreator zipCreator = new ParallelScatterZipCreator();
+        final ParallelScatterZipCreator zipCreator = new ParallelScatterZipCreator();
 
-        Map<String, byte[]> entries = writeEntries(zipCreator);
+        final Map<String, byte[]> entries = writeEntries(zipCreator);
         zipCreator.writeTo(zos);
         zos.close();
         removeEntriesFoundInZipFile(result, entries);
@@ -73,19 +73,19 @@ public class ParallelScatterZipCreatorTest {
     public void callableApi()
             throws Exception {
         result = File.createTempFile("parallelScatterGather2", "");
-        ZipArchiveOutputStream zos = new ZipArchiveOutputStream(result);
+        final ZipArchiveOutputStream zos = new ZipArchiveOutputStream(result);
         zos.setEncoding("UTF-8");
-        ExecutorService es = Executors.newFixedThreadPool(1);
+        final ExecutorService es = Executors.newFixedThreadPool(1);
 
-        ScatterGatherBackingStoreSupplier supp = new ScatterGatherBackingStoreSupplier() {
+        final ScatterGatherBackingStoreSupplier supp = new ScatterGatherBackingStoreSupplier() {
             @Override
             public ScatterGatherBackingStore get() throws IOException {
                 return new FileBasedScatterGatherBackingStore(tmp = File.createTempFile("parallelscatter", "n1"));
             }
         };
 
-        ParallelScatterZipCreator zipCreator = new ParallelScatterZipCreator(es, supp);
-        Map<String, byte[]> entries = writeEntriesAsCallable(zipCreator);
+        final ParallelScatterZipCreator zipCreator = new ParallelScatterZipCreator(es, supp);
+        final Map<String, byte[]> entries = writeEntriesAsCallable(zipCreator);
         zipCreator.writeTo(zos);
         zos.close();
 
@@ -96,23 +96,23 @@ public class ParallelScatterZipCreatorTest {
     }
 
     private void removeEntriesFoundInZipFile(final File result, final Map<String, byte[]> entries) throws IOException {
-        ZipFile zf = new ZipFile(result);
-        Enumeration<ZipArchiveEntry> entriesInPhysicalOrder = zf.getEntriesInPhysicalOrder();
+        final ZipFile zf = new ZipFile(result);
+        final Enumeration<ZipArchiveEntry> entriesInPhysicalOrder = zf.getEntriesInPhysicalOrder();
         while (entriesInPhysicalOrder.hasMoreElements()){
-            ZipArchiveEntry zipArchiveEntry = entriesInPhysicalOrder.nextElement();
-            InputStream inputStream = zf.getInputStream(zipArchiveEntry);
-            byte[] actual = IOUtils.toByteArray(inputStream);
-            byte[] expected = entries.remove(zipArchiveEntry.getName());
+            final ZipArchiveEntry zipArchiveEntry = entriesInPhysicalOrder.nextElement();
+            final InputStream inputStream = zf.getInputStream(zipArchiveEntry);
+            final byte[] actual = IOUtils.toByteArray(inputStream);
+            final byte[] expected = entries.remove(zipArchiveEntry.getName());
             assertArrayEquals( "For " + zipArchiveEntry.getName(),  expected, actual);
         }
         zf.close();
     }
 
     private Map<String, byte[]> writeEntries(final ParallelScatterZipCreator zipCreator) {
-        Map<String, byte[]> entries = new HashMap<String, byte[]>();
+        final Map<String, byte[]> entries = new HashMap<String, byte[]>();
         for (int i = 0; i < NUMITEMS; i++){
             final byte[] payloadBytes = ("content" + i).getBytes();
-            ZipArchiveEntry za = createZipArchiveEntry(entries, i, payloadBytes);
+            final ZipArchiveEntry za = createZipArchiveEntry(entries, i, payloadBytes);
             zipCreator.addArchiveEntry(za, new InputStreamSupplier() {
                 @Override
                 public InputStream get() {
@@ -124,10 +124,10 @@ public class ParallelScatterZipCreatorTest {
     }
 
     private Map<String, byte[]> writeEntriesAsCallable(final ParallelScatterZipCreator zipCreator) {
-        Map<String, byte[]> entries = new HashMap<String, byte[]>();
+        final Map<String, byte[]> entries = new HashMap<String, byte[]>();
         for (int i = 0; i < NUMITEMS; i++){
             final byte[] payloadBytes = ("content" + i).getBytes();
-            ZipArchiveEntry za = createZipArchiveEntry(entries, i, payloadBytes);
+            final ZipArchiveEntry za = createZipArchiveEntry(entries, i, payloadBytes);
             final Callable<Object> callable = zipCreator.createCallable(za, new InputStreamSupplier() {
                 @Override
                 public InputStream get() {
@@ -140,7 +140,7 @@ public class ParallelScatterZipCreatorTest {
     }
 
     private ZipArchiveEntry createZipArchiveEntry(final Map<String, byte[]> entries, final int i, final byte[] payloadBytes) {
-        ZipArchiveEntry za = new ZipArchiveEntry( "file" + i);
+        final ZipArchiveEntry za = new ZipArchiveEntry( "file" + i);
         entries.put( za.getName(), payloadBytes);
         za.setMethod(ZipEntry.DEFLATED);
         za.setSize(payloadBytes.length);

http://git-wip-us.apache.org/repos/asf/commons-compress/blob/3f2c760a/src/test/java/org/apache/commons/compress/archivers/zip/ScatterSampleTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/compress/archivers/zip/ScatterSampleTest.java b/src/test/java/org/apache/commons/compress/archivers/zip/ScatterSampleTest.java
index 8125576..d94f294 100644
--- a/src/test/java/org/apache/commons/compress/archivers/zip/ScatterSampleTest.java
+++ b/src/test/java/org/apache/commons/compress/archivers/zip/ScatterSampleTest.java
@@ -34,17 +34,17 @@ public class ScatterSampleTest {
 
     @Test
     public void testSample() throws Exception {
-        File result = File.createTempFile("testSample", "fe");
+        final File result = File.createTempFile("testSample", "fe");
 
         createFile(result);
         checkFile(result);
     }
 
     private void createFile(final File result) throws IOException, ExecutionException, InterruptedException {
-        ScatterSample scatterSample = new ScatterSample();
-        ZipArchiveEntry archiveEntry = new ZipArchiveEntry("test1.xml");
+        final ScatterSample scatterSample = new ScatterSample();
+        final ZipArchiveEntry archiveEntry = new ZipArchiveEntry("test1.xml");
         archiveEntry.setMethod(ZipEntry.DEFLATED);
-        InputStreamSupplier supp = new InputStreamSupplier() {
+        final InputStreamSupplier supp = new InputStreamSupplier() {
             @Override
             public InputStream get() {
                 return new ByteArrayInputStream("Hello".getBytes());
@@ -52,18 +52,18 @@ public class ScatterSampleTest {
         };
 
         scatterSample.addEntry(archiveEntry, supp);
-        ZipArchiveOutputStream zipArchiveOutputStream = new ZipArchiveOutputStream(result);
+        final ZipArchiveOutputStream zipArchiveOutputStream = new ZipArchiveOutputStream(result);
         scatterSample.writeTo(zipArchiveOutputStream);
         zipArchiveOutputStream.close();
     }
 
     private void checkFile(final File result) throws IOException {
-        ZipFile zf = new ZipFile(result);
-        ZipArchiveEntry archiveEntry1 = zf.getEntries().nextElement();
+        final ZipFile zf = new ZipFile(result);
+        final ZipArchiveEntry archiveEntry1 = zf.getEntries().nextElement();
         assertEquals( "test1.xml", archiveEntry1.getName());
-        InputStream inputStream = zf.getInputStream(archiveEntry1);
-        byte[] b = new byte[6];
-        int i = IOUtils.readFully(inputStream, b);
+        final InputStream inputStream = zf.getInputStream(archiveEntry1);
+        final byte[] b = new byte[6];
+        final int i = IOUtils.readFully(inputStream, b);
         assertEquals(5, i);
         assertEquals('H', b[0]);
         assertEquals('o', b[4]);

http://git-wip-us.apache.org/repos/asf/commons-compress/blob/3f2c760a/src/test/java/org/apache/commons/compress/archivers/zip/ScatterZipOutputStreamTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/compress/archivers/zip/ScatterZipOutputStreamTest.java b/src/test/java/org/apache/commons/compress/archivers/zip/ScatterZipOutputStreamTest.java
index f7550ce..388b2ca 100644
--- a/src/test/java/org/apache/commons/compress/archivers/zip/ScatterZipOutputStreamTest.java
+++ b/src/test/java/org/apache/commons/compress/archivers/zip/ScatterZipOutputStreamTest.java
@@ -46,27 +46,27 @@ public class ScatterZipOutputStreamTest {
     @Test
     public void putArchiveEntry() throws Exception {
         scatterFile = File.createTempFile("scattertest", ".notzip");
-        ScatterZipOutputStream scatterZipOutputStream = ScatterZipOutputStream.fileBased(scatterFile);
+        final ScatterZipOutputStream scatterZipOutputStream = ScatterZipOutputStream.fileBased(scatterFile);
         final byte[] B_PAYLOAD = "RBBBBBBS".getBytes();
         final byte[] A_PAYLOAD = "XAAY".getBytes();
 
-        ZipArchiveEntry zab = new ZipArchiveEntry("b.txt");
+        final ZipArchiveEntry zab = new ZipArchiveEntry("b.txt");
         zab.setMethod(ZipEntry.DEFLATED);
         final ByteArrayInputStream payload = new ByteArrayInputStream(B_PAYLOAD);
         scatterZipOutputStream.addArchiveEntry(createZipArchiveEntryRequest(zab, createPayloadSupplier(payload)));
 
-        ZipArchiveEntry zae = new ZipArchiveEntry("a.txt");
+        final ZipArchiveEntry zae = new ZipArchiveEntry("a.txt");
         zae.setMethod(ZipEntry.DEFLATED);
-        ByteArrayInputStream payload1 = new ByteArrayInputStream(A_PAYLOAD);
+        final ByteArrayInputStream payload1 = new ByteArrayInputStream(A_PAYLOAD);
         scatterZipOutputStream.addArchiveEntry(createZipArchiveEntryRequest(zae, createPayloadSupplier(payload1)));
 
         target = File.createTempFile("scattertest", ".zip");
-        ZipArchiveOutputStream outputStream = new ZipArchiveOutputStream(target);
+        final ZipArchiveOutputStream outputStream = new ZipArchiveOutputStream(target);
         scatterZipOutputStream.writeTo( outputStream);
         outputStream.close();
         scatterZipOutputStream.close();
 
-        ZipFile zf = new ZipFile(target);
+        final ZipFile zf = new ZipFile(target);
         final ZipArchiveEntry b_entry = zf.getEntries("b.txt").iterator().next();
         assertEquals(8, b_entry.getSize());
         assertArrayEquals(B_PAYLOAD, IOUtils.toByteArray(zf.getInputStream(b_entry)));

http://git-wip-us.apache.org/repos/asf/commons-compress/blob/3f2c760a/src/test/java/org/apache/commons/compress/archivers/zip/StreamCompressorTest.java
----------------------------------------------------------------------
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 905751f..27505c4 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
@@ -30,8 +30,8 @@ public class StreamCompressorTest {
 
     @Test
     public void storedEntries() throws Exception {
-        ByteArrayOutputStream baos = new ByteArrayOutputStream();
-        StreamCompressor sc = StreamCompressor.create( baos);
+        final ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        final StreamCompressor sc = StreamCompressor.create( baos);
         sc.deflate(new ByteArrayInputStream("A".getBytes()), ZipEntry.STORED);
         sc.deflate(new ByteArrayInputStream("BAD".getBytes()), ZipEntry.STORED);
         assertEquals(3, sc.getBytesRead());
@@ -43,15 +43,15 @@ public class StreamCompressorTest {
 
     @Test
     public void deflatedEntries() throws Exception {
-        ByteArrayOutputStream baos = new ByteArrayOutputStream();
-        StreamCompressor sc = StreamCompressor.create( baos);
+        final ByteArrayOutputStream baos = new ByteArrayOutputStream();
+        final StreamCompressor sc = StreamCompressor.create( baos);
         sc.deflate(new ByteArrayInputStream("AAAAAABBBBBB".getBytes()), ZipEntry.DEFLATED);
         assertEquals(12, sc.getBytesRead());
         assertEquals(8, sc.getBytesWrittenForLastEntry());
         assertEquals(3299542, sc.getCrc32());
 
         final byte[] actuals = baos.toByteArray();
-        byte[] expected = new byte[]{115,116,4,1,39,48,0,0};
+        final byte[] expected = new byte[]{115,116,4,1,39,48,0,0};
         // Note that this test really asserts stuff about the java Deflater, which might be a little bit brittle
         assertArrayEquals(expected, actuals);
     }

http://git-wip-us.apache.org/repos/asf/commons-compress/blob/3f2c760a/src/test/java/org/apache/commons/compress/archivers/zip/UTF8ZipFilesTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/compress/archivers/zip/UTF8ZipFilesTest.java b/src/test/java/org/apache/commons/compress/archivers/zip/UTF8ZipFilesTest.java
index 27d1889..aecc005 100644
--- a/src/test/java/org/apache/commons/compress/archivers/zip/UTF8ZipFilesTest.java
+++ b/src/test/java/org/apache/commons/compress/archivers/zip/UTF8ZipFilesTest.java
@@ -96,7 +96,7 @@ public class UTF8ZipFilesTest extends AbstractTestCase {
      */
     @Test
     public void testRead7ZipArchive() throws IOException {
-        File archive = getFile("utf8-7zip-test.zip");
+        final File archive = getFile("utf8-7zip-test.zip");
         ZipFile zf = null;
         try {
             zf = new ZipFile(archive, CP437, false);
@@ -110,7 +110,7 @@ public class UTF8ZipFilesTest extends AbstractTestCase {
 
     @Test
     public void testRead7ZipArchiveForStream() throws IOException {
-        FileInputStream archive =
+        final FileInputStream archive =
             new FileInputStream(getFile("utf8-7zip-test.zip"));
         ZipArchiveInputStream zi = null;
         try {
@@ -131,7 +131,7 @@ public class UTF8ZipFilesTest extends AbstractTestCase {
      */
     @Test
     public void testReadWinZipArchive() throws IOException {
-        File archive = getFile("utf8-winzip-test.zip");
+        final File archive = getFile("utf8-winzip-test.zip");
         ZipFile zf = null;
         try {
             zf = new ZipFile(archive, null, true);
@@ -144,9 +144,9 @@ public class UTF8ZipFilesTest extends AbstractTestCase {
     }
 
     private void assertCanRead(final ZipFile zf, final String fileName) throws IOException {
-        ZipArchiveEntry entry = zf.getEntry(fileName);
+        final ZipArchiveEntry entry = zf.getEntry(fileName);
         assertNotNull("Entry doesn't exist", entry);
-        InputStream is = zf.getInputStream(entry);
+        final InputStream is = zf.getInputStream(entry);
         assertNotNull("InputStream is null", is);
         try {
             is.read();
@@ -157,7 +157,7 @@ public class UTF8ZipFilesTest extends AbstractTestCase {
 
     @Test
     public void testReadWinZipArchiveForStream() throws IOException {
-        FileInputStream archive =
+        final FileInputStream archive =
             new FileInputStream(getFile("utf8-winzip-test.zip"));
         ZipArchiveInputStream zi = null;
         try {
@@ -174,12 +174,12 @@ public class UTF8ZipFilesTest extends AbstractTestCase {
 
     @Test
     public void testZipFileReadsUnicodeFields() throws IOException {
-        File file = File.createTempFile("unicode-test", ".zip");
+        final File file = File.createTempFile("unicode-test", ".zip");
         file.deleteOnExit();
         ZipArchiveInputStream zi = null;
         try {
             createTestFile(file, CharsetNames.US_ASCII, false, true);
-            FileInputStream archive = new FileInputStream(file);
+            final FileInputStream archive = new FileInputStream(file);
             zi = new ZipArchiveInputStream(archive, CharsetNames.US_ASCII, true);
             assertEquals(OIL_BARREL_TXT, zi.getNextEntry().getName());
             assertEquals(EURO_FOR_DOLLAR_TXT, zi.getNextEntry().getName());
@@ -195,7 +195,7 @@ public class UTF8ZipFilesTest extends AbstractTestCase {
     @Test
     public void testZipArchiveInputStreamReadsUnicodeFields()
         throws IOException {
-        File file = File.createTempFile("unicode-test", ".zip");
+        final File file = File.createTempFile("unicode-test", ".zip");
         file.deleteOnExit();
         ZipFile zf = null;
         try {
@@ -213,7 +213,7 @@ public class UTF8ZipFilesTest extends AbstractTestCase {
     @Test
     public void testRawNameReadFromZipFile()
         throws IOException {
-        File archive = getFile("utf8-7zip-test.zip");
+        final File archive = getFile("utf8-7zip-test.zip");
         ZipFile zf = null;
         try {
             zf = new ZipFile(archive, CP437, false);
@@ -226,7 +226,7 @@ public class UTF8ZipFilesTest extends AbstractTestCase {
     @Test
     public void testRawNameReadFromStream()
         throws IOException {
-        FileInputStream archive =
+        final FileInputStream archive =
             new FileInputStream(getFile("utf8-7zip-test.zip"));
         ZipArchiveInputStream zi = null;
         try {
@@ -243,7 +243,7 @@ public class UTF8ZipFilesTest extends AbstractTestCase {
                                           final boolean withExplicitUnicodeExtra)
         throws IOException {
 
-        File file = File.createTempFile(encoding + "-test", ".zip");
+        final File file = File.createTempFile(encoding + "-test", ".zip");
         file.deleteOnExit();
         try {
             createTestFile(file, encoding, withEFS, withExplicitUnicodeExtra);
@@ -258,7 +258,7 @@ public class UTF8ZipFilesTest extends AbstractTestCase {
                                        final boolean withExplicitUnicodeExtra)
         throws UnsupportedEncodingException, IOException {
 
-        ZipEncoding zipEncoding = ZipEncodingHelper.getZipEncoding(encoding);
+        final ZipEncoding zipEncoding = ZipEncodingHelper.getZipEncoding(encoding);
 
         ZipArchiveOutputStream zos = null;
         try {
@@ -275,7 +275,7 @@ public class UTF8ZipFilesTest extends AbstractTestCase {
             if (withExplicitUnicodeExtra
                 && !zipEncoding.canEncode(ze.getName())) {
 
-                ByteBuffer en = zipEncoding.encode(ze.getName());
+                final ByteBuffer en = zipEncoding.encode(ze.getName());
 
                 ze.addExtraField(new UnicodePathExtraField(ze.getName(),
                                                            en.array(),
@@ -292,7 +292,7 @@ public class UTF8ZipFilesTest extends AbstractTestCase {
             if (withExplicitUnicodeExtra
                 && !zipEncoding.canEncode(ze.getName())) {
 
-                ByteBuffer en = zipEncoding.encode(ze.getName());
+                final ByteBuffer en = zipEncoding.encode(ze.getName());
 
                 ze.addExtraField(new UnicodePathExtraField(ze.getName(),
                                                            en.array(),
@@ -310,7 +310,7 @@ public class UTF8ZipFilesTest extends AbstractTestCase {
             if (withExplicitUnicodeExtra
                 && !zipEncoding.canEncode(ze.getName())) {
 
-                ByteBuffer en = zipEncoding.encode(ze.getName());
+                final ByteBuffer en = zipEncoding.encode(ze.getName());
 
                 ze.addExtraField(new UnicodePathExtraField(ze.getName(),
                                                            en.array(),
@@ -328,7 +328,7 @@ public class UTF8ZipFilesTest extends AbstractTestCase {
             if (zos != null) {
                 try {
                     zos.close();
-                } catch (IOException e) { /* swallow */ }
+                } catch (final IOException e) { /* swallow */ }
             }
         }
     }
@@ -339,9 +339,9 @@ public class UTF8ZipFilesTest extends AbstractTestCase {
         try {
             zf = new ZipFile(file, encoding, false);
 
-            Enumeration<ZipArchiveEntry> e = zf.getEntries();
+            final Enumeration<ZipArchiveEntry> e = zf.getEntries();
             while (e.hasMoreElements()) {
-                ZipArchiveEntry ze = e.nextElement();
+                final ZipArchiveEntry ze = e.nextElement();
 
                 if (ze.getName().endsWith("sser.txt")) {
                     assertUnicodeName(ze, OIL_BARREL_TXT, encoding);
@@ -368,13 +368,13 @@ public class UTF8ZipFilesTest extends AbstractTestCase {
                                           final String encoding)
         throws IOException {
         if (!expectedName.equals(ze.getName())) {
-            UnicodePathExtraField ucpf = findUniCodePath(ze);
+            final UnicodePathExtraField ucpf = findUniCodePath(ze);
             assertNotNull(ucpf);
 
-            ZipEncoding enc = ZipEncodingHelper.getZipEncoding(encoding);
-            ByteBuffer ne = enc.encode(ze.getName());
+            final ZipEncoding enc = ZipEncodingHelper.getZipEncoding(encoding);
+            final ByteBuffer ne = enc.encode(ze.getName());
 
-            CRC32 crc = new CRC32();
+            final CRC32 crc = new CRC32();
             crc.update(ne.array(), ne.arrayOffset(),
                        ne.limit() - ne.position());
 
@@ -386,8 +386,8 @@ public class UTF8ZipFilesTest extends AbstractTestCase {
 
     @Test
     public void testUtf8Interoperability() throws IOException {
-        File file1 = getFile("utf8-7zip-test.zip");
-        File file2 = getFile("utf8-winzip-test.zip");
+        final File file1 = getFile("utf8-7zip-test.zip");
+        final File file2 = getFile("utf8-winzip-test.zip");
 
         testFile(file1,CP437);
         testFile(file2,CP437);
@@ -395,7 +395,7 @@ public class UTF8ZipFilesTest extends AbstractTestCase {
     }
 
     private static void assertRawNameOfAcsiiTxt(final ZipArchiveEntry ze) {
-        byte[] b = ze.getRawName();
+        final byte[] b = ze.getRawName();
         assertNotNull(b);
         final int len = ASCII_TXT.length();
         assertEquals(len, b.length);

http://git-wip-us.apache.org/repos/asf/commons-compress/blob/3f2c760a/src/test/java/org/apache/commons/compress/archivers/zip/X000A_NTFSTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/compress/archivers/zip/X000A_NTFSTest.java b/src/test/java/org/apache/commons/compress/archivers/zip/X000A_NTFSTest.java
index 76f4317..277d360 100644
--- a/src/test/java/org/apache/commons/compress/archivers/zip/X000A_NTFSTest.java
+++ b/src/test/java/org/apache/commons/compress/archivers/zip/X000A_NTFSTest.java
@@ -27,14 +27,14 @@ public class X000A_NTFSTest {
 
     @Test
     public void simpleRountrip() throws Exception {
-        X000A_NTFS xf = new X000A_NTFS();
+        final X000A_NTFS xf = new X000A_NTFS();
         xf.setModifyJavaTime(new Date(0));
         // one second past midnight
         xf.setAccessJavaTime(new Date(-11644473601000l));
         xf.setCreateJavaTime(null);
-        byte[] b = xf.getLocalFileDataData();
+        final byte[] b = xf.getLocalFileDataData();
 
-        X000A_NTFS xf2 = new X000A_NTFS();
+        final X000A_NTFS xf2 = new X000A_NTFS();
         xf2.parseFromLocalFileData(b, 0, b.length);
         assertEquals(new Date(0), xf2.getModifyJavaTime());
         assertEquals(new Date(-11644473601000l), xf2.getAccessJavaTime());

http://git-wip-us.apache.org/repos/asf/commons-compress/blob/3f2c760a/src/test/java/org/apache/commons/compress/archivers/zip/X5455_ExtendedTimestampTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/compress/archivers/zip/X5455_ExtendedTimestampTest.java b/src/test/java/org/apache/commons/compress/archivers/zip/X5455_ExtendedTimestampTest.java
index 17ec460..06c77d3 100644
--- a/src/test/java/org/apache/commons/compress/archivers/zip/X5455_ExtendedTimestampTest.java
+++ b/src/test/java/org/apache/commons/compress/archivers/zip/X5455_ExtendedTimestampTest.java
@@ -107,37 +107,37 @@ public class X5455_ExtendedTimestampTest {
         http://hg.openjdk.java.net/jdk8u/jdk8u/jdk/rev/90df6756406f
          */
 
-        File archive = getFile("COMPRESS-210_unix_time_zip_test.zip");
+        final File archive = getFile("COMPRESS-210_unix_time_zip_test.zip");
         ZipFile zf = null;
 
         try {
             zf = new ZipFile(archive);
-            Enumeration<ZipArchiveEntry> en = zf.getEntries();
+            final Enumeration<ZipArchiveEntry> en = zf.getEntries();
 
             // We expect EVERY entry of this zip file
             // to contain extra field 0x5455.
             while (en.hasMoreElements()) {
 
-                ZipArchiveEntry zae = en.nextElement();
-                String name = zae.getName();
-                X5455_ExtendedTimestamp xf = (X5455_ExtendedTimestamp) zae.getExtraField(X5455);
-                Date rawZ = zae.getLastModifiedDate();
-                Date m = xf.getModifyJavaTime();
-                boolean zipTimeUsesExtendedTimestamp = rawZ.equals(m);
-                Date z = zipTimeUsesExtendedTimestamp ? rawZ : adjustFromGMTToExpectedOffset(rawZ);
-                Date a = xf.getAccessJavaTime();
+                final ZipArchiveEntry zae = en.nextElement();
+                final String name = zae.getName();
+                final X5455_ExtendedTimestamp xf = (X5455_ExtendedTimestamp) zae.getExtraField(X5455);
+                final Date rawZ = zae.getLastModifiedDate();
+                final Date m = xf.getModifyJavaTime();
+                final boolean zipTimeUsesExtendedTimestamp = rawZ.equals(m);
+                final Date z = zipTimeUsesExtendedTimestamp ? rawZ : adjustFromGMTToExpectedOffset(rawZ);
+                final Date a = xf.getAccessJavaTime();
 
-                String zipTime = DATE_FORMAT.format(z);
-                String modTime = DATE_FORMAT.format(m);
-                String accTime = DATE_FORMAT.format(a);
+                final String zipTime = DATE_FORMAT.format(z);
+                final String modTime = DATE_FORMAT.format(m);
+                final String accTime = DATE_FORMAT.format(a);
 
                 if (!zae.isDirectory()) {
-                    int x = name.lastIndexOf('/');
-                    String yearString = name.substring(x + 1);
+                    final int x = name.lastIndexOf('/');
+                    final String yearString = name.substring(x + 1);
                     int year;
                     try {
                         year = Integer.parseInt(yearString);
-                    } catch (NumberFormatException nfe) {
+                    } catch (final NumberFormatException nfe) {
                         year = -1;
                     }
                     if (year >= 0) {
@@ -229,22 +229,22 @@ public class X5455_ExtendedTimestampTest {
     public void testGettersSetters() {
         // X5455 is concerned with time, so let's
         // get a timestamp to play with (Jan 1st, 2000).
-        Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
+        final Calendar cal = Calendar.getInstance(TimeZone.getTimeZone("UTC"));
         cal.set(Calendar.YEAR, 2000);
         cal.set(Calendar.MONTH, Calendar.JANUARY);
         cal.set(Calendar.DATE, 1);
         cal.set(Calendar.HOUR_OF_DAY, 0);
         cal.set(Calendar.MINUTE, 0);
         cal.set(Calendar.MILLISECOND, 0);
-        Date timeMillis = cal.getTime();
-        ZipLong time = new ZipLong(timeMillis.getTime() / 1000);
+        final Date timeMillis = cal.getTime();
+        final ZipLong time = new ZipLong(timeMillis.getTime() / 1000);
 
         // set too big
         try {
             // Java time is 1000 x larger (milliseconds).
             xf.setModifyJavaTime(new Date(1000L * (MAX_TIME_SECONDS.getValue() + 1L)));
             fail("Time too big for 32 bits!");
-        } catch (IllegalArgumentException iae) {
+        } catch (final IllegalArgumentException iae) {
             // All is good.
         }
 
@@ -423,13 +423,13 @@ public class X5455_ExtendedTimestampTest {
     @Test
     public void testWriteReadRoundtrip() throws IOException {
         tmpDir = mkdir("X5455");
-        File output = new File(tmpDir, "write_rewrite.zip");
+        final File output = new File(tmpDir, "write_rewrite.zip");
         final OutputStream out = new FileOutputStream(output);
-        Date d = new Date(97, 8, 24, 15, 10, 2);
+        final Date d = new Date(97, 8, 24, 15, 10, 2);
         ZipArchiveOutputStream os = null;
         try {
             os = new ZipArchiveOutputStream(out);
-            ZipArchiveEntry ze = new ZipArchiveEntry("foo");
+            final ZipArchiveEntry ze = new ZipArchiveEntry("foo");
             xf.setModifyJavaTime(d);
             xf.setFlags((byte) 1);
             ze.addExtraField(xf);
@@ -442,9 +442,9 @@ public class X5455_ExtendedTimestampTest {
         }
         out.close();
         
-        ZipFile zf = new ZipFile(output);
-        ZipArchiveEntry ze = zf.getEntry("foo");
-        X5455_ExtendedTimestamp ext =
+        final ZipFile zf = new ZipFile(output);
+        final ZipArchiveEntry ze = zf.getEntry("foo");
+        final X5455_ExtendedTimestamp ext =
             (X5455_ExtendedTimestamp) ze.getExtraField(X5455);
         assertNotNull(ext);
         assertTrue(ext.isBit0_modifyTimePresent());
@@ -548,7 +548,7 @@ public class X5455_ExtendedTimestampTest {
      * with GMT-8 so we need to adjust for the difference.
      */
     private static Date adjustFromGMTToExpectedOffset(final Date from) {
-        Calendar cal = Calendar.getInstance();
+        final Calendar cal = Calendar.getInstance();
         cal.setTime(from);
         cal.add(Calendar.MILLISECOND, cal.get(Calendar.ZONE_OFFSET));
         if (cal.getTimeZone().inDaylightTime(from)) {

http://git-wip-us.apache.org/repos/asf/commons-compress/blob/3f2c760a/src/test/java/org/apache/commons/compress/archivers/zip/X7875_NewUnixTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/compress/archivers/zip/X7875_NewUnixTest.java b/src/test/java/org/apache/commons/compress/archivers/zip/X7875_NewUnixTest.java
index db53171..b148809 100644
--- a/src/test/java/org/apache/commons/compress/archivers/zip/X7875_NewUnixTest.java
+++ b/src/test/java/org/apache/commons/compress/archivers/zip/X7875_NewUnixTest.java
@@ -46,20 +46,20 @@ public class X7875_NewUnixTest {
 
     @Test
     public void testSampleFile() throws Exception {
-        File archive = getFile("COMPRESS-211_uid_gid_zip_test.zip");
+        final File archive = getFile("COMPRESS-211_uid_gid_zip_test.zip");
         ZipFile zf = null;
 
         try {
             zf = new ZipFile(archive);
-            Enumeration<ZipArchiveEntry> en = zf.getEntries();
+            final Enumeration<ZipArchiveEntry> en = zf.getEntries();
 
             // We expect EVERY entry of this zip file (dir & file) to
             // contain extra field 0x7875.
             while (en.hasMoreElements()) {
 
-                ZipArchiveEntry zae = en.nextElement();
-                String name = zae.getName();
-                X7875_NewUnix xf = (X7875_NewUnix) zae.getExtraField(X7875);
+                final ZipArchiveEntry zae = en.nextElement();
+                final String name = zae.getName();
+                final X7875_NewUnix xf = (X7875_NewUnix) zae.getExtraField(X7875);
 
                 // The directory entry in the test zip file is uid/gid 1000.
                 long expected = 1000;
@@ -97,7 +97,7 @@ public class X7875_NewUnixTest {
     public void testMisc() throws Exception {
         assertFalse(xf.equals(new Object()));
         assertTrue(xf.toString().startsWith("0x7875 Zip Extra Field"));
-        Object o = xf.clone();
+        final Object o = xf.clone();
         assertEquals(o.hashCode(), xf.hashCode());
         assertTrue(xf.equals(o));
         xf.setUID(12345);

http://git-wip-us.apache.org/repos/asf/commons-compress/blob/3f2c760a/src/test/java/org/apache/commons/compress/archivers/zip/Zip64ExtendedInformationExtraFieldTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/compress/archivers/zip/Zip64ExtendedInformationExtraFieldTest.java b/src/test/java/org/apache/commons/compress/archivers/zip/Zip64ExtendedInformationExtraFieldTest.java
index 8e2f23b..e366ffa 100644
--- a/src/test/java/org/apache/commons/compress/archivers/zip/Zip64ExtendedInformationExtraFieldTest.java
+++ b/src/test/java/org/apache/commons/compress/archivers/zip/Zip64ExtendedInformationExtraFieldTest.java
@@ -39,20 +39,20 @@ public class Zip64ExtendedInformationExtraFieldTest {
 
     @Test
     public void testWriteCDOnlySizes() {
-        Zip64ExtendedInformationExtraField f =
+        final Zip64ExtendedInformationExtraField f =
             new Zip64ExtendedInformationExtraField(SIZE, CSIZE);
         assertEquals(new ZipShort(16), f.getCentralDirectoryLength());
-        byte[] b = f.getCentralDirectoryData();
+        final byte[] b = f.getCentralDirectoryData();
         assertEquals(16, b.length);
         checkSizes(b);
     }
 
     @Test
     public void testWriteCDSizeAndOffset() {
-        Zip64ExtendedInformationExtraField f =
+        final Zip64ExtendedInformationExtraField f =
             new Zip64ExtendedInformationExtraField(SIZE, CSIZE, OFF, null);
         assertEquals(new ZipShort(24), f.getCentralDirectoryLength());
-        byte[] b = f.getCentralDirectoryData();
+        final byte[] b = f.getCentralDirectoryData();
         assertEquals(24, b.length);
         checkSizes(b);
         checkOffset(b, 16);
@@ -60,10 +60,10 @@ public class Zip64ExtendedInformationExtraFieldTest {
 
     @Test
     public void testWriteCDSizeOffsetAndDisk() {
-        Zip64ExtendedInformationExtraField f =
+        final Zip64ExtendedInformationExtraField f =
             new Zip64ExtendedInformationExtraField(SIZE, CSIZE, OFF, DISK);
         assertEquals(new ZipShort(28), f.getCentralDirectoryLength());
-        byte[] b = f.getCentralDirectoryData();
+        final byte[] b = f.getCentralDirectoryData();
         assertEquals(28, b.length);
         checkSizes(b);
         checkOffset(b, 16);
@@ -72,10 +72,10 @@ public class Zip64ExtendedInformationExtraFieldTest {
 
     @Test
     public void testWriteCDSizeAndDisk() {
-        Zip64ExtendedInformationExtraField f =
+        final Zip64ExtendedInformationExtraField f =
             new Zip64ExtendedInformationExtraField(SIZE, CSIZE, null, DISK);
         assertEquals(new ZipShort(20), f.getCentralDirectoryLength());
-        byte[] b = f.getCentralDirectoryData();
+        final byte[] b = f.getCentralDirectoryData();
         assertEquals(20, b.length);
         checkSizes(b);
         checkDisk(b, 16);
@@ -83,9 +83,9 @@ public class Zip64ExtendedInformationExtraFieldTest {
 
     @Test
     public void testReadLFHSizesOnly() throws ZipException {
-        Zip64ExtendedInformationExtraField f =
+        final Zip64ExtendedInformationExtraField f =
             new Zip64ExtendedInformationExtraField();
-        byte[] b = new byte[16];
+        final byte[] b = new byte[16];
         System.arraycopy(SIZE.getBytes(), 0, b, 0, 8);
         System.arraycopy(CSIZE.getBytes(), 0, b, 8, 8);
         f.parseFromLocalFileData(b, 0, b.length);
@@ -97,9 +97,9 @@ public class Zip64ExtendedInformationExtraFieldTest {
 
     @Test
     public void testReadLFHSizesAndOffset() throws ZipException {
-        Zip64ExtendedInformationExtraField f =
+        final Zip64ExtendedInformationExtraField f =
             new Zip64ExtendedInformationExtraField();
-        byte[] b = new byte[24];
+        final byte[] b = new byte[24];
         System.arraycopy(SIZE.getBytes(), 0, b, 0, 8);
         System.arraycopy(CSIZE.getBytes(), 0, b, 8, 8);
         System.arraycopy(OFF.getBytes(), 0, b, 16, 8);
@@ -112,9 +112,9 @@ public class Zip64ExtendedInformationExtraFieldTest {
 
     @Test
     public void testReadLFHSizesOffsetAndDisk() throws ZipException {
-        Zip64ExtendedInformationExtraField f =
+        final Zip64ExtendedInformationExtraField f =
             new Zip64ExtendedInformationExtraField();
-        byte[] b = new byte[28];
+        final byte[] b = new byte[28];
         System.arraycopy(SIZE.getBytes(), 0, b, 0, 8);
         System.arraycopy(CSIZE.getBytes(), 0, b, 8, 8);
         System.arraycopy(OFF.getBytes(), 0, b, 16, 8);
@@ -128,9 +128,9 @@ public class Zip64ExtendedInformationExtraFieldTest {
 
     @Test
     public void testReadLFHSizesAndDisk() throws ZipException {
-        Zip64ExtendedInformationExtraField f =
+        final Zip64ExtendedInformationExtraField f =
             new Zip64ExtendedInformationExtraField();
-        byte[] b = new byte[20];
+        final byte[] b = new byte[20];
         System.arraycopy(SIZE.getBytes(), 0, b, 0, 8);
         System.arraycopy(CSIZE.getBytes(), 0, b, 8, 8);
         System.arraycopy(DISK.getBytes(), 0, b, 16, 4);
@@ -143,9 +143,9 @@ public class Zip64ExtendedInformationExtraFieldTest {
 
     @Test
     public void testReadCDSizesOffsetAndDisk() throws ZipException {
-        Zip64ExtendedInformationExtraField f =
+        final Zip64ExtendedInformationExtraField f =
             new Zip64ExtendedInformationExtraField();
-        byte[] b = new byte[28];
+        final byte[] b = new byte[28];
         System.arraycopy(SIZE.getBytes(), 0, b, 0, 8);
         System.arraycopy(CSIZE.getBytes(), 0, b, 8, 8);
         System.arraycopy(OFF.getBytes(), 0, b, 16, 8);
@@ -159,9 +159,9 @@ public class Zip64ExtendedInformationExtraFieldTest {
 
     @Test
     public void testReadCDSizesAndOffset() throws ZipException {
-        Zip64ExtendedInformationExtraField f =
+        final Zip64ExtendedInformationExtraField f =
             new Zip64ExtendedInformationExtraField();
-        byte[] b = new byte[24];
+        final byte[] b = new byte[24];
         System.arraycopy(SIZE.getBytes(), 0, b, 0, 8);
         System.arraycopy(CSIZE.getBytes(), 0, b, 8, 8);
         System.arraycopy(OFF.getBytes(), 0, b, 16, 8);
@@ -174,9 +174,9 @@ public class Zip64ExtendedInformationExtraFieldTest {
 
     @Test
     public void testReadCDSomethingAndDisk() throws ZipException {
-        Zip64ExtendedInformationExtraField f =
+        final Zip64ExtendedInformationExtraField f =
             new Zip64ExtendedInformationExtraField();
-        byte[] b = new byte[12];
+        final byte[] b = new byte[12];
         System.arraycopy(SIZE.getBytes(), 0, b, 0, 8);
         System.arraycopy(DISK.getBytes(), 0, b, 8, 4);
         f.parseFromCentralDirectoryData(b, 0, b.length);
@@ -188,9 +188,9 @@ public class Zip64ExtendedInformationExtraFieldTest {
 
     @Test
     public void testReparseCDSingleEightByteData() throws ZipException {
-        Zip64ExtendedInformationExtraField f =
+        final Zip64ExtendedInformationExtraField f =
             new Zip64ExtendedInformationExtraField();
-        byte[] b = new byte[8];
+        final byte[] b = new byte[8];
         System.arraycopy(SIZE.getBytes(), 0, b, 0, 8);
         f.parseFromCentralDirectoryData(b, 0, b.length);
         f.reparseCentralDirectoryData(true, false, false, false);

http://git-wip-us.apache.org/repos/asf/commons-compress/blob/3f2c760a/src/test/java/org/apache/commons/compress/archivers/zip/Zip64SupportIT.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/compress/archivers/zip/Zip64SupportIT.java b/src/test/java/org/apache/commons/compress/archivers/zip/Zip64SupportIT.java
index 821329b..6a39623 100644
--- a/src/test/java/org/apache/commons/compress/archivers/zip/Zip64SupportIT.java
+++ b/src/test/java/org/apache/commons/compress/archivers/zip/Zip64SupportIT.java
@@ -143,12 +143,12 @@ public class Zip64SupportIT {
     }
 
     private static File write5GBZerosFile(final String testName) throws Throwable {
-        File f = getTempFile(testName);
-        ZipArchiveOutputStream zos = new ZipArchiveOutputStream(f);
+        final File f = getTempFile(testName);
+        final ZipArchiveOutputStream zos = new ZipArchiveOutputStream(f);
         try {
             zos.setUseZip64(Zip64Mode.Always);
-            byte[] buf = new byte[ONE_MILLION];
-            ZipArchiveEntry zae = new ZipArchiveEntry("5GB_of_Zeros");
+            final byte[] buf = new byte[ONE_MILLION];
+            final ZipArchiveEntry zae = new ZipArchiveEntry("5GB_of_Zeros");
             zae.setSize(FIVE_BILLION);
             zae.setMethod(ZipEntry.DEFLATED);
             zae.setCrc(0x8a408f16L);
@@ -158,7 +158,7 @@ public class Zip64SupportIT {
             }
             zos.closeArchiveEntry();
             zos.close();
-        } catch (IOException ex) {
+        } catch (final IOException ex) {
             System.err.println("Failed to write archive because of: "
                                + ex.getMessage()
                                + " - likely not enough disk space.");
@@ -211,7 +211,7 @@ public class Zip64SupportIT {
                     zos.setUseZip64(mode);
                 }
                 write100KFilesToStream(zos);
-                RandomAccessFile a = new RandomAccessFile(f, "r");
+                final RandomAccessFile a = new RandomAccessFile(f, "r");
                 try {
                     final long end = a.length();
 
@@ -220,7 +220,7 @@ public class Zip64SupportIT {
                     // value 0xFFFF as "number of entries".
                     a.seek(end
                            - 22 /* length of EOCD without file comment */);
-                    byte[] eocd = new byte[12];
+                    final byte[] eocd = new byte[12];
                     a.readFully(eocd);
                     assertArrayEquals(new byte[] {
                             // sig
@@ -236,13 +236,13 @@ public class Zip64SupportIT {
                     // locator" is right in front of the EOCD and
                     // the location of the "Zip64 end of central
                     // directory record" seems correct
-                    long expectedZ64EocdOffset = end - 22 /* eocd.length */
+                    final long expectedZ64EocdOffset = end - 22 /* eocd.length */
                         - 20 /* z64 eocd locator.length */
                         - 56 /* z64 eocd without extensible data sector */;
-                    byte[] loc =
+                    final byte[] loc =
                         ZipEightByteInteger.getBytes(expectedZ64EocdOffset);
                     a.seek(end - 22 - 20);
-                    byte[] z64EocdLoc = new byte[20];
+                    final byte[] z64EocdLoc = new byte[20];
                     a.readFully(z64EocdLoc);
                     assertArrayEquals(new byte[] {
                             // sig
@@ -261,7 +261,7 @@ public class Zip64SupportIT {
                     // known values are fine and read the location
                     // of the central directory from it
                     a.seek(expectedZ64EocdOffset);
-                    byte[] z64EocdStart = new byte[40];
+                    final byte[] z64EocdStart = new byte[40];
                     a.readFully(z64EocdStart);
                     assertArrayEquals(new byte[] {
                             // sig
@@ -283,14 +283,14 @@ public class Zip64SupportIT {
                             0, 0, 0, 0,
                         }, z64EocdStart);
                     a.seek(expectedZ64EocdOffset + 48 /* skip size */);
-                    byte[] cdOffset = new byte[8];
+                    final byte[] cdOffset = new byte[8];
                     a.readFully(cdOffset);
-                    long cdLoc = ZipEightByteInteger.getLongValue(cdOffset);
+                    final long cdLoc = ZipEightByteInteger.getLongValue(cdOffset);
 
                     // finally verify there really is a central
                     // directory entry where the Zip64 EOCD claims
                     a.seek(cdLoc);
-                    byte[] sig = new byte[4];
+                    final byte[] sig = new byte[4];
                     a.readFully(sig);
                     assertArrayEquals(new byte[] {
                             (byte) 0x50, (byte) 0x4b, 1, 2,
@@ -329,7 +329,7 @@ public class Zip64SupportIT {
                 try {
                     write100KFilesToStream(zos);
                     fail("expected a Zip64RequiredException");
-                } catch (Zip64RequiredException ex) {
+                } catch (final Zip64RequiredException ex) {
                     assertEquals(Zip64RequiredException.TOO_MANY_ENTRIES_MESSAGE,
                                  ex.getMessage());
                 }
@@ -383,7 +383,7 @@ public class Zip64SupportIT {
                 }
                 write3EntriesCreatingBigArchiveToStream(zos);
 
-                RandomAccessFile a = new RandomAccessFile(f, "r");
+                final RandomAccessFile a = new RandomAccessFile(f, "r");
                 try {
                     getLengthAndPositionAtCentralDirectory(a);
                     // skip first two entries
@@ -397,7 +397,7 @@ public class Zip64SupportIT {
                     // grab third entry, verify offset is
                     // 0xFFFFFFFF and it has a ZIP64 extended
                     // information extra field
-                    byte[] header = new byte[12];
+                    final byte[] header = new byte[12];
                     a.readFully(header);
                     assertArrayEquals(new byte[] {
                             // sig
@@ -413,7 +413,7 @@ public class Zip64SupportIT {
                         }, header);
                     // ignore timestamp, CRC, compressed size
                     a.skipBytes(12);
-                    byte[] rest = new byte[23];
+                    final byte[] rest = new byte[23];
                     a.readFully(rest);
                     assertArrayEquals(new byte[] {
                             // Original Size
@@ -435,7 +435,7 @@ public class Zip64SupportIT {
                             // file name
                             (byte) '2'
                         }, rest);
-                    byte[] extra = new byte[4];
+                    final byte[] extra = new byte[4];
                     a.readFully(extra);
                     assertArrayEquals(new byte[] {
                             // Header-ID
@@ -445,11 +445,11 @@ public class Zip64SupportIT {
                         }, extra);
 
                     // read offset of LFH
-                    byte[] offset = new byte[8];
+                    final byte[] offset = new byte[8];
                     a.readFully(offset);
                     // verify there is a LFH where the CD claims it
                     a.seek(ZipEightByteInteger.getLongValue(offset));
-                    byte[] sig = new byte[4];
+                    final byte[] sig = new byte[4];
                     a.readFully(sig);
                     assertArrayEquals(new byte[] {
                             (byte) 0x50, (byte) 0x4b, 3, 4,
@@ -496,7 +496,7 @@ public class Zip64SupportIT {
                 try {
                     write3EntriesCreatingBigArchiveToStream(zos);
                     fail("expected a Zip64RequiredException");
-                } catch (Zip64RequiredException ex) {
+                } catch (final Zip64RequiredException ex) {
                     assertEquals(Zip64RequiredException.ARCHIVE_TOO_BIG_MESSAGE,
                                  ex.getMessage());
                 }
@@ -530,10 +530,10 @@ public class Zip64SupportIT {
                                      try {
                                          zf = new ZipFile(f);
                                          int idx = 0;
-                                         for (Enumeration<ZipArchiveEntry> e =
+                                         for (final Enumeration<ZipArchiveEntry> e =
                                                   zf.getEntriesInPhysicalOrder();
                                               e.hasMoreElements(); ) {
-                                             ZipArchiveEntry zae = e.nextElement();
+                                             final ZipArchiveEntry zae = e.nextElement();
                                              assertEquals(String.valueOf(idx),
                                                           zae.getName());
                                              if (idx++ < 2) {
@@ -542,7 +542,7 @@ public class Zip64SupportIT {
                                              } else {
                                                  assertEquals(1,
                                                               zae.getSize());
-                                                 InputStream i =
+                                                 final InputStream i =
                                                      zf.getInputStream(zae);
                                                  try {
                                                      assertNotNull(i);
@@ -582,8 +582,8 @@ public class Zip64SupportIT {
                 if (mode != Zip64Mode.AsNeeded) {
                     zos.setUseZip64(mode);
                 }
-                byte[] buf = new byte[ONE_MILLION];
-                ZipArchiveEntry zae = new ZipArchiveEntry("0");
+                final byte[] buf = new byte[ONE_MILLION];
+                final ZipArchiveEntry zae = new ZipArchiveEntry("0");
                 if (knownSize) {
                     zae.setSize(FIVE_BILLION);
                     zae.setCrc(0x5c316f50L);
@@ -596,7 +596,7 @@ public class Zip64SupportIT {
                 zos.closeArchiveEntry();
                 zos.close();
 
-                RandomAccessFile a = new RandomAccessFile(f, "r");
+                final RandomAccessFile a = new RandomAccessFile(f, "r");
                 try {
                     getLengthAndPositionAtCentralDirectory(a);
 
@@ -644,7 +644,7 @@ public class Zip64SupportIT {
                             // file name
                             (byte) '0'
                         }, rest);
-                    byte[] extra = new byte[20];
+                    final byte[] extra = new byte[20];
                     a.readFully(extra);
                     // 5e9 == 0x12A05F200
                     assertArrayEquals(new byte[] {
@@ -763,8 +763,8 @@ public class Zip64SupportIT {
                 throws IOException {
                 zos.setUseZip64(Zip64Mode.Never);
                 try {
-                    byte[] buf = new byte[ONE_MILLION];
-                    ZipArchiveEntry zae = new ZipArchiveEntry("0");
+                    final byte[] buf = new byte[ONE_MILLION];
+                    final ZipArchiveEntry zae = new ZipArchiveEntry("0");
                     if (knownSize) {
                         zae.setSize(FIVE_BILLION);
                         zae.setCrc(0x5c316f50L);
@@ -776,7 +776,7 @@ public class Zip64SupportIT {
                     }
                     zos.closeArchiveEntry();
                     fail("expected a Zip64RequiredException");
-                } catch (Zip64RequiredException ex) {
+                } catch (final Zip64RequiredException ex) {
                     assertTrue(ex.getMessage().startsWith("0's size"));
                 }
             }
@@ -823,8 +823,8 @@ public class Zip64SupportIT {
                 if (mode != Zip64Mode.AsNeeded) {
                     zos.setUseZip64(mode);
                 }
-                byte[] buf = new byte[ONE_MILLION];
-                ZipArchiveEntry zae = new ZipArchiveEntry("0");
+                final byte[] buf = new byte[ONE_MILLION];
+                final ZipArchiveEntry zae = new ZipArchiveEntry("0");
                 if (knownSize) {
                     zae.setSize(FIVE_BILLION);
                 }
@@ -836,12 +836,12 @@ public class Zip64SupportIT {
                 zos.closeArchiveEntry();
                 zos.close();
 
-                RandomAccessFile a =
+                final RandomAccessFile a =
                     new RandomAccessFile(f, "r");
                 try {
                     getLengthAndPositionAtCentralDirectory(a);
 
-                    long cfhPos = a.getFilePointer();
+                    final long cfhPos = a.getFilePointer();
                     // grab first entry, verify
                     // sizes are 0xFFFFFFFF and
                     // it has a ZIP64 extended
@@ -887,7 +887,7 @@ public class Zip64SupportIT {
                             // file name
                             (byte) '0'
                         }, rest);
-                    byte[] extra = new byte[20];
+                    final byte[] extra = new byte[20];
                     a.readFully(extra);
                     // 5e9 == 0x12A05F200
                     assertArrayEquals(new byte[] {
@@ -1010,8 +1010,8 @@ public class Zip64SupportIT {
                     if (mode != Zip64Mode.AsNeeded) {
                         zos.setUseZip64(mode);
                     }
-                    byte[] buf = new byte[ONE_MILLION];
-                    ZipArchiveEntry zae = new ZipArchiveEntry("0");
+                    final byte[] buf = new byte[ONE_MILLION];
+                    final ZipArchiveEntry zae = new ZipArchiveEntry("0");
                     zae.setMethod(ZipEntry.DEFLATED);
                     zos.putArchiveEntry(zae);
                     for (int j = 0; j < FIVE_BILLION / 1000 / 1000; j++) {
@@ -1019,7 +1019,7 @@ public class Zip64SupportIT {
                     }
                     zos.closeArchiveEntry();
                     fail("expected a Zip64RequiredException");
-                } catch (Zip64RequiredException ex) {
+                } catch (final Zip64RequiredException ex) {
                     assertTrue(ex.getMessage().startsWith("0's size"));
                 }
             }
@@ -1066,8 +1066,8 @@ public class Zip64SupportIT {
                 if (mode != Zip64Mode.AsNeeded) {
                     zos.setUseZip64(mode);
                 }
-                byte[] buf = new byte[ONE_MILLION];
-                ZipArchiveEntry zae = new ZipArchiveEntry("0");
+                final byte[] buf = new byte[ONE_MILLION];
+                final ZipArchiveEntry zae = new ZipArchiveEntry("0");
                 if (knownSize) {
                     zae.setSize(FIVE_BILLION);
                 }
@@ -1081,7 +1081,7 @@ public class Zip64SupportIT {
                 zos.closeArchiveEntry();
                 zos.close();
 
-                RandomAccessFile a = new RandomAccessFile(f, "r");
+                final RandomAccessFile a = new RandomAccessFile(f, "r");
                 try {
                     getLengthAndPositionAtCentralDirectory(a);
 
@@ -1238,14 +1238,14 @@ public class Zip64SupportIT {
                                      throws IOException {
                                      zos.setUseZip64(Zip64Mode.Never);
                                      try {
-                                         ZipArchiveEntry zae =
+                                         final ZipArchiveEntry zae =
                                              new ZipArchiveEntry("0");
                                          zae.setSize(FIVE_BILLION);
                                          zae.setMethod(ZipEntry.DEFLATED);
                                          zos.putArchiveEntry(zae);
                                          fail("expected a"
                                               + " Zip64RequiredException");
-                                     } catch (Zip64RequiredException ex) {
+                                     } catch (final Zip64RequiredException ex) {
                                          assertTrue(ex.getMessage()
                                                     .startsWith("0's size"));
                                      }
@@ -1271,8 +1271,8 @@ public class Zip64SupportIT {
                 throws IOException {
                 zos.setUseZip64(Zip64Mode.Never);
                 try {
-                    byte[] buf = new byte[ONE_MILLION];
-                    ZipArchiveEntry zae = new ZipArchiveEntry("0");
+                    final byte[] buf = new byte[ONE_MILLION];
+                    final ZipArchiveEntry zae = new ZipArchiveEntry("0");
                     if (knownSize) {
                         zae.setSize(FIVE_BILLION);
                     }
@@ -1285,7 +1285,7 @@ public class Zip64SupportIT {
                     }
                     zos.closeArchiveEntry();
                     fail("expected a Zip64RequiredException");
-                } catch (Zip64RequiredException ex) {
+                } catch (final Zip64RequiredException ex) {
                     assertTrue(ex.getMessage().startsWith("0's size"));
                 }
             }
@@ -1328,8 +1328,8 @@ public class Zip64SupportIT {
                 if (mode != Zip64Mode.AsNeeded) {
                     zos.setUseZip64(mode);
                 }
-                byte[] buf = new byte[ONE_MILLION];
-                ZipArchiveEntry zae = new ZipArchiveEntry("0");
+                final byte[] buf = new byte[ONE_MILLION];
+                final ZipArchiveEntry zae = new ZipArchiveEntry("0");
                 if (knownSize) {
                     zae.setSize(ONE_MILLION);
                     zae.setCrc(0x1279CB9EL);
@@ -1340,7 +1340,7 @@ public class Zip64SupportIT {
                 zos.closeArchiveEntry();
                 zos.close();
 
-                RandomAccessFile a = new RandomAccessFile(f, "r");
+                final RandomAccessFile a = new RandomAccessFile(f, "r");
                 try {
                     getLengthAndPositionAtCentralDirectory(a);
 
@@ -1394,7 +1394,7 @@ public class Zip64SupportIT {
                     // has a ZIP64 extra field if and only if size was
                     // unknown and mode was not Never or the mode was
                     // Always (regardless of size)
-                    boolean hasExtra = mode == Zip64Mode.Always
+                    final boolean hasExtra = mode == Zip64Mode.Always
                         || (mode == Zip64Mode.AsNeeded && !knownSize);
                     a.seek(0);
                     header = new byte[10];
@@ -1429,7 +1429,7 @@ public class Zip64SupportIT {
                             (byte) '0'
                         }, rest);
                     if (hasExtra) {
-                        byte[] extra = new byte[20];
+                        final byte[] extra = new byte[20];
                         a.readFully(extra);
                         assertArrayEquals(new byte[] {
                                 // Header-ID
@@ -1505,8 +1505,8 @@ public class Zip64SupportIT {
             public void test(final File f, final ZipArchiveOutputStream zos)
                 throws IOException {
                 zos.setUseZip64(Zip64Mode.Always);
-                byte[] buf = new byte[ONE_MILLION];
-                ZipArchiveEntry zae = new ZipArchiveEntry("0");
+                final byte[] buf = new byte[ONE_MILLION];
+                final ZipArchiveEntry zae = new ZipArchiveEntry("0");
                 if (knownSize) {
                     zae.setSize(ONE_MILLION);
                     zae.setCrc(0x1279CB9EL);
@@ -1517,7 +1517,7 @@ public class Zip64SupportIT {
                 zos.closeArchiveEntry();
                 zos.close();
 
-                RandomAccessFile a = new RandomAccessFile(f, "r");
+                final RandomAccessFile a = new RandomAccessFile(f, "r");
                 try {
                     getLengthAndPositionAtCentralDirectory(a);
 
@@ -1670,8 +1670,8 @@ public class Zip64SupportIT {
                 if (mode != Zip64Mode.AsNeeded) {
                     zos.setUseZip64(mode);
                 }
-                byte[] buf = new byte[ONE_MILLION];
-                ZipArchiveEntry zae = new ZipArchiveEntry("0");
+                final byte[] buf = new byte[ONE_MILLION];
+                final ZipArchiveEntry zae = new ZipArchiveEntry("0");
                 if (knownSize) {
                     zae.setSize(ONE_MILLION);
                 }
@@ -1681,11 +1681,11 @@ public class Zip64SupportIT {
                 zos.closeArchiveEntry();
                 zos.close();
 
-                RandomAccessFile a = new RandomAccessFile(f, "r");
+                final RandomAccessFile a = new RandomAccessFile(f, "r");
                 try {
                     getLengthAndPositionAtCentralDirectory(a);
 
-                    long cfhPos = a.getFilePointer();
+                    final long cfhPos = a.getFilePointer();
                     // grab first entry, verify sizes are not
                     // 0xFFFFFFF and it has no ZIP64 extended
                     // information extra field
@@ -1705,7 +1705,7 @@ public class Zip64SupportIT {
                         }, header);
                     // ignore timestamp
                     a.skipBytes(4);
-                    byte[] crc = new byte[4];
+                    final byte[] crc = new byte[4];
                     a.readFully(crc);
                     assertArrayEquals(new byte[] {
                             (byte) 0x9E, (byte) 0xCB,
@@ -1841,8 +1841,8 @@ public class Zip64SupportIT {
             public void test(final File f, final ZipArchiveOutputStream zos)
                 throws IOException {
                 zos.setUseZip64(Zip64Mode.Always);
-                byte[] buf = new byte[ONE_MILLION];
-                ZipArchiveEntry zae = new ZipArchiveEntry("0");
+                final byte[] buf = new byte[ONE_MILLION];
+                final ZipArchiveEntry zae = new ZipArchiveEntry("0");
                 if (knownSize) {
                     zae.setSize(ONE_MILLION);
                 }
@@ -1852,11 +1852,11 @@ public class Zip64SupportIT {
                 zos.closeArchiveEntry();
                 zos.close();
 
-                RandomAccessFile a = new RandomAccessFile(f, "r");
+                final RandomAccessFile a = new RandomAccessFile(f, "r");
                 try {
                     getLengthAndPositionAtCentralDirectory(a);
 
-                    long cfhPos = a.getFilePointer();
+                    final long cfhPos = a.getFilePointer();
                     // grab first entry, verify sizes are not
                     // 0xFFFFFFF and it has an empty ZIP64 extended
                     // information extra field
@@ -1876,7 +1876,7 @@ public class Zip64SupportIT {
                         }, header);
                     // ignore timestamp
                     a.skipBytes(4);
-                    byte[] crc = new byte[4];
+                    final byte[] crc = new byte[4];
                     a.readFully(crc);
                     assertArrayEquals(new byte[] {
                             (byte) 0x9E, (byte) 0xCB,
@@ -2026,8 +2026,8 @@ public class Zip64SupportIT {
                 if (mode != Zip64Mode.AsNeeded) {
                     zos.setUseZip64(mode);
                 }
-                byte[] buf = new byte[ONE_MILLION];
-                ZipArchiveEntry zae = new ZipArchiveEntry("0");
+                final byte[] buf = new byte[ONE_MILLION];
+                final ZipArchiveEntry zae = new ZipArchiveEntry("0");
                 if (knownSize) {
                     zae.setSize(ONE_MILLION);
                 }
@@ -2037,7 +2037,7 @@ public class Zip64SupportIT {
                 zos.closeArchiveEntry();
                 zos.close();
 
-                RandomAccessFile a = new RandomAccessFile(f, "r");
+                final RandomAccessFile a = new RandomAccessFile(f, "r");
                 try {
                     getLengthAndPositionAtCentralDirectory(a);
 
@@ -2117,7 +2117,7 @@ public class Zip64SupportIT {
                     rest = new byte[9];
                     a.readFully(rest);
 
-                    boolean hasExtra = 
+                    final boolean hasExtra = 
                         mode == Zip64Mode.AsNeeded && !knownSize;
 
                     assertArrayEquals(new byte[] {
@@ -2131,7 +2131,7 @@ public class Zip64SupportIT {
                             (byte) '0'
                         }, rest);
                     if (hasExtra) {
-                        byte[] extra = new byte[12];
+                        final byte[] extra = new byte[12];
                         a.readFully(extra);
                         assertArrayEquals(new byte[] {
                                 // Header-ID
@@ -2199,8 +2199,8 @@ public class Zip64SupportIT {
             public void test(final File f, final ZipArchiveOutputStream zos)
                 throws IOException {
                 zos.setUseZip64(Zip64Mode.Always);
-                byte[] buf = new byte[ONE_MILLION];
-                ZipArchiveEntry zae = new ZipArchiveEntry("0");
+                final byte[] buf = new byte[ONE_MILLION];
+                final ZipArchiveEntry zae = new ZipArchiveEntry("0");
                 if (knownSize) {
                     zae.setSize(ONE_MILLION);
                 }
@@ -2210,7 +2210,7 @@ public class Zip64SupportIT {
                 zos.closeArchiveEntry();
                 zos.close();
 
-                RandomAccessFile a = new RandomAccessFile(f, "r");
+                final RandomAccessFile a = new RandomAccessFile(f, "r");
                 try {
                     getLengthAndPositionAtCentralDirectory(a);
 
@@ -2352,14 +2352,14 @@ public class Zip64SupportIT {
                                              final ZipOutputTest test,
                                              final boolean useRandomAccessFile)
         throws Throwable {
-        File f = getTempFile(testName);
+        final File f = getTempFile(testName);
         BufferedOutputStream os = null;
-        ZipArchiveOutputStream zos = useRandomAccessFile
+        final ZipArchiveOutputStream zos = useRandomAccessFile
             ? new ZipArchiveOutputStream(f)
             : new ZipArchiveOutputStream(os = new BufferedOutputStream(new FileOutputStream(f)));
         try {
             test.test(f, zos);
-        } catch (IOException ex) {
+        } catch (final IOException ex) {
             System.err.println("Failed to write archive because of: "
                                + ex.getMessage()
                                + " - likely not enough disk space.");
@@ -2421,14 +2421,14 @@ public class Zip64SupportIT {
     }
 
     private static File getTempFile(final String testName) throws Throwable {
-        File f = File.createTempFile("commons-compress-" + testName, ".zip");
+        final File f = File.createTempFile("commons-compress-" + testName, ".zip");
         f.deleteOnExit();
         return f;
     }
 
     private static void read5GBOfZerosImpl(final File f, final String expectedName)
         throws IOException {
-        FileInputStream fin = new FileInputStream(f);
+        final FileInputStream fin = new FileInputStream(f);
         ZipArchiveInputStream zin = null;
         try {
             zin = new ZipArchiveInputStream(fin);
@@ -2437,15 +2437,15 @@ public class Zip64SupportIT {
                 zae = zin.getNextZipEntry();
             }
             assertEquals(expectedName, zae.getName());
-            byte[] buf = new byte[1024 * 1024];
+            final byte[] buf = new byte[1024 * 1024];
             long read = 0;
-            Random r = new Random(System.currentTimeMillis());
+            final Random r = new Random(System.currentTimeMillis());
             int readNow;
             while ((readNow = zin.read(buf, 0, buf.length)) > 0) {
                 // testing all bytes for a value of 0 is going to take
                 // too long, just pick a few ones randomly
                 for (int i = 0; i < 1024; i++) {
-                    int idx = r.nextInt(readNow);
+                    final int idx = r.nextInt(readNow);
                     assertEquals("testing byte " + (read + idx), 0, buf[idx]);
                 }
                 read += readNow;
@@ -2467,7 +2467,7 @@ public class Zip64SupportIT {
         ZipFile zf = null;
         try {
             zf = new ZipFile(f);
-            Enumeration<ZipArchiveEntry> e = zf.getEntries();
+            final Enumeration<ZipArchiveEntry> e = zf.getEntries();
             assertTrue(e.hasMoreElements());
             ZipArchiveEntry zae = e.nextElement();
             while (zae.isDirectory()) {
@@ -2475,17 +2475,17 @@ public class Zip64SupportIT {
             }
             assertEquals(expectedName, zae.getName());
             assertEquals(FIVE_BILLION, zae.getSize());
-            byte[] buf = new byte[1024 * 1024];
+            final byte[] buf = new byte[1024 * 1024];
             long read = 0;
-            Random r = new Random(System.currentTimeMillis());
+            final Random r = new Random(System.currentTimeMillis());
             int readNow;
-            InputStream zin = zf.getInputStream(zae);
+            final InputStream zin = zf.getInputStream(zae);
             try {
                 while ((readNow = zin.read(buf, 0, buf.length)) > 0) {
                     // testing all bytes for a value of 0 is going to take
                     // too long, just pick a few ones randomly
                     for (int i = 0; i < 1024; i++) {
-                        int idx = r.nextInt(readNow);
+                        final int idx = r.nextInt(readNow);
                         assertEquals("testing byte " + (read + idx), 0, buf[idx]);
                     }
                     read += readNow;
@@ -2501,7 +2501,7 @@ public class Zip64SupportIT {
     }
 
     private static void read100KFilesImpl(final File f) throws IOException {
-        FileInputStream fin = new FileInputStream(f);
+        final FileInputStream fin = new FileInputStream(f);
         ZipArchiveInputStream zin = null;
         try {
             zin = new ZipArchiveInputStream(fin);
@@ -2528,8 +2528,8 @@ public class Zip64SupportIT {
         try {
             zf = new ZipFile(f);
             int files = 0;
-            for (Enumeration<ZipArchiveEntry> e = zf.getEntries(); e.hasMoreElements(); ) {
-                ZipArchiveEntry zae = e.nextElement();
+            for (final Enumeration<ZipArchiveEntry> e = zf.getEntries(); e.hasMoreElements(); ) {
+                final ZipArchiveEntry zae = e.nextElement();
                 if (!zae.isDirectory()) {
                     files++;
                     assertEquals(0, zae.getSize());
@@ -2545,7 +2545,7 @@ public class Zip64SupportIT {
         throws IOException {
         final long end = a.length();
         a.seek(end - 22 - 20);
-        byte[] sig = new byte[4];
+        final byte[] sig = new byte[4];
         a.readFully(sig);
         if (sig[0] != (byte) 0x50 || sig[1] != (byte) 0x4b
             || sig[2] != 6 || sig[3] != 7) {
@@ -2553,10 +2553,10 @@ public class Zip64SupportIT {
             return getLengthAndPositionAtCentralDirectory32(a, end);
         }
 
-        long cdOffsetLoc = end - 22 - 20 - 56 + 48;
+        final long cdOffsetLoc = end - 22 - 20 - 56 + 48;
         // seek to central directory locator
         a.seek(cdOffsetLoc);
-        byte[] cdOffset = new byte[8];
+        final byte[] cdOffset = new byte[8];
         a.readFully(cdOffset);
         a.seek(ZipEightByteInteger.getLongValue(cdOffset));
         return end;
@@ -2565,7 +2565,7 @@ public class Zip64SupportIT {
     private static long getLengthAndPositionAtCentralDirectory32(final RandomAccessFile a, final long end)
         throws IOException {
         a.seek(end - 22 + 16);
-        byte[] cdOffset = new byte[4];
+        final byte[] cdOffset = new byte[4];
         a.readFully(cdOffset);
         a.seek(ZipLong.getValue(cdOffset));
         return end;
@@ -2574,7 +2574,7 @@ public class Zip64SupportIT {
     private static void write100KFilesToStream(final ZipArchiveOutputStream zos)
         throws IOException {
         for (int i = 0; i < ONE_HUNDRED_THOUSAND; i++) {
-            ZipArchiveEntry zae = new ZipArchiveEntry(String.valueOf(i));
+            final ZipArchiveEntry zae = new ZipArchiveEntry(String.valueOf(i));
             zae.setSize(0);
             zos.putArchiveEntry(zae);
             zos.closeArchiveEntry();
@@ -2585,7 +2585,7 @@ public class Zip64SupportIT {
     private static void
         write3EntriesCreatingBigArchiveToStream(final ZipArchiveOutputStream zos)
         throws IOException {
-        byte[] buf = new byte[ONE_MILLION];
+        final byte[] buf = new byte[ONE_MILLION];
         ZipArchiveEntry zae = null;
         for (int i = 0; i < 2; i++) {
             zae = new ZipArchiveEntry(String.valueOf(i));

http://git-wip-us.apache.org/repos/asf/commons-compress/blob/3f2c760a/src/test/java/org/apache/commons/compress/archivers/zip/ZipArchiveEntryTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/compress/archivers/zip/ZipArchiveEntryTest.java b/src/test/java/org/apache/commons/compress/archivers/zip/ZipArchiveEntryTest.java
index a0b4024..320b2ff 100644
--- a/src/test/java/org/apache/commons/compress/archivers/zip/ZipArchiveEntryTest.java
+++ b/src/test/java/org/apache/commons/compress/archivers/zip/ZipArchiveEntryTest.java
@@ -36,34 +36,34 @@ public class ZipArchiveEntryTest {
      */
     @Test
     public void testExtraFields() {
-        AsiExtraField a = new AsiExtraField();
+        final AsiExtraField a = new AsiExtraField();
         a.setDirectory(true);
         a.setMode(0755);
-        UnrecognizedExtraField u = new UnrecognizedExtraField();
+        final UnrecognizedExtraField u = new UnrecognizedExtraField();
         u.setHeaderId(ExtraFieldUtilsTest.UNRECOGNIZED_HEADER);
         u.setLocalFileDataData(new byte[0]);
 
-        ZipArchiveEntry ze = new ZipArchiveEntry("test/");
+        final ZipArchiveEntry ze = new ZipArchiveEntry("test/");
         ze.setExtraFields(new ZipExtraField[] {a, u});
-        byte[] data1 = ze.getExtra();
+        final byte[] data1 = ze.getExtra();
         ZipExtraField[] result = ze.getExtraFields();
         assertEquals("first pass", 2, result.length);
         assertSame(a, result[0]);
         assertSame(u, result[1]);
 
-        UnrecognizedExtraField u2 = new UnrecognizedExtraField();
+        final UnrecognizedExtraField u2 = new UnrecognizedExtraField();
         u2.setHeaderId(ExtraFieldUtilsTest.UNRECOGNIZED_HEADER);
         u2.setLocalFileDataData(new byte[] {1});
 
         ze.addExtraField(u2);
-        byte[] data2 = ze.getExtra();
+        final byte[] data2 = ze.getExtra();
         result = ze.getExtraFields();
         assertEquals("second pass", 2, result.length);
         assertSame(a, result[0]);
         assertSame(u2, result[1]);
         assertEquals("length second pass", data1.length+1, data2.length);
 
-        UnrecognizedExtraField u3 = new UnrecognizedExtraField();
+        final UnrecognizedExtraField u3 = new UnrecognizedExtraField();
         u3.setHeaderId(new ZipShort(2));
         u3.setLocalFileDataData(new byte[] {1});
         ze.addExtraField(u3);
@@ -71,7 +71,7 @@ public class ZipArchiveEntryTest {
         assertEquals("third pass", 3, result.length);
 
         ze.removeExtraField(ExtraFieldUtilsTest.UNRECOGNIZED_HEADER);
-        byte[] data3 = ze.getExtra();
+        final byte[] data3 = ze.getExtra();
         result = ze.getExtraFields();
         assertEquals("fourth pass", 2, result.length);
         assertSame(a, result[0]);
@@ -81,7 +81,7 @@ public class ZipArchiveEntryTest {
         try {
             ze.removeExtraField(ExtraFieldUtilsTest.UNRECOGNIZED_HEADER);
             fail("should be no such element");
-        } catch (java.util.NoSuchElementException nse) {
+        } catch (final java.util.NoSuchElementException nse) {
         }
     }
 
@@ -90,19 +90,19 @@ public class ZipArchiveEntryTest {
      */
     @Test
     public void testExtraFieldMerging() {
-        AsiExtraField a = new AsiExtraField();
+        final AsiExtraField a = new AsiExtraField();
         a.setDirectory(true);
         a.setMode(0755);
-        UnrecognizedExtraField u = new UnrecognizedExtraField();
+        final UnrecognizedExtraField u = new UnrecognizedExtraField();
         u.setHeaderId(ExtraFieldUtilsTest.UNRECOGNIZED_HEADER);
         u.setLocalFileDataData(new byte[0]);
 
-        ZipArchiveEntry ze = new ZipArchiveEntry("test/");
+        final ZipArchiveEntry ze = new ZipArchiveEntry("test/");
         ze.setExtraFields(new ZipExtraField[] {a, u});
 
         // merge
         // Header-ID 1 + length 1 + one byte of data
-        byte[] b = ExtraFieldUtilsTest.UNRECOGNIZED_HEADER.getBytes();
+        final byte[] b = ExtraFieldUtilsTest.UNRECOGNIZED_HEADER.getBytes();
         ze.setCentralDirectoryExtra(new byte[] {b[0], b[1], 1, 0, 127});
 
         ZipExtraField[] result = ze.getExtraFields();
@@ -137,30 +137,30 @@ public class ZipArchiveEntryTest {
      */
     @Test
     public void testAddAsFirstExtraField() {
-        AsiExtraField a = new AsiExtraField();
+        final AsiExtraField a = new AsiExtraField();
         a.setDirectory(true);
         a.setMode(0755);
-        UnrecognizedExtraField u = new UnrecognizedExtraField();
+        final UnrecognizedExtraField u = new UnrecognizedExtraField();
         u.setHeaderId(ExtraFieldUtilsTest.UNRECOGNIZED_HEADER);
         u.setLocalFileDataData(new byte[0]);
 
-        ZipArchiveEntry ze = new ZipArchiveEntry("test/");
+        final ZipArchiveEntry ze = new ZipArchiveEntry("test/");
         ze.setExtraFields(new ZipExtraField[] {a, u});
-        byte[] data1 = ze.getExtra();
+        final byte[] data1 = ze.getExtra();
 
-        UnrecognizedExtraField u2 = new UnrecognizedExtraField();
+        final UnrecognizedExtraField u2 = new UnrecognizedExtraField();
         u2.setHeaderId(ExtraFieldUtilsTest.UNRECOGNIZED_HEADER);
         u2.setLocalFileDataData(new byte[] {1});
 
         ze.addAsFirstExtraField(u2);
-        byte[] data2 = ze.getExtra();
+        final byte[] data2 = ze.getExtra();
         ZipExtraField[] result = ze.getExtraFields();
         assertEquals("second pass", 2, result.length);
         assertSame(u2, result[0]);
         assertSame(a, result[1]);
         assertEquals("length second pass", data1.length + 1, data2.length);
 
-        UnrecognizedExtraField u3 = new UnrecognizedExtraField();
+        final UnrecognizedExtraField u3 = new UnrecognizedExtraField();
         u3.setHeaderId(new ZipShort(2));
         u3.setLocalFileDataData(new byte[] {1});
         ze.addAsFirstExtraField(u3);
@@ -209,9 +209,9 @@ public class ZipArchiveEntryTest {
      */
     @Test
     public void testCompressionMethod() throws Exception {
-        ZipArchiveOutputStream zos =
+        final ZipArchiveOutputStream zos =
             new ZipArchiveOutputStream(new ByteArrayOutputStream());
-        ZipArchiveEntry entry = new ZipArchiveEntry("foo");
+        final ZipArchiveEntry entry = new ZipArchiveEntry("foo");
         assertEquals(-1, entry.getMethod());
         assertFalse(zos.canWriteEntryData(entry));
 
@@ -237,8 +237,8 @@ public class ZipArchiveEntryTest {
      */
     @Test
     public void testNotEquals() {
-        ZipArchiveEntry entry1 = new ZipArchiveEntry("foo");
-        ZipArchiveEntry entry2 = new ZipArchiveEntry("bar");
+        final ZipArchiveEntry entry1 = new ZipArchiveEntry("foo");
+        final ZipArchiveEntry entry2 = new ZipArchiveEntry("bar");
         assertFalse(entry1.equals(entry2));
     }
 
@@ -248,9 +248,9 @@ public class ZipArchiveEntryTest {
      */
     @Test
     public void testNullCommentEqualsEmptyComment() {
-        ZipArchiveEntry entry1 = new ZipArchiveEntry("foo");
-        ZipArchiveEntry entry2 = new ZipArchiveEntry("foo");
-        ZipArchiveEntry entry3 = new ZipArchiveEntry("foo");
+        final ZipArchiveEntry entry1 = new ZipArchiveEntry("foo");
+        final ZipArchiveEntry entry2 = new ZipArchiveEntry("foo");
+        final ZipArchiveEntry entry3 = new ZipArchiveEntry("foo");
         entry1.setComment(null);
         entry2.setComment("");
         entry3.setComment("bar");
@@ -261,11 +261,11 @@ public class ZipArchiveEntryTest {
 
     @Test
     public void testCopyConstructor() throws Exception {
-        ZipArchiveEntry archiveEntry = new ZipArchiveEntry("fred");
+        final ZipArchiveEntry archiveEntry = new ZipArchiveEntry("fred");
         archiveEntry.setUnixMode(0664);
         archiveEntry.setMethod(ZipEntry.DEFLATED);
         archiveEntry.getGeneralPurposeBit().useStrongEncryption(true);
-        ZipArchiveEntry copy = new ZipArchiveEntry(archiveEntry);
+        final ZipArchiveEntry copy = new ZipArchiveEntry(archiveEntry);
         assertEquals(archiveEntry, copy);
     }
 }

http://git-wip-us.apache.org/repos/asf/commons-compress/blob/3f2c760a/src/test/java/org/apache/commons/compress/archivers/zip/ZipArchiveInputStreamTest.java
----------------------------------------------------------------------
diff --git a/src/test/java/org/apache/commons/compress/archivers/zip/ZipArchiveInputStreamTest.java b/src/test/java/org/apache/commons/compress/archivers/zip/ZipArchiveInputStreamTest.java
index 1a9bb5d..c0abdcc 100644
--- a/src/test/java/org/apache/commons/compress/archivers/zip/ZipArchiveInputStreamTest.java
+++ b/src/test/java/org/apache/commons/compress/archivers/zip/ZipArchiveInputStreamTest.java
@@ -62,7 +62,7 @@ public class ZipArchiveInputStreamTest {
         ZipArchiveInputStream in = null;
         try {
             zf = new ZipFile(getFile("COMPRESS-189.zip"));
-            ZipArchiveEntry zae = zf.getEntry("USD0558682-20080101.ZIP");
+            final ZipArchiveEntry zae = zf.getEntry("USD0558682-20080101.ZIP");
             in = new ZipArchiveInputStream(new BufferedInputStream(zf.getInputStream(zae)));
             ZipArchiveEntry innerEntry;
             while ((innerEntry = in.getNextZipEntry()) != null) {
@@ -82,16 +82,16 @@ public class ZipArchiveInputStreamTest {
 
     @Test
     public void shouldConsumeArchiveCompletely() throws Exception {
-        InputStream is = ZipArchiveInputStreamTest.class
+        final InputStream is = ZipArchiveInputStreamTest.class
             .getResourceAsStream("/archive_with_trailer.zip");
-        ZipArchiveInputStream zip = new ZipArchiveInputStream(is);
+        final ZipArchiveInputStream zip = new ZipArchiveInputStream(is);
         while (zip.getNextZipEntry() != null) {
             // just consume the archive
         }
-        byte[] expected = new byte[] {
+        final byte[] expected = new byte[] {
             'H', 'e', 'l', 'l', 'o', ',', ' ', 'w', 'o', 'r', 'l', 'd', '!', '\n'
         };
-        byte[] actual = new byte[expected.length];
+        final byte[] actual = new byte[expected.length];
         is.read(actual);
         assertArrayEquals(expected, actual);
         zip.close();
@@ -126,7 +126,7 @@ public class ZipArchiveInputStreamTest {
 
     @Test
     public void testUnshrinkEntry() throws Exception {
-        ZipArchiveInputStream in = new ZipArchiveInputStream(new FileInputStream(getFile("SHRUNK.ZIP")));
+        final ZipArchiveInputStream in = new ZipArchiveInputStream(new FileInputStream(getFile("SHRUNK.ZIP")));
         
         ZipArchiveEntry entry = in.getNextZipEntry();
         assertEquals("method", ZipMethod.UNSHRINKING.getCode(), entry.getMethod());
@@ -159,10 +159,10 @@ public class ZipArchiveInputStreamTest {
      */
     @Test
     public void testReadingOfFirstStoredEntry() throws Exception {
-        ZipArchiveInputStream in = new ZipArchiveInputStream(new FileInputStream(getFile("COMPRESS-264.zip")));
+        final ZipArchiveInputStream in = new ZipArchiveInputStream(new FileInputStream(getFile("COMPRESS-264.zip")));
         
         try {
-            ZipArchiveEntry ze = in.getNextZipEntry();
+            final ZipArchiveEntry ze = in.getNextZipEntry();
             assertEquals(5, ze.getSize());
             assertArrayEquals(new byte[] {'d', 'a', 't', 'a', '\n'},
                               IOUtils.toByteArray(in));
@@ -173,12 +173,12 @@ public class ZipArchiveInputStreamTest {
 
     @Test
     public void testUnzipBZip2CompressedEntry() throws Exception {
-        ZipArchiveInputStream in = new ZipArchiveInputStream(new FileInputStream(getFile("bzip2-zip.zip")));
+        final ZipArchiveInputStream in = new ZipArchiveInputStream(new FileInputStream(getFile("bzip2-zip.zip")));
         
         try {
-            ZipArchiveEntry ze = in.getNextZipEntry();
+            final ZipArchiveEntry ze = in.getNextZipEntry();
             assertEquals(42, ze.getSize());
-            byte[] expected = new byte[42];
+            final byte[] expected = new byte[42];
             Arrays.fill(expected , (byte)'a');
             assertArrayEquals(expected, IOUtils.toByteArray(in));
         } finally {