View Javadoc
1   /*
2    * Licensed to the Apache Software Foundation (ASF) under one
3    * or more contributor license agreements.  See the NOTICE file
4    * distributed with this work for additional information
5    * regarding copyright ownership.  The ASF licenses this file
6    * to you under the Apache License, Version 2.0 (the
7    * "License"); you may not use this file except in compliance
8    * with the License.  You may obtain a copy of the License at
9    *
10   * http://www.apache.org/licenses/LICENSE-2.0
11   *
12   * Unless required by applicable law or agreed to in writing,
13   * software distributed under the License is distributed on an
14   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
15   * KIND, either express or implied.  See the License for the
16   * specific language governing permissions and limitations
17   * under the License.
18   */
19  package org.apache.commons.compress.changes;
20  
21  import static org.junit.Assert.*;
22  
23  import java.io.BufferedInputStream;
24  import java.io.BufferedReader;
25  import java.io.File;
26  import java.io.FileInputStream;
27  import java.io.FileOutputStream;
28  import java.io.FileReader;
29  import java.io.InputStream;
30  import java.util.ArrayList;
31  import java.util.Iterator;
32  import java.util.List;
33  
34  import org.apache.commons.compress.AbstractTestCase;
35  import org.apache.commons.compress.archivers.ArchiveEntry;
36  import org.apache.commons.compress.archivers.ArchiveInputStream;
37  import org.apache.commons.compress.archivers.ArchiveOutputStream;
38  import org.apache.commons.compress.archivers.ar.ArArchiveEntry;
39  import org.apache.commons.compress.archivers.cpio.CpioArchiveEntry;
40  import org.apache.commons.compress.archivers.jar.JarArchiveEntry;
41  import org.apache.commons.compress.archivers.tar.TarArchiveEntry;
42  import org.apache.commons.compress.archivers.zip.ZipArchiveEntry;
43  import org.apache.commons.compress.archivers.zip.ZipFile;
44  import org.junit.Test;
45  
46  /**
47   * Checks several ChangeSet business logics.
48   */
49  public final class ChangeSetTestCase extends AbstractTestCase {
50  
51      // Delete a directory tree
52      private void archiveListDeleteDir(String prefix){
53          Iterator<String> it = archiveList.iterator();
54          while(it.hasNext()){
55              String entry = it.next();
56              if (entry.startsWith(prefix+"/")){ // TODO won't work with folders
57                  it.remove();
58              }
59          }
60      }
61  
62      // Delete a single file
63      private void archiveListDelete(String prefix){
64          Iterator<String> it = archiveList.iterator();
65          while(it.hasNext()){
66              String entry = it.next();
67              if (entry.equals(prefix)){
68                  it.remove();
69              }
70          }
71      }
72  
73      /**
74       * Adds an ArchiveEntry with the same name two times.
75       * Only the latest addition should be found in the ChangeSet,
76       * the first add should be replaced.
77       * 
78       * @throws Exception
79       */
80      @Test
81      public void testAddChangeTwice() throws Exception {
82          InputStream in = null;
83          InputStream in2 = null;
84          try {
85              in = new FileInputStream(getFile("test.txt"));
86              in2 = new FileInputStream(getFile("test2.xml"));
87  
88              ArchiveEntry e = new ZipArchiveEntry("test.txt");
89              ArchiveEntry e2 = new ZipArchiveEntry("test.txt");
90  
91              ChangeSet changes = new ChangeSet();
92              changes.add(e, in);
93              changes.add(e2, in2);
94  
95              assertEquals(1, changes.getChanges().size());
96              Change c = changes.getChanges().iterator().next();
97              assertEquals(in2, c.getInput());
98          } finally {
99              if (in != null) {
100                 in.close();
101             }
102             if (in2 != null) {
103                 in2.close();
104             }
105         }
106     }
107 
108     /**
109      * Adds an ArchiveEntry with the same name two times.
110      * Only the first addition should be found in the ChangeSet,
111      * the second add should never be added since replace = false
112      * 
113      * @throws Exception
114      */
115     @Test
116     public void testAddChangeTwiceWithoutReplace() throws Exception {
117         InputStream in = null;
118         InputStream in2 = null;
119         try {
120             in = new FileInputStream(getFile("test.txt"));
121             in2 = new FileInputStream(getFile("test2.xml"));
122 
123             ArchiveEntry e = new ZipArchiveEntry("test.txt");
124             ArchiveEntry e2 = new ZipArchiveEntry("test.txt");
125 
126             ChangeSet changes = new ChangeSet();
127             changes.add(e, in, true);
128             changes.add(e2, in2, false);
129 
130             assertEquals(1, changes.getChanges().size());
131             Change c = changes.getChanges().iterator().next();
132             assertEquals(in, c.getInput());
133         } finally {
134             if (in != null) {
135                 in.close();
136             }
137             if (in2 != null) {
138                 in2.close();
139             }
140         }
141     }
142 
143     /**
144      * Tries to delete the folder "bla" from an archive file. This should result in
145      * the deletion of bla/*, which actually means bla/test4.xml should be
146      * removed from the archive. The file something/bla (without ending, named
147      * like the folder) should not be deleted.
148      * 
149      * @throws Exception
150      */
151     @Test
152     public void testDeleteDir() throws Exception {
153         final String archivename = "cpio";
154         File input = this.createArchive(archivename);
155 
156         ArchiveOutputStream out = null;
157         ArchiveInputStream ais = null;
158         File result = File.createTempFile("test", "."+archivename);
159         result.deleteOnExit();
160         try {
161 
162             final InputStream is = new FileInputStream(input);
163             ais = factory.createArchiveInputStream(archivename, is);
164 
165             out = factory.createArchiveOutputStream(archivename,
166                     new FileOutputStream(result));
167 
168             ChangeSet changes = new ChangeSet();
169             changes.deleteDir("bla");
170             archiveListDeleteDir("bla");
171             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
172             performer.perform(ais, out);
173             is.close();
174 
175         } finally {
176             if (out != null) {
177                 out.close();
178             }
179             if (ais != null) {
180                 ais.close();
181             }
182         }
183 
184         this.checkArchiveContent(result, archiveList);
185     }
186 
187     /**
188      * Tries to delete the folder "la" from an archive file. This should result in
189      * the deletion of la/*, which should not match any files/folders.
190      * 
191      * @throws Exception
192      */
193     @Test
194     public void testDeleteDir2() throws Exception {
195         final String archivename = "cpio";
196         File input = this.createArchive(archivename);
197 
198         ArchiveOutputStream out = null;
199         ArchiveInputStream ais = null;
200         File result = File.createTempFile("test", "."+archivename);
201         result.deleteOnExit();
202         try {
203 
204             final InputStream is = new FileInputStream(input);
205             ais = factory.createArchiveInputStream(archivename, is);
206 
207             out = factory.createArchiveOutputStream(archivename,
208                     new FileOutputStream(result));
209 
210             ChangeSet changes = new ChangeSet();
211             changes.deleteDir("la");
212             archiveListDeleteDir("la");
213             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
214             performer.perform(ais, out);
215             is.close();
216 
217         } finally {
218             if (out != null) {
219                 out.close();
220             }
221             if (ais != null) {
222                 ais.close();
223             }
224         }
225 
226         this.checkArchiveContent(result, archiveList);
227     }
228 
229     /**
230      * Tries to delete the folder "test.txt" from an archive file.
231      * This should not match any files/folders.
232      * 
233      * @throws Exception
234      */
235     @Test
236     public void testDeleteDir3() throws Exception {
237         final String archivename = "cpio";
238         File input = this.createArchive(archivename);
239 
240         ArchiveOutputStream out = null;
241         ArchiveInputStream ais = null;
242         File result = File.createTempFile("test", "."+archivename);
243         result.deleteOnExit();
244         try {
245 
246             final InputStream is = new FileInputStream(input);
247             ais = factory.createArchiveInputStream(archivename, is);
248 
249             out = factory.createArchiveOutputStream(archivename,
250                     new FileOutputStream(result));
251 
252             ChangeSet changes = new ChangeSet();
253             changes.deleteDir("test.txt");
254             archiveListDeleteDir("test.txt");
255             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
256             performer.perform(ais, out);
257             is.close();
258 
259         } finally {
260             if (out != null) {
261                 out.close();
262             }
263             if (ais != null) {
264                 ais.close();
265             }
266         }
267 
268         this.checkArchiveContent(result, archiveList);
269     }
270 
271     /**
272      * Tries to delete the file "bla/test5.xml" from an archive. This should
273      * result in the deletion of "bla/test5.xml".
274      * 
275      * @throws Exception
276      */
277     @Test
278     public void testDeleteFile() throws Exception {
279         final String archivename = "cpio";
280         File input = this.createArchive(archivename);
281 
282         ArchiveOutputStream out = null;
283         ArchiveInputStream ais = null;
284         File result = File.createTempFile("test", "."+archivename);
285         result.deleteOnExit();
286         try {
287 
288             final InputStream is = new FileInputStream(input);
289             ais = factory.createArchiveInputStream(archivename, is);
290 
291             out = factory.createArchiveOutputStream(archivename,
292                     new FileOutputStream(result));
293 
294             ChangeSet changes = new ChangeSet();
295             changes.delete("bla/test5.xml");
296             archiveListDelete("bla/test5.xml");
297 
298             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
299             performer.perform(ais, out);
300             is.close();
301 
302         } finally {
303             if (out != null) {
304                 out.close();
305             }
306             if (ais != null) {
307                 ais.close();
308             }
309         }
310 
311         this.checkArchiveContent(result, archiveList);
312     }
313 
314     /**
315      * Tries to delete the file "bla" from an archive. This should
316      * result in the deletion of nothing.
317      * 
318      * @throws Exception
319      */
320     @Test
321     public void testDeleteFile2() throws Exception {
322         final String archivename = "cpio";
323         File input = this.createArchive(archivename);
324 
325         ArchiveOutputStream out = null;
326         ArchiveInputStream ais = null;
327         File result = File.createTempFile("test", "."+archivename);
328         result.deleteOnExit();
329         try {
330 
331             final InputStream is = new FileInputStream(input);
332             ais = factory.createArchiveInputStream(archivename, is);
333 
334             out = factory.createArchiveOutputStream(archivename,
335                     new FileOutputStream(result));
336 
337             ChangeSet changes = new ChangeSet();
338             changes.delete("bla");
339             //archiveListDelete("bla");
340 
341             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
342             performer.perform(ais, out);
343             is.close();
344 
345         } finally {
346             if (out != null) {
347                 out.close();
348             }
349             if (ais != null) {
350                 ais.close();
351             }
352         }
353 
354         this.checkArchiveContent(result, archiveList);
355     }
356 
357     /**
358      * Tries to delete and then add a file with the same name.
359      * Should delete test/test3.xml and adds test.txt with the name
360      * test/test3.xml
361      * 
362      * @throws Exception
363      */
364     @Test
365     public void testDeletePlusAddSame() throws Exception {
366         final String archivename = "zip";
367         File input = this.createArchive(archivename);
368 
369         ArchiveOutputStream out = null;
370         ArchiveInputStream ais = null;
371         File result = File.createTempFile("test", "."+archivename);
372         result.deleteOnExit();
373 
374         File testtxt = null;
375         try {
376 
377             final InputStream is = new FileInputStream(input);
378             ais = factory.createArchiveInputStream(archivename, is);
379             out = factory.createArchiveOutputStream(archivename,
380                     new FileOutputStream(result));
381 
382             ChangeSet changes = new ChangeSet();
383             changes.delete("test/test3.xml");
384             archiveListDelete("test/test3.xml");
385 
386             // Add a file
387             testtxt = getFile("test.txt");
388             ArchiveEntry entry = out.createArchiveEntry(testtxt, "test/test3.xml");
389             changes.add(entry, new FileInputStream(testtxt));
390             archiveList.add("test/test3.xml");
391 
392             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
393             performer.perform(ais, out);
394             is.close();
395 
396         } finally {
397             if (out != null) {
398                 out.close();
399             }
400             if (ais != null) {
401                 ais.close();
402             }
403         }
404 
405         // Checks
406         ArchiveInputStream in = null;
407         File check = null;
408         try {
409             final InputStream is = new FileInputStream(result);
410             final BufferedInputStream buf = new BufferedInputStream(is);
411             in = factory.createArchiveInputStream(buf);
412             check = this.checkArchiveContent(in, archiveList, false);
413             File test3xml = new File(check,"result/test/test3.xml");
414             assertEquals(testtxt.length(), test3xml.length());
415 
416             BufferedReader reader = new BufferedReader(new FileReader(test3xml));
417             String str;
418             while ((str = reader.readLine()) != null) {
419                 // All lines look like this
420                 "111111111111111111111111111000101011".equals(str);
421             }
422             reader.close();
423         } finally {
424             if (in != null) {
425                 in.close();
426             }
427             rmdir(check);
428         } 
429     }
430 
431     /**
432      * Checks for the correct ChangeSetResults
433      * 
434      * @throws Exception
435      */
436     @Test
437     public void testChangeSetResults() throws Exception {
438         final String archivename = "cpio";
439         File input = this.createArchive(archivename);
440 
441         ArchiveOutputStream out = null;
442         ArchiveInputStream ais = null;
443         File result = File.createTempFile("test", "."+archivename);
444         result.deleteOnExit();
445         try {
446 
447             final InputStream is = new FileInputStream(input);
448             ais = factory.createArchiveInputStream(archivename, is);
449             out = factory.createArchiveOutputStream(archivename,
450                     new FileOutputStream(result));
451 
452             ChangeSet changes = new ChangeSet();
453             changes.deleteDir("bla");
454             archiveListDeleteDir("bla");
455 
456             // Add a file
457             final File file1 = getFile("test.txt");
458             ArchiveEntry entry = out.createArchiveEntry(file1, "bla/test.txt");
459             changes.add(entry, new FileInputStream(file1));
460             archiveList.add("bla/test.txt");
461 
462             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
463             ChangeSetResults results = performer.perform(ais, out);
464             is.close();
465 
466             // Checks
467             assertEquals(1,results.getAddedFromChangeSet().size());
468             assertEquals("bla/test.txt",results.getAddedFromChangeSet().iterator().next());
469             assertEquals(3,results.getDeleted().size());
470             assertTrue(results.getDeleted().contains("bla/test4.xml"));
471             assertTrue(results.getDeleted().contains("bla/test5.xml"));
472             assertTrue(results.getDeleted().contains("bla/blubber/test6.xml"));
473 
474             assertTrue(results.getAddedFromStream().contains("testdata/test1.xml"));
475             assertTrue(results.getAddedFromStream().contains("testdata/test2.xml"));
476             assertTrue(results.getAddedFromStream().contains("test/test3.xml"));
477             assertTrue(results.getAddedFromStream().contains("test.txt"));
478             assertTrue(results.getAddedFromStream().contains("something/bla"));
479             assertTrue(results.getAddedFromStream().contains("test with spaces.txt"));
480             assertEquals(6,results.getAddedFromStream().size());
481         } finally {
482             if (out != null) {
483                 out.close();
484             }
485             if (ais != null) {
486                 ais.close();
487             }
488         }
489 
490         this.checkArchiveContent(result, archiveList);
491     }
492 
493     /**
494      * Tries to delete a directory with a file and adds a new directory with a
495      * new file and with the same name. Should delete dir1/* and add
496      * dir1/test.txt at the end
497      * 
498      * @throws Exception
499      */
500     @Test
501     public void testDeletePlusAdd() throws Exception {
502         final String archivename = "cpio";
503         File input = this.createArchive(archivename);
504 
505         ArchiveOutputStream out = null;
506         ArchiveInputStream ais = null;
507         File result = File.createTempFile("test", "."+archivename);
508         result.deleteOnExit();
509         try {
510 
511             final InputStream is = new FileInputStream(input);
512             ais = factory.createArchiveInputStream(archivename, is);
513             out = factory.createArchiveOutputStream(archivename,
514                     new FileOutputStream(result));
515 
516             ChangeSet changes = new ChangeSet();
517             changes.deleteDir("bla");
518             archiveListDeleteDir("bla");
519 
520             // Add a file
521             final File file1 = getFile("test.txt");
522             ArchiveEntry entry = out.createArchiveEntry(file1, "bla/test.txt");
523             changes.add(entry, new FileInputStream(file1));
524             archiveList.add("bla/test.txt");
525 
526             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
527             performer.perform(ais, out);
528             is.close();
529 
530         } finally {
531             if (out != null) {
532                 out.close();
533             }
534             if (ais != null) {
535                 ais.close();
536             }
537         }
538 
539         this.checkArchiveContent(result, archiveList);
540     }
541 
542     /**
543      * Adds a file to a zip archive. Deletes an other file.
544      * 
545      * @throws Exception
546      */
547     @Test
548     public void testDeleteFromAndAddToZip() throws Exception {
549         final String archivename = "zip";
550         File input = this.createArchive(archivename);
551 
552         ArchiveOutputStream out = null;
553         ArchiveInputStream ais = null;
554         File result = File.createTempFile("test", "."+archivename);
555         result.deleteOnExit();
556         try {
557 
558             final InputStream is = new FileInputStream(input);
559             ais = factory.createArchiveInputStream(archivename, is);
560             out = factory.createArchiveOutputStream(archivename,
561                     new FileOutputStream(result));
562 
563             ChangeSet changes = new ChangeSet();
564 
565             final File file1 = getFile("test.txt");
566             ArchiveEntry entry = new ZipArchiveEntry("blub/test.txt");
567             changes.add(entry, new FileInputStream(file1));
568             archiveList.add("blub/test.txt");
569 
570             changes.delete("testdata/test1.xml");
571             archiveListDelete("testdata/test1.xml");
572 
573             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
574             performer.perform(ais, out);
575             is.close();
576 
577         } finally {
578             if (out != null) {
579                 out.close();
580             }
581             if (ais != null) {
582                 ais.close();
583             }
584         }
585 
586         this.checkArchiveContent(result, archiveList);
587     }
588 
589     /**
590      * Adds a file to a zip archive. Deletes an other file.
591      * 
592      * @throws Exception
593      */
594     @Test
595     public void testDeleteFromAndAddToZipUsingZipFilePerform() throws Exception {
596         final String archivename = "zip";
597         File input = this.createArchive(archivename);
598 
599         ArchiveOutputStream out = null;
600         ZipFile ais = null;
601         File result = File.createTempFile("test", "."+archivename);
602         result.deleteOnExit();
603         try {
604 
605             ais = new ZipFile(input);
606             out = factory.createArchiveOutputStream(archivename,
607                     new FileOutputStream(result));
608 
609             ChangeSet changes = new ChangeSet();
610 
611             final File file1 = getFile("test.txt");
612             ArchiveEntry entry = new ZipArchiveEntry("blub/test.txt");
613             changes.add(entry, new FileInputStream(file1));
614             archiveList.add("blub/test.txt");
615 
616             changes.delete("testdata/test1.xml");
617             archiveListDelete("testdata/test1.xml");
618 
619             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
620             performer.perform(ais, out);
621 
622         } finally {
623             if (out != null) {
624                 out.close();
625             }
626             if (ais != null) {
627                 ais.close();
628             }
629         }
630 
631         this.checkArchiveContent(result, archiveList);
632     }
633 
634     /**
635      * add blub/test.txt + delete blub Should add blub/test.txt and delete it
636      * afterwards. In this example, the archive should stay untouched.
637      * 
638      * @throws Exception
639      */
640     @Test
641     public void testAddDeleteAdd() throws Exception {
642         final String archivename = "cpio";
643         File input = this.createArchive(archivename);
644 
645         ArchiveOutputStream out = null;
646         ArchiveInputStream ais = null;
647         File result = File.createTempFile("test", "."+archivename);
648         result.deleteOnExit();
649         try {
650 
651             final InputStream is = new FileInputStream(input);
652             ais = factory.createArchiveInputStream(archivename, is);
653             out = factory.createArchiveOutputStream(archivename,
654                     new FileOutputStream(result));
655 
656             ChangeSet changes = new ChangeSet();
657 
658             final File file1 = getFile("test.txt");
659             ArchiveEntry entry = new CpioArchiveEntry("blub/test.txt");
660             changes.add(entry, new FileInputStream(file1));
661             archiveList.add("blub/test.txt");
662 
663             changes.deleteDir("blub");
664             archiveListDeleteDir("blub");
665 
666             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
667             performer.perform(ais, out);
668 
669             is.close();
670 
671         } finally {
672             if (out != null) {
673                 out.close();
674             }
675             if (ais != null) {
676                 ais.close();
677             }
678         }
679 
680         this.checkArchiveContent(result, archiveList);
681     }
682 
683     /**
684      * delete bla + add bla/test.txt + delete bla Deletes dir1/* first, then
685      * suppresses the add of bla.txt because there is a delete operation later.
686      * 
687      * @throws Exception
688      */
689     @Test
690     public void testDeleteAddDelete() throws Exception {
691         final String archivename = "cpio";
692         File input = this.createArchive(archivename);
693 
694         ArchiveOutputStream out = null;
695         ArchiveInputStream ais = null;
696         File result = File.createTempFile("test", "."+archivename);
697         result.deleteOnExit();
698         try {
699 
700             final InputStream is = new FileInputStream(input);
701             ais = factory.createArchiveInputStream(archivename, is);
702             out = factory.createArchiveOutputStream(archivename,
703                     new FileOutputStream(result));
704 
705             ChangeSet changes = new ChangeSet();
706 
707             changes.deleteDir("bla");
708 
709             final File file1 = getFile("test.txt");
710             ArchiveEntry entry = new CpioArchiveEntry("bla/test.txt");
711             changes.add(entry, new FileInputStream(file1));
712             archiveList.add("bla/test.txt");
713 
714             changes.deleteDir("bla");
715             archiveListDeleteDir("bla");
716 
717             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
718             performer.perform(ais, out);
719 
720             is.close();
721 
722         } finally {
723             if (out != null) {
724                 out.close();
725             }
726             if (ais != null) {
727                 ais.close();
728             }
729         }
730 
731         this.checkArchiveContent(result, archiveList);
732     }
733 
734     /**
735      * Simple Delete from a zip file.
736      * 
737      * @throws Exception
738      */
739     @Test
740     public void testDeleteFromZip() throws Exception {
741         ArchiveOutputStream out = null;
742         ArchiveInputStream ais = null;
743         File temp = null;
744         try {
745             ChangeSet changes = new ChangeSet();
746             changes.delete("test2.xml");
747 
748             final File input = getFile("bla.zip");
749             final InputStream is = new FileInputStream(input);
750             ais = factory.createArchiveInputStream("zip", is);
751 
752             temp = File.createTempFile("test", ".zip");
753             temp.deleteOnExit();
754             out = factory.createArchiveOutputStream("zip",
755                     new FileOutputStream(temp));
756 
757             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
758             performer.perform(ais, out);
759 
760         } finally {
761             if (out != null) {
762                 out.close();
763             }
764             if (ais != null) {
765                 ais.close();
766             }
767         }
768 
769         List<String> expected = new ArrayList<String>();
770         expected.add("test1.xml");
771 
772         this.checkArchiveContent(temp, expected);
773     }
774 
775     /**
776      * Simple delete from a tar file
777      * 
778      * @throws Exception
779      */
780     @Test
781     public void testDeleteFromTar() throws Exception {
782         ArchiveOutputStream out = null;
783         ArchiveInputStream ais = null;
784         File temp = null;
785         try {
786             ChangeSet changes = new ChangeSet();
787             changes.delete("test2.xml");
788 
789             final File input = getFile("bla.tar");
790             final InputStream is = new FileInputStream(input);
791             ais = factory.createArchiveInputStream("tar", is);
792 
793             temp = new File(dir, "bla.tar");
794             out = factory.createArchiveOutputStream("tar",
795                     new FileOutputStream(temp));
796 
797             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
798             performer.perform(ais, out);
799 
800         } finally {
801             if (out != null) {
802                 out.close();
803             }
804             if (ais != null) {
805                 ais.close();
806             }
807         }
808         List<String> expected = new ArrayList<String>();
809         expected.add("test1.xml");
810         this.checkArchiveContent(temp, expected);
811     }
812 
813     /**
814      * Simple delete from a jar file
815      * 
816      * @throws Exception
817      */
818     @Test
819     public void testDeleteFromJar() throws Exception {
820         ArchiveOutputStream out = null;
821         ArchiveInputStream ais = null;
822         File temp = null;
823         try {
824             ChangeSet changes = new ChangeSet();
825             changes.delete("test2.xml");
826             changes.deleteDir("META-INF");
827             changes.delete(".classpath");
828             changes.delete(".project");
829 
830             final File input = getFile("bla.jar");
831             final InputStream is = new FileInputStream(input);
832             ais = factory.createArchiveInputStream("jar", is);
833 
834             temp = new File(dir, "bla.jar");
835             out = factory.createArchiveOutputStream("jar",
836                     new FileOutputStream(temp));
837 
838             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
839             performer.perform(ais, out);
840 
841         } finally {
842             if (out != null) {
843                 out.close();
844             }
845             if (ais != null) {
846                 ais.close();
847             }
848         }
849         List<String> expected = new ArrayList<String>();
850         expected.add("test1.xml");
851         this.checkArchiveContent(temp, expected);
852     }
853 
854     @Test
855     public void testDeleteFromAndAddToTar() throws Exception {
856         ArchiveOutputStream out = null;
857         ArchiveInputStream ais = null;
858         File temp = null;
859         try {
860             ChangeSet changes = new ChangeSet();
861             changes.delete("test2.xml");
862 
863             final File file1 = getFile("test.txt");
864 
865             final TarArchiveEntry entry = new TarArchiveEntry(
866                     "testdata/test.txt");
867             entry.setModTime(0);
868             entry.setSize(file1.length());
869             entry.setUserId(0);
870             entry.setGroupId(0);
871             entry.setUserName("avalon");
872             entry.setGroupName("excalibur");
873             entry.setMode(0100000);
874 
875             changes.add(entry, new FileInputStream(file1));
876 
877             final File input = getFile("bla.tar");
878             final InputStream is = new FileInputStream(input);
879             ais = factory.createArchiveInputStream("tar", is);
880 
881             temp = new File(dir, "bla.tar");
882             out = factory.createArchiveOutputStream("tar",
883                     new FileOutputStream(temp));
884 
885             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
886             performer.perform(ais, out);
887 
888         } finally {
889             if (out != null) {
890                 out.close();
891             }
892             if (ais != null) {
893                 ais.close();
894             }
895         }
896         List<String> expected = new ArrayList<String>();
897         expected.add("test1.xml");
898         expected.add("testdata/test.txt");
899         final ArchiveInputStream in = factory.createArchiveInputStream("tar", new FileInputStream(temp));
900         this.checkArchiveContent(in, expected);
901     }
902 
903     /**
904      * Delete from a jar file and add another file
905      * 
906      * @throws Exception
907      */
908     @Test
909     public void testDeleteFromAndAddToJar() throws Exception {
910         ArchiveOutputStream out = null;
911         ArchiveInputStream ais = null;
912         File temp = null;
913         try {
914             ChangeSet changes = new ChangeSet();
915             changes.delete("test2.xml");
916             changes.deleteDir("META-INF");
917             changes.delete(".classpath");
918             changes.delete(".project");
919 
920             final File file1 = getFile("test.txt");
921             JarArchiveEntry entry = new JarArchiveEntry("testdata/test.txt");
922             changes.add(entry, new FileInputStream(file1));
923 
924             final File input = getFile("bla.jar");
925             final InputStream is = new FileInputStream(input);
926             ais = factory.createArchiveInputStream("jar", is);
927 
928             temp = new File(dir, "bla.jar");
929             out = factory.createArchiveOutputStream("jar",
930                     new FileOutputStream(temp));
931 
932             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
933             performer.perform(ais, out);
934 
935         } finally {
936             if (out != null) {
937                 out.close();
938             }
939             if (ais != null) {
940                 ais.close();
941             }
942         }
943         List<String> expected = new ArrayList<String>();
944         expected.add("test1.xml");
945         expected.add("testdata/test.txt");
946         this.checkArchiveContent(temp, expected);
947     }
948 
949     /**
950      * Simple delete from an ar file
951      * 
952      * @throws Exception
953      */
954     @Test
955     public void testDeleteFromAr() throws Exception {
956         ArchiveOutputStream out = null;
957         ArchiveInputStream ais = null;
958         File temp = null;
959         try {
960             ChangeSet changes = new ChangeSet();
961             changes.delete("test2.xml");
962 
963             final File input = getFile("bla.ar");
964             final InputStream is = new FileInputStream(input);
965             ais = factory.createArchiveInputStream("ar", is);
966 
967             temp = new File(dir, "bla.ar");
968             out = factory.createArchiveOutputStream("ar",
969                     new FileOutputStream(temp));
970 
971             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
972             performer.perform(ais, out);
973 
974         } finally {
975             if (out != null) {
976                 out.close();
977             }
978             if (ais != null) {
979                 ais.close();
980             }
981         }
982 
983         List<String> expected = new ArrayList<String>();
984         expected.add("test1.xml");
985         this.checkArchiveContent(temp, expected);
986     }
987 
988     /**
989      * Deletes a file from an AR-archive and adds another
990      * 
991      * @throws Exception
992      */
993     @Test
994     public void testDeleteFromAndAddToAr() throws Exception {
995         ArchiveOutputStream out = null;
996         ArchiveInputStream ais = null;
997         File temp = null;
998         try {
999             ChangeSet changes = new ChangeSet();
1000             changes.delete("test2.xml");
1001 
1002             final File file1 = getFile("test.txt");
1003 
1004             final ArArchiveEntry entry = new ArArchiveEntry("test.txt", file1
1005                     .length());
1006 
1007             changes.add(entry, new FileInputStream(file1));
1008 
1009             final File input = getFile("bla.ar");
1010             final InputStream is = new FileInputStream(input);
1011             ais = factory.createArchiveInputStream("ar", is);
1012 
1013             temp = new File(dir, "bla.ar");
1014             out = factory.createArchiveOutputStream("ar",
1015                     new FileOutputStream(temp));
1016 
1017             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
1018             performer.perform(ais, out);
1019 
1020         } finally {
1021             if (out != null) {
1022                 out.close();
1023             }
1024             if (ais != null) {
1025                 ais.close();
1026             }
1027         }
1028         List<String> expected = new ArrayList<String>();
1029         expected.add("test1.xml");
1030         expected.add("test.txt");
1031         this.checkArchiveContent(temp, expected);
1032     }
1033 
1034     /**
1035      * TODO: Move operations are not supported currently
1036      * 
1037      * mv dir1/test.text dir2/test.txt + delete dir1 Moves the file to dir2 and
1038      * deletes everything in dir1
1039      * 
1040      * @throws Exception
1041      */
1042     @Test
1043     public void testRenameAndDelete() throws Exception {
1044     }
1045 
1046     /**
1047      * TODO: Move operations are not supported currently
1048      * 
1049      * add dir1/bla.txt + mv dir1/test.text dir2/test.txt + delete dir1
1050      * 
1051      * Add dir1/bla.txt should be surpressed. All other dir1 files will be
1052      * deleted, except dir1/test.text will be moved
1053      * 
1054      * @throws Exception
1055      */
1056     @Test
1057     public void testAddMoveDelete() throws Exception {
1058     }
1059 
1060     /**
1061      * Check can add a file to an empty archive.
1062      * 
1063      * @throws Exception
1064      */
1065     @Test
1066     public void testAddToEmptyArchive() throws Exception {
1067         final String archivename = "zip";
1068         File input = this.createEmptyArchive(archivename);
1069 
1070         ArchiveOutputStream out = null;
1071         ArchiveInputStream ais = null;
1072         InputStream is = null;
1073         File result = File.createTempFile("test", "."+archivename);
1074         result.deleteOnExit();
1075         ChangeSet changes = new ChangeSet();
1076         try {
1077 
1078             is = new FileInputStream(input);
1079             ais = factory.createArchiveInputStream(archivename, is);
1080 
1081             out = factory.createArchiveOutputStream(archivename,
1082                     new FileOutputStream(result));
1083 
1084             final File file1 = getFile("test.txt");
1085             ArchiveEntry entry = new ZipArchiveEntry("bla/test.txt");
1086             changes.add(entry, new FileInputStream(file1));
1087             archiveList.add("bla/test.txt");
1088             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
1089             performer.perform(ais, out);
1090             is.close();
1091 
1092         } finally {
1093             if (out != null) {
1094                 out.close();
1095             }
1096             if (ais != null) {
1097                 ais.close(); // will close is 
1098             } else if (is != null){
1099                 is.close();
1100             }
1101         }
1102 
1103         this.checkArchiveContent(result, archiveList);
1104     }
1105 
1106     /**
1107      * Check can delete and add a file to an archive with a single file
1108      * 
1109      * @throws Exception
1110      */
1111     @Test
1112     public void testDeleteAddToOneFileArchive() throws Exception {
1113         final String archivename = "zip";
1114         File input = this.createSingleEntryArchive(archivename);
1115 
1116         ArchiveOutputStream out = null;
1117         ArchiveInputStream ais = null;
1118         InputStream is = null;
1119         File result = File.createTempFile("test", "."+archivename);
1120         result.deleteOnExit();
1121         ChangeSet changes = new ChangeSet();
1122         try {
1123 
1124             is = new FileInputStream(input);
1125             ais = factory.createArchiveInputStream(archivename, is);
1126 
1127             out = factory.createArchiveOutputStream(archivename,
1128                     new FileOutputStream(result));
1129             changes.delete("test1.xml");
1130             archiveListDelete("test1.xml");
1131 
1132             final File file = getFile("test.txt");
1133             ArchiveEntry entry = out.createArchiveEntry(file,"bla/test.txt");
1134             changes.add(entry, new FileInputStream(file));
1135             archiveList.add("bla/test.txt");
1136 
1137             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
1138             performer.perform(ais, out);
1139             is.close();
1140 
1141         } finally {
1142             if (out != null) {
1143                 out.close();
1144             }
1145             if (ais != null) {
1146                 ais.close(); // will close is 
1147             } else if (is != null){
1148                 is.close();
1149             }
1150         }
1151 
1152         this.checkArchiveContent(result, archiveList);
1153     }
1154 
1155     /**
1156      * Check can add and delete a file to an archive with a single file
1157      * 
1158      * @throws Exception
1159      */
1160     @Test
1161     public void testAddDeleteToOneFileArchive() throws Exception {
1162         final String archivename = "cpio";
1163         File input = this.createSingleEntryArchive(archivename);
1164 
1165         ArchiveOutputStream out = null;
1166         ArchiveInputStream ais = null;
1167         InputStream is = null;
1168         File result = File.createTempFile("test", "."+archivename);
1169         result.deleteOnExit();
1170         ChangeSet changes = new ChangeSet();
1171         try {
1172 
1173             is = new FileInputStream(input);
1174             ais = factory.createArchiveInputStream(archivename, is);
1175 
1176             out = factory.createArchiveOutputStream(archivename,
1177                     new FileOutputStream(result));
1178             final File file = getFile("test.txt");
1179             ArchiveEntry entry = out.createArchiveEntry(file,"bla/test.txt"); 
1180             changes.add(entry, new FileInputStream(file));
1181             archiveList.add("bla/test.txt");
1182 
1183             changes.delete("test1.xml");
1184             archiveListDelete("test1.xml");
1185 
1186             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
1187             performer.perform(ais, out);
1188             is.close();
1189 
1190         } finally {
1191             if (out != null) {
1192                 out.close();
1193             }
1194             if (ais != null) {
1195                 ais.close(); // will close is 
1196             } else if (is != null){
1197                 is.close();
1198             }
1199         }
1200 
1201         this.checkArchiveContent(result, archiveList);
1202     }
1203 
1204     /**
1205      * Adds a file with the same filename as an existing file from the stream.
1206      * Should lead to a replacement.
1207      * 
1208      * @throws Exception
1209      */
1210     @Test
1211     public void testAddAllreadyExistingWithReplaceTrue() throws Exception {
1212         final String archivename = "zip";
1213         File input = this.createArchive(archivename);
1214 
1215         ArchiveOutputStream out = null;
1216         ArchiveInputStream ais = null;
1217         File result = File.createTempFile("test", "."+archivename);
1218         result.deleteOnExit();
1219         try {
1220 
1221             final InputStream is = new FileInputStream(input);
1222             ais = factory.createArchiveInputStream(archivename, is);
1223             out = factory.createArchiveOutputStream(archivename,
1224                     new FileOutputStream(result));
1225 
1226             ChangeSet changes = new ChangeSet();
1227 
1228             final File file1 = getFile("test.txt");
1229             ArchiveEntry entry = new ZipArchiveEntry("testdata/test1.xml");
1230             changes.add(entry, new FileInputStream(file1), true);
1231 
1232             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
1233             ChangeSetResults results = performer.perform(ais, out);
1234             assertTrue(results.getAddedFromChangeSet().contains("testdata/test1.xml"));
1235             is.close();
1236 
1237         } finally {
1238             if (out != null) {
1239                 out.close();
1240             }
1241             if (ais != null) {
1242                 ais.close();
1243             }
1244         }
1245 
1246         this.checkArchiveContent(result, archiveList);
1247     }
1248 
1249     /**
1250      * Adds a file with the same filename as an existing file from the stream.
1251      * Should lead to a replacement.
1252      * 
1253      * @throws Exception
1254      */
1255     @Test
1256     public void testAddAllreadyExistingWithReplaceFalse() throws Exception {
1257         final String archivename = "zip";
1258         File input = this.createArchive(archivename);
1259 
1260         ArchiveOutputStream out = null;
1261         ArchiveInputStream ais = null;
1262         File result = File.createTempFile("test", "."+archivename);
1263         result.deleteOnExit();
1264         try {
1265 
1266             final InputStream is = new FileInputStream(input);
1267             ais = factory.createArchiveInputStream(archivename, is);
1268             out = factory.createArchiveOutputStream(archivename,
1269                     new FileOutputStream(result));
1270 
1271             ChangeSet changes = new ChangeSet();
1272 
1273             final File file1 = getFile("test.txt");
1274             ArchiveEntry entry = new ZipArchiveEntry("testdata/test1.xml");
1275             changes.add(entry, new FileInputStream(file1), false);
1276 
1277             ChangeSetPerformer performer = new ChangeSetPerformer(changes);
1278             ChangeSetResults results = performer.perform(ais, out);
1279             assertTrue(results.getAddedFromStream().contains("testdata/test1.xml"));
1280             assertTrue(results.getAddedFromChangeSet().isEmpty());
1281             assertTrue(results.getDeleted().isEmpty());
1282             is.close();
1283 
1284         } finally {
1285             if (out != null) {
1286                 out.close();
1287             }
1288             if (ais != null) {
1289                 ais.close();
1290             }
1291         }
1292 
1293         this.checkArchiveContent(result, archiveList);
1294     }
1295 
1296 }