1 package org.apache.maven.plugin.assembly.archive;
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22 import static org.junit.Assert.assertEquals;
23 import static org.junit.Assert.assertFalse;
24 import static org.junit.Assert.assertNull;
25 import static org.junit.Assert.fail;
26
27 import java.io.File;
28 import java.io.IOException;
29 import java.util.ArrayList;
30 import java.util.Collections;
31 import java.util.List;
32 import java.util.Map;
33
34 import junit.framework.Assert;
35
36 import org.apache.maven.artifact.repository.ArtifactRepository;
37 import org.apache.maven.model.Model;
38 import org.apache.maven.plugin.assembly.AssemblerConfigurationSource;
39 import org.apache.maven.plugin.assembly.AssemblyContext;
40 import org.apache.maven.plugin.assembly.DefaultAssemblyContext;
41 import org.apache.maven.plugin.assembly.InvalidAssemblerConfigurationException;
42 import org.apache.maven.plugin.assembly.archive.phase.AssemblyArchiverPhase;
43 import org.apache.maven.plugin.assembly.artifact.DependencyResolutionException;
44 import org.apache.maven.plugin.assembly.artifact.DependencyResolver;
45 import org.apache.maven.plugin.assembly.format.AssemblyFormattingException;
46 import org.apache.maven.plugin.assembly.model.Assembly;
47 import org.apache.maven.plugin.assembly.testutils.MockManager;
48 import org.apache.maven.plugin.assembly.testutils.TestFileManager;
49 import org.apache.maven.project.MavenProject;
50 import org.codehaus.plexus.DefaultPlexusContainer;
51 import org.codehaus.plexus.PlexusContainer;
52 import org.codehaus.plexus.PlexusContainerException;
53 import org.codehaus.plexus.archiver.ArchivedFileSet;
54 import org.codehaus.plexus.archiver.Archiver;
55 import org.codehaus.plexus.archiver.ArchiverException;
56 import org.codehaus.plexus.archiver.FileSet;
57 import org.codehaus.plexus.archiver.FinalizerEnabled;
58 import org.codehaus.plexus.archiver.ResourceIterator;
59 import org.codehaus.plexus.archiver.manager.ArchiverManager;
60 import org.codehaus.plexus.archiver.manager.NoSuchArchiverException;
61 import org.codehaus.plexus.archiver.tar.TarArchiver;
62 import org.codehaus.plexus.archiver.tar.TarLongFileMode;
63 import org.codehaus.plexus.archiver.war.WarArchiver;
64 import org.codehaus.plexus.archiver.zip.ZipArchiver;
65 import org.codehaus.plexus.components.io.resources.PlexusIoResource;
66 import org.codehaus.plexus.components.io.resources.PlexusIoResourceCollection;
67 import org.codehaus.plexus.logging.Logger;
68 import org.codehaus.plexus.logging.console.ConsoleLogger;
69 import org.codehaus.plexus.util.FileUtils;
70 import org.easymock.MockControl;
71 import org.junit.AfterClass;
72 import org.junit.Before;
73 import org.junit.Test;
74
75 public class DefaultAssemblyArchiverTest
76
77 {
78
79 private static final TestFileManager fileManager = new TestFileManager( "def-assy-archiver.test.", "" );
80
81 private PlexusContainer container;
82
83 @Before
84 public void setup()
85 throws PlexusContainerException
86 {
87 container = new DefaultPlexusContainer();
88 container.initialize();
89 container.start();
90 }
91
92 public void shutdown()
93 {
94 container.dispose();
95 }
96
97
98 @AfterClass
99 public static void tearDown()
100 throws Exception
101 {
102 fileManager.cleanUp();
103 }
104
105 @Test( expected = InvalidAssemblerConfigurationException.class )
106 public void failWhenAssemblyIdIsNull()
107 throws ArchiveCreationException, AssemblyFormattingException, InvalidAssemblerConfigurationException
108 {
109 final MockManager mm = new MockManager();
110 final MockAndControlForAssemblyArchiver macMgr = new MockAndControlForAssemblyArchiver( mm );
111
112 final MockControl csControl = MockControl.createControl( AssemblerConfigurationSource.class );
113 mm.add( csControl );
114
115 final AssemblerConfigurationSource configSource = (AssemblerConfigurationSource) csControl.getMock();
116
117 mm.replayAll();
118
119 final DefaultAssemblyArchiver archiver = createSubject( macMgr, null, null );
120 archiver.createArchive( new Assembly(), "full-name", "zip", configSource, false);
121
122 mm.verifyAll();
123 }
124
125 @Test
126 public void testCreateArchive()
127 throws ArchiveCreationException, AssemblyFormattingException, InvalidAssemblerConfigurationException,
128 IOException
129 {
130 final MockManager mm = new MockManager();
131
132 final MockAndControlForAssemblyArchiver macMgr = new MockAndControlForAssemblyArchiver( mm );
133
134 macMgr.expectGetArchiver( "zip", Archiver.class );
135 macMgr.expectGetDestFile( new File( "test" ) );
136
137 final MockControl phaseControl = MockControl.createControl( AssemblyArchiverPhase.class );
138 mm.add( phaseControl );
139
140 final AssemblyArchiverPhase phase = (AssemblyArchiverPhase) phaseControl.getMock();
141
142 phase.execute( null, null, null, null );
143 phaseControl.setMatcher( MockControl.ALWAYS_MATCHER );
144
145 final MockControl csControl = MockControl.createControl( AssemblerConfigurationSource.class );
146 mm.add( csControl );
147
148 final AssemblerConfigurationSource configSource = (AssemblerConfigurationSource) csControl.getMock();
149
150 final File tempDir = fileManager.createTempDir();
151 FileUtils.deleteDirectory( tempDir );
152
153 configSource.getTemporaryRootDirectory();
154 csControl.setReturnValue( tempDir, MockControl.ZERO_OR_MORE );
155
156 configSource.isDryRun();
157 csControl.setReturnValue( false, MockControl.ZERO_OR_MORE );
158
159 configSource.isIgnoreDirFormatExtensions();
160 csControl.setReturnValue( false, MockControl.ZERO_OR_MORE );
161
162 final File outDir = fileManager.createTempDir();
163
164 macMgr.archiver.setDestFile( new File( outDir, "full-name.zip" ) );
165
166 try
167 {
168 macMgr.archiver.createArchive();
169 }
170 catch ( final ArchiverException e )
171 {
172 fail( "Should never happen" );
173 }
174 catch ( final IOException e )
175 {
176 fail( "Should never happen" );
177 }
178
179 configSource.getOutputDirectory();
180 csControl.setReturnValue( outDir );
181
182 configSource.getFinalName();
183 csControl.setReturnValue( "finalName" );
184
185 configSource.getArchiverConfig();
186 csControl.setReturnValue( null, MockControl.ZERO_OR_MORE );
187
188 configSource.getWorkingDirectory();
189 csControl.setReturnValue( new File( "." ), MockControl.ZERO_OR_MORE );
190
191 configSource.isUpdateOnly();
192 csControl.setReturnValue( false, MockControl.ZERO_OR_MORE );
193
194 configSource.isIgnorePermissions();
195 csControl.setReturnValue( true, MockControl.ZERO_OR_MORE );
196
197 final Assembly assembly = new Assembly();
198 assembly.setId( "id" );
199
200 final AssemblyContext context = new DefaultAssemblyContext();
201
202 try
203 {
204 macMgr.dependencyResolver.resolve( assembly, configSource, context );
205 macMgr.dependencyResolverControl.setMatcher( MockControl.ALWAYS_MATCHER );
206 }
207 catch ( final DependencyResolutionException e )
208 {
209 fail( "Should never happen" );
210 }
211
212 mm.replayAll();
213
214 final DefaultAssemblyArchiver subject = createSubject( macMgr, Collections.singletonList( phase ), null );
215
216 subject.createArchive( assembly, "full-name", "zip", configSource, false);
217
218 mm.verifyAll();
219 }
220
221 @Test
222 public void testCreateArchiver_ShouldConfigureArchiver()
223 throws NoSuchArchiverException, ArchiverException
224 {
225 final MockManager mm = new MockManager();
226
227 final MockAndControlForAssemblyArchiver macArchiverManager = new MockAndControlForAssemblyArchiver( mm );
228
229 final TestArchiverWithConfig archiver = new TestArchiverWithConfig();
230
231 macArchiverManager.expectGetArchiver( "dummy", archiver );
232
233 final MockControl configCtl = MockControl.createControl( AssemblerConfigurationSource.class );
234 final AssemblerConfigurationSource configSource = (AssemblerConfigurationSource) configCtl.getMock();
235
236 final String simpleConfig = "value";
237
238 configSource.getArchiverConfig();
239 configCtl.setReturnValue( "<configuration><simpleConfig>" + simpleConfig + "</simpleConfig></configuration>",
240 MockControl.ZERO_OR_MORE );
241
242 final MavenProject project = new MavenProject( new Model() );
243
244 configSource.getProject();
245 configCtl.setReturnValue( project, MockControl.ZERO_OR_MORE );
246
247 configSource.getMavenSession();
248 configCtl.setReturnValue( null, MockControl.ZERO_OR_MORE );
249
250 configSource.isDryRun();
251 configCtl.setReturnValue( false, MockControl.ZERO_OR_MORE );
252
253 configSource.getWorkingDirectory();
254 configCtl.setReturnValue( new File( "." ), MockControl.ZERO_OR_MORE );
255
256 configSource.isUpdateOnly();
257 configCtl.setReturnValue( false, MockControl.ZERO_OR_MORE );
258
259 final MockControl lrCtl = MockControl.createControl( ArtifactRepository.class );
260 final ArtifactRepository lr = (ArtifactRepository) lrCtl.getMock();
261 mm.add( lrCtl );
262
263 lr.getBasedir();
264 lrCtl.setReturnValue( "/path/to/local/repo", MockControl.ZERO_OR_MORE );
265
266 configSource.getLocalRepository();
267 configCtl.setReturnValue( lr, MockControl.ZERO_OR_MORE );
268
269 configSource.isIgnorePermissions();
270 configCtl.setReturnValue( true, MockControl.ZERO_OR_MORE );
271
272 mm.add( configCtl );
273
274 mm.replayAll();
275
276 final DefaultAssemblyArchiver subject =
277 createSubject( macArchiverManager, new ArrayList<AssemblyArchiverPhase>(), null );
278
279 subject.createArchiver( "dummy", false, "finalName", configSource, null, false);
280
281 assertEquals( simpleConfig, archiver.getSimpleConfig() );
282
283 mm.verifyAll();
284 }
285
286 @Test
287 public void testCreateArchiver_ShouldCreateTarArchiverWithNoCompression()
288 throws NoSuchArchiverException, ArchiverException
289 {
290 final MockManager mm = new MockManager();
291
292 final TestTarArchiver ttArchiver = new TestTarArchiver();
293
294 final MockAndControlForAssemblyArchiver macArchiverManager = new MockAndControlForAssemblyArchiver( mm );
295
296 macArchiverManager.expectGetArchiver( "tar", ttArchiver );
297
298 final MockControl configCtl = MockControl.createControl( AssemblerConfigurationSource.class );
299 final AssemblerConfigurationSource configSource = (AssemblerConfigurationSource) configCtl.getMock();
300
301 configSource.getTarLongFileMode();
302 configCtl.setReturnValue( TarLongFileMode.FAIL, MockControl.ZERO_OR_MORE );
303
304 configSource.isDryRun();
305 configCtl.setReturnValue( false, MockControl.ZERO_OR_MORE );
306
307 configSource.getArchiverConfig();
308 configCtl.setReturnValue( null, MockControl.ZERO_OR_MORE );
309
310 configSource.getProject();
311 configCtl.setReturnValue( new MavenProject( new Model() ), MockControl.ZERO_OR_MORE );
312
313 configSource.getJarArchiveConfiguration();
314 configCtl.setReturnValue( null, MockControl.ZERO_OR_MORE );
315
316 configSource.getWorkingDirectory();
317 configCtl.setReturnValue( new File( "." ), MockControl.ZERO_OR_MORE );
318
319 configSource.isUpdateOnly();
320 configCtl.setReturnValue( false, MockControl.ZERO_OR_MORE );
321
322 configSource.isIgnorePermissions();
323 configCtl.setReturnValue( true, MockControl.ZERO_OR_MORE );
324
325 mm.add( configCtl );
326
327 mm.replayAll();
328
329 final DefaultAssemblyArchiver subject =
330 createSubject( macArchiverManager, new ArrayList<AssemblyArchiverPhase>(), null );
331
332 subject.createArchiver( "tar", false, "finalName", configSource, null, false);
333
334 assertNull( ttArchiver.compressionMethod );
335 assertEquals( TarLongFileMode.FAIL, ttArchiver.longFileMode.getValue() );
336
337 mm.verifyAll();
338 }
339
340 @Test
341 public void testCreateArchiver_ShouldCreateWarArchiverWithIgnoreWebxmlSetToFalse()
342 throws NoSuchArchiverException, ArchiverException
343 {
344 final MockManager mm = new MockManager();
345
346 final TestWarArchiver twArchiver = new TestWarArchiver();
347
348 final MockAndControlForAssemblyArchiver macArchiverManager = new MockAndControlForAssemblyArchiver( mm );
349
350 macArchiverManager.expectGetArchiver( "war", twArchiver );
351
352 final MockControl configCtl = MockControl.createControl( AssemblerConfigurationSource.class );
353 final AssemblerConfigurationSource configSource = (AssemblerConfigurationSource) configCtl.getMock();
354
355 configSource.isDryRun();
356 configCtl.setReturnValue( false, MockControl.ZERO_OR_MORE );
357
358 configSource.getArchiverConfig();
359 configCtl.setReturnValue( null, MockControl.ZERO_OR_MORE );
360
361 configSource.getMavenSession();
362 configCtl.setReturnValue( null, MockControl.ZERO_OR_MORE );
363
364 configSource.getProject();
365 configCtl.setReturnValue( new MavenProject( new Model() ), MockControl.ZERO_OR_MORE );
366
367 configSource.getJarArchiveConfiguration();
368 configCtl.setReturnValue( null, MockControl.ZERO_OR_MORE );
369
370 configSource.getWorkingDirectory();
371 configCtl.setReturnValue( new File( "." ), MockControl.ZERO_OR_MORE );
372
373 configSource.isUpdateOnly();
374 configCtl.setReturnValue( false, MockControl.ZERO_OR_MORE );
375
376 configSource.isIgnorePermissions();
377 configCtl.setReturnValue( true, MockControl.ZERO_OR_MORE );
378
379 mm.add( configCtl );
380
381 mm.replayAll();
382
383 final DefaultAssemblyArchiver subject =
384 createSubject( macArchiverManager, new ArrayList<AssemblyArchiverPhase>(), null );
385
386 subject.createArchiver( "war", false, null, configSource, null, false);
387
388 assertFalse( twArchiver.ignoreWebxml );
389 }
390
391 @Test
392 public void testCreateArchiver_ShouldCreateZipArchiver()
393 throws NoSuchArchiverException, ArchiverException
394 {
395 final MockManager mm = new MockManager();
396
397 final ZipArchiver archiver = new ZipArchiver();
398
399 final MockAndControlForAssemblyArchiver macArchiverManager = new MockAndControlForAssemblyArchiver( mm );
400
401 macArchiverManager.expectGetArchiver( "zip", archiver );
402
403 final MockControl configCtl = MockControl.createControl( AssemblerConfigurationSource.class );
404 final AssemblerConfigurationSource configSource = (AssemblerConfigurationSource) configCtl.getMock();
405
406 configSource.isDryRun();
407 configCtl.setReturnValue( false, MockControl.ZERO_OR_MORE );
408
409 configSource.getArchiverConfig();
410 configCtl.setReturnValue( null, MockControl.ZERO_OR_MORE );
411
412 configSource.getWorkingDirectory();
413 configCtl.setReturnValue( new File( "." ), MockControl.ZERO_OR_MORE );
414
415 configSource.isUpdateOnly();
416 configCtl.setReturnValue( false, MockControl.ZERO_OR_MORE );
417
418 configSource.isIgnorePermissions();
419 configCtl.setReturnValue( true, MockControl.ZERO_OR_MORE );
420
421 mm.add( configCtl );
422
423 mm.replayAll();
424
425 final DefaultAssemblyArchiver subject =
426 createSubject( macArchiverManager, new ArrayList<AssemblyArchiverPhase>(), null );
427
428 subject.createArchiver( "zip", false, null, configSource, null, false);
429 }
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535 @Test
536 public void testCreateWarArchiver_ShouldDisableIgnoreWebxmlOption()
537 throws NoSuchArchiverException
538 {
539 final MockManager mm = new MockManager();
540
541 final TestWarArchiver twArchiver = new TestWarArchiver();
542
543 final MockAndControlForAssemblyArchiver macArchiverManager = new MockAndControlForAssemblyArchiver( mm );
544
545 macArchiverManager.expectGetArchiver( "war", twArchiver );
546
547 mm.replayAll();
548
549 final DefaultAssemblyArchiver subject =
550 createSubject( macArchiverManager, new ArrayList<AssemblyArchiverPhase>(), null );
551
552 subject.createWarArchiver();
553
554 assertFalse( twArchiver.ignoreWebxml );
555 }
556
557 @Test
558 public void testCreateTarArchiver_ShouldNotInitializeCompression()
559 throws NoSuchArchiverException, ArchiverException
560 {
561 final MockManager mm = new MockManager();
562
563 final TestTarArchiver ttArchiver = new TestTarArchiver();
564
565 final MockAndControlForAssemblyArchiver macArchiverManager = new MockAndControlForAssemblyArchiver( mm );
566
567 macArchiverManager.expectGetArchiver( "tar", ttArchiver );
568
569 mm.replayAll();
570
571 final DefaultAssemblyArchiver subject =
572 createSubject( macArchiverManager, new ArrayList<AssemblyArchiverPhase>(), null );
573
574 subject.createTarArchiver( "tar", TarLongFileMode.FAIL );
575
576 assertNull( ttArchiver.compressionMethod );
577 assertEquals( TarLongFileMode.FAIL, ttArchiver.longFileMode.getValue() );
578
579 mm.verifyAll();
580 }
581
582 @Test
583 public void testCreateTarArchiver_ShouldInitializeGZipCompression()
584 throws NoSuchArchiverException, ArchiverException
585 {
586 final MockManager mm = new MockManager();
587
588 final TestTarArchiver ttArchiver = new TestTarArchiver();
589
590 final MockAndControlForAssemblyArchiver macArchiverManager = new MockAndControlForAssemblyArchiver( mm );
591
592 macArchiverManager.expectGetArchiver( "tar", ttArchiver );
593
594 mm.replayAll();
595
596 final DefaultAssemblyArchiver subject =
597 createSubject( macArchiverManager, new ArrayList<AssemblyArchiverPhase>(), null );
598
599 subject.createTarArchiver( "tar.gz", TarLongFileMode.FAIL );
600
601 assertEquals( "gzip", ttArchiver.compressionMethod.getValue() );
602 assertEquals( TarLongFileMode.FAIL, ttArchiver.longFileMode.getValue() );
603
604 mm.verifyAll();
605 }
606
607 @Test
608 public void testCreateTarArchiver_ShouldInitializeBZipCompression()
609 throws NoSuchArchiverException, ArchiverException
610 {
611 final MockManager mm = new MockManager();
612
613 final TestTarArchiver ttArchiver = new TestTarArchiver();
614
615 final MockAndControlForAssemblyArchiver macArchiverManager = new MockAndControlForAssemblyArchiver( mm );
616
617 macArchiverManager.expectGetArchiver( "tar", ttArchiver );
618
619 mm.replayAll();
620
621 final DefaultAssemblyArchiver subject =
622 createSubject( macArchiverManager, new ArrayList<AssemblyArchiverPhase>(), null );
623
624 subject.createTarArchiver( "tar.bz2", TarLongFileMode.FAIL );
625
626 assertEquals( "bzip2", ttArchiver.compressionMethod.getValue() );
627 assertEquals( TarLongFileMode.FAIL, ttArchiver.longFileMode.getValue() );
628
629 mm.verifyAll();
630 }
631
632 @Test
633 public void testCreateTarArchiver_ShouldFailWithInvalidCompression()
634 throws NoSuchArchiverException, ArchiverException
635 {
636 final MockManager mm = new MockManager();
637
638 final TestTarArchiver ttArchiver = new TestTarArchiver();
639
640 final MockAndControlForAssemblyArchiver macArchiverManager = new MockAndControlForAssemblyArchiver( mm );
641
642 macArchiverManager.expectGetArchiver( "tar", ttArchiver );
643
644 mm.replayAll();
645
646 final DefaultAssemblyArchiver subject =
647 createSubject( macArchiverManager, new ArrayList<AssemblyArchiverPhase>(), null );
648
649 try
650 {
651 subject.createTarArchiver( "tar.Z", null );
652
653 fail( "Invalid compression formats should throw an error." );
654 }
655 catch ( final IllegalArgumentException e )
656 {
657
658 }
659
660 mm.verifyAll();
661 }
662
663 private DefaultAssemblyArchiver createSubject( final MockAndControlForAssemblyArchiver macMgr,
664 final List<AssemblyArchiverPhase> phases, Logger logger )
665 {
666 final DefaultAssemblyArchiver subject =
667 new DefaultAssemblyArchiver( macMgr.archiverManager, macMgr.dependencyResolver, phases );
668
669 subject.setContainer( container );
670
671 if ( logger == null )
672 {
673 logger = new ConsoleLogger( Logger.LEVEL_DEBUG, "test" );
674 }
675
676 subject.enableLogging( logger );
677
678 return subject;
679 }
680
681 private final class MockAndControlForAssemblyArchiver
682 {
683 ArchiverManager archiverManager;
684
685 MockControl control;
686
687 MockControl archiverControl;
688
689 Archiver archiver;
690
691 MockControl dependencyResolverControl;
692
693 DependencyResolver dependencyResolver;
694
695 private final MockManager mm;
696
697 public MockAndControlForAssemblyArchiver( final MockManager mm )
698 {
699 this.mm = mm;
700 control = MockControl.createControl( ArchiverManager.class );
701 mm.add( control );
702
703 archiverManager = (ArchiverManager) control.getMock();
704
705 dependencyResolverControl = MockControl.createControl( DependencyResolver.class );
706 mm.add( dependencyResolverControl );
707
708 dependencyResolver = (DependencyResolver) dependencyResolverControl.getMock();
709 }
710
711 void expectGetDestFile( final File file )
712 {
713 archiver.getDestFile();
714 archiverControl.setReturnValue( file, MockControl.ZERO_OR_MORE );
715 }
716
717 void createArchiver( final Class<?> archiverClass )
718 {
719 archiverControl = MockControl.createControl( archiverClass );
720 mm.add( archiverControl );
721
722 archiver = (Archiver) archiverControl.getMock();
723
724 archiver.setForced( false );
725 archiverControl.setMatcher( MockControl.ALWAYS_MATCHER );
726 archiverControl.setVoidCallable( MockControl.ZERO_OR_MORE );
727
728 archiver.setIgnorePermissions( false );
729 archiverControl.setMatcher( MockControl.ALWAYS_MATCHER );
730 archiverControl.setVoidCallable( MockControl.ZERO_OR_MORE );
731 }
732
733
734
735
736
737
738
739 void expectGetArchiver( final String format, final Class<?> archiverClass )
740 {
741 createArchiver( archiverClass );
742
743 try
744 {
745 archiverManager.getArchiver( format );
746 }
747 catch ( final NoSuchArchiverException e )
748 {
749 Assert.fail( "should never happen" );
750 }
751
752 control.setReturnValue( archiver );
753 }
754
755 void expectGetArchiver( final String format, final Archiver archiver )
756 throws NoSuchArchiverException
757 {
758 archiverManager.getArchiver( format );
759 control.setReturnValue( archiver );
760 }
761 }
762
763 private static final class TestTarArchiver
764 extends TarArchiver
765 {
766
767 TarCompressionMethod compressionMethod;
768
769 TarLongFileMode longFileMode;
770
771 @Override
772 protected void execute()
773 throws ArchiverException, IOException
774 {
775 super.createArchive();
776 }
777
778 @Override
779 public TarOptions getOptions()
780 {
781 return super.getOptions();
782 }
783
784 @Override
785 public void setCompression( final TarCompressionMethod mode )
786 {
787 compressionMethod = mode;
788 super.setCompression( mode );
789 }
790
791 @Override
792 public void setLongfile( final TarLongFileMode mode )
793 {
794 longFileMode = mode;
795 super.setLongfile( mode );
796 }
797
798 @Override
799 public void setOptions( final TarOptions options )
800 {
801 super.setOptions( options );
802 }
803
804 }
805
806 private static final class TestWarArchiver
807 extends WarArchiver
808 {
809
810 boolean ignoreWebxml;
811
812 @Override
813 public void setIgnoreWebxml( final boolean ignore )
814 {
815 ignoreWebxml = ignore;
816 super.setIgnoreWebxml( ignore );
817 }
818
819 }
820
821 interface TestFinalizerFilteredArchiver
822 extends Archiver, FinalizerEnabled
823 {
824
825 }
826
827 public static final class TestArchiverWithConfig
828 implements Archiver
829 {
830
831 private String simpleConfig;
832
833 private boolean useJvmChmod;
834
835 private boolean ignorePermissions;
836
837 public void setSimpleConfig( final String simpleConfig )
838 {
839 this.simpleConfig = simpleConfig;
840 }
841
842 public String getSimpleConfig()
843 {
844 return simpleConfig;
845 }
846
847 public void addArchivedFileSet( final File arg0 )
848 throws ArchiverException
849 {
850 }
851
852 public void addArchivedFileSet( final ArchivedFileSet arg0 )
853 throws ArchiverException
854 {
855 }
856
857 public void addArchivedFileSet( final File arg0, final String arg1 )
858 throws ArchiverException
859 {
860 }
861
862 public void addArchivedFileSet( final File arg0, final String[] arg1, final String[] arg2 )
863 throws ArchiverException
864 {
865 }
866
867 public void addArchivedFileSet( final File arg0, final String arg1, final String[] arg2, final String[] arg3 )
868 throws ArchiverException
869 {
870 }
871
872 public void addDirectory( final File arg0 )
873 throws ArchiverException
874 {
875 }
876
877 public void addDirectory( final File arg0, final String arg1 )
878 throws ArchiverException
879 {
880 }
881
882 public void addDirectory( final File arg0, final String[] arg1, final String[] arg2 )
883 throws ArchiverException
884 {
885 }
886
887 public void addDirectory( final File arg0, final String arg1, final String[] arg2, final String[] arg3 )
888 throws ArchiverException
889 {
890 }
891
892 public void addFile( final File arg0, final String arg1 )
893 throws ArchiverException
894 {
895 }
896
897 public void addFile( final File arg0, final String arg1, final int arg2 )
898 throws ArchiverException
899 {
900 }
901
902 public void addFileSet( final FileSet arg0 )
903 throws ArchiverException
904 {
905 }
906
907 public void addResource( final PlexusIoResource arg0, final String arg1, final int arg2 )
908 throws ArchiverException
909 {
910 }
911
912 public void addResources( final PlexusIoResourceCollection arg0 )
913 throws ArchiverException
914 {
915 }
916
917 public void createArchive()
918 throws ArchiverException, IOException
919 {
920 }
921
922 public int getDefaultDirectoryMode()
923 {
924 return 0;
925 }
926
927 public int getDefaultFileMode()
928 {
929 return 0;
930 }
931
932 public File getDestFile()
933 {
934 return null;
935 }
936
937 @SuppressWarnings( "rawtypes" )
938 public Map getFiles()
939 {
940 return null;
941 }
942
943 public boolean getIncludeEmptyDirs()
944 {
945 return false;
946 }
947
948 public ResourceIterator getResources()
949 throws ArchiverException
950 {
951 return null;
952 }
953
954 public boolean isForced()
955 {
956 return false;
957 }
958
959 public boolean isSupportingForced()
960 {
961 return false;
962 }
963
964 public void setDefaultDirectoryMode( final int arg0 )
965 {
966 }
967
968 public void setDefaultFileMode( final int arg0 )
969 {
970 }
971
972 public void setDestFile( final File arg0 )
973 {
974 }
975
976 public void setDotFileDirectory( final File arg0 )
977 {
978 }
979
980 public void setForced( final boolean arg0 )
981 {
982 }
983
984 public void setIncludeEmptyDirs( final boolean arg0 )
985 {
986 }
987
988 public String getDuplicateBehavior()
989 {
990 return Archiver.DUPLICATES_ADD;
991 }
992
993 public void setDuplicateBehavior( final String duplicate )
994 {
995 }
996
997 public int getDirectoryMode()
998 {
999 return 0;
1000 }
1001
1002 public int getFileMode()
1003 {
1004 return 0;
1005 }
1006
1007 public int getOverrideDirectoryMode()
1008 {
1009 return 0;
1010 }
1011
1012 public int getOverrideFileMode()
1013 {
1014 return 0;
1015 }
1016
1017 public void setDirectoryMode( final int mode )
1018 {
1019 }
1020
1021 public void setFileMode( final int mode )
1022 {
1023 }
1024
1025 public boolean isUseJvmChmod()
1026 {
1027 return useJvmChmod;
1028 }
1029
1030 public void setUseJvmChmod( final boolean useJvmChmod )
1031 {
1032 this.useJvmChmod = useJvmChmod;
1033 }
1034
1035 public boolean isIgnorePermissions()
1036 {
1037 return ignorePermissions;
1038 }
1039
1040 public void setIgnorePermissions( final boolean ignorePermissions )
1041 {
1042 this.ignorePermissions = ignorePermissions;
1043 }
1044
1045 }
1046
1047 }