src/test/java/com/google/devtools/build/android/ziputils/ZipInTest.java - bazel - Git at Google

 // Copyright 2015 The Bazel Authors. 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.devtools.build.android.ziputils;

 import static com.google.common.truth.Truth.assertThat;
 import static com.google.common.truth.Truth.assertWithMessage;
 import static com.google.devtools.build.android.ziputils.DirectoryEntry.CENHOW;
 import static com.google.devtools.build.android.ziputils.DirectoryEntry.CENLEN;
 import static com.google.devtools.build.android.ziputils.DirectoryEntry.CENOFF;
 import static com.google.devtools.build.android.ziputils.DirectoryEntry.CENSIZ;
 import static com.google.devtools.build.android.ziputils.EndOfCentralDirectory.ENDOFF;
 import static com.google.devtools.build.android.ziputils.EndOfCentralDirectory.ENDSIG;
 import static com.google.devtools.build.android.ziputils.EndOfCentralDirectory.ENDSIZ;
 import static com.google.devtools.build.android.ziputils.EndOfCentralDirectory.ENDSUB;
 import static com.google.devtools.build.android.ziputils.EndOfCentralDirectory.ENDTOT;
 import static java.nio.charset.StandardCharsets.UTF_8;
 import static org.junit.Assert.fail;

 import com.google.devtools.build.android.ziputils.ZipIn.ZipEntry;
 import java.io.IOException;
 import java.nio.ByteBuffer;
 import java.util.Arrays;
 import java.util.List;
 import java.util.zip.ZipInputStream;
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
 import org.junit.runners.JUnit4;

 /**
  * Unit tests for {@link ZipIn}.
  */
 @RunWith(JUnit4.class)
 public class ZipInTest {

   private static final int ENTRY_COUNT = 1000;
   private FakeFileSystem fileSystem;

   @Before
   public void setUp() throws Exception {
     fileSystem = new FakeFileSystem();
   }

   /**
    * Test of endOfCentralDirectory method, of class ZipIn.
    */
   @Test
   public void testEndOfCentralDirectory() throws Exception {

     String filename = "test.zip";
     byte[] bytes;
     ByteBuffer buffer;
     String comment;
     int commentLen;
     int offset;
     ZipIn zipIn;
     EndOfCentralDirectory result;
     String subcase;

     // Find it, even if it's the only useful thing in the file.
     subcase = " EOCD found it, ";
     bytes = new byte[] {
       0x50, 0x4b, 0x05, 0x06, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     };
     fileSystem.addFile(filename, bytes);
     zipIn = newZipIn(filename);
     result = zipIn.endOfCentralDirectory();
     assertWithMessage(subcase + "found").that(result).isNotNull();

     subcase = " EOCD not there at all, ";
     bytes = new byte[]{
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     };
     fileSystem.addFile(filename, bytes);
     zipIn = newZipIn(filename);
     try {
       zipIn.endOfCentralDirectory();
       fail(subcase + "expected IllegalStateException");
     } catch (Exception ex) {
       assertWithMessage(subcase + "caught exception")
           .that(ex.getClass())
           .isSameAs(IllegalStateException.class);
     }

     // If we can't read it, it's not there
     subcase = " EOCD too late to read, ";
     bytes = new byte[] {
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0x50, 0x4b, 0x05, 0x06, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     };
     fileSystem.addFile(filename, bytes);
     zipIn = newZipIn(filename);
     try {
       zipIn.endOfCentralDirectory();
       fail(subcase + "expected IndexOutOfBoundsException");
     } catch (Exception ex) {
       assertWithMessage(subcase + "caught exception")
           .that(ex.getClass())
           .isSameAs(IndexOutOfBoundsException.class);
     }

     // Current implementation doesn't know to scan past a bad EOCD record.
     // I'm not sure if it should.
     subcase = " EOCD good hidden by bad, ";
     bytes = new byte[] {
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0x50, 0x4b, 0x05, 0x06, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
       0x50, 0x4b, 0x05, 0x06, 0, 0, 0, 0, 0, 0,
       0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
     };
     fileSystem.addFile(filename, bytes);
     zipIn = newZipIn(filename);
     try {
       zipIn.endOfCentralDirectory();
       fail(subcase + "expected IndexOutOfBoundsException");
     } catch (Exception ex) {
       assertWithMessage(subcase + "caught exception")
           .that(ex.getClass())
           .isSameAs(IndexOutOfBoundsException.class);
     }

     // Minimal format checking here, assuming the EndOfDirectoryTest class
     // test for that.

     subcase = " EOCD truncated comment, ";
     bytes = new byte[100];
     buffer = ByteBuffer.wrap(bytes);
     comment = "optional file comment";
     commentLen = comment.getBytes(UTF_8).length;
     offset = bytes.length - ZipInputStream.ENDHDR - commentLen;
     buffer.position(offset);
     EndOfCentralDirectory.view(buffer, comment);
     byte[] truncated = Arrays.copyOf(bytes, bytes.length - 5);
     fileSystem.addFile(filename, truncated);
     zipIn = newZipIn(filename);
     try { // not sure this is the exception we want!
       zipIn.endOfCentralDirectory();
       fail(subcase + "expected IllegalArgumentException");
     } catch (Exception ex) {
       assertWithMessage(subcase + "caught exception")
           .that(ex.getClass())
           .isSameAs(IllegalArgumentException.class);
     }

     subcase = " EOCD no comment, ";
     bytes = new byte[100];
     buffer = ByteBuffer.wrap(bytes);
     comment = null;
     commentLen = 0;
     offset = bytes.length - ZipInputStream.ENDHDR - commentLen;
     buffer.position(offset);
     EndOfCentralDirectory.view(buffer, comment);
     fileSystem.addFile(filename, bytes);
     zipIn = newZipIn(filename);
     result = zipIn.endOfCentralDirectory();
     assertWithMessage(subcase + "found").that(result).isNotNull();
     assertWithMessage(subcase + "comment").that(result.getComment()).isEqualTo("");
     assertWithMessage(subcase + "marker")
         .that((int) result.get(ENDSIG))
         .isEqualTo(ZipInputStream.ENDSIG);

     subcase = " EOCD comment, ";
     bytes = new byte[100];
     buffer = ByteBuffer.wrap(bytes);
     comment = "optional file comment";
     commentLen = comment.getBytes(UTF_8).length;
     offset = bytes.length - ZipInputStream.ENDHDR - commentLen;
     buffer.position(offset);
     EndOfCentralDirectory.view(buffer, comment);
     assertWithMessage(subcase + "setup")
         .that(new String(bytes, bytes.length - commentLen, commentLen, UTF_8))
         .isEqualTo(comment);
     fileSystem.addFile(filename, bytes);
     zipIn = newZipIn(filename);
     result = zipIn.endOfCentralDirectory();
     assertWithMessage(subcase + "found").that(result).isNotNull();
     assertWithMessage(subcase + "comment").that(result.getComment()).isEqualTo(comment);
     assertWithMessage(subcase + "marker")
         .that((int) result.get(ENDSIG))
         .isEqualTo(ZipInputStream.ENDSIG);

     subcase = " EOCD extra data, ";
     bytes = new byte[100];
     buffer = ByteBuffer.wrap(bytes);
     comment = null;
     commentLen = 0;
     offset = bytes.length - ZipInputStream.ENDHDR - commentLen - 10;
     buffer.position(offset);
     EndOfCentralDirectory.view(buffer, comment);
     fileSystem.addFile(filename, bytes);
     zipIn = newZipIn(filename);
     result = zipIn.endOfCentralDirectory();
     assertWithMessage(subcase + "found").that(result).isNotNull();
     assertWithMessage(subcase + "comment").that(result.getComment()).isEqualTo("");
     assertWithMessage(subcase + "marker")
         .that((int) result.get(ENDSIG))
         .isEqualTo(ZipInputStream.ENDSIG);
   }

   /**
    * Test of centralDirectory method, of class ZipIn.
    */
   @Test
   public void testCentralDirectory() throws Exception {
     String filename = "test.zip";
     ByteBuffer buffer;
     int offset;
     ZipIn zipIn;
     String subcase;
     subcase = " EOCD extra data, ";
     String commonName = "thisIsNotNormal.txt";
     int filenameLen = commonName.getBytes(UTF_8).length;
     int count = ENTRY_COUNT;
     int dirEntry = ZipInputStream.CENHDR;
     int before = count;
     int between = 0; // implementation doesn't tolerate data between dir entries, does the spec?
     int after = 20;
     int eocd = ZipInputStream.ENDHDR;
     int total = before + (count * (dirEntry + filenameLen)) + ((count - 1) * between)
         + after + eocd;
     byte[] bytes = new byte[total];
     offset = before;
     for (int i = 0; i < count; i++) {
       if (i > 0) {
         offset += between;
       }
       buffer = ByteBuffer.wrap(bytes, offset, bytes.length - offset);
       DirectoryEntry.view(buffer, commonName, null, null)
           .set(CENHOW, (short) 8)
           .set(CENSIZ, before)
           .set(CENLEN, 2 * before)
           .set(CENOFF, i); // Not valid of course, but we're only testing central dir parsing.
           // and there are currently no checks in the parser to see if offset makes sense.
       offset += dirEntry + filenameLen;
     }
     offset += after;
     buffer = ByteBuffer.wrap(bytes, offset, bytes.length - offset);
     EndOfCentralDirectory.view(buffer, null)
         .set(ENDOFF, before)
         .set(ENDSIZ, offset - before - after)
         .set(ENDTOT, (short) count)
         .set(ENDSUB, (short) count);

     fileSystem.addFile(filename, bytes);
     zipIn = newZipIn(filename);
     CentralDirectory result = zipIn.centralDirectory();
     assertWithMessage(subcase + "found").that(result).isNotNull();
     List<DirectoryEntry> list = result.list();
     assertWithMessage(subcase + "size").that(list.size()).isEqualTo(count);
     for (int i = 0; i < list.size(); i++) {
       assertWithMessage(subcase + "offset check[" + i + "]")
           .that(list.get(i).get(CENOFF))
           .isEqualTo(i);
     }
   }

   /**
    * Test of scanEntries method, of class ZipIn.
    */
   @Test
   public void testScanEntries() throws Exception {
     int count = ENTRY_COUNT * 100;
     String filename = "test.jar";

     ZipFileBuilder builder = new ZipFileBuilder();
     for (int i = 0; i < count; i++) {
       builder.add("pkg/f" + i + ".class", "All day long");
     }
     builder.create(filename);

     final ZipIn zipIn = newZipIn(filename);
     zipIn.scanEntries(
         new EntryHandler() {
           int count = 0;

           @Override
           public void handle(
               ZipIn in, LocalFileHeader header, DirectoryEntry dirEntry, ByteBuffer data)
               throws IOException {
             assertThat(in).isSameAs(zipIn);
             String filename = "pkg/f" + count + ".class";
             assertThat(header.getFilename()).isEqualTo(filename);
             assertThat(dirEntry.getFilename()).isEqualTo(filename);
             count++;
           }
         });
   }

   /**
    * Test of nextHeaderFrom method, of class ZipIn.
    */
   @Test
   public void testNextHeaderFrom_long() throws Exception {
     int count = ENTRY_COUNT;
     String filename = "test.jar";
     ZipFileBuilder builder = new ZipFileBuilder();
     for (int i = 0; i < count; i++) {
       builder.add("pkg/f" + i + ".class", "All day long");
     }
     builder.create(filename);
     final ZipIn zipIn = newZipIn(filename);
     zipIn.endOfCentralDirectory();
     count = 0;
     int offset = 0;
     LocalFileHeader header;
     do {
       header = zipIn.nextHeaderFrom(offset);
       String name = "pkg/f" + count + ".class";
       if (header != null) {
         assertThat(header.getFilename()).isEqualTo(name);
         count++;
         offset = (int) header.fileOffset() + 4;
       }
     } while(header != null);
     assertThat(count).isEqualTo(ENTRY_COUNT);
   }

   /**
    * Test of nextHeaderFrom method, of class ZipIn.
    */
   @Test
   public void testNextHeaderFrom_DirectoryEntry() throws Exception {
     int count = ENTRY_COUNT;
     String filename = "test.jar";
     ZipFileBuilder builder = new ZipFileBuilder();
     for (int i = 0; i < count; i++) {
       builder.add("pkg/f" + i + ".class", "All day long");
     }
     builder.create(filename);
     final ZipIn zipIn = newZipIn(filename);
     zipIn.centralDirectory();
     List<DirectoryEntry> list = zipIn.centralDirectory().list();
     count = 0;
     String name;
     LocalFileHeader header = zipIn.nextHeaderFrom(null);
     for (DirectoryEntry dirEntry : list) {
       name = "pkg/f" + count + ".class";
       assertThat(dirEntry.getFilename()).isEqualTo(name);
       assertThat(header.getFilename()).isEqualTo(name);
       header = zipIn.nextHeaderFrom(dirEntry);
       count++;
     }
     assertThat(header).isNull();
   }

   /**
    * Test of localHeaderFor method, of class ZipIn.
    */
   @Test
   public void testLocalHeaderFor() throws Exception {
     int count = ENTRY_COUNT;
     String filename = "test.jar";
     ZipFileBuilder builder = new ZipFileBuilder();
     for (int i = 0; i < count; i++) {
       builder.add("pkg/f" + i + ".class", "All day long");
     }
     builder.create(filename);
     final ZipIn zipIn = newZipIn(filename);
     zipIn.centralDirectory();
     List<DirectoryEntry> list = zipIn.centralDirectory().list();
     count = 0;
     String name;
     LocalFileHeader header;
     for (DirectoryEntry dirEntry : list) {
       name = "pkg/f" + count + ".class";
       header = zipIn.localHeaderFor(dirEntry);
       assertThat(dirEntry.getFilename()).isEqualTo(name);
       assertThat(header.getFilename()).isEqualTo(name);
       count++;
     }
   }

   /**
    * Test of localHeaderAt method, of class ZipIn.
    */
   @Test
   public void testLocalHeaderAt() throws Exception {
     int count = ENTRY_COUNT;
     String filename = "test.jar";
     ZipFileBuilder builder = new ZipFileBuilder();
     for (int i = 0; i < count; i++) {
       builder.add("pkg/f" + i + ".class", "All day long");
     }
     builder.create(filename);
     final ZipIn zipIn = newZipIn(filename);
     zipIn.centralDirectory();
     List<DirectoryEntry> list = zipIn.centralDirectory().list();
     count = 0;
     String name;
     LocalFileHeader header;
     for (DirectoryEntry dirEntry : list) {
       name = "pkg/f" + count + ".class";
       header = zipIn.localHeaderAt(dirEntry.get(CENOFF));
       assertThat(dirEntry.getFilename()).isEqualTo(name);
       assertThat(header.getFilename()).isEqualTo(name);
       count++;
     }
   }

   /**
    * Test of nextFrom method, of class ZipIn.
    */
   @Test
   public void testNextFrom_long() throws Exception {
     int count = ENTRY_COUNT;
     String filename = "test.jar";
     ZipFileBuilder builder = new ZipFileBuilder();
     for (int i = 0; i < count; i++) {
       builder.add("pkg/f" + i + ".class", "All day long");
     }
     builder.create(filename);
     final ZipIn zipIn = newZipIn(filename);
     zipIn.centralDirectory();
     count = 0;
     int offset = 0;
     ZipEntry zipEntry;
     do {
       zipEntry = zipIn.nextFrom(offset);
       String name = "pkg/f" + count + ".class";
       if (zipEntry.getCode() != ZipEntry.Status.ENTRY_NOT_FOUND) {
         assertThat(zipEntry.getHeader()).isNotNull();
         assertThat(zipEntry.getDirEntry()).isNotNull();
         assertThat(zipEntry.getHeader().getFilename()).isEqualTo(name);
         assertThat(zipEntry.getDirEntry().getFilename()).isEqualTo(name);
         count++;
         offset = (int) zipEntry.getHeader().fileOffset() + 4;
       }
     } while(zipEntry.getCode() != ZipEntry.Status.ENTRY_NOT_FOUND);
     assertThat(count).isEqualTo(ENTRY_COUNT);
   }

   /**
    * Test of nextFrom method, of class ZipIn.
    */
   @Test
   public void testNextFrom_DirectoryEntry() throws Exception {
     int count = ENTRY_COUNT;
     String filename = "test.jar";
     ZipFileBuilder builder = new ZipFileBuilder();
     for (int i = 0; i < count; i++) {
       builder.add("pkg/f" + i + ".class", "All day long");
     }
     builder.create(filename);
     final ZipIn zipIn = newZipIn(filename);
     zipIn.centralDirectory();
     List<DirectoryEntry> list = zipIn.centralDirectory().list();
     count = 0;
     String name;
     ZipEntry zipEntry = zipIn.nextFrom(null);
     for (DirectoryEntry dirEntry : list) {
       if (zipEntry.getCode() == ZipEntry.Status.ENTRY_NOT_FOUND) {
         break;
       }
       name = "pkg/f" + count + ".class";
       assertThat(zipEntry.getHeader()).isNotNull();
       assertThat(zipEntry.getDirEntry()).isNotNull();
       assertThat(zipEntry.getHeader().getFilename()).isEqualTo(name);
       assertThat(zipEntry.getDirEntry().getFilename()).isEqualTo(name);
       zipEntry = zipIn.nextFrom(dirEntry);
       count++;
     }
     assertThat(count).isEqualTo(ENTRY_COUNT);
   }

   /**
    * Test of entryAt method, of class ZipIn.
    */
   @Test
   public void testEntryAt() throws Exception {
     int count = ENTRY_COUNT;
     String filename = "test.jar";
     ZipFileBuilder builder = new ZipFileBuilder();
     for (int i = 0; i < count; i++) {
       builder.add("pkg/f" + i + ".class", "All day long");
     }
     builder.create(filename);
     final ZipIn zipIn = newZipIn(filename);
     zipIn.centralDirectory();
     List<DirectoryEntry> list = zipIn.centralDirectory().list();
     count = 0;
     String name;
     ZipEntry zipEntry;
     for (DirectoryEntry dirEntry : list) {
       zipEntry = zipIn.entryAt(dirEntry.get(CENOFF));
       name = "pkg/f" + count + ".class";
       assertThat(zipEntry.getHeader()).isNotNull();
       assertThat(zipEntry.getDirEntry()).isNotNull();
       assertThat(zipEntry.getHeader().getFilename()).isEqualTo(name);
       assertThat(zipEntry.getDirEntry().getFilename()).isEqualTo(name);
       count++;
     }
     assertThat(count).isEqualTo(ENTRY_COUNT);
   }

   /**
    * Test of entryWith method, of class ZipIn.
    */
   @Test
   public void testEntryWith() throws Exception {
     int count = ENTRY_COUNT;
     String filename = "test.jar";
     ZipFileBuilder builder = new ZipFileBuilder();
     for (int i = 0; i < count; i++) {
       builder.add("pkg/f" + i + ".class", "All day long");
     }
     builder.create(filename);
     final ZipIn zipIn = newZipIn(filename);
     zipIn.centralDirectory();
     count = 0;
     int offset = 0;
     LocalFileHeader header;
     do {
       header = zipIn.nextHeaderFrom(offset);
       String name = "pkg/f" + count + ".class";
       if (header != null) {
         ZipEntry zipEntry = zipIn.entryWith(header);
         assertThat(zipEntry.getDirEntry()).isNotNull();
         assertThat(zipEntry.getHeader()).isSameAs(header);
         assertThat(zipEntry.getHeader().getFilename()).isEqualTo(name);
         assertThat(zipEntry.getDirEntry().getFilename()).isEqualTo(name);
         assertThat(header.getFilename()).isEqualTo(name);
         count++;
         offset = (int) header.fileOffset() + 4;
       }
     } while(header != null);
     assertThat(count).isEqualTo(ENTRY_COUNT);
   }

   private ZipIn newZipIn(String filename) throws IOException {
     return new ZipIn(fileSystem.getInputChannel(filename), filename);
   }
 }
	// Copyright 2015 The Bazel Authors. 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.devtools.build.android.ziputils;

	import static com.google.common.truth.Truth.assertThat;
	import static com.google.common.truth.Truth.assertWithMessage;
	import static com.google.devtools.build.android.ziputils.DirectoryEntry.CENHOW;
	import static com.google.devtools.build.android.ziputils.DirectoryEntry.CENLEN;
	import static com.google.devtools.build.android.ziputils.DirectoryEntry.CENOFF;
	import static com.google.devtools.build.android.ziputils.DirectoryEntry.CENSIZ;
	import static com.google.devtools.build.android.ziputils.EndOfCentralDirectory.ENDOFF;
	import static com.google.devtools.build.android.ziputils.EndOfCentralDirectory.ENDSIG;
	import static com.google.devtools.build.android.ziputils.EndOfCentralDirectory.ENDSIZ;
	import static com.google.devtools.build.android.ziputils.EndOfCentralDirectory.ENDSUB;
	import static com.google.devtools.build.android.ziputils.EndOfCentralDirectory.ENDTOT;
	import static java.nio.charset.StandardCharsets.UTF_8;
	import static org.junit.Assert.fail;

	import com.google.devtools.build.android.ziputils.ZipIn.ZipEntry;
	import java.io.IOException;
	import java.nio.ByteBuffer;
	import java.util.Arrays;
	import java.util.List;
	import java.util.zip.ZipInputStream;
	import org.junit.Before;
	import org.junit.Test;
	import org.junit.runner.RunWith;
	import org.junit.runners.JUnit4;

	/**
	* Unit tests for {@link ZipIn}.
	*/
	@RunWith(JUnit4.class)
	public class ZipInTest {

	private static final int ENTRY_COUNT = 1000;
	private FakeFileSystem fileSystem;

	@Before
	public void setUp() throws Exception {
	fileSystem = new FakeFileSystem();
	}

	/**
	* Test of endOfCentralDirectory method, of class ZipIn.
	*/
	@Test
	public void testEndOfCentralDirectory() throws Exception {

	String filename = "test.zip";
	byte[] bytes;
	ByteBuffer buffer;
	String comment;
	int commentLen;
	int offset;
	ZipIn zipIn;
	EndOfCentralDirectory result;
	String subcase;

	// Find it, even if it's the only useful thing in the file.
	subcase = " EOCD found it, ";
	bytes = new byte[] {
	0x50, 0x4b, 0x05, 0x06, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	};
	fileSystem.addFile(filename, bytes);
	zipIn = newZipIn(filename);
	result = zipIn.endOfCentralDirectory();
	assertWithMessage(subcase + "found").that(result).isNotNull();

	subcase = " EOCD not there at all, ";
	bytes = new byte[]{
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	};
	fileSystem.addFile(filename, bytes);
	zipIn = newZipIn(filename);
	try {
	zipIn.endOfCentralDirectory();
	fail(subcase + "expected IllegalStateException");
	} catch (Exception ex) {
	assertWithMessage(subcase + "caught exception")
	.that(ex.getClass())
	.isSameAs(IllegalStateException.class);
	}

	// If we can't read it, it's not there
	subcase = " EOCD too late to read, ";
	bytes = new byte[] {
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0x50, 0x4b, 0x05, 0x06, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	};
	fileSystem.addFile(filename, bytes);
	zipIn = newZipIn(filename);
	try {
	zipIn.endOfCentralDirectory();
	fail(subcase + "expected IndexOutOfBoundsException");
	} catch (Exception ex) {
	assertWithMessage(subcase + "caught exception")
	.that(ex.getClass())
	.isSameAs(IndexOutOfBoundsException.class);
	}

	// Current implementation doesn't know to scan past a bad EOCD record.
	// I'm not sure if it should.
	subcase = " EOCD good hidden by bad, ";
	bytes = new byte[] {
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0x50, 0x4b, 0x05, 0x06, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	0x50, 0x4b, 0x05, 0x06, 0, 0, 0, 0, 0, 0,
	0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	};
	fileSystem.addFile(filename, bytes);
	zipIn = newZipIn(filename);
	try {
	zipIn.endOfCentralDirectory();
	fail(subcase + "expected IndexOutOfBoundsException");
	} catch (Exception ex) {
	assertWithMessage(subcase + "caught exception")
	.that(ex.getClass())
	.isSameAs(IndexOutOfBoundsException.class);
	}

	// Minimal format checking here, assuming the EndOfDirectoryTest class
	// test for that.

	subcase = " EOCD truncated comment, ";
	bytes = new byte[100];
	buffer = ByteBuffer.wrap(bytes);
	comment = "optional file comment";
	commentLen = comment.getBytes(UTF_8).length;
	offset = bytes.length - ZipInputStream.ENDHDR - commentLen;
	buffer.position(offset);
	EndOfCentralDirectory.view(buffer, comment);
	byte[] truncated = Arrays.copyOf(bytes, bytes.length - 5);
	fileSystem.addFile(filename, truncated);
	zipIn = newZipIn(filename);
	try { // not sure this is the exception we want!
	zipIn.endOfCentralDirectory();
	fail(subcase + "expected IllegalArgumentException");
	} catch (Exception ex) {
	assertWithMessage(subcase + "caught exception")
	.that(ex.getClass())
	.isSameAs(IllegalArgumentException.class);
	}

	subcase = " EOCD no comment, ";
	bytes = new byte[100];
	buffer = ByteBuffer.wrap(bytes);
	comment = null;
	commentLen = 0;
	offset = bytes.length - ZipInputStream.ENDHDR - commentLen;
	buffer.position(offset);
	EndOfCentralDirectory.view(buffer, comment);
	fileSystem.addFile(filename, bytes);
	zipIn = newZipIn(filename);
	result = zipIn.endOfCentralDirectory();
	assertWithMessage(subcase + "found").that(result).isNotNull();
	assertWithMessage(subcase + "comment").that(result.getComment()).isEqualTo("");
	assertWithMessage(subcase + "marker")
	.that((int) result.get(ENDSIG))
	.isEqualTo(ZipInputStream.ENDSIG);

	subcase = " EOCD comment, ";
	bytes = new byte[100];
	buffer = ByteBuffer.wrap(bytes);
	comment = "optional file comment";
	commentLen = comment.getBytes(UTF_8).length;
	offset = bytes.length - ZipInputStream.ENDHDR - commentLen;
	buffer.position(offset);
	EndOfCentralDirectory.view(buffer, comment);
	assertWithMessage(subcase + "setup")
	.that(new String(bytes, bytes.length - commentLen, commentLen, UTF_8))
	.isEqualTo(comment);
	fileSystem.addFile(filename, bytes);
	zipIn = newZipIn(filename);
	result = zipIn.endOfCentralDirectory();
	assertWithMessage(subcase + "found").that(result).isNotNull();
	assertWithMessage(subcase + "comment").that(result.getComment()).isEqualTo(comment);
	assertWithMessage(subcase + "marker")
	.that((int) result.get(ENDSIG))
	.isEqualTo(ZipInputStream.ENDSIG);

	subcase = " EOCD extra data, ";
	bytes = new byte[100];
	buffer = ByteBuffer.wrap(bytes);
	comment = null;
	commentLen = 0;
	offset = bytes.length - ZipInputStream.ENDHDR - commentLen - 10;
	buffer.position(offset);
	EndOfCentralDirectory.view(buffer, comment);
	fileSystem.addFile(filename, bytes);
	zipIn = newZipIn(filename);
	result = zipIn.endOfCentralDirectory();
	assertWithMessage(subcase + "found").that(result).isNotNull();
	assertWithMessage(subcase + "comment").that(result.getComment()).isEqualTo("");
	assertWithMessage(subcase + "marker")
	.that((int) result.get(ENDSIG))
	.isEqualTo(ZipInputStream.ENDSIG);
	}

	/**
	* Test of centralDirectory method, of class ZipIn.
	*/
	@Test
	public void testCentralDirectory() throws Exception {
	String filename = "test.zip";
	ByteBuffer buffer;
	int offset;
	ZipIn zipIn;
	String subcase;
	subcase = " EOCD extra data, ";
	String commonName = "thisIsNotNormal.txt";
	int filenameLen = commonName.getBytes(UTF_8).length;
	int count = ENTRY_COUNT;
	int dirEntry = ZipInputStream.CENHDR;
	int before = count;
	int between = 0; // implementation doesn't tolerate data between dir entries, does the spec?
	int after = 20;
	int eocd = ZipInputStream.ENDHDR;
	int total = before + (count * (dirEntry + filenameLen)) + ((count - 1) * between)
	+ after + eocd;
	byte[] bytes = new byte[total];
	offset = before;
	for (int i = 0; i < count; i++) {
	if (i > 0) {
	offset += between;
	}
	buffer = ByteBuffer.wrap(bytes, offset, bytes.length - offset);
	DirectoryEntry.view(buffer, commonName, null, null)
	.set(CENHOW, (short) 8)
	.set(CENSIZ, before)
	.set(CENLEN, 2 * before)
	.set(CENOFF, i); // Not valid of course, but we're only testing central dir parsing.
	// and there are currently no checks in the parser to see if offset makes sense.
	offset += dirEntry + filenameLen;
	}
	offset += after;
	buffer = ByteBuffer.wrap(bytes, offset, bytes.length - offset);
	EndOfCentralDirectory.view(buffer, null)
	.set(ENDOFF, before)
	.set(ENDSIZ, offset - before - after)
	.set(ENDTOT, (short) count)
	.set(ENDSUB, (short) count);

	fileSystem.addFile(filename, bytes);
	zipIn = newZipIn(filename);
	CentralDirectory result = zipIn.centralDirectory();
	assertWithMessage(subcase + "found").that(result).isNotNull();
	List<DirectoryEntry> list = result.list();
	assertWithMessage(subcase + "size").that(list.size()).isEqualTo(count);
	for (int i = 0; i < list.size(); i++) {
	assertWithMessage(subcase + "offset check[" + i + "]")
	.that(list.get(i).get(CENOFF))
	.isEqualTo(i);
	}
	}

	/**
	* Test of scanEntries method, of class ZipIn.
	*/
	@Test
	public void testScanEntries() throws Exception {
	int count = ENTRY_COUNT * 100;
	String filename = "test.jar";

	ZipFileBuilder builder = new ZipFileBuilder();
	for (int i = 0; i < count; i++) {
	builder.add("pkg/f" + i + ".class", "All day long");
	}
	builder.create(filename);

	final ZipIn zipIn = newZipIn(filename);
	zipIn.scanEntries(
	new EntryHandler() {
	int count = 0;

	@Override
	public void handle(
	ZipIn in, LocalFileHeader header, DirectoryEntry dirEntry, ByteBuffer data)
	throws IOException {
	assertThat(in).isSameAs(zipIn);
	String filename = "pkg/f" + count + ".class";
	assertThat(header.getFilename()).isEqualTo(filename);
	assertThat(dirEntry.getFilename()).isEqualTo(filename);
	count++;
	}
	});
	}

	/**
	* Test of nextHeaderFrom method, of class ZipIn.
	*/
	@Test
	public void testNextHeaderFrom_long() throws Exception {
	int count = ENTRY_COUNT;
	String filename = "test.jar";
	ZipFileBuilder builder = new ZipFileBuilder();
	for (int i = 0; i < count; i++) {
	builder.add("pkg/f" + i + ".class", "All day long");
	}
	builder.create(filename);
	final ZipIn zipIn = newZipIn(filename);
	zipIn.endOfCentralDirectory();
	count = 0;
	int offset = 0;
	LocalFileHeader header;
	do {
	header = zipIn.nextHeaderFrom(offset);
	String name = "pkg/f" + count + ".class";
	if (header != null) {
	assertThat(header.getFilename()).isEqualTo(name);
	count++;
	offset = (int) header.fileOffset() + 4;
	}
	} while(header != null);
	assertThat(count).isEqualTo(ENTRY_COUNT);
	}

	/**
	* Test of nextHeaderFrom method, of class ZipIn.
	*/
	@Test
	public void testNextHeaderFrom_DirectoryEntry() throws Exception {
	int count = ENTRY_COUNT;
	String filename = "test.jar";
	ZipFileBuilder builder = new ZipFileBuilder();
	for (int i = 0; i < count; i++) {
	builder.add("pkg/f" + i + ".class", "All day long");
	}
	builder.create(filename);
	final ZipIn zipIn = newZipIn(filename);
	zipIn.centralDirectory();
	List<DirectoryEntry> list = zipIn.centralDirectory().list();
	count = 0;
	String name;
	LocalFileHeader header = zipIn.nextHeaderFrom(null);
	for (DirectoryEntry dirEntry : list) {
	name = "pkg/f" + count + ".class";
	assertThat(dirEntry.getFilename()).isEqualTo(name);
	assertThat(header.getFilename()).isEqualTo(name);
	header = zipIn.nextHeaderFrom(dirEntry);
	count++;
	}
	assertThat(header).isNull();
	}

	/**
	* Test of localHeaderFor method, of class ZipIn.
	*/
	@Test
	public void testLocalHeaderFor() throws Exception {
	int count = ENTRY_COUNT;
	String filename = "test.jar";
	ZipFileBuilder builder = new ZipFileBuilder();
	for (int i = 0; i < count; i++) {
	builder.add("pkg/f" + i + ".class", "All day long");
	}
	builder.create(filename);
	final ZipIn zipIn = newZipIn(filename);
	zipIn.centralDirectory();
	List<DirectoryEntry> list = zipIn.centralDirectory().list();
	count = 0;
	String name;
	LocalFileHeader header;
	for (DirectoryEntry dirEntry : list) {
	name = "pkg/f" + count + ".class";
	header = zipIn.localHeaderFor(dirEntry);
	assertThat(dirEntry.getFilename()).isEqualTo(name);
	assertThat(header.getFilename()).isEqualTo(name);
	count++;
	}
	}

	/**
	* Test of localHeaderAt method, of class ZipIn.
	*/
	@Test
	public void testLocalHeaderAt() throws Exception {
	int count = ENTRY_COUNT;
	String filename = "test.jar";
	ZipFileBuilder builder = new ZipFileBuilder();
	for (int i = 0; i < count; i++) {
	builder.add("pkg/f" + i + ".class", "All day long");
	}
	builder.create(filename);
	final ZipIn zipIn = newZipIn(filename);
	zipIn.centralDirectory();
	List<DirectoryEntry> list = zipIn.centralDirectory().list();
	count = 0;
	String name;
	LocalFileHeader header;
	for (DirectoryEntry dirEntry : list) {
	name = "pkg/f" + count + ".class";
	header = zipIn.localHeaderAt(dirEntry.get(CENOFF));
	assertThat(dirEntry.getFilename()).isEqualTo(name);
	assertThat(header.getFilename()).isEqualTo(name);
	count++;
	}
	}

	/**
	* Test of nextFrom method, of class ZipIn.
	*/
	@Test
	public void testNextFrom_long() throws Exception {
	int count = ENTRY_COUNT;
	String filename = "test.jar";
	ZipFileBuilder builder = new ZipFileBuilder();
	for (int i = 0; i < count; i++) {
	builder.add("pkg/f" + i + ".class", "All day long");
	}
	builder.create(filename);
	final ZipIn zipIn = newZipIn(filename);
	zipIn.centralDirectory();
	count = 0;
	int offset = 0;
	ZipEntry zipEntry;
	do {
	zipEntry = zipIn.nextFrom(offset);
	String name = "pkg/f" + count + ".class";
	if (zipEntry.getCode() != ZipEntry.Status.ENTRY_NOT_FOUND) {
	assertThat(zipEntry.getHeader()).isNotNull();
	assertThat(zipEntry.getDirEntry()).isNotNull();
	assertThat(zipEntry.getHeader().getFilename()).isEqualTo(name);
	assertThat(zipEntry.getDirEntry().getFilename()).isEqualTo(name);
	count++;
	offset = (int) zipEntry.getHeader().fileOffset() + 4;
	}
	} while(zipEntry.getCode() != ZipEntry.Status.ENTRY_NOT_FOUND);
	assertThat(count).isEqualTo(ENTRY_COUNT);
	}

	/**
	* Test of nextFrom method, of class ZipIn.
	*/
	@Test
	public void testNextFrom_DirectoryEntry() throws Exception {
	int count = ENTRY_COUNT;
	String filename = "test.jar";
	ZipFileBuilder builder = new ZipFileBuilder();
	for (int i = 0; i < count; i++) {
	builder.add("pkg/f" + i + ".class", "All day long");
	}
	builder.create(filename);
	final ZipIn zipIn = newZipIn(filename);
	zipIn.centralDirectory();
	List<DirectoryEntry> list = zipIn.centralDirectory().list();
	count = 0;
	String name;
	ZipEntry zipEntry = zipIn.nextFrom(null);
	for (DirectoryEntry dirEntry : list) {
	if (zipEntry.getCode() == ZipEntry.Status.ENTRY_NOT_FOUND) {
	break;
	}
	name = "pkg/f" + count + ".class";
	assertThat(zipEntry.getHeader()).isNotNull();
	assertThat(zipEntry.getDirEntry()).isNotNull();
	assertThat(zipEntry.getHeader().getFilename()).isEqualTo(name);
	assertThat(zipEntry.getDirEntry().getFilename()).isEqualTo(name);
	zipEntry = zipIn.nextFrom(dirEntry);
	count++;
	}
	assertThat(count).isEqualTo(ENTRY_COUNT);
	}

	/**
	* Test of entryAt method, of class ZipIn.
	*/
	@Test
	public void testEntryAt() throws Exception {
	int count = ENTRY_COUNT;
	String filename = "test.jar";
	ZipFileBuilder builder = new ZipFileBuilder();
	for (int i = 0; i < count; i++) {
	builder.add("pkg/f" + i + ".class", "All day long");
	}
	builder.create(filename);
	final ZipIn zipIn = newZipIn(filename);
	zipIn.centralDirectory();
	List<DirectoryEntry> list = zipIn.centralDirectory().list();
	count = 0;
	String name;
	ZipEntry zipEntry;
	for (DirectoryEntry dirEntry : list) {
	zipEntry = zipIn.entryAt(dirEntry.get(CENOFF));
	name = "pkg/f" + count + ".class";
	assertThat(zipEntry.getHeader()).isNotNull();
	assertThat(zipEntry.getDirEntry()).isNotNull();
	assertThat(zipEntry.getHeader().getFilename()).isEqualTo(name);
	assertThat(zipEntry.getDirEntry().getFilename()).isEqualTo(name);
	count++;
	}
	assertThat(count).isEqualTo(ENTRY_COUNT);
	}

	/**
	* Test of entryWith method, of class ZipIn.
	*/
	@Test
	public void testEntryWith() throws Exception {
	int count = ENTRY_COUNT;
	String filename = "test.jar";
	ZipFileBuilder builder = new ZipFileBuilder();
	for (int i = 0; i < count; i++) {
	builder.add("pkg/f" + i + ".class", "All day long");
	}
	builder.create(filename);
	final ZipIn zipIn = newZipIn(filename);
	zipIn.centralDirectory();
	count = 0;
	int offset = 0;
	LocalFileHeader header;
	do {
	header = zipIn.nextHeaderFrom(offset);
	String name = "pkg/f" + count + ".class";
	if (header != null) {
	ZipEntry zipEntry = zipIn.entryWith(header);
	assertThat(zipEntry.getDirEntry()).isNotNull();
	assertThat(zipEntry.getHeader()).isSameAs(header);
	assertThat(zipEntry.getHeader().getFilename()).isEqualTo(name);
	assertThat(zipEntry.getDirEntry().getFilename()).isEqualTo(name);
	assertThat(header.getFilename()).isEqualTo(name);
	count++;
	offset = (int) header.fileOffset() + 4;
	}
	} while(header != null);
	assertThat(count).isEqualTo(ENTRY_COUNT);
	}

	private ZipIn newZipIn(String filename) throws IOException {
	return new ZipIn(fileSystem.getInputChannel(filename), filename);
	}
	}