/** @throws IOException java.util.jar.JarFile#getJarEntry(java.lang.String) */
  public void test_getJarEntryLjava_lang_String() throws IOException {
    try {
      Support_Resources.copyFile(resources, null, jarName);
      JarFile jarFile = new JarFile(new File(resources, jarName));
      assertEquals("Error in returned entry", 311, jarFile.getJarEntry(entryName).getSize());
      jarFile.close();
    } catch (Exception e) {
      fail("Exception during test: " + e.toString());
    }

    Support_Resources.copyFile(resources, null, jarName);
    JarFile jarFile = new JarFile(new File(resources, jarName));
    Enumeration<JarEntry> enumeration = jarFile.entries();
    assertTrue(enumeration.hasMoreElements());
    while (enumeration.hasMoreElements()) {
      JarEntry je = enumeration.nextElement();
      jarFile.getJarEntry(je.getName());
    }

    enumeration = jarFile.entries();
    assertTrue(enumeration.hasMoreElements());
    JarEntry je = enumeration.nextElement();
    try {
      jarFile.close();
      jarFile.getJarEntry(je.getName());
      // fail("IllegalStateException expected.");
    } catch (IllegalStateException ee) { // Per documentation exception
      // may be thrown.
      // expected
    }
  }
  /** java.util.jar.JarFile#JarFile(java.io.File, boolean, int) */
  public void test_ConstructorLjava_io_FileZI() {
    try {
      JarFile jarFile = new JarFile(new File("Wrong.file"), true, ZipFile.OPEN_READ);
      fail("Should throw IOException");
    } catch (IOException e) {
      // expected
    }

    try {
      Support_Resources.copyFile(resources, null, jarName);
      JarFile jarFile = new JarFile(new File(resources, jarName), false, ZipFile.OPEN_READ);
    } catch (IOException e) {
      fail("Should not throw IOException");
    }

    try {
      Support_Resources.copyFile(resources, null, jarName);
      JarFile jarFile =
          new JarFile(
              new File(resources, jarName), false, ZipFile.OPEN_READ | ZipFile.OPEN_DELETE + 33);
      fail("Should throw IllegalArgumentException");
    } catch (IOException e) {
      fail("Should not throw IOException");
    } catch (IllegalArgumentException e) {
      // expected
    }
  }
Esempio n. 3
0
  public void test_equals() throws IOException {
    Manifest manifest1 =
        new Manifest(new URL(Support_Resources.getURL("manifest/hyts_MANIFEST.MF")).openStream());
    Manifest manifest2 =
        new Manifest(new URL(Support_Resources.getURL("manifest/hyts_MANIFEST.MF")).openStream());
    Manifest manifest3 = new Manifest();

    assertTrue(manifest1.equals(manifest1));
    assertTrue(manifest1.equals(manifest2));
    assertFalse(manifest1.equals(manifest3));
    assertFalse(manifest1.equals(this));
  }
Esempio n. 4
0
  Package getTestPackage(String resourceJar, String className) throws Exception {
    Support_Resources.copyFile(resources, "Package", resourceJar);
    URL resourceURL = new URL("file:/" + resPath + "/Package/" + resourceJar);

    URLClassLoader ucl = new URLClassLoader(new URL[] {resourceURL}, null);
    return Class.forName(className, true, ucl).getPackage();
  }
  private void checkSignedJar(String jarName) throws Exception {
    Support_Resources.copyFile(resources, null, jarName);

    File file = new File(resources, jarName);
    boolean foundCerts = false;

    JarFile jarFile = new JarFile(file, true);
    try {

      Enumeration<JarEntry> e = jarFile.entries();
      while (e.hasMoreElements()) {
        JarEntry entry = e.nextElement();
        InputStream is = jarFile.getInputStream(entry);
        is.skip(100000);
        is.close();
        Certificate[] certs = entry.getCertificates();
        if (certs != null && certs.length > 0) {
          foundCerts = true;
          break;
        }
      }
    } finally {
      jarFile.close();
    }

    assertTrue(
        "No certificates found during signed jar test for jar \"" + jarName + "\"", foundCerts);
  }
  private Certificate[] getSignedJarCerts(String jarName, boolean chainCheck) throws Exception {
    Support_Resources.copyFile(resources, null, jarName);

    File file = new File(resources, jarName);
    Certificate[] foundCerts = null;

    JarFile jarFile = new JarFile(file, true, ZipFile.OPEN_READ, chainCheck);
    try {

      Enumeration<JarEntry> e = jarFile.entries();
      while (e.hasMoreElements()) {
        JarEntry entry = e.nextElement();
        InputStream is = jarFile.getInputStream(entry);
        // Skip bytes because we have to read the entire file for it to read signatures.
        is.skip(entry.getSize());
        is.close();
        Certificate[] certs = entry.getCertificates();
        if (certs != null && certs.length > 0) {
          foundCerts = certs;
          break;
        }
      }
    } finally {
      jarFile.close();
    }

    return foundCerts;
  }
