nucleus/deployment/common/src/test/java/com/sun/enterprise/deploy/shared/FileArchiveTest.java - glassfish - Git at Google

 /*
  * Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
  * Copyright (c) 2021 Contributors to the Eclipse Foundation
  *
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v. 2.0, which is available at
  * http://www.eclipse.org/legal/epl-2.0.
  *
  * This Source Code may also be made available under the following Secondary
  * Licenses when the conditions for such availability set forth in the
  * Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
  * version 2 with the GNU Classpath Exception, which is available at
  * https://www.gnu.org/software/classpath/license.html.
  *
  * SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
  */

 package com.sun.enterprise.deploy.shared;

 import com.sun.enterprise.module.ModulesRegistry;
 import com.sun.enterprise.module.single.StaticModulesRegistry;

 import java.io.File;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Enumeration;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Set;
 import java.util.Vector;
 import java.util.logging.Handler;
 import java.util.logging.LogRecord;
 import java.util.logging.Logger;

 import org.glassfish.api.deployment.archive.ReadableArchive;
 import org.glassfish.api.deployment.archive.WritableArchive;
 import org.glassfish.hk2.api.ServiceLocator;
 import org.junit.jupiter.api.AfterAll;
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;

 import static org.glassfish.deployment.common.DeploymentContextImpl.deplLogger;
 import static org.hamcrest.MatcherAssert.assertThat;
 import static org.hamcrest.Matchers.emptyIterable;
 import static org.hamcrest.Matchers.not;
 import static org.junit.jupiter.api.Assertions.assertEquals;
 import static org.junit.jupiter.api.Assertions.assertNull;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assertions.fail;

 /**
  * @author Tim Quinn
  */
 public class FileArchiveTest {

     private static final String EXPECTED_LOG_KEY = "NCLS-DEPLOYMENT-00022";
     private static final String LINE_SEP = System.getProperty("line.separator");
     private static final String STALE_ENTRY = "oldLower/oldFile.txt";
     private static final String SUBARCHIVE_NAME = "subarch";

     private File archiveDir;
     private final Set<String> usualEntryNames =
             new HashSet<>(Arrays.asList(new String[] {"sample.txt", "lower/other.txt"}));

     private final Set<String> usualExpectedEntryNames = initUsualExpectedEntryNames();
     private final Set<String> usualExpectedEntryNamesWithOverwrittenStaleEntry =
             initUsualExpectedEntryNamesWithOverwrittenStaleEntry();

     private final Set<String> usualSubarchiveEntryNames =
             new HashSet<>(Arrays.asList(new String[] {"a.txt", "under/b.txt"}));

     private final Set<String> usualExpectedSubarchiveEntryNames = initUsualExpectedSubarchiveEntryNames();

     private static ServiceLocator locator;
     private static ModulesRegistry registry;
     private static ArchiveFactory archiveFactory;
     private static RecordingHandler handler;

     @BeforeAll
     public static void setUpClass() throws Exception {
         registry = new StaticModulesRegistry(FileArchiveTest.class.getClassLoader());
         locator = registry.createServiceLocator("default");
         archiveFactory = locator.getService(ArchiveFactory.class);
         handler = new RecordingHandler();
         deplLogger.addHandler(handler);
     }

     @BeforeEach
     public void setUp() throws IOException {
         archiveDir = tempDir();
     }

     @AfterEach
     public void tearDown() {
         if (archiveDir != null) {
             clean(archiveDir);
         }
         archiveDir = null;
     }

     @AfterAll
     public static void shutdownLocator() {
         if (locator != null) {
             locator.shutdown();
         }
         if (registry != null) {
             registry.shutdown();
         }
     }


     private Set<String> initUsualExpectedEntryNames() {
         final Set<String> expectedEntryNames = new HashSet<>(usualEntryNames);
         expectedEntryNames.add("lower");
         return expectedEntryNames;
     }

     private Set<String> initUsualExpectedEntryNamesWithOverwrittenStaleEntry() {
         final Set<String> result = initUsualExpectedEntryNames();
         result.add(STALE_ENTRY);
         result.add("oldLower");
         return result;
     }

     private  Set<String> initUsualExpectedSubarchiveEntryNames() {
         final Set<String> result = new HashSet<>(usualSubarchiveEntryNames);
         result.add("under");
         return result;
     }

     private File tempDir() throws IOException {
         final File f = File.createTempFile("FileArch", "");
         f.delete();
         f.mkdir();
         return f;
     }

     private void clean(final File dir) {
         for (File f : dir.listFiles()) {
             if (f.isDirectory()) {
                 clean(f);
             }
             if ( ! f.delete()) {
                 f.deleteOnExit();
             }
         }
         if ( ! dir.delete()) {
             dir.deleteOnExit();
         }
     }


     private ReadableArchive createAndPopulateArchive(final Set<String> entryNames) throws Exception {
         WritableArchive instance = archiveFactory.createArchive(archiveDir.toURI());
         instance.create(archiveDir.toURI());

         // Add some entries.
         for (String entryName : entryNames) {
             instance.putNextEntry(entryName);
             instance.closeEntry();
         }
         instance.close();
         return archiveFactory.openArchive(archiveDir);
     }

     private ReadableArchive createAndPopulateSubarchive(
             final WritableArchive parent,
             final String subarchiveName,
             final Set<String> entryNames) throws Exception {
         final WritableArchive result = parent.createSubArchive(subarchiveName);
         for (String entryName : entryNames) {
             result.putNextEntry(entryName);
             result.closeEntry();
         }
         result.close();

         final ReadableArchive readableParent = archiveFactory.openArchive(parent.getURI());
         return readableParent.getSubArchive(subarchiveName);
     }


     private void createAndPopulateAndCheckArchive(final Set<String> entryNames) throws Exception {
         final ReadableArchive instance = createAndPopulateArchive(entryNames);

         checkArchive(instance, usualExpectedEntryNames);

     }


     private void checkArchive(final ReadableArchive instance, final Set<String> expectedEntryNames) {
         final Set<String> foundEntryNames = new HashSet<>();
         for (Enumeration<String> e = instance.entries(); e.hasMoreElements();) {
             foundEntryNames.add(e.nextElement());
         }
         assertEquals(expectedEntryNames, foundEntryNames, "Missing or unexpected entry names reported");
     }


     private void getListOfFiles(final FileArchive instance, final Set<String> expectedEntryNames, final Logger logger) {
         final List<String> foundEntryNames = new ArrayList<>();
         instance.getListOfFiles(archiveDir, foundEntryNames, null, logger);
         assertEquals(expectedEntryNames, new HashSet<>(foundEntryNames), "Missing or unexpected entry names reported");
     }

     private void getListOfFilesCheckForLogRecord(FileArchive instance, final Set<String> expectedEntryNames) throws IOException {
         handler.flush();
         getListOfFiles(instance, expectedEntryNames, deplLogger);
         if (handler.logRecords().size() != 1) {
             final StringBuilder sb = new StringBuilder();
             for (LogRecord record : handler.logRecords()) {
                 sb.append(record.getLevel().getLocalizedName())
                         .append(": ")
                         .append(record.getMessage())
                         .append(LINE_SEP);
             }
             fail("Expected 1 log message but received " + handler.logRecords().size() + " as follows:" + LINE_SEP + sb);
         }

         // We have a stale file under a stale directory.  Make sure a direct
         // request for the stale file fails.  (We know already from above that
         // getting the entries list triggers a warning about the skipped stale file.)
         final InputStream is = instance.getEntry(STALE_ENTRY);
         assertNull(is, "Incorrectly located stale FileArchive entry " + STALE_ENTRY);
     }

     /**
      * Computes the expected entry names for an archive which contains a subarchive.
      * <p>
      * The archive's entries method will report all the entries in the main
      * archive, plus the subarchive name, plus the entries in the subarchive.
      * @param expectedFromArchive entries from the main archive
      * @param subarchiveName name of the subarchive
      * @param expectedFromSubarchive entries in the subarchive
      * @return entry names that should be returned from the main archive's entries() method
      */
     private Set<String> expectedEntryNames(Set<String> expectedFromArchive, final String subarchiveName, Set<String>expectedFromSubarchive) {
         final Set<String> result = new HashSet<>(expectedFromArchive);
         result.add(subarchiveName);
         for (String expectedSubarchEntryName : expectedFromSubarchive) {
             final StringBuilder path = new StringBuilder();
             path.append(subarchiveName).append("/");
             final String[] segments = expectedSubarchEntryName.split("/");
             for (int i = 0; i < segments.length; i++) {
                 path.append(segments[i]);
                 result.add(path.toString());
                 if (i < segments.length) {
                     path.append("/");
                 }
             }
         }
         return result;
     }

     @Test
     public void testSubarchive() throws Exception {
         final ArchiveAndSubarchive archives = createAndPopulateArchiveAndSubarchive();
         checkArchive(archives.parent, archives.fullExpectedEntryNames);
         checkArchive(archives.subarchive, usualExpectedSubarchiveEntryNames);
     }

     @Test
     public void testSubArchiveCreateWithStaleEntry() throws Exception {
         // Subarchives are a little tricky.  The marker file lives only at
         // the top level (because that's where undeployment puts it).  So
         // when a subarchive tests to see if an entry is valid it needs to
         // consult the marker file (if any) in the top-level owning archive.
         //
         // This test creates a directory structure containing a stale file
         // in a lower-level directory, creates the top-level marker file
         // as undeployment would, then creates an archive for the top level
         // and a subarchive for the lower-level directory (as the next
         // deployment would).  The archive and subarchive need to skip the
         // stale file.

         //  Create a file in the directory before creating the archive.
         final File oldDir = new File(archiveDir, SUBARCHIVE_NAME);
         final File oldFile = new File(oldDir, STALE_ENTRY);
         oldFile.getParentFile().mkdirs();
         oldFile.createNewFile();

         //  Mimic what undeployment does by creating a marker file for the
         //  archive recording the pre-existing file.
         FileArchive.StaleFileManager.Util.markDeletedArchive(archiveDir);

         //  Now create the archive and subarchive on top of the directories
         //  which already exist and contain the stale file and directory.
         final ArchiveAndSubarchive archives = createAndPopulateArchiveAndSubarchive();

         checkArchive(archives.parent, archives.fullExpectedEntryNames);
         checkArchive(archives.subarchive, usualExpectedSubarchiveEntryNames);

         getListOfFilesCheckForLogRecord((FileArchive) archives.parent, archives.fullExpectedEntryNames);

     }

     private static class ArchiveAndSubarchive {
         ReadableArchive parent;
         ReadableArchive subarchive;
         Set<String> fullExpectedEntryNames;
     }

     private ArchiveAndSubarchive createAndPopulateArchiveAndSubarchive() throws Exception {
         final ArchiveAndSubarchive result = new ArchiveAndSubarchive();
         result.parent = createAndPopulateArchive(usualEntryNames);
         result.subarchive = createAndPopulateSubarchive(
                 (FileArchive) result.parent,
                 SUBARCHIVE_NAME,
                 usualSubarchiveEntryNames);
         result.fullExpectedEntryNames = expectedEntryNames(
                 usualExpectedEntryNames, SUBARCHIVE_NAME, usualSubarchiveEntryNames);

         return result;
     }

     /**
      * Test of open method, of class FileArchive.
      */
     @Test
     public void testNormalCreate() throws Exception {
         createAndPopulateAndCheckArchive(usualEntryNames);
     }

     @Test
     public void testCreateWithOlderLeftoverEntry() throws Exception {
         final ReadableArchive instance = createWithOlderLeftoverEntry(usualEntryNames);
         getListOfFilesCheckForLogRecord((FileArchive) instance, usualExpectedEntryNames);
     }

     @Test
     public void testCreateWithOlderLeftoverEntryWhichIsCreatedAgain() throws Exception {
         final FileArchive instance = (FileArchive) createWithOlderLeftoverEntry(usualEntryNames);
         // Now add the stale entry explicitly which should make it valid.
         try (OutputStream os = instance.putNextEntry(STALE_ENTRY)) {
             os.write("No longer stale!".getBytes());
         }
         checkArchive(instance, usualExpectedEntryNamesWithOverwrittenStaleEntry);
     }

     private ReadableArchive createWithOlderLeftoverEntry(final Set<String> entryNames) throws Exception {
         // Create a file in the directory before creating the archive.
         final File oldFile = new File(archiveDir, STALE_ENTRY);
         oldFile.getParentFile().mkdirs();
         oldFile.createNewFile();

         // Mimic what undeployment does by creating a marker file for the
         // archive recording the pre-existing file.
         FileArchive.StaleFileManager.Util.markDeletedArchive(archiveDir);

         // Now create the archive.  The archive should not see the old file.
         return createAndPopulateArchive(entryNames);
     }

     @Test
     public void testCreateWithOlderLeftoverEntryAndThenOpen() throws Exception {
         createWithOlderLeftoverEntry(usualEntryNames);
         final FileArchive openedArchive = new FileArchive();
         openedArchive.open(archiveDir.toURI());
         System.err.println("A WARNING should appear next");
         checkArchive(openedArchive, usualExpectedEntryNames);
     }

     @Test
     public void testOpenWithPreexistingDir() throws Exception {
         createPreexistingDir();
         final FileArchive openedArchive = new FileArchive();
         openedArchive.open(archiveDir.toURI());
         checkArchive(openedArchive, usualExpectedEntryNames);
     }

     private void createPreexistingDir() throws IOException {
          for (String entryName : usualEntryNames) {
              final File f = fileForPath(archiveDir, entryName);
              final File parentDir = f.getParentFile();
              if(parentDir != null) {
                  parentDir.mkdirs();
              }
              try {
                  f.createNewFile();
              } catch (Exception ex) {
                  throw new IOException(f.getAbsolutePath(), ex);
              }
          }
      }

     private File fileForPath(File anchor, final String path) {
          final String[] interveningDirNames = path.split("/");
          File interveningDir = anchor;
          for (int i = 0; i < interveningDirNames.length - 1; i++) {
              String name = interveningDirNames[i];
              interveningDir = new File(interveningDir, name + "/");
          }
          return new File(interveningDir,interveningDirNames[interveningDirNames.length - 1]);
      }

     @Test
     public void testInaccessibleDirectoryInFileArchive() throws Exception {
         final FileArchive archive = (FileArchive) createAndPopulateArchive(usualEntryNames);

         // Now make the lower-level directory impossible to execute - therefore
         // the attempt to list the files should fail.
         final File lower = new File(archiveDir, "lower");
         lower.setExecutable(false, false);
         assertTrue(lower.setReadable(false, false));

         // Try to list the files.  This should fail with our logger getting one record.
         final Vector<String> fileList = new Vector<>();
         handler.flush();
         archive.getListOfFiles(lower, fileList, null /* embeddedArchives */, deplLogger);

         List<LogRecord> logRecords = handler.logRecords();
         assertThat("FileArchive logged no message about being unable to list files; expected " + EXPECTED_LOG_KEY,
             logRecords, not(emptyIterable()));
         assertEquals(EXPECTED_LOG_KEY, logRecords.get(0).getMessage(),
             "FileArchive did not log expected message (re: being unable to list files)");
         // Change the protection back.
         lower.setExecutable(true, false);
         lower.setReadable(true, false);
         handler.flush();

         archive.getListOfFiles(lower, fileList, null, deplLogger);
         assertTrue(logRecords.isEmpty(),
             "FileArchive was incorrectly unable to list files; error key in log record:" + logRecords);
     }

     private static class RecordingHandler extends Handler {
         private final List<LogRecord> records = new ArrayList<>();

         @Override
         public void close() {
             records.clear();
         }

         @Override
         public void flush() {
             records.clear();
         }

         @Override
         public void publish(LogRecord record) {
             records.add(record);
         }

         List<LogRecord> logRecords() {
             return records;
         }
     }
 }
	/*
	* Copyright (c) 2010, 2018 Oracle and/or its affiliates. All rights reserved.
	* Copyright (c) 2021 Contributors to the Eclipse Foundation
	*
	* This program and the accompanying materials are made available under the
	* terms of the Eclipse Public License v. 2.0, which is available at
	* http://www.eclipse.org/legal/epl-2.0.
	*
	* This Source Code may also be made available under the following Secondary
	* Licenses when the conditions for such availability set forth in the
	* Eclipse Public License v. 2.0 are satisfied: GNU General Public License,
	* version 2 with the GNU Classpath Exception, which is available at
	* https://www.gnu.org/software/classpath/license.html.
	*
	* SPDX-License-Identifier: EPL-2.0 OR GPL-2.0 WITH Classpath-exception-2.0
	*/

	package com.sun.enterprise.deploy.shared;

	import com.sun.enterprise.module.ModulesRegistry;
	import com.sun.enterprise.module.single.StaticModulesRegistry;

	import java.io.File;
	import java.io.IOException;
	import java.io.InputStream;
	import java.io.OutputStream;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.Enumeration;
	import java.util.HashSet;
	import java.util.List;
	import java.util.Set;
	import java.util.Vector;
	import java.util.logging.Handler;
	import java.util.logging.LogRecord;
	import java.util.logging.Logger;

	import org.glassfish.api.deployment.archive.ReadableArchive;
	import org.glassfish.api.deployment.archive.WritableArchive;
	import org.glassfish.hk2.api.ServiceLocator;
	import org.junit.jupiter.api.AfterAll;
	import org.junit.jupiter.api.AfterEach;
	import org.junit.jupiter.api.BeforeAll;
	import org.junit.jupiter.api.BeforeEach;
	import org.junit.jupiter.api.Test;

	import static org.glassfish.deployment.common.DeploymentContextImpl.deplLogger;
	import static org.hamcrest.MatcherAssert.assertThat;
	import static org.hamcrest.Matchers.emptyIterable;
	import static org.hamcrest.Matchers.not;
	import static org.junit.jupiter.api.Assertions.assertEquals;
	import static org.junit.jupiter.api.Assertions.assertNull;
	import static org.junit.jupiter.api.Assertions.assertTrue;
	import static org.junit.jupiter.api.Assertions.fail;

	/**
	* @author Tim Quinn
	*/
	public class FileArchiveTest {

	private static final String EXPECTED_LOG_KEY = "NCLS-DEPLOYMENT-00022";
	private static final String LINE_SEP = System.getProperty("line.separator");
	private static final String STALE_ENTRY = "oldLower/oldFile.txt";
	private static final String SUBARCHIVE_NAME = "subarch";

	private File archiveDir;
	private final Set<String> usualEntryNames =
	new HashSet<>(Arrays.asList(new String[] {"sample.txt", "lower/other.txt"}));

	private final Set<String> usualExpectedEntryNames = initUsualExpectedEntryNames();
	private final Set<String> usualExpectedEntryNamesWithOverwrittenStaleEntry =
	initUsualExpectedEntryNamesWithOverwrittenStaleEntry();

	private final Set<String> usualSubarchiveEntryNames =
	new HashSet<>(Arrays.asList(new String[] {"a.txt", "under/b.txt"}));

	private final Set<String> usualExpectedSubarchiveEntryNames = initUsualExpectedSubarchiveEntryNames();

	private static ServiceLocator locator;
	private static ModulesRegistry registry;
	private static ArchiveFactory archiveFactory;
	private static RecordingHandler handler;

	@BeforeAll
	public static void setUpClass() throws Exception {
	registry = new StaticModulesRegistry(FileArchiveTest.class.getClassLoader());
	locator = registry.createServiceLocator("default");
	archiveFactory = locator.getService(ArchiveFactory.class);
	handler = new RecordingHandler();
	deplLogger.addHandler(handler);
	}

	@BeforeEach
	public void setUp() throws IOException {
	archiveDir = tempDir();
	}

	@AfterEach
	public void tearDown() {
	if (archiveDir != null) {
	clean(archiveDir);
	}
	archiveDir = null;
	}

	@AfterAll
	public static void shutdownLocator() {
	if (locator != null) {
	locator.shutdown();
	}
	if (registry != null) {
	registry.shutdown();
	}
	}


	private Set<String> initUsualExpectedEntryNames() {
	final Set<String> expectedEntryNames = new HashSet<>(usualEntryNames);
	expectedEntryNames.add("lower");
	return expectedEntryNames;
	}

	private Set<String> initUsualExpectedEntryNamesWithOverwrittenStaleEntry() {
	final Set<String> result = initUsualExpectedEntryNames();
	result.add(STALE_ENTRY);
	result.add("oldLower");
	return result;
	}

	private Set<String> initUsualExpectedSubarchiveEntryNames() {
	final Set<String> result = new HashSet<>(usualSubarchiveEntryNames);
	result.add("under");
	return result;
	}

	private File tempDir() throws IOException {
	final File f = File.createTempFile("FileArch", "");
	f.delete();
	f.mkdir();
	return f;
	}

	private void clean(final File dir) {
	for (File f : dir.listFiles()) {
	if (f.isDirectory()) {
	clean(f);
	}
	if ( ! f.delete()) {
	f.deleteOnExit();
	}
	}
	if ( ! dir.delete()) {
	dir.deleteOnExit();
	}
	}


	private ReadableArchive createAndPopulateArchive(final Set<String> entryNames) throws Exception {
	WritableArchive instance = archiveFactory.createArchive(archiveDir.toURI());
	instance.create(archiveDir.toURI());

	// Add some entries.
	for (String entryName : entryNames) {
	instance.putNextEntry(entryName);
	instance.closeEntry();
	}
	instance.close();
	return archiveFactory.openArchive(archiveDir);
	}

	private ReadableArchive createAndPopulateSubarchive(
	final WritableArchive parent,
	final String subarchiveName,
	final Set<String> entryNames) throws Exception {
	final WritableArchive result = parent.createSubArchive(subarchiveName);
	for (String entryName : entryNames) {
	result.putNextEntry(entryName);
	result.closeEntry();
	}
	result.close();

	final ReadableArchive readableParent = archiveFactory.openArchive(parent.getURI());
	return readableParent.getSubArchive(subarchiveName);
	}


	private void createAndPopulateAndCheckArchive(final Set<String> entryNames) throws Exception {
	final ReadableArchive instance = createAndPopulateArchive(entryNames);

	checkArchive(instance, usualExpectedEntryNames);

	}


	private void checkArchive(final ReadableArchive instance, final Set<String> expectedEntryNames) {
	final Set<String> foundEntryNames = new HashSet<>();
	for (Enumeration<String> e = instance.entries(); e.hasMoreElements();) {
	foundEntryNames.add(e.nextElement());
	}
	assertEquals(expectedEntryNames, foundEntryNames, "Missing or unexpected entry names reported");
	}


	private void getListOfFiles(final FileArchive instance, final Set<String> expectedEntryNames, final Logger logger) {
	final List<String> foundEntryNames = new ArrayList<>();
	instance.getListOfFiles(archiveDir, foundEntryNames, null, logger);
	assertEquals(expectedEntryNames, new HashSet<>(foundEntryNames), "Missing or unexpected entry names reported");
	}

	private void getListOfFilesCheckForLogRecord(FileArchive instance, final Set<String> expectedEntryNames) throws IOException {
	handler.flush();
	getListOfFiles(instance, expectedEntryNames, deplLogger);
	if (handler.logRecords().size() != 1) {
	final StringBuilder sb = new StringBuilder();
	for (LogRecord record : handler.logRecords()) {
	sb.append(record.getLevel().getLocalizedName())
	.append(": ")
	.append(record.getMessage())
	.append(LINE_SEP);
	}
	fail("Expected 1 log message but received " + handler.logRecords().size() + " as follows:" + LINE_SEP + sb);
	}

	// We have a stale file under a stale directory. Make sure a direct
	// request for the stale file fails. (We know already from above that
	// getting the entries list triggers a warning about the skipped stale file.)
	final InputStream is = instance.getEntry(STALE_ENTRY);
	assertNull(is, "Incorrectly located stale FileArchive entry " + STALE_ENTRY);
	}

	/**
	* Computes the expected entry names for an archive which contains a subarchive.
	* <p>
	* The archive's entries method will report all the entries in the main
	* archive, plus the subarchive name, plus the entries in the subarchive.
	* @param expectedFromArchive entries from the main archive
	* @param subarchiveName name of the subarchive
	* @param expectedFromSubarchive entries in the subarchive
	* @return entry names that should be returned from the main archive's entries() method
	*/
	private Set<String> expectedEntryNames(Set<String> expectedFromArchive, final String subarchiveName, Set<String>expectedFromSubarchive) {
	final Set<String> result = new HashSet<>(expectedFromArchive);
	result.add(subarchiveName);
	for (String expectedSubarchEntryName : expectedFromSubarchive) {
	final StringBuilder path = new StringBuilder();
	path.append(subarchiveName).append("/");
	final String[] segments = expectedSubarchEntryName.split("/");
	for (int i = 0; i < segments.length; i++) {
	path.append(segments[i]);
	result.add(path.toString());
	if (i < segments.length) {
	path.append("/");
	}
	}
	}
	return result;
	}

	@Test
	public void testSubarchive() throws Exception {
	final ArchiveAndSubarchive archives = createAndPopulateArchiveAndSubarchive();
	checkArchive(archives.parent, archives.fullExpectedEntryNames);
	checkArchive(archives.subarchive, usualExpectedSubarchiveEntryNames);
	}

	@Test
	public void testSubArchiveCreateWithStaleEntry() throws Exception {
	// Subarchives are a little tricky. The marker file lives only at
	// the top level (because that's where undeployment puts it). So
	// when a subarchive tests to see if an entry is valid it needs to
	// consult the marker file (if any) in the top-level owning archive.
	//
	// This test creates a directory structure containing a stale file
	// in a lower-level directory, creates the top-level marker file
	// as undeployment would, then creates an archive for the top level
	// and a subarchive for the lower-level directory (as the next
	// deployment would). The archive and subarchive need to skip the
	// stale file.

	// Create a file in the directory before creating the archive.
	final File oldDir = new File(archiveDir, SUBARCHIVE_NAME);
	final File oldFile = new File(oldDir, STALE_ENTRY);
	oldFile.getParentFile().mkdirs();
	oldFile.createNewFile();

	// Mimic what undeployment does by creating a marker file for the
	// archive recording the pre-existing file.
	FileArchive.StaleFileManager.Util.markDeletedArchive(archiveDir);

	// Now create the archive and subarchive on top of the directories
	// which already exist and contain the stale file and directory.
	final ArchiveAndSubarchive archives = createAndPopulateArchiveAndSubarchive();

	checkArchive(archives.parent, archives.fullExpectedEntryNames);
	checkArchive(archives.subarchive, usualExpectedSubarchiveEntryNames);

	getListOfFilesCheckForLogRecord((FileArchive) archives.parent, archives.fullExpectedEntryNames);

	}

	private static class ArchiveAndSubarchive {
	ReadableArchive parent;
	ReadableArchive subarchive;
	Set<String> fullExpectedEntryNames;
	}

	private ArchiveAndSubarchive createAndPopulateArchiveAndSubarchive() throws Exception {
	final ArchiveAndSubarchive result = new ArchiveAndSubarchive();
	result.parent = createAndPopulateArchive(usualEntryNames);
	result.subarchive = createAndPopulateSubarchive(
	(FileArchive) result.parent,
	SUBARCHIVE_NAME,
	usualSubarchiveEntryNames);
	result.fullExpectedEntryNames = expectedEntryNames(
	usualExpectedEntryNames, SUBARCHIVE_NAME, usualSubarchiveEntryNames);

	return result;
	}

	/**
	* Test of open method, of class FileArchive.
	*/
	@Test
	public void testNormalCreate() throws Exception {
	createAndPopulateAndCheckArchive(usualEntryNames);
	}

	@Test
	public void testCreateWithOlderLeftoverEntry() throws Exception {
	final ReadableArchive instance = createWithOlderLeftoverEntry(usualEntryNames);
	getListOfFilesCheckForLogRecord((FileArchive) instance, usualExpectedEntryNames);
	}

	@Test
	public void testCreateWithOlderLeftoverEntryWhichIsCreatedAgain() throws Exception {
	final FileArchive instance = (FileArchive) createWithOlderLeftoverEntry(usualEntryNames);
	// Now add the stale entry explicitly which should make it valid.
	try (OutputStream os = instance.putNextEntry(STALE_ENTRY)) {
	os.write("No longer stale!".getBytes());
	}
	checkArchive(instance, usualExpectedEntryNamesWithOverwrittenStaleEntry);
	}

	private ReadableArchive createWithOlderLeftoverEntry(final Set<String> entryNames) throws Exception {
	// Create a file in the directory before creating the archive.
	final File oldFile = new File(archiveDir, STALE_ENTRY);
	oldFile.getParentFile().mkdirs();
	oldFile.createNewFile();

	// Mimic what undeployment does by creating a marker file for the
	// archive recording the pre-existing file.
	FileArchive.StaleFileManager.Util.markDeletedArchive(archiveDir);

	// Now create the archive. The archive should not see the old file.
	return createAndPopulateArchive(entryNames);
	}

	@Test
	public void testCreateWithOlderLeftoverEntryAndThenOpen() throws Exception {
	createWithOlderLeftoverEntry(usualEntryNames);
	final FileArchive openedArchive = new FileArchive();
	openedArchive.open(archiveDir.toURI());
	System.err.println("A WARNING should appear next");
	checkArchive(openedArchive, usualExpectedEntryNames);
	}

	@Test
	public void testOpenWithPreexistingDir() throws Exception {
	createPreexistingDir();
	final FileArchive openedArchive = new FileArchive();
	openedArchive.open(archiveDir.toURI());
	checkArchive(openedArchive, usualExpectedEntryNames);
	}

	private void createPreexistingDir() throws IOException {
	for (String entryName : usualEntryNames) {
	final File f = fileForPath(archiveDir, entryName);
	final File parentDir = f.getParentFile();
	if(parentDir != null) {
	parentDir.mkdirs();
	}
	try {
	f.createNewFile();
	} catch (Exception ex) {
	throw new IOException(f.getAbsolutePath(), ex);
	}
	}
	}

	private File fileForPath(File anchor, final String path) {
	final String[] interveningDirNames = path.split("/");
	File interveningDir = anchor;
	for (int i = 0; i < interveningDirNames.length - 1; i++) {
	String name = interveningDirNames[i];
	interveningDir = new File(interveningDir, name + "/");
	}
	return new File(interveningDir,interveningDirNames[interveningDirNames.length - 1]);
	}

	@Test
	public void testInaccessibleDirectoryInFileArchive() throws Exception {
	final FileArchive archive = (FileArchive) createAndPopulateArchive(usualEntryNames);

	// Now make the lower-level directory impossible to execute - therefore
	// the attempt to list the files should fail.
	final File lower = new File(archiveDir, "lower");
	lower.setExecutable(false, false);
	assertTrue(lower.setReadable(false, false));

	// Try to list the files. This should fail with our logger getting one record.
	final Vector<String> fileList = new Vector<>();
	handler.flush();
	archive.getListOfFiles(lower, fileList, null /* embeddedArchives */, deplLogger);

	List<LogRecord> logRecords = handler.logRecords();
	assertThat("FileArchive logged no message about being unable to list files; expected " + EXPECTED_LOG_KEY,
	logRecords, not(emptyIterable()));
	assertEquals(EXPECTED_LOG_KEY, logRecords.get(0).getMessage(),
	"FileArchive did not log expected message (re: being unable to list files)");
	// Change the protection back.
	lower.setExecutable(true, false);
	lower.setReadable(true, false);
	handler.flush();

	archive.getListOfFiles(lower, fileList, null, deplLogger);
	assertTrue(logRecords.isEmpty(),
	"FileArchive was incorrectly unable to list files; error key in log record:" + logRecords);
	}

	private static class RecordingHandler extends Handler {
	private final List<LogRecord> records = new ArrayList<>();

	@Override
	public void close() {
	records.clear();
	}

	@Override
	public void flush() {
	records.clear();
	}

	@Override
	public void publish(LogRecord record) {
	records.add(record);
	}

	List<LogRecord> logRecords() {
	return records;
	}
	}
	}