/*
    * Licensed to the Apache Software Foundation (ASF) under one
    * or more contributor license agreements.  See the NOTICE file
    * distributed with this work for additional information
    * regarding copyright ownership.  The ASF licenses this file
    * to you 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 org.apache.commons.compress.changes;
  
  import java.io.BufferedInputStream;
  import java.io.BufferedReader;
  import java.io.File;
  import java.io.FileInputStream;
  import java.io.FileOutputStream;
  import java.io.FileReader;
  import java.io.InputStream;
  import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.List;
  
  import org.apache.commons.compress.AbstractTestCase;
  import org.apache.commons.compress.archivers.ArchiveEntry;
  import org.apache.commons.compress.archivers.ArchiveInputStream;
  import org.apache.commons.compress.archivers.ArchiveOutputStream;
  import org.apache.commons.compress.archivers.ar.ArArchiveEntry;
  import org.apache.commons.compress.archivers.cpio.CpioArchiveEntry;
  import org.apache.commons.compress.archivers.jar.JarArchiveEntry;
  import org.apache.commons.compress.archivers.tar.TarArchiveEntry;
  import org.apache.commons.compress.archivers.zip.ZipArchiveEntry;
  import org.apache.commons.compress.archivers.zip.ZipFile;
  
  /**
   * Checks several ChangeSet business logics.
   */
  public final class ChangeSetTestCase extends AbstractTestCase {
  
      // Delete a directory tree
      private void archiveListDeleteDir(String prefix){
          Iterator<String> it = archiveList.iterator();
          while(it.hasNext()){
              String entry = it.next();
              if (entry.startsWith(prefix+"/")){ // TODO won't work with folders
                  it.remove();
              }
          }
      }
  
      // Delete a single file
      private void archiveListDelete(String prefix){
          Iterator<String> it = archiveList.iterator();
          while(it.hasNext()){
              String entry = it.next();
              if (entry.equals(prefix)){
                  it.remove();
              }
          }
      }
  
      /**
       * Adds an ArchiveEntry with the same name two times.
       * Only the latest addition should be found in the ChangeSet,
       * the first add should be replaced.
       * 
       * @throws Exception
       */
      public void testAddChangeTwice() throws Exception {
          InputStream in = null;
          InputStream in2 = null;
          try {
              in = new FileInputStream(getFile("test.txt"));
              in2 = new FileInputStream(getFile("test2.xml"));
  
              ArchiveEntry e = new ZipArchiveEntry("test.txt");
              ArchiveEntry e2 = new ZipArchiveEntry("test.txt");
  
              ChangeSet changes = new ChangeSet();
              changes.add(e, in);
              changes.add(e2, in2);
  
              assertEquals(1, changes.getChanges().size());
              Change c = changes.getChanges().iterator().next();
              assertEquals(in2, c.getInput());
          } finally {
              if (in != null) {
                  in.close();
              }
              if (in2 != null) {
                  in2.close();
             }
         }
     }
 
     /**
      * Adds an ArchiveEntry with the same name two times.
      * Only the first addition should be found in the ChangeSet,
      * the second add should never be added since replace = false
      * 
      * @throws Exception
      */
     public void testAddChangeTwiceWithoutReplace() throws Exception {
         InputStream in = null;
         InputStream in2 = null;
         try {
             in = new FileInputStream(getFile("test.txt"));
             in2 = new FileInputStream(getFile("test2.xml"));
 
             ArchiveEntry e = new ZipArchiveEntry("test.txt");
             ArchiveEntry e2 = new ZipArchiveEntry("test.txt");
 
             ChangeSet changes = new ChangeSet();
             changes.add(e, in, true);
             changes.add(e2, in2, false);
 
             assertEquals(1, changes.getChanges().size());
             Change c = changes.getChanges().iterator().next();
             assertEquals(in, c.getInput());
         } finally {
             if (in != null) {
                 in.close();
             }
             if (in2 != null) {
                 in2.close();
             }
         }
     }
 
     /**
      * Tries to delete the folder "bla" from an archive file. This should result in
      * the deletion of bla/*, which actually means bla/test4.xml should be
      * removed from the archive. The file something/bla (without ending, named
      * like the folder) should not be deleted.
      * 
      * @throws Exception
      */
     public void testDeleteDir() throws Exception {
         final String archivename = "cpio";
         File input = this.createArchive(archivename);
 
         ArchiveOutputStream out = null;
         ArchiveInputStream ais = null;
         File result = File.createTempFile("test", "."+archivename);
         result.deleteOnExit();
         try {
 
             final InputStream is = new FileInputStream(input);
             ais = factory.createArchiveInputStream(archivename, is);
 
             out = factory.createArchiveOutputStream(archivename,
                     new FileOutputStream(result));
 
             ChangeSet changes = new ChangeSet();
             changes.deleteDir("bla");
             archiveListDeleteDir("bla");
             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
             performer.perform(ais, out);
             is.close();
 
         } finally {
             if (out != null) {
                 out.close();
             }
             if (ais != null) {
                 ais.close();
             }
         }
 
         this.checkArchiveContent(result, archiveList);
     }
 
     /**
      * Tries to delete the folder "la" from an archive file. This should result in
      * the deletion of la/*, which should not match any files/folders.
      * 
      * @throws Exception
      */
     public void testDeleteDir2() throws Exception {
         final String archivename = "cpio";
         File input = this.createArchive(archivename);
 
         ArchiveOutputStream out = null;
         ArchiveInputStream ais = null;
         File result = File.createTempFile("test", "."+archivename);
         result.deleteOnExit();
         try {
 
             final InputStream is = new FileInputStream(input);
             ais = factory.createArchiveInputStream(archivename, is);
 
             out = factory.createArchiveOutputStream(archivename,
                     new FileOutputStream(result));
 
             ChangeSet changes = new ChangeSet();
             changes.deleteDir("la");
             archiveListDeleteDir("la");
             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
             performer.perform(ais, out);
             is.close();
 
         } finally {
             if (out != null) {
                 out.close();
             }
             if (ais != null) {
                 ais.close();
             }
         }
 
         this.checkArchiveContent(result, archiveList);
     }
 
     /**
      * Tries to delete the folder "test.txt" from an archive file.
      * This should not match any files/folders.
      * 
      * @throws Exception
      */
     public void testDeleteDir3() throws Exception {
         final String archivename = "cpio";
         File input = this.createArchive(archivename);
 
         ArchiveOutputStream out = null;
         ArchiveInputStream ais = null;
         File result = File.createTempFile("test", "."+archivename);
         result.deleteOnExit();
         try {
 
             final InputStream is = new FileInputStream(input);
             ais = factory.createArchiveInputStream(archivename, is);
 
             out = factory.createArchiveOutputStream(archivename,
                     new FileOutputStream(result));
 
             ChangeSet changes = new ChangeSet();
             changes.deleteDir("test.txt");
             archiveListDeleteDir("test.txt");
             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
             performer.perform(ais, out);
             is.close();
 
         } finally {
             if (out != null) {
                 out.close();
             }
             if (ais != null) {
                 ais.close();
             }
         }
 
         this.checkArchiveContent(result, archiveList);
     }
 
     /**
      * Tries to delete the file "bla/test5.xml" from an archive. This should
      * result in the deletion of "bla/test5.xml".
      * 
      * @throws Exception
      */
     public void testDeleteFile() throws Exception {
         final String archivename = "cpio";
         File input = this.createArchive(archivename);
 
         ArchiveOutputStream out = null;
         ArchiveInputStream ais = null;
         File result = File.createTempFile("test", "."+archivename);
         result.deleteOnExit();
         try {
 
             final InputStream is = new FileInputStream(input);
             ais = factory.createArchiveInputStream(archivename, is);
 
             out = factory.createArchiveOutputStream(archivename,
                     new FileOutputStream(result));
 
             ChangeSet changes = new ChangeSet();
             changes.delete("bla/test5.xml");
             archiveListDelete("bla/test5.xml");
 
             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
             performer.perform(ais, out);
             is.close();
 
         } finally {
             if (out != null) {
                 out.close();
             }
             if (ais != null) {
                 ais.close();
             }
         }
 
         this.checkArchiveContent(result, archiveList);
     }
 
     /**
      * Tries to delete the file "bla" from an archive. This should
      * result in the deletion of nothing.
      * 
      * @throws Exception
      */
     public void testDeleteFile2() throws Exception {
         final String archivename = "cpio";
         File input = this.createArchive(archivename);
 
         ArchiveOutputStream out = null;
         ArchiveInputStream ais = null;
         File result = File.createTempFile("test", "."+archivename);
         result.deleteOnExit();
         try {
 
             final InputStream is = new FileInputStream(input);
             ais = factory.createArchiveInputStream(archivename, is);
 
             out = factory.createArchiveOutputStream(archivename,
                     new FileOutputStream(result));
 
             ChangeSet changes = new ChangeSet();
             changes.delete("bla");
             //archiveListDelete("bla");
 
             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
             performer.perform(ais, out);
             is.close();
 
         } finally {
             if (out != null) {
                 out.close();
             }
             if (ais != null) {
                 ais.close();
             }
         }
 
         this.checkArchiveContent(result, archiveList);
     }
 
     /**
      * Tries to delete and then add a file with the same name.
      * Should delete test/test3.xml and adds test.txt with the name
      * test/test3.xml
      * 
      * @throws Exception
      */
     public void testDeletePlusAddSame() throws Exception {
         final String archivename = "zip";
         File input = this.createArchive(archivename);
 
         ArchiveOutputStream out = null;
         ArchiveInputStream ais = null;
         File result = File.createTempFile("test", "."+archivename);
         result.deleteOnExit();
 
         File testtxt = null;
         try {
 
             final InputStream is = new FileInputStream(input);
             ais = factory.createArchiveInputStream(archivename, is);
             out = factory.createArchiveOutputStream(archivename,
                     new FileOutputStream(result));
 
             ChangeSet changes = new ChangeSet();
             changes.delete("test/test3.xml");
             archiveListDelete("test/test3.xml");
 
             // Add a file
             testtxt = getFile("test.txt");
             ArchiveEntry entry = out.createArchiveEntry(testtxt, "test/test3.xml");
             changes.add(entry, new FileInputStream(testtxt));
             archiveList.add("test/test3.xml");
 
             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
             performer.perform(ais, out);
             is.close();
 
         } finally {
             if (out != null) {
                 out.close();
             }
             if (ais != null) {
                 ais.close();
             }
         }
 
         // Checks
         ArchiveInputStream in = null;
         File check = null;
         try {
             final InputStream is = new FileInputStream(result);
             final BufferedInputStream buf = new BufferedInputStream(is);
             in = factory.createArchiveInputStream(buf);
             check = this.checkArchiveContent(in, archiveList, false);
             File test3xml = new File(check,"result/test/test3.xml");
             assertEquals(testtxt.length(), test3xml.length());
 
             BufferedReader reader = new BufferedReader(new FileReader(test3xml));
             String str;
             while ((str = reader.readLine()) != null) {
                 // All lines look like this
                 "111111111111111111111111111000101011".equals(str);
             }
             reader.close();
         } finally {
             if (in != null) {
                 in.close();
             }
             rmdir(check);
         } 
     }
 
     /**
      * Checks for the correct ChangeSetResults
      * 
      * @throws Exception
      */
     public void testChangeSetResults() throws Exception {
         final String archivename = "cpio";
         File input = this.createArchive(archivename);
 
         ArchiveOutputStream out = null;
         ArchiveInputStream ais = null;
         File result = File.createTempFile("test", "."+archivename);
         result.deleteOnExit();
         try {
 
             final InputStream is = new FileInputStream(input);
             ais = factory.createArchiveInputStream(archivename, is);
             out = factory.createArchiveOutputStream(archivename,
                     new FileOutputStream(result));
 
             ChangeSet changes = new ChangeSet();
             changes.deleteDir("bla");
             archiveListDeleteDir("bla");
 
             // Add a file
             final File file1 = getFile("test.txt");
             ArchiveEntry entry = out.createArchiveEntry(file1, "bla/test.txt");
             changes.add(entry, new FileInputStream(file1));
             archiveList.add("bla/test.txt");
 
             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
             ChangeSetResults results = performer.perform(ais, out);
             is.close();
 
             // Checks
             assertEquals(1,results.getAddedFromChangeSet().size());
             assertEquals("bla/test.txt",results.getAddedFromChangeSet().iterator().next());
             assertEquals(3,results.getDeleted().size());
             assertTrue(results.getDeleted().contains("bla/test4.xml"));
             assertTrue(results.getDeleted().contains("bla/test5.xml"));
             assertTrue(results.getDeleted().contains("bla/blubber/test6.xml"));
 
             assertTrue(results.getAddedFromStream().contains("testdata/test1.xml"));
             assertTrue(results.getAddedFromStream().contains("testdata/test2.xml"));
             assertTrue(results.getAddedFromStream().contains("test/test3.xml"));
             assertTrue(results.getAddedFromStream().contains("test.txt"));
             assertTrue(results.getAddedFromStream().contains("something/bla"));
             assertTrue(results.getAddedFromStream().contains("test with spaces.txt"));
             assertEquals(6,results.getAddedFromStream().size());
         } finally {
             if (out != null) {
                 out.close();
             }
             if (ais != null) {
                 ais.close();
             }
         }
 
         this.checkArchiveContent(result, archiveList);
     }
 
     /**
      * Tries to delete a directory with a file and adds a new directory with a
      * new file and with the same name. Should delete dir1/* and add
      * dir1/test.txt at the end
      * 
      * @throws Exception
      */
     public void testDeletePlusAdd() throws Exception {
         final String archivename = "cpio";
         File input = this.createArchive(archivename);
 
         ArchiveOutputStream out = null;
         ArchiveInputStream ais = null;
         File result = File.createTempFile("test", "."+archivename);
         result.deleteOnExit();
         try {
 
             final InputStream is = new FileInputStream(input);
             ais = factory.createArchiveInputStream(archivename, is);
             out = factory.createArchiveOutputStream(archivename,
                     new FileOutputStream(result));
 
             ChangeSet changes = new ChangeSet();
             changes.deleteDir("bla");
             archiveListDeleteDir("bla");
 
             // Add a file
             final File file1 = getFile("test.txt");
             ArchiveEntry entry = out.createArchiveEntry(file1, "bla/test.txt");
             changes.add(entry, new FileInputStream(file1));
             archiveList.add("bla/test.txt");
 
             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
             performer.perform(ais, out);
             is.close();
 
         } finally {
             if (out != null) {
                 out.close();
             }
             if (ais != null) {
                 ais.close();
             }
         }
 
         this.checkArchiveContent(result, archiveList);
     }
 
     /**
      * Adds a file to a zip archive. Deletes an other file.
      * 
      * @throws Exception
      */
     public void testDeleteFromAndAddToZip() throws Exception {
         final String archivename = "zip";
         File input = this.createArchive(archivename);
 
         ArchiveOutputStream out = null;
         ArchiveInputStream ais = null;
         File result = File.createTempFile("test", "."+archivename);
         result.deleteOnExit();
         try {
 
             final InputStream is = new FileInputStream(input);
             ais = factory.createArchiveInputStream(archivename, is);
             out = factory.createArchiveOutputStream(archivename,
                     new FileOutputStream(result));
 
             ChangeSet changes = new ChangeSet();
 
             final File file1 = getFile("test.txt");
             ArchiveEntry entry = new ZipArchiveEntry("blub/test.txt");
             changes.add(entry, new FileInputStream(file1));
             archiveList.add("blub/test.txt");
 
             changes.delete("testdata/test1.xml");
             archiveListDelete("testdata/test1.xml");
 
             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
             performer.perform(ais, out);
             is.close();
 
         } finally {
             if (out != null) {
                 out.close();
             }
             if (ais != null) {
                 ais.close();
             }
         }
 
         this.checkArchiveContent(result, archiveList);
     }
 
     /**
      * Adds a file to a zip archive. Deletes an other file.
      * 
      * @throws Exception
      */
     public void testDeleteFromAndAddToZipUsingZipFilePerform() throws Exception {
         final String archivename = "zip";
         File input = this.createArchive(archivename);
 
         ArchiveOutputStream out = null;
         ZipFile ais = null;
         File result = File.createTempFile("test", "."+archivename);
         result.deleteOnExit();
         try {
 
             ais = new ZipFile(input);
             out = factory.createArchiveOutputStream(archivename,
                     new FileOutputStream(result));
 
             ChangeSet changes = new ChangeSet();
 
             final File file1 = getFile("test.txt");
             ArchiveEntry entry = new ZipArchiveEntry("blub/test.txt");
             changes.add(entry, new FileInputStream(file1));
             archiveList.add("blub/test.txt");
 
             changes.delete("testdata/test1.xml");
             archiveListDelete("testdata/test1.xml");
 
             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
             performer.perform(ais, out);
 
         } finally {
             if (out != null) {
                 out.close();
             }
             if (ais != null) {
                 ais.close();
             }
         }
 
         this.checkArchiveContent(result, archiveList);
     }
 
     /**
      * add blub/test.txt + delete blub Should add blub/test.txt and delete it
      * afterwards. In this example, the archive should stay untouched.
      * 
      * @throws Exception
      */
     public void testAddDeleteAdd() throws Exception {
         final String archivename = "cpio";
         File input = this.createArchive(archivename);
 
         ArchiveOutputStream out = null;
         ArchiveInputStream ais = null;
         File result = File.createTempFile("test", "."+archivename);
         result.deleteOnExit();
         try {
 
             final InputStream is = new FileInputStream(input);
             ais = factory.createArchiveInputStream(archivename, is);
             out = factory.createArchiveOutputStream(archivename,
                     new FileOutputStream(result));
 
             ChangeSet changes = new ChangeSet();
 
             final File file1 = getFile("test.txt");
             ArchiveEntry entry = new CpioArchiveEntry("blub/test.txt");
             changes.add(entry, new FileInputStream(file1));
             archiveList.add("blub/test.txt");
 
             changes.deleteDir("blub");
             archiveListDeleteDir("blub");
 
             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
             performer.perform(ais, out);
 
             is.close();
 
         } finally {
             if (out != null) {
                 out.close();
             }
             if (ais != null) {
                 ais.close();
             }
         }
 
         this.checkArchiveContent(result, archiveList);
     }
 
     /**
      * delete bla + add bla/test.txt + delete bla Deletes dir1/* first, then
      * suppresses the add of bla.txt because there is a delete operation later.
      * 
      * @throws Exception
      */
     public void testDeleteAddDelete() throws Exception {
         final String archivename = "cpio";
         File input = this.createArchive(archivename);
 
         ArchiveOutputStream out = null;
         ArchiveInputStream ais = null;
         File result = File.createTempFile("test", "."+archivename);
         result.deleteOnExit();
         try {
 
             final InputStream is = new FileInputStream(input);
             ais = factory.createArchiveInputStream(archivename, is);
             out = factory.createArchiveOutputStream(archivename,
                     new FileOutputStream(result));
 
             ChangeSet changes = new ChangeSet();
 
             changes.deleteDir("bla");
 
             final File file1 = getFile("test.txt");
             ArchiveEntry entry = new CpioArchiveEntry("bla/test.txt");
             changes.add(entry, new FileInputStream(file1));
             archiveList.add("bla/test.txt");
 
             changes.deleteDir("bla");
             archiveListDeleteDir("bla");
 
             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
             performer.perform(ais, out);
 
             is.close();
 
         } finally {
             if (out != null) {
                 out.close();
             }
             if (ais != null) {
                 ais.close();
             }
         }
 
         this.checkArchiveContent(result, archiveList);
     }
 
     /**
      * Simple Delete from a zip file.
      * 
      * @throws Exception
      */
     public void testDeleteFromZip() throws Exception {
         ArchiveOutputStream out = null;
         ArchiveInputStream ais = null;
         File temp = null;
         try {
             ChangeSet changes = new ChangeSet();
             changes.delete("test2.xml");
 
             final File input = getFile("bla.zip");
             final InputStream is = new FileInputStream(input);
             ais = factory.createArchiveInputStream("zip", is);
 
             temp = File.createTempFile("test", ".zip");
             temp.deleteOnExit();
             out = factory.createArchiveOutputStream("zip",
                     new FileOutputStream(temp));
 
             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
             performer.perform(ais, out);
 
         } finally {
             if (out != null) {
                 out.close();
             }
             if (ais != null) {
                 ais.close();
             }
         }
 
         List<String> expected = new ArrayList<String>();
         expected.add("test1.xml");
 
         this.checkArchiveContent(temp, expected);
     }
 
     /**
      * Simple delete from a tar file
      * 
      * @throws Exception
      */
     public void testDeleteFromTar() throws Exception {
         ArchiveOutputStream out = null;
         ArchiveInputStream ais = null;
         File temp = null;
         try {
             ChangeSet changes = new ChangeSet();
             changes.delete("test2.xml");
 
             final File input = getFile("bla.tar");
             final InputStream is = new FileInputStream(input);
             ais = factory.createArchiveInputStream("tar", is);
 
             temp = new File(dir, "bla.tar");
             out = factory.createArchiveOutputStream("tar",
                     new FileOutputStream(temp));
 
             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
             performer.perform(ais, out);
 
         } finally {
             if (out != null) {
                 out.close();
             }
             if (ais != null) {
                 ais.close();
             }
         }
         List<String> expected = new ArrayList<String>();
         expected.add("test1.xml");
         this.checkArchiveContent(temp, expected);
     }
 
     /**
      * Simple delete from a jar file
      * 
      * @throws Exception
      */
     public void testDeleteFromJar() throws Exception {
         ArchiveOutputStream out = null;
         ArchiveInputStream ais = null;
         File temp = null;
         try {
             ChangeSet changes = new ChangeSet();
             changes.delete("test2.xml");
             changes.deleteDir("META-INF");
             changes.delete(".classpath");
             changes.delete(".project");
 
             final File input = getFile("bla.jar");
             final InputStream is = new FileInputStream(input);
             ais = factory.createArchiveInputStream("jar", is);
 
             temp = new File(dir, "bla.jar");
             out = factory.createArchiveOutputStream("jar",
                     new FileOutputStream(temp));
 
             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
             performer.perform(ais, out);
 
         } finally {
             if (out != null) {
                 out.close();
             }
             if (ais != null) {
                 ais.close();
             }
         }
         List<String> expected = new ArrayList<String>();
         expected.add("test1.xml");
         this.checkArchiveContent(temp, expected);
     }
 
     public void testDeleteFromAndAddToTar() throws Exception {
         ArchiveOutputStream out = null;
         ArchiveInputStream ais = null;
         File temp = null;
         try {
             ChangeSet changes = new ChangeSet();
             changes.delete("test2.xml");
 
             final File file1 = getFile("test.txt");
 
             final TarArchiveEntry entry = new TarArchiveEntry(
                     "testdata/test.txt");
             entry.setModTime(0);
             entry.setSize(file1.length());
             entry.setUserId(0);
             entry.setGroupId(0);
             entry.setUserName("avalon");
             entry.setGroupName("excalibur");
             entry.setMode(0100000);
 
             changes.add(entry, new FileInputStream(file1));
 
             final File input = getFile("bla.tar");
             final InputStream is = new FileInputStream(input);
             ais = factory.createArchiveInputStream("tar", is);
 
             temp = new File(dir, "bla.tar");
             out = factory.createArchiveOutputStream("tar",
                     new FileOutputStream(temp));
 
             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
             performer.perform(ais, out);
 
         } finally {
             if (out != null) {
                 out.close();
             }
             if (ais != null) {
                 ais.close();
             }
         }
         List<String> expected = new ArrayList<String>();
         expected.add("test1.xml");
         expected.add("testdata/test.txt");
         final ArchiveInputStream in = factory.createArchiveInputStream("tar", new FileInputStream(temp));
         this.checkArchiveContent(in, expected);
     }
 
     /**
      * Delete from a jar file and add another file
      * 
      * @throws Exception
      */
     public void testDeleteFromAndAddToJar() throws Exception {
         ArchiveOutputStream out = null;
         ArchiveInputStream ais = null;
         File temp = null;
         try {
             ChangeSet changes = new ChangeSet();
             changes.delete("test2.xml");
             changes.deleteDir("META-INF");
             changes.delete(".classpath");
             changes.delete(".project");
 
             final File file1 = getFile("test.txt");
             JarArchiveEntry entry = new JarArchiveEntry("testdata/test.txt");
             changes.add(entry, new FileInputStream(file1));
 
             final File input = getFile("bla.jar");
             final InputStream is = new FileInputStream(input);
             ais = factory.createArchiveInputStream("jar", is);
 
             temp = new File(dir, "bla.jar");
             out = factory.createArchiveOutputStream("jar",
                     new FileOutputStream(temp));
 
             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
             performer.perform(ais, out);
 
         } finally {
             if (out != null) {
                 out.close();
             }
             if (ais != null) {
                 ais.close();
             }
         }
         List<String> expected = new ArrayList<String>();
         expected.add("test1.xml");
         expected.add("testdata/test.txt");
         this.checkArchiveContent(temp, expected);
     }
 
     /**
      * Simple delete from an ar file
      * 
      * @throws Exception
      */
     public void testDeleteFromAr() throws Exception {
         ArchiveOutputStream out = null;
         ArchiveInputStream ais = null;
         File temp = null;
         try {
             ChangeSet changes = new ChangeSet();
             changes.delete("test2.xml");
 
             final File input = getFile("bla.ar");
             final InputStream is = new FileInputStream(input);
             ais = factory.createArchiveInputStream("ar", is);
 
             temp = new File(dir, "bla.ar");
             out = factory.createArchiveOutputStream("ar",
                     new FileOutputStream(temp));
 
             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
             performer.perform(ais, out);
 
         } finally {
             if (out != null) {
                 out.close();
             }
             if (ais != null) {
                 ais.close();
             }
         }
 
         List<String> expected = new ArrayList<String>();
         expected.add("test1.xml");
         this.checkArchiveContent(temp, expected);
     }
 
     /**
      * Deletes a file from an AR-archive and adds another
      * 
      * @throws Exception
      */
     public void testDeleteFromAndAddToAr() throws Exception {
         ArchiveOutputStream out = null;
         ArchiveInputStream ais = null;
         File temp = null;
         try {
             ChangeSet changes = new ChangeSet();
             changes.delete("test2.xml");
 
             final File file1 = getFile("test.txt");
 
             final ArArchiveEntry entry = new ArArchiveEntry("test.txt", file1
                     .length());
 
             changes.add(entry, new FileInputStream(file1));
 
             final File input = getFile("bla.ar");
             final InputStream is = new FileInputStream(input);
             ais = factory.createArchiveInputStream("ar", is);
 
             temp = new File(dir, "bla.ar");
             out = factory.createArchiveOutputStream("ar",
                     new FileOutputStream(temp));
 
             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
             performer.perform(ais, out);
 
         } finally {
             if (out != null) {
                 out.close();
             }
             if (ais != null) {
                 ais.close();
             }
         }
         List<String> expected = new ArrayList<String>();
         expected.add("test1.xml");
         expected.add("test.txt");
         this.checkArchiveContent(temp, expected);
     }
 
     /**
      * TODO: Move operations are not supported currently
      * 
      * mv dir1/test.text dir2/test.txt + delete dir1 Moves the file to dir2 and
      * deletes everything in dir1
      * 
      * @throws Exception
      */
     public void testRenameAndDelete() throws Exception {
     }
 
     /**
      * TODO: Move operations are not supported currently
      * 
      * add dir1/bla.txt + mv dir1/test.text dir2/test.txt + delete dir1
      * 
      * Add dir1/bla.txt should be surpressed. All other dir1 files will be
      * deleted, except dir1/test.text will be moved
      * 
      * @throws Exception
      */
     public void testAddMoveDelete() throws Exception {
     }
 
     /**
      * Check can add a file to an empty archive.
      * 
      * @throws Exception
      */
     public void testAddToEmptyArchive() throws Exception {
         final String archivename = "zip";
         File input = this.createEmptyArchive(archivename);
 
         ArchiveOutputStream out = null;
         ArchiveInputStream ais = null;
         InputStream is = null;
         File result = File.createTempFile("test", "."+archivename);
         result.deleteOnExit();
         ChangeSet changes = new ChangeSet();
         try {
 
             is = new FileInputStream(input);
             ais = factory.createArchiveInputStream(archivename, is);
 
             out = factory.createArchiveOutputStream(archivename,
                     new FileOutputStream(result));
 
             final File file1 = getFile("test.txt");
             ArchiveEntry entry = new ZipArchiveEntry("bla/test.txt");
             changes.add(entry, new FileInputStream(file1));
             archiveList.add("bla/test.txt");
             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
             performer.perform(ais, out);
             is.close();
 
         } finally {
             if (out != null) {
                 out.close();
             }
             if (ais != null) {
                 ais.close(); // will close is 
             } else if (is != null){
                 is.close();
             }
         }
 
         this.checkArchiveContent(result, archiveList);
     }
 
     /**
      * Check can delete and add a file to an archive with a single file
      * 
      * @throws Exception
      */
     public void testDeleteAddToOneFileArchive() throws Exception {
         final String archivename = "zip";
         File input = this.createSingleEntryArchive(archivename);
 
         ArchiveOutputStream out = null;
         ArchiveInputStream ais = null;
         InputStream is = null;
         File result = File.createTempFile("test", "."+archivename);
         result.deleteOnExit();
         ChangeSet changes = new ChangeSet();
         try {
 
             is = new FileInputStream(input);
             ais = factory.createArchiveInputStream(archivename, is);
 
             out = factory.createArchiveOutputStream(archivename,
                     new FileOutputStream(result));
             changes.delete("test1.xml");
             archiveListDelete("test1.xml");
 
             final File file = getFile("test.txt");
             ArchiveEntry entry = out.createArchiveEntry(file,"bla/test.txt");
             changes.add(entry, new FileInputStream(file));
             archiveList.add("bla/test.txt");
 
             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
             performer.perform(ais, out);
             is.close();
 
         } finally {
             if (out != null) {
                 out.close();
             }
             if (ais != null) {
                 ais.close(); // will close is 
             } else if (is != null){
                 is.close();
             }
         }
 
         this.checkArchiveContent(result, archiveList);
     }
 
     /**
      * Check can add and delete a file to an archive with a single file
      * 
      * @throws Exception
      */
     public void testAddDeleteToOneFileArchive() throws Exception {
         final String archivename = "cpio";
         File input = this.createSingleEntryArchive(archivename);
 
         ArchiveOutputStream out = null;
         ArchiveInputStream ais = null;
         InputStream is = null;
         File result = File.createTempFile("test", "."+archivename);
         result.deleteOnExit();
         ChangeSet changes = new ChangeSet();
         try {
 
             is = new FileInputStream(input);
             ais = factory.createArchiveInputStream(archivename, is);
 
             out = factory.createArchiveOutputStream(archivename,
                     new FileOutputStream(result));
             final File file = getFile("test.txt");
             ArchiveEntry entry = out.createArchiveEntry(file,"bla/test.txt"); 
             changes.add(entry, new FileInputStream(file));
             archiveList.add("bla/test.txt");
 
             changes.delete("test1.xml");
             archiveListDelete("test1.xml");
 
             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
             performer.perform(ais, out);
             is.close();
 
         } finally {
             if (out != null) {
                 out.close();
             }
             if (ais != null) {
                 ais.close(); // will close is 
             } else if (is != null){
                 is.close();
             }
         }
 
         this.checkArchiveContent(result, archiveList);
     }
 
     /**
      * Adds a file with the same filename as an existing file from the stream.
      * Should lead to a replacement.
      * 
      * @throws Exception
      */
     public void testAddAllreadyExistingWithReplaceTrue() throws Exception {
         final String archivename = "zip";
         File input = this.createArchive(archivename);
 
         ArchiveOutputStream out = null;
         ArchiveInputStream ais = null;
         File result = File.createTempFile("test", "."+archivename);
         result.deleteOnExit();
         try {
 
             final InputStream is = new FileInputStream(input);
             ais = factory.createArchiveInputStream(archivename, is);
             out = factory.createArchiveOutputStream(archivename,
                     new FileOutputStream(result));
 
             ChangeSet changes = new ChangeSet();
 
             final File file1 = getFile("test.txt");
             ArchiveEntry entry = new ZipArchiveEntry("testdata/test1.xml");
             changes.add(entry, new FileInputStream(file1), true);
 
             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
             ChangeSetResults results = performer.perform(ais, out);
             assertTrue(results.getAddedFromChangeSet().contains("testdata/test1.xml"));
             is.close();
 
         } finally {
             if (out != null) {
                 out.close();
             }
             if (ais != null) {
                 ais.close();
             }
         }
 
         this.checkArchiveContent(result, archiveList);
     }
 
     /**
      * Adds a file with the same filename as an existing file from the stream.
      * Should lead to a replacement.
      * 
      * @throws Exception
      */
     public void testAddAllreadyExistingWithReplaceFalse() throws Exception {
         final String archivename = "zip";
         File input = this.createArchive(archivename);
 
         ArchiveOutputStream out = null;
         ArchiveInputStream ais = null;
         File result = File.createTempFile("test", "."+archivename);
         result.deleteOnExit();
         try {
 
             final InputStream is = new FileInputStream(input);
             ais = factory.createArchiveInputStream(archivename, is);
             out = factory.createArchiveOutputStream(archivename,
                     new FileOutputStream(result));
 
             ChangeSet changes = new ChangeSet();
 
             final File file1 = getFile("test.txt");
             ArchiveEntry entry = new ZipArchiveEntry("testdata/test1.xml");
             changes.add(entry, new FileInputStream(file1), false);
 
             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
             ChangeSetResults results = performer.perform(ais, out);
             assertTrue(results.getAddedFromStream().contains("testdata/test1.xml"));
             assertTrue(results.getAddedFromChangeSet().isEmpty());
             assertTrue(results.getDeleted().isEmpty());
             is.close();
 
         } finally {
             if (out != null) {
                 out.close();
             }
             if (ais != null) {
                 ais.close();
             }
         }
 
         this.checkArchiveContent(result, archiveList);
     }
 
 }