Esempio n. 7
0
  public void test_1562() throws Exception {
    Manifest man = new Manifest();
    Attributes att = man.getMainAttributes();
    att.put(Attributes.Name.MANIFEST_VERSION, "1.0");
    att.put(Attributes.Name.MAIN_CLASS, "foo.bar.execjartest.Foo");

    File outputZip = File.createTempFile("hyts_", ".zip");
    outputZip.deleteOnExit();
    ZipOutputStream zout = new ZipOutputStream(new FileOutputStream(outputZip));
    File resources = Support_Resources.createTempFolder();

    for (String zipClass : new String[] {"Foo", "Bar"}) {
      zout.putNextEntry(new ZipEntry("foo/bar/execjartest/" + zipClass + ".class"));
      zout.write(getResource(resources, "hyts_" + zipClass + ".ser"));
    }

    zout.putNextEntry(new ZipEntry("META-INF/MANIFEST.MF"));
    man.write(zout);
    zout.close();

    // set up the VM parameters
    String[] args = new String[] {"-jar", outputZip.getAbsolutePath()};

    // execute the JAR and read the result
    String res = Support_Exec.execJava(args, null, false);

    assertTrue("Error executing ZIP : result returned was incorrect.", res.startsWith("FOOBAR"));
  }
Esempio n. 8
0
  /**
   * tests case when Main-Class is not in the zip launched but in another zip referenced by
   * Class-Path
   *
   * @throws Exception in case of troubles
   */
  public void test_main_class_in_another_zip() throws Exception {
    File fooZip = File.createTempFile("hyts_", ".zip");
    File barZip = File.createTempFile("hyts_", ".zip");
    fooZip.deleteOnExit();
    barZip.deleteOnExit();

    // create the manifest
    Manifest man = new Manifest();
    Attributes att = man.getMainAttributes();
    att.put(Attributes.Name.MANIFEST_VERSION, "1.0");
    att.put(Attributes.Name.MAIN_CLASS, "foo.bar.execjartest.Foo");
    att.put(Attributes.Name.CLASS_PATH, fooZip.getName());

    File resources = Support_Resources.createTempFolder();

    ZipOutputStream zoutFoo = new ZipOutputStream(new FileOutputStream(fooZip));
    zoutFoo.putNextEntry(new ZipEntry("foo/bar/execjartest/Foo.class"));
    zoutFoo.write(getResource(resources, "hyts_Foo.ser"));
    zoutFoo.close();

    ZipOutputStream zoutBar = new ZipOutputStream(new FileOutputStream(barZip));
    zoutBar.putNextEntry(new ZipEntry("META-INF/MANIFEST.MF"));
    man.write(zoutBar);

    zoutBar.putNextEntry(new ZipEntry("foo/bar/execjartest/Bar.class"));
    zoutBar.write(getResource(resources, "hyts_Bar.ser"));
    zoutBar.close();

    String[] args = new String[] {"-jar", barZip.getAbsolutePath()};

    // execute the JAR and read the result
    String res = Support_Exec.execJava(args, null, false);

    assertTrue("Error executing JAR : result returned was incorrect.", res.startsWith("FOOBAR"));
  }
 /* The jar is intact, then everything is all right. */
 public void test_JarFile_Integrate_Jar() throws IOException {
   String modifiedJarName = "Integrate.jar";
   Support_Resources.copyFile(resources, null, modifiedJarName);
   JarFile jarFile = new JarFile(new File(resources, modifiedJarName), true);
   Enumeration<JarEntry> entries = jarFile.entries();
   while (entries.hasMoreElements()) {
     ZipEntry zipEntry = entries.nextElement();
     jarFile.getInputStream(zipEntry).skip(Long.MAX_VALUE);
   }
 }
 /*
  * The jar created by 1.4 which does not provide a
  * algorithm-Digest-Manifest-Main-Attributes entry in .SF file.
  */
 public void test_Jar_created_before_java_5() throws IOException {
   String modifiedJarName = "Created_by_1_4.jar";
   Support_Resources.copyFile(resources, null, modifiedJarName);
   JarFile jarFile = new JarFile(new File(resources, modifiedJarName), true);
   Enumeration<JarEntry> entries = jarFile.entries();
   while (entries.hasMoreElements()) {
     ZipEntry zipEntry = entries.nextElement();
     jarFile.getInputStream(zipEntry);
   }
 }
  public void test_close() throws IOException {
    String modifiedJarName = "Modified_SF_EntryAttributes.jar";
    Support_Resources.copyFile(resources, null, modifiedJarName);
    JarFile jarFile = new JarFile(new File(resources, modifiedJarName), true);
    Enumeration<JarEntry> entries = jarFile.entries();

    jarFile.close();
    jarFile.close();

    // Can not check IOException
  }
 public void test_entries2() throws Exception {
   Support_Resources.copyFile(resources, null, jarName);
   JarFile jarFile = new JarFile(new File(resources, jarName));
   Enumeration<JarEntry> enumeration = jarFile.entries();
   jarFile.close();
   try {
     enumeration.hasMoreElements();
     fail("hasMoreElements() did not detect a closed jar file");
   } catch (IllegalStateException e) {
   }
   Support_Resources.copyFile(resources, null, jarName);
   jarFile = new JarFile(new File(resources, jarName));
   enumeration = jarFile.entries();
   jarFile.close();
   try {
     enumeration.nextElement();
     fail("nextElement() did not detect closed jar file");
   } catch (IllegalStateException e) {
   }
 }
