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 org.apache.maven.artifact.repository.ArtifactRepository;
28 import org.apache.maven.model.Model;
29 import org.apache.maven.plugin.assembly.AssemblerConfigurationSource;
30 import org.apache.maven.plugin.assembly.AssemblyContext;
31 import org.apache.maven.plugin.assembly.DefaultAssemblyContext;
32 import org.apache.maven.plugin.assembly.InvalidAssemblerConfigurationException;
33 import org.apache.maven.plugin.assembly.archive.phase.AssemblyArchiverPhase;
34 import org.apache.maven.plugin.assembly.artifact.DependencyResolutionException;
35 import org.apache.maven.plugin.assembly.artifact.DependencyResolver;
36 import org.apache.maven.plugin.assembly.format.AssemblyFormattingException;
37 import org.apache.maven.plugin.assembly.model.Assembly;
38 import org.apache.maven.plugin.assembly.testutils.MockManager;
39 import org.apache.maven.plugin.assembly.testutils.TestFileManager;
40 import org.apache.maven.project.MavenProject;
41 import org.codehaus.plexus.DefaultPlexusContainer;
42 import org.codehaus.plexus.PlexusContainer;
43 import org.codehaus.plexus.PlexusContainerException;
44 import org.codehaus.plexus.archiver.ArchivedFileSet;
45 import org.codehaus.plexus.archiver.Archiver;
46 import org.codehaus.plexus.archiver.ArchiverException;
47 import org.codehaus.plexus.archiver.FileSet;
48 import org.codehaus.plexus.archiver.FinalizerEnabled;
49 import org.codehaus.plexus.archiver.ResourceIterator;
50 import org.codehaus.plexus.archiver.manager.ArchiverManager;
51 import org.codehaus.plexus.archiver.manager.NoSuchArchiverException;
52 import org.codehaus.plexus.archiver.tar.TarArchiver;
53 import org.codehaus.plexus.archiver.tar.TarLongFileMode;
54 import org.codehaus.plexus.archiver.war.WarArchiver;
55 import org.codehaus.plexus.archiver.zip.ZipArchiver;
56 import org.codehaus.plexus.components.io.resources.PlexusIoResource;
57 import org.codehaus.plexus.components.io.resources.PlexusIoResourceCollection;
58 import org.codehaus.plexus.logging.Logger;
59 import org.codehaus.plexus.logging.console.ConsoleLogger;
60 import org.codehaus.plexus.util.FileUtils;
61 import org.easymock.MockControl;
62 import org.junit.AfterClass;
63 import org.junit.Before;
64 import org.junit.Test;
65
66 import java.io.File;
67 import java.io.IOException;
68 import java.util.ArrayList;
69 import java.util.Collections;
70 import java.util.List;
71 import java.util.Map;
72
73 import junit.framework.Assert;
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 );
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 );
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 );
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 );
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.getProject();
362 configCtl.setReturnValue( new MavenProject( new Model() ), MockControl.ZERO_OR_MORE );
363
364 configSource.getJarArchiveConfiguration();
365 configCtl.setReturnValue( null, MockControl.ZERO_OR_MORE );
366
367 configSource.getWorkingDirectory();
368 configCtl.setReturnValue( new File( "." ), MockControl.ZERO_OR_MORE );
369
370 configSource.isUpdateOnly();
371 configCtl.setReturnValue( false, MockControl.ZERO_OR_MORE );
372
373 configSource.isIgnorePermissions();
374 configCtl.setReturnValue( true, MockControl.ZERO_OR_MORE );
375
376 mm.add( configCtl );
377
378 mm.replayAll();
379
380 final DefaultAssemblyArchiver subject =
381 createSubject( macArchiverManager, new ArrayList<AssemblyArchiverPhase>(), null );
382
383 subject.createArchiver( "war", false, null, configSource, null );
384
385 assertFalse( twArchiver.ignoreWebxml );
386 }
387
388 @Test
389 public void testCreateArchiver_ShouldCreateZipArchiver()
390 throws NoSuchArchiverException, ArchiverException
391 {
392 final MockManager mm = new MockManager();
393
394 final ZipArchiver archiver = new ZipArchiver();
395
396 final MockAndControlForAssemblyArchiver macArchiverManager = new MockAndControlForAssemblyArchiver( mm );
397
398 macArchiverManager.expectGetArchiver( "zip", archiver );
399
400 final MockControl configCtl = MockControl.createControl( AssemblerConfigurationSource.class );
401 final AssemblerConfigurationSource configSource = (AssemblerConfigurationSource) configCtl.getMock();
402
403 configSource.isDryRun();
404 configCtl.setReturnValue( false, MockControl.ZERO_OR_MORE );
405
406 configSource.getArchiverConfig();
407 configCtl.setReturnValue( null, MockControl.ZERO_OR_MORE );
408
409 configSource.getWorkingDirectory();
410 configCtl.setReturnValue( new File( "." ), MockControl.ZERO_OR_MORE );
411
412 configSource.isUpdateOnly();
413 configCtl.setReturnValue( false, MockControl.ZERO_OR_MORE );
414
415 configSource.isIgnorePermissions();
416 configCtl.setReturnValue( true, MockControl.ZERO_OR_MORE );
417
418 mm.add( configCtl );
419
420 mm.replayAll();
421
422 final DefaultAssemblyArchiver subject =
423 createSubject( macArchiverManager, new ArrayList<AssemblyArchiverPhase>(), null );
424
425 subject.createArchiver( "zip", false, null, configSource, null );
426 }
427
428
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 @Test
533 public void testCreateWarArchiver_ShouldDisableIgnoreWebxmlOption()
534 throws NoSuchArchiverException
535 {
536 final MockManager mm = new MockManager();
537
538 final TestWarArchiver twArchiver = new TestWarArchiver();
539
540 final MockAndControlForAssemblyArchiver macArchiverManager = new MockAndControlForAssemblyArchiver( mm );
541
542 macArchiverManager.expectGetArchiver( "war", twArchiver );
543
544 mm.replayAll();
545
546 final DefaultAssemblyArchiver subject =
547 createSubject( macArchiverManager, new ArrayList<AssemblyArchiverPhase>(), null );
548
549 subject.createWarArchiver();
550
551 assertFalse( twArchiver.ignoreWebxml );
552 }
553
554 @Test
555 public void testCreateTarArchiver_ShouldNotInitializeCompression()
556 throws NoSuchArchiverException, ArchiverException
557 {
558 final MockManager mm = new MockManager();
559
560 final TestTarArchiver ttArchiver = new TestTarArchiver();
561
562 final MockAndControlForAssemblyArchiver macArchiverManager = new MockAndControlForAssemblyArchiver( mm );
563
564 macArchiverManager.expectGetArchiver( "tar", ttArchiver );
565
566 mm.replayAll();
567
568 final DefaultAssemblyArchiver subject =
569 createSubject( macArchiverManager, new ArrayList<AssemblyArchiverPhase>(), null );
570
571 subject.createTarArchiver( "tar", TarLongFileMode.FAIL );
572
573 assertNull( ttArchiver.compressionMethod );
574 assertEquals( TarLongFileMode.FAIL, ttArchiver.longFileMode.getValue() );
575
576 mm.verifyAll();
577 }
578
579 @Test
580 public void testCreateTarArchiver_ShouldInitializeGZipCompression()
581 throws NoSuchArchiverException, ArchiverException
582 {
583 final MockManager mm = new MockManager();
584
585 final TestTarArchiver ttArchiver = new TestTarArchiver();
586
587 final MockAndControlForAssemblyArchiver macArchiverManager = new MockAndControlForAssemblyArchiver( mm );
588
589 macArchiverManager.expectGetArchiver( "tar", ttArchiver );
590
591 mm.replayAll();
592
593 final DefaultAssemblyArchiver subject =
594 createSubject( macArchiverManager, new ArrayList<AssemblyArchiverPhase>(), null );
595
596 subject.createTarArchiver( "tar.gz", TarLongFileMode.FAIL );
597
598 assertEquals( "gzip", ttArchiver.compressionMethod.getValue() );
599 assertEquals( TarLongFileMode.FAIL, ttArchiver.longFileMode.getValue() );
600
601 mm.verifyAll();
602 }
603
604 @Test
605 public void testCreateTarArchiver_ShouldInitializeBZipCompression()
606 throws NoSuchArchiverException, ArchiverException
607 {
608 final MockManager mm = new MockManager();
609
610 final TestTarArchiver ttArchiver = new TestTarArchiver();
611
612 final MockAndControlForAssemblyArchiver macArchiverManager = new MockAndControlForAssemblyArchiver( mm );
613
614 macArchiverManager.expectGetArchiver( "tar", ttArchiver );
615
616 mm.replayAll();
617
618 final DefaultAssemblyArchiver subject =
619 createSubject( macArchiverManager, new ArrayList<AssemblyArchiverPhase>(), null );
620
621 subject.createTarArchiver( "tar.bz2", TarLongFileMode.FAIL );
622
623 assertEquals( "bzip2", ttArchiver.compressionMethod.getValue() );
624 assertEquals( TarLongFileMode.FAIL, ttArchiver.longFileMode.getValue() );
625
626 mm.verifyAll();
627 }
628
629 @Test
630 public void testCreateTarArchiver_ShouldFailWithInvalidCompression()
631 throws NoSuchArchiverException, ArchiverException
632 {
633 final MockManager mm = new MockManager();
634
635 final TestTarArchiver ttArchiver = new TestTarArchiver();
636
637 final MockAndControlForAssemblyArchiver macArchiverManager = new MockAndControlForAssemblyArchiver( mm );
638
639 macArchiverManager.expectGetArchiver( "tar", ttArchiver );
640
641 mm.replayAll();
642
643 final DefaultAssemblyArchiver subject =
644 createSubject( macArchiverManager, new ArrayList<AssemblyArchiverPhase>(), null );
645
646 try
647 {
648 subject.createTarArchiver( "tar.Z", null );
649
650 fail( "Invalid compression formats should throw an error." );
651 }
652 catch ( final IllegalArgumentException e )
653 {
654
655 }
656
657 mm.verifyAll();
658 }
659
660 private DefaultAssemblyArchiver createSubject( final MockAndControlForAssemblyArchiver macMgr,
661 final List<AssemblyArchiverPhase> phases, Logger logger )
662 {
663 final DefaultAssemblyArchiver subject =
664 new DefaultAssemblyArchiver( macMgr.archiverManager, macMgr.dependencyResolver, phases );
665
666 subject.setContainer( container );
667
668 if ( logger == null )
669 {
670 logger = new ConsoleLogger( Logger.LEVEL_DEBUG, "test" );
671 }
672
673 subject.enableLogging( logger );
674
675 return subject;
676 }
677
678 private final class MockAndControlForAssemblyArchiver
679 {
680 ArchiverManager archiverManager;
681
682 MockControl control;
683
684 MockControl archiverControl;
685
686 Archiver archiver;
687
688 MockControl dependencyResolverControl;
689
690 DependencyResolver dependencyResolver;
691
692 private final MockManager mm;
693
694 public MockAndControlForAssemblyArchiver( final MockManager mm )
695 {
696 this.mm = mm;
697 control = MockControl.createControl( ArchiverManager.class );
698 mm.add( control );
699
700 archiverManager = (ArchiverManager) control.getMock();
701
702 dependencyResolverControl = MockControl.createControl( DependencyResolver.class );
703 mm.add( dependencyResolverControl );
704
705 dependencyResolver = (DependencyResolver) dependencyResolverControl.getMock();
706 }
707
708 void expectGetDestFile( final File file )
709 {
710 archiver.getDestFile();
711 archiverControl.setReturnValue( file, MockControl.ZERO_OR_MORE );
712 }
713
714 void createArchiver( final Class<?> archiverClass )
715 {
716 archiverControl = MockControl.createControl( archiverClass );
717 mm.add( archiverControl );
718
719 archiver = (Archiver) archiverControl.getMock();
720
721 archiver.setForced( false );
722 archiverControl.setMatcher( MockControl.ALWAYS_MATCHER );
723 archiverControl.setVoidCallable( MockControl.ZERO_OR_MORE );
724
725 archiver.setIgnorePermissions( false );
726 archiverControl.setMatcher( MockControl.ALWAYS_MATCHER );
727 archiverControl.setVoidCallable( MockControl.ZERO_OR_MORE );
728 }
729
730
731
732
733
734
735
736 void expectGetArchiver( final String format, final Class<?> archiverClass )
737 {
738 createArchiver( archiverClass );
739
740 try
741 {
742 archiverManager.getArchiver( format );
743 }
744 catch ( final NoSuchArchiverException e )
745 {
746 Assert.fail( "should never happen" );
747 }
748
749 control.setReturnValue( archiver );
750 }
751
752 void expectGetArchiver( final String format, final Archiver archiver )
753 throws NoSuchArchiverException
754 {
755 archiverManager.getArchiver( format );
756 control.setReturnValue( archiver );
757 }
758 }
759
760 private static final class TestTarArchiver
761 extends TarArchiver
762 {
763
764 TarCompressionMethod compressionMethod;
765
766 TarLongFileMode longFileMode;
767
768 @Override
769 protected void execute()
770 throws ArchiverException, IOException
771 {
772 super.createArchive();
773 }
774
775 @Override
776 public TarOptions getOptions()
777 {
778 return super.getOptions();
779 }
780
781 @Override
782 public void setCompression( final TarCompressionMethod mode )
783 {
784 compressionMethod = mode;
785 super.setCompression( mode );
786 }
787
788 @Override
789 public void setLongfile( final TarLongFileMode mode )
790 {
791 longFileMode = mode;
792 super.setLongfile( mode );
793 }
794
795 @Override
796 public void setOptions( final TarOptions options )
797 {
798 super.setOptions( options );
799 }
800
801 }
802
803 private static final class TestWarArchiver
804 extends WarArchiver
805 {
806
807 boolean ignoreWebxml;
808
809 @Override
810 public void setIgnoreWebxml( final boolean ignore )
811 {
812 ignoreWebxml = ignore;
813 super.setIgnoreWebxml( ignore );
814 }
815
816 }
817
818 interface TestFinalizerFilteredArchiver
819 extends Archiver, FinalizerEnabled
820 {
821
822 }
823
824 public static final class TestArchiverWithConfig
825 implements Archiver
826 {
827
828 private String simpleConfig;
829
830 private boolean useJvmChmod;
831
832 private boolean ignorePermissions;
833
834 public void setSimpleConfig( final String simpleConfig )
835 {
836 this.simpleConfig = simpleConfig;
837 }
838
839 public String getSimpleConfig()
840 {
841 return simpleConfig;
842 }
843
844 public void addArchivedFileSet( final File arg0 )
845 throws ArchiverException
846 {
847 }
848
849 public void addArchivedFileSet( final ArchivedFileSet arg0 )
850 throws ArchiverException
851 {
852 }
853
854 public void addArchivedFileSet( final File arg0, final String arg1 )
855 throws ArchiverException
856 {
857 }
858
859 public void addArchivedFileSet( final File arg0, final String[] arg1, final String[] arg2 )
860 throws ArchiverException
861 {
862 }
863
864 public void addArchivedFileSet( final File arg0, final String arg1, final String[] arg2, final String[] arg3 )
865 throws ArchiverException
866 {
867 }
868
869 public void addDirectory( final File arg0 )
870 throws ArchiverException
871 {
872 }
873
874 public void addDirectory( final File arg0, final String arg1 )
875 throws ArchiverException
876 {
877 }
878
879 public void addDirectory( final File arg0, final String[] arg1, final String[] arg2 )
880 throws ArchiverException
881 {
882 }
883
884 public void addDirectory( final File arg0, final String arg1, final String[] arg2, final String[] arg3 )
885 throws ArchiverException
886 {
887 }
888
889 public void addFile( final File arg0, final String arg1 )
890 throws ArchiverException
891 {
892 }
893
894 public void addFile( final File arg0, final String arg1, final int arg2 )
895 throws ArchiverException
896 {
897 }
898
899 public void addFileSet( final FileSet arg0 )
900 throws ArchiverException
901 {
902 }
903
904 public void addResource( final PlexusIoResource arg0, final String arg1, final int arg2 )
905 throws ArchiverException
906 {
907 }
908
909 public void addResources( final PlexusIoResourceCollection arg0 )
910 throws ArchiverException
911 {
912 }
913
914 public void createArchive()
915 throws ArchiverException, IOException
916 {
917 }
918
919 public int getDefaultDirectoryMode()
920 {
921 return 0;
922 }
923
924 public int getDefaultFileMode()
925 {
926 return 0;
927 }
928
929 public File getDestFile()
930 {
931 return null;
932 }
933
934 @SuppressWarnings( "rawtypes" )
935 public Map getFiles()
936 {
937 return null;
938 }
939
940 public boolean getIncludeEmptyDirs()
941 {
942 return false;
943 }
944
945 public ResourceIterator getResources()
946 throws ArchiverException
947 {
948 return null;
949 }
950
951 public boolean isForced()
952 {
953 return false;
954 }
955
956 public boolean isSupportingForced()
957 {
958 return false;
959 }
960
961 public void setDefaultDirectoryMode( final int arg0 )
962 {
963 }
964
965 public void setDefaultFileMode( final int arg0 )
966 {
967 }
968
969 public void setDestFile( final File arg0 )
970 {
971 }
972
973 public void setDotFileDirectory( final File arg0 )
974 {
975 }
976
977 public void setForced( final boolean arg0 )
978 {
979 }
980
981 public void setIncludeEmptyDirs( final boolean arg0 )
982 {
983 }
984
985 public String getDuplicateBehavior()
986 {
987 return Archiver.DUPLICATES_ADD;
988 }
989
990 public void setDuplicateBehavior( final String duplicate )
991 {
992 }
993
994 public int getDirectoryMode()
995 {
996 return 0;
997 }
998
999 public int getFileMode()
1000 {
1001 return 0;
1002 }
1003
1004 public int getOverrideDirectoryMode()
1005 {
1006 return 0;
1007 }
1008
1009 public int getOverrideFileMode()
1010 {
1011 return 0;
1012 }
1013
1014 public void setDirectoryMode( final int mode )
1015 {
1016 }
1017
1018 public void setFileMode( final int mode )
1019 {
1020 }
1021
1022 public boolean isUseJvmChmod()
1023 {
1024 return useJvmChmod;
1025 }
1026
1027 public void setUseJvmChmod( final boolean useJvmChmod )
1028 {
1029 this.useJvmChmod = useJvmChmod;
1030 }
1031
1032 public boolean isIgnorePermissions()
1033 {
1034 return ignorePermissions;
1035 }
1036
1037 public void setIgnorePermissions( final boolean ignorePermissions )
1038 {
1039 this.ignorePermissions = ignorePermissions;
1040 }
1041
1042 }
1043
1044 }