Esempio n. 13
0
  private static byte[] getResource(File tempDir, String resourceName) throws IOException {
    Support_Resources.copyFile(tempDir, null, resourceName);
    File resourceFile = new File(tempDir, resourceName);
    resourceFile.deleteOnExit();

    // read whole resource data into memory
    byte[] resourceBody = new byte[(int) resourceFile.length()];
    FileInputStream fis = new FileInputStream(resourceFile);
    fis.read(resourceBody);
    fis.close();

    return resourceBody;
  }
 /*
  * If another entry is inserted into Manifest, no security exception will be
  * thrown out.
  */
 public void test_Inserted_Entry_Manifest_with_DigestCode() throws IOException {
   String modifiedJarName = "Inserted_Entry_Manifest_with_DigestCode.jar";
   Support_Resources.copyFile(resources, null, modifiedJarName);
   JarFile jarFile = new JarFile(new File(resources, modifiedJarName), true);
   Enumeration<JarEntry> entries = jarFile.entries();
   int count = 0;
   while (entries.hasMoreElements()) {
     ZipEntry zipEntry = entries.nextElement();
     jarFile.getInputStream(zipEntry);
     count++;
   }
   assertEquals(5, count);
 }
Esempio n. 15
0
  public void test_clone() throws IOException {
    Manifest emptyManifest = new Manifest();
    Manifest emptyClone = (Manifest) emptyManifest.clone();
    assertTrue("Should have no entries", emptyClone.getEntries().isEmpty());
    assertTrue("Should have no main attributes", emptyClone.getMainAttributes().isEmpty());
    assertEquals(emptyClone, emptyManifest);
    assertEquals(emptyManifest.clone().getClass().getName(), "java.util.jar.Manifest");

    Manifest manifest =
        new Manifest(new URL(Support_Resources.getURL("manifest/hyts_MANIFEST.MF")).openStream());
    Manifest manifestClone = (Manifest) manifest.clone();
    manifestClone.getMainAttributes();
    checkManifest(manifestClone);
  }
 /*
  * If the content of the .SA file is modified, no matter what it resides,
  * JarFile.getInputStream of any JarEntry will throw Security Exception.
  */
 public void test_JarFile_Modified_SF_EntryAttributes() throws IOException {
   String modifiedJarName = "Modified_SF_EntryAttributes.jar";
   Support_Resources.copyFile(resources, null, modifiedJarName);
   JarFile jarFile = new JarFile(new File(resources, modifiedJarName), true);
   Enumeration<JarEntry> entries = jarFile.entries();
   while (entries.hasMoreElements()) {
     ZipEntry zipEntry = entries.nextElement();
     try {
       jarFile.getInputStream(zipEntry);
       fail("should throw Security Exception");
     } catch (SecurityException e) {
       // desired
     }
   }
 }
  /** java.util.jar.JarFile#JarFile(java.io.File, boolean) */
  public void test_ConstructorLjava_io_FileZ() {
    try {
      JarFile jarFile = new JarFile(new File("Wrong.file"), true);
      fail("Should throw IOException");
    } catch (IOException e) {
      // expected
    }

    try {
      Support_Resources.copyFile(resources, null, jarName);
      JarFile jarFile = new JarFile(new File(resources, jarName), false);
    } catch (IOException e) {
      fail("Should not throw IOException");
    }
  }
  /** java.util.jar.JarFile#JarFile(java.lang.String, boolean) */
  public void test_ConstructorLjava_lang_StringZ() {
    try {
      JarFile jarFile = new JarFile("Wrong.file", false);
      fail("Should throw IOException");
    } catch (IOException e) {
      // expected
    }

    try {
      Support_Resources.copyFile(resources, null, jarName);
      String fileName = (new File(resources, jarName)).getCanonicalPath();
      JarFile jarFile = new JarFile(fileName, true);
    } catch (IOException e) {
      fail("Should not throw IOException");
    }
  }
 /** java.util.jar.JarFile#entries() */
 public void test_entries() throws Exception {
   /*
    * Note only (and all of) the following should be contained in the file
    * META-INF/ META-INF/MANIFEST.MF foo/ foo/bar/ foo/bar/A.class Blah.txt
    */
   Support_Resources.copyFile(resources, null, jarName);
   JarFile jarFile = new JarFile(new File(resources, jarName));
   Enumeration<JarEntry> e = jarFile.entries();
   int i;
   for (i = 0; e.hasMoreElements(); i++) {
     e.nextElement();
   }
   assertEquals(jarFile.size(), i);
   jarFile.close();
   assertEquals(6, i);
 }
  // Regression test for issue introduced by HARMONY-4569: signed archives containing files with
  // size 0 could not get verified.
  public void testJarVerificationEmptyEntry() throws IOException {
    Support_Resources.copyFile(resources, null, emptyEntryJar);
    File f = new File(resources, emptyEntryJar);

    JarFile jarFile = new JarFile(f);

    ZipEntry zipEntry = jarFile.getJarEntry(emptyEntry1);
    int res = jarFile.getInputStream(zipEntry).read(new byte[100], 0, 100);
    assertEquals("Wrong length of empty jar entry", -1, res);

    zipEntry = jarFile.getJarEntry(emptyEntry2);
    res = jarFile.getInputStream(zipEntry).read(new byte[100], 0, 100);
    assertEquals("Wrong length of empty jar entry", -1, res);

    zipEntry = jarFile.getJarEntry(emptyEntry3);
    res = jarFile.getInputStream(zipEntry).read();
    assertEquals("Wrong length of empty jar entry", -1, res);
  }
  /** The jar is intact, but the entry object is modified. */
  public void testJarVerificationModifiedEntry() throws IOException {
    Support_Resources.copyFile(resources, null, integrateJar);
    File f = new File(resources, integrateJar);

    JarFile jarFile = new JarFile(f);
    ZipEntry zipEntry = jarFile.getJarEntry(integrateJarEntry);
    zipEntry.setSize(zipEntry.getSize() + 1);
    jarFile.getInputStream(zipEntry).skip(Long.MAX_VALUE);

    jarFile = new JarFile(f);
    zipEntry = jarFile.getJarEntry(integrateJarEntry);
    zipEntry.setSize(zipEntry.getSize() - 1);
    try {
      // jarFile.getInputStream(zipEntry).skip(Long.MAX_VALUE);
      jarFile.getInputStream(zipEntry).read(new byte[5000], 0, 5000);
      fail("SecurityException expected");
    } catch (SecurityException e) {
      // desired
    }
  }
 /*
  * The content of Test.class is modified, jarFile.getInputStream will not
  * throw security Exception, but it will anytime before the inputStream got
  * from getInputStream method has been read to end.
  */
 public void test_JarFile_Modified_Class() throws IOException {
   String modifiedJarName = "Modified_Class.jar";
   Support_Resources.copyFile(resources, null, modifiedJarName);
   JarFile jarFile = new JarFile(new File(resources, modifiedJarName), true);
   Enumeration<JarEntry> entries = jarFile.entries();
   while (entries.hasMoreElements()) {
     ZipEntry zipEntry = entries.nextElement();
     jarFile.getInputStream(zipEntry);
   }
   /* The content of Test.class has been tampered. */
   ZipEntry zipEntry = jarFile.getEntry("Test.class");
   InputStream in = jarFile.getInputStream(zipEntry);
   byte[] buffer = new byte[1024];
   try {
     while (in.available() > 0) {
       in.read(buffer);
     }
     fail("SecurityException expected");
   } catch (SecurityException e) {
     // desired
   }
 }
Esempio n. 23
0
  public void test_writeLjava_io_OutputStream() throws IOException {
    byte b[];
    Manifest manifest1 = null;
    Manifest manifest2 = null;
    try {
      manifest1 =
          new Manifest(new URL(Support_Resources.getURL("manifest/hyts_MANIFEST.MF")).openStream());
    } catch (MalformedURLException e) {
      fail("Malformed URL");
    }

    ByteArrayOutputStream baos = new ByteArrayOutputStream();

    manifest1.write(baos);

    b = baos.toByteArray();

    File f = File.createTempFile("111", "111");
    FileOutputStream fos = new FileOutputStream(f);
    fos.close();
    try {
      manifest1.write(fos);
      fail("IOException expected");
    } catch (IOException e) {
      // expected
    }
    f.delete();

    ByteArrayInputStream bais = new ByteArrayInputStream(b);

    try {
      manifest2 = new Manifest(bais);
    } catch (MalformedURLException e) {
      fail("Malformed URL");
    }

    assertTrue(manifest1.equals(manifest2));
  }
  /** @tests java.security.cert.X509Certificate#getExtensionValue(java.lang.String) */
  public void test_getExtensionValueLjava_lang_String() throws Exception {

    InputStream is = Support_Resources.getResourceStream("hyts_certificate_PEM.txt");

    CertificateFactory certFact = CertificateFactory.getInstance("X509");
    X509Certificate pemCert = (X509Certificate) certFact.generateCertificate(is);

    Vector<String> extensionOids = new Vector<String>();
    extensionOids.addAll(pemCert.getCriticalExtensionOIDs());
    extensionOids.addAll(pemCert.getNonCriticalExtensionOIDs());
    Iterator i = extensionOids.iterator();
    while (i.hasNext()) {
      String oid = (String) i.next();
      byte[] value = pemCert.getExtensionValue(oid);
      if (value != null && value.length > 0) {
        // check that it is an encoded as a OCTET STRING
        assertEquals(
            "The extension value for the oid " + oid + " was not encoded as an OCTET STRING",
            0x04,
            value[0]);
      }
    }
  }
 /**
  * @throws IOException
  * @tests java.util.Properties#load(java.io.InputStream)
  */
 @TestTargetNew(
     level = TestLevel.PARTIAL_COMPLETE,
     notes = "Doesn't verify IOException, IllegalArgumentException.",
     method = "load",
     args = {java.io.InputStream.class})
 public void test_loadLjava_io_InputStream_subtest0() throws IOException {
   InputStream is = Support_Resources.getStream("hyts_PropertiesTest.properties");
   Properties props = new Properties();
   props.load(is);
   is.close();
   assertEquals("1", "\n \t \f", props.getProperty(" \r"));
   assertEquals("2", "a", props.getProperty("a"));
   assertEquals("3", "bb as,dn   ", props.getProperty("b"));
   assertEquals("4", ":: cu", props.getProperty("c\r \t\nu"));
   assertEquals("5", "bu", props.getProperty("bu"));
   assertEquals("6", "d\r\ne=e", props.getProperty("d"));
   assertEquals("7", "fff", props.getProperty("f"));
   assertEquals("8", "g", props.getProperty("g"));
   assertEquals("9", "", props.getProperty("h h"));
   assertEquals("10", "i=i", props.getProperty(" "));
   assertEquals("11", "   j", props.getProperty("j"));
   assertEquals("12", "   c", props.getProperty("space"));
   assertEquals("13", "\\", props.getProperty("dblbackslash"));
 }
Esempio n. 26
0
 @Override
 protected void setUp() {
   resources = Support_Resources.createTempFolder();
   resPath = resources.toString();
   if (resPath.charAt(0) == '/' || resPath.charAt(0) == '\\') resPath = resPath.substring(1);
 }
  /** java.util.jar.JarFile#getManifest() */
  public void test_getManifest() {
    // Test for method java.util.jar.Manifest
    // java.util.jar.JarFile.getManifest()
    try {
      Support_Resources.copyFile(resources, null, jarName);
      JarFile jarFile = new JarFile(new File(resources, jarName));
      assertNotNull("Error--Manifest not returned", jarFile.getManifest());
      jarFile.close();
    } catch (Exception e) {
      fail("Exception during 1st test: " + e.toString());
    }
    try {
      Support_Resources.copyFile(resources, null, jarName2);
      JarFile jarFile = new JarFile(new File(resources, jarName2));
      assertNull("Error--should have returned null", jarFile.getManifest());
      jarFile.close();
    } catch (Exception e) {
      fail("Exception during 2nd test: " + e.toString());
    }

    try {
      // jarName3 was created using the following test
      Support_Resources.copyFile(resources, null, jarName3);
      JarFile jarFile = new JarFile(new File(resources, jarName3));
      assertNotNull("Should find manifest without verifying", jarFile.getManifest());
      jarFile.close();
    } catch (Exception e) {
      fail("Exception during 3rd test: " + e.toString());
    }

    try {
      // this is used to create jarName3 used in the previous test
      Manifest manifest = new Manifest();
      Attributes attributes = manifest.getMainAttributes();
      attributes.put(new Attributes.Name("Manifest-Version"), "1.0");
      ByteArrayOutputStream manOut = new ByteArrayOutputStream();
      manifest.write(manOut);
      byte[] manBytes = manOut.toByteArray();
      File file = File.createTempFile("hyts_manifest1", ".jar");
      JarOutputStream jarOut = new JarOutputStream(new FileOutputStream(file.getAbsolutePath()));
      ZipEntry entry = new ZipEntry("META-INF/");
      entry.setSize(0);
      jarOut.putNextEntry(entry);
      entry = new ZipEntry(JarFile.MANIFEST_NAME);
      entry.setSize(manBytes.length);
      jarOut.putNextEntry(entry);
      jarOut.write(manBytes);
      entry = new ZipEntry("myfile");
      entry.setSize(1);
      jarOut.putNextEntry(entry);
      jarOut.write(65);
      jarOut.close();
      JarFile jar = new JarFile(file.getAbsolutePath(), false);
      assertNotNull("Should find manifest without verifying", jar.getManifest());
      jar.close();
      file.delete();
    } catch (IOException e) {
      fail("IOException 3");
    }
    try {
      Support_Resources.copyFile(resources, null, jarName2);
      JarFile jF = new JarFile(new File(resources, jarName2));
      jF.close();
      jF.getManifest();
      fail("FAILED: expected IllegalStateException");
    } catch (IllegalStateException ise) {
      // expected;
    } catch (Exception e) {
      fail("Exception during 4th test: " + e.toString());
    }

    Support_Resources.copyFile(resources, null, "Broken_manifest.jar");
    JarFile jf;
    try {
      jf = new JarFile(new File(resources, "Broken_manifest.jar"));
      jf.getManifest();
      fail("IOException expected.");
    } catch (IOException e) {
      // expected.
    }
  }
Esempio n. 28
0
  /**
   * tests Class-Path entry in manifest
   *
   * @throws Exception in case of troubles
   */
  public void test_zip_class_path() throws Exception {
    File fooZip = File.createTempFile("hyts_", ".zip");
    File barZip = File.createTempFile("hyts_", ".zip");
    fooZip.deleteOnExit();
    barZip.deleteOnExit();

    // create the manifest
    Manifest man = new Manifest();
    Attributes att = man.getMainAttributes();
    att.put(Attributes.Name.MANIFEST_VERSION, "1.0");
    att.put(Attributes.Name.MAIN_CLASS, "foo.bar.execjartest.Foo");
    att.put(Attributes.Name.CLASS_PATH, barZip.getName());

    File resources = Support_Resources.createTempFolder();

    ZipOutputStream zoutFoo = new ZipOutputStream(new FileOutputStream(fooZip));
    zoutFoo.putNextEntry(new ZipEntry("META-INF/MANIFEST.MF"));
    man.write(zoutFoo);
    zoutFoo.putNextEntry(new ZipEntry("foo/bar/execjartest/Foo.class"));
    zoutFoo.write(getResource(resources, "hyts_Foo.ser"));
    zoutFoo.close();

    ZipOutputStream zoutBar = new ZipOutputStream(new FileOutputStream(barZip));
    zoutBar.putNextEntry(new ZipEntry("foo/bar/execjartest/Bar.class"));
    zoutBar.write(getResource(resources, "hyts_Bar.ser"));
    zoutBar.close();

    String[] args = new String[] {"-jar", fooZip.getAbsolutePath()};

    // execute the JAR and read the result
    String res = Support_Exec.execJava(args, null, false);

    assertTrue("Error executing JAR : result returned was incorrect.", res.startsWith("FOOBAR"));

    // rewrite manifest so it contains not only reference to bar but useless entries as well
    att.put(Attributes.Name.CLASS_PATH, "xx yy zz " + barZip.getName());
    zoutFoo = new ZipOutputStream(new FileOutputStream(fooZip));
    zoutFoo.putNextEntry(new ZipEntry("META-INF/MANIFEST.MF"));
    man.write(zoutFoo);
    zoutFoo.putNextEntry(new ZipEntry("foo/bar/execjartest/Foo.class"));
    zoutFoo.write(getResource(resources, "hyts_Foo.ser"));
    zoutFoo.close();
    // execute the JAR and read the result
    res = Support_Exec.execJava(args, null, false);
    assertTrue("Error executing JAR : result returned was incorrect.", res.startsWith("FOOBAR"));

    // play with relative file names - put relative path as ../<parent dir name>/xx.zip
    att.put(
        Attributes.Name.CLASS_PATH,
        ".."
            + File.separator
            + barZip.getParentFile().getName()
            + File.separator
            + barZip.getName());
    zoutFoo = new ZipOutputStream(new FileOutputStream(fooZip));
    zoutFoo.putNextEntry(new ZipEntry("META-INF/MANIFEST.MF"));
    man.write(zoutFoo);
    zoutFoo.putNextEntry(new ZipEntry("foo/bar/execjartest/Foo.class"));
    zoutFoo.write(getResource(resources, "hyts_Foo.ser"));
    zoutFoo.close();
    // execute the ZIP and read the result
    res = Support_Exec.execJava(args, null, false);
    assertTrue("Error executing JAR : result returned was incorrect.", res.startsWith("FOOBAR"));
  }
  // This test doesn't pass on RI. If entry size is set up incorrectly,
  // SecurityException is thrown. But SecurityException is thrown on RI only
  // if jar file is signed incorrectly.
  public void test_getInputStreamLjava_util_jar_JarEntry_subtest0() throws Exception {
    File signedFile = null;
    try {
      Support_Resources.copyFile(resources, null, jarName4);
      signedFile = new File(resources, jarName4);
    } catch (Exception e) {
      fail("Failed to create local file 2: " + e);
    }

    try {
      JarFile jar = new JarFile(signedFile);
      JarEntry entry = new JarEntry(entryName3);
      InputStream in = jar.getInputStream(entry);
      in.read();
    } catch (Exception e) {
      fail("Exception during test 3: " + e);
    }

    try {
      JarFile jar = new JarFile(signedFile);
      JarEntry entry = new JarEntry(entryName3);
      InputStream in = jar.getInputStream(entry);
      // BEGIN android-added
      byte[] dummy = getAllBytesFromStream(in);
      // END android-added
      assertNull("found certificates", entry.getCertificates());
    } catch (Exception e) {
      fail("Exception during test 4: " + e);
    }

    try {
      JarFile jar = new JarFile(signedFile);
      JarEntry entry = new JarEntry(entryName3);
      entry.setSize(1076);
      InputStream in = jar.getInputStream(entry);
      // BEGIN android-added
      byte[] dummy = getAllBytesFromStream(in);
      // END android-added
      fail("SecurityException should be thrown.");
    } catch (SecurityException e) {
      // expected
    } catch (Exception e) {
      fail("Exception during test 5: " + e);
    }

    try {
      Support_Resources.copyFile(resources, null, jarName5);
      signedFile = new File(resources, jarName5);
    } catch (Exception e) {
      fail("Failed to create local file 5: " + e);
    }

    try {
      JarFile jar = new JarFile(signedFile);
      JarEntry entry = new JarEntry(entryName3);
      InputStream in = jar.getInputStream(entry);
      fail("SecurityException should be thrown.");
    } catch (SecurityException e) {
      // expected
    } catch (Exception e) {
      fail("Exception during test 5: " + e);
    }

    // SHA1 digest, SHA256withRSA signed JAR
    checkSignedJar(jarName6);

    // SHA-256 digest, SHA256withRSA signed JAR
    checkSignedJar(jarName7);

    // SHA-512 digest, SHA512withECDSA signed JAR
    checkSignedJar(jarName8);

    // JAR with a signature that has PKCS#7 Authenticated Attributes
    checkSignedJar(authAttrsJar);
  }
  /** @throws IOException java.util.jar.JarFile#getInputStream(java.util.zip.ZipEntry) */
  public void test_getInputStreamLjava_util_jar_JarEntry() throws IOException {
    File localFile = null;
    try {
      Support_Resources.copyFile(resources, null, jarName);
      localFile = new File(resources, jarName);
    } catch (Exception e) {
      fail("Failed to create local file: " + e);
    }

    byte[] b = new byte[1024];
    try {
      JarFile jf = new JarFile(localFile);
      java.io.InputStream is = jf.getInputStream(jf.getEntry(entryName));
      // BEGIN android-removed
      // jf.close();
      // END android-removed
      assertTrue("Returned invalid stream", is.available() > 0);
      int r = is.read(b, 0, 1024);
      is.close();
      StringBuffer sb = new StringBuffer(r);
      for (int i = 0; i < r; i++) {
        sb.append((char) (b[i] & 0xff));
      }
      String contents = sb.toString();
      assertTrue("Incorrect stream read", contents.indexOf("bar") > 0);
      // BEGIN android-added
      jf.close();
      // END android-added
    } catch (Exception e) {
      fail("Exception during test: " + e.toString());
    }

    try {
      JarFile jf = new JarFile(localFile);
      InputStream in = jf.getInputStream(new JarEntry("invalid"));
      assertNull("Got stream for non-existent entry", in);
    } catch (Exception e) {
      fail("Exception during test 2: " + e);
    }

    try {
      Support_Resources.copyFile(resources, null, jarName);
      File signedFile = new File(resources, jarName);
      JarFile jf = new JarFile(signedFile);
      JarEntry jre = new JarEntry("foo/bar/A.class");
      jf.getInputStream(jre);
      // InputStream returned in any way, exception can be thrown in case
      // of reading from this stream only.
      // fail("Should throw ZipException");
    } catch (ZipException ee) {
      // expected
    }

    try {
      Support_Resources.copyFile(resources, null, jarName);
      File signedFile = new File(resources, jarName);
      JarFile jf = new JarFile(signedFile);
      JarEntry jre = new JarEntry("foo/bar/A.class");
      jf.close();
      jf.getInputStream(jre);
      // InputStream returned in any way, exception can be thrown in case
      // of reading from this stream only.
      // The same for IOException
      fail("Should throw IllegalStateException");
    } catch (IllegalStateException ee) {
      // expected
    }
  }