View Javadoc

1   package org.apache.maven.plugin.resources;
2   
3   /*
4    * Licensed to the Apache Software Foundation (ASF) under one
5    * or more contributor license agreements.  See the NOTICE file
6    * distributed with this work for additional information
7    * regarding copyright ownership.  The ASF licenses this file
8    * to you under the Apache License, Version 2.0 (the
9    * "License"); you may not use this file except in compliance
10   * with the License.  You may obtain a copy of the License at
11   *
12   *   http://www.apache.org/licenses/LICENSE-2.0
13   *
14   * Unless required by applicable law or agreed to in writing,
15   * software distributed under the License is distributed on an
16   * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
17   * KIND, either express or implied.  See the License for the
18   * specific language governing permissions and limitations
19   * under the License.
20   */
21  
22  import org.apache.maven.execution.MavenSession;
23  import org.apache.maven.plugin.resources.stub.MavenProjectResourcesStub;
24  import org.apache.maven.plugin.testing.AbstractMojoTestCase;
25  import org.codehaus.plexus.util.FileUtils;
26  
27  import java.io.BufferedReader;
28  import java.io.File;
29  import java.io.FileInputStream;
30  import java.io.FileReader;
31  import java.io.IOException;
32  import java.util.LinkedList;
33  import java.util.List;
34  import java.util.Properties;
35  
36  public class ResourcesMojoTest
37      extends AbstractMojoTestCase
38  {
39      protected final static String defaultPomFilePath = "/target/test-classes/unit/resources-test/plugin-config.xml";
40      
41      /**
42       * test mojo lookup, test harness should be working fine
43       * 
44       * @throws Exception
45       */
46      public void testHarnessEnvironment()
47          throws Exception
48      {
49          File testPom = new File( getBasedir(), defaultPomFilePath );
50          ResourcesMojo mojo = (ResourcesMojo) lookupMojo( "resources", testPom );
51  
52          assertNotNull( mojo );
53      }
54      
55      /**
56       * @throws Exception
57       */
58      public void testResourceDirectoryStructure()
59          throws Exception
60      {
61          File testPom = new File( getBasedir(), defaultPomFilePath );
62          ResourcesMojo mojo = (ResourcesMojo) lookupMojo( "resources", testPom );
63          MavenProjectResourcesStub project = new MavenProjectResourcesStub( "resourceDirectoryStructure" );
64          List resources = project.getBuild().getResources();
65  
66          assertNotNull( mojo );
67  
68          project.addFile( "file4.txt" );
69          project.addFile( "package/file3.nottest" );
70          project.addFile( "notpackage/file1.include" );
71          project.addFile( "package/test/file1.txt" );
72          project.addFile( "notpackage/test/file2.txt" );
73          project.setupBuildEnvironment();
74  
75          setVariableValueToObject( mojo, "project", project );
76          setVariableValueToObject( mojo, "resources", resources );
77          setVariableValueToObject( mojo, "outputDirectory", new File( project.getBuild().getOutputDirectory() ) );
78          setVariableValueToObject( mojo, "buildFilters", new LinkedList() );
79          setVariableValueToObject( mojo, "useBuildFilters", Boolean.TRUE );
80          mojo.execute();
81  
82          String resourcesDir = project.getOutputDirectory();
83  
84          assertTrue( FileUtils.fileExists( resourcesDir + "/file4.txt" ) );
85          assertTrue( FileUtils.fileExists( resourcesDir + "/package/file3.nottest" ) );
86          assertTrue( FileUtils.fileExists( resourcesDir + "/notpackage/file1.include" ) );
87          assertTrue( FileUtils.fileExists( resourcesDir + "/package/test" ) );
88          assertTrue( FileUtils.fileExists( resourcesDir + "/notpackage/test" ) );
89      }
90  
91      /**
92       * @throws Exception
93       */
94      public void testResourceDirectoryStructure_RelativePath()
95          throws Exception
96      {
97          File testPom = new File( getBasedir(), defaultPomFilePath );
98          ResourcesMojo mojo = (ResourcesMojo) lookupMojo( "resources", testPom );
99          MavenProjectResourcesStub project = new MavenProjectResourcesStub( "resourceDirectoryStructure_RelativePath" );
100         List resources = project.getBuild().getResources();
101 
102         assertNotNull( mojo );
103 
104         project.setOutputDirectory( "../relative_dir" );
105         project.addFile( "file4.txt" );
106         project.addFile( "package/file3.nottest" );
107         project.addFile( "notpackage/file1.include" );
108         project.addFile( "package/test/file1.txt" );
109         project.addFile( "notpackage/test/file2.txt" );
110         project.setupBuildEnvironment();
111 
112         setVariableValueToObject( mojo, "outputDirectory", new File( project.getBuild().getOutputDirectory() ) );
113         setVariableValueToObject( mojo, "project", project );
114         setVariableValueToObject( mojo, "resources", resources );
115         setVariableValueToObject( mojo, "buildFilters", new LinkedList() );
116         setVariableValueToObject( mojo, "useBuildFilters", Boolean.TRUE );
117         mojo.execute();
118 
119         String resourcesDir = project.getOutputDirectory();
120 
121         assertTrue( FileUtils.fileExists( resourcesDir + "/file4.txt" ) );
122         assertTrue( FileUtils.fileExists( resourcesDir + "/package/file3.nottest" ) );
123         assertTrue( FileUtils.fileExists( resourcesDir + "/notpackage/file1.include" ) );
124         assertTrue( FileUtils.fileExists( resourcesDir + "/package/test" ) );
125         assertTrue( FileUtils.fileExists( resourcesDir + "/notpackage/test" ) );
126     }
127 
128     /**
129      * @throws Exception
130      */
131     public void testResourceEncoding()
132         throws Exception
133     {
134         File testPom = new File( getBasedir(), defaultPomFilePath );
135         ResourcesMojo mojo = (ResourcesMojo) lookupMojo( "resources", testPom );
136         MavenProjectResourcesStub project = new MavenProjectResourcesStub( "encoding" );
137         List resources = project.getBuild().getResources();
138 
139         assertNotNull( mojo );
140 
141         project.addFile( "file4.txt" );
142         project.setResourceFiltering( 0, true );
143         project.setupBuildEnvironment();
144 
145         setVariableValueToObject( mojo, "encoding", "UTF-8" );
146         setVariableValueToObject( mojo, "project", project );
147         setVariableValueToObject( mojo, "resources", resources );
148         setVariableValueToObject( mojo, "outputDirectory", new File( project.getBuild().getOutputDirectory() ) );
149         setVariableValueToObject( mojo, "buildFilters", new LinkedList() );
150         setVariableValueToObject( mojo, "useBuildFilters", Boolean.TRUE );
151         mojo.execute();
152 
153         String resourcesDir = project.getOutputDirectory();
154 
155         assertTrue( FileUtils.fileExists( resourcesDir + "/file4.txt" ) );
156     }
157 
158     /**
159      * @throws Exception
160      */
161     public void testResourceInclude()
162         throws Exception
163     {
164         File testPom = new File( getBasedir(), defaultPomFilePath );
165         ResourcesMojo mojo = (ResourcesMojo) lookupMojo( "resources", testPom );
166         MavenProjectResourcesStub project = new MavenProjectResourcesStub( "resourceInclude" );
167         List resources = project.getBuild().getResources();
168 
169         assertNotNull( mojo );
170 
171         project.addFile( "file1.include" );
172         project.addFile( "file2.exclude" );
173         project.addFile( "file3.nottest" );
174         project.addFile( "file4.txt" );
175         project.addFile( "package/file1.include" );
176         project.addFile( "package/file2.exclude" );
177         project.addFile( "package/file3.nottest" );
178         project.addFile( "package/file4.txt" );
179         project.addFile( "notpackage/file1.include" );
180         project.addFile( "notpackage/file2.exclude" );
181         project.addFile( "notpackage/file3.nottest" );
182         project.addFile( "notpackage/file4.txt" );
183         project.addFile( "package/test/file1.txt" );
184         project.addFile( "package/nottest/file2.txt" );
185         project.addFile( "notpackage/test/file1.txt" );
186         project.addFile( "notpackage/nottest/file.txt" );
187         project.setupBuildEnvironment();
188 
189         project.addInclude( "*.include" );
190         project.addInclude( "**/test" );
191         project.addInclude( "**/test/file*" );
192         project.addInclude( "**/package/*.include" );
193 
194         setVariableValueToObject( mojo, "outputDirectory", new File( project.getBuild().getOutputDirectory() ) );
195         setVariableValueToObject( mojo, "project", project );
196         setVariableValueToObject( mojo, "resources", resources );
197         setVariableValueToObject( mojo, "buildFilters", new LinkedList() );
198         setVariableValueToObject( mojo, "useBuildFilters", Boolean.TRUE );
199         mojo.execute();
200 
201         String resourcesDir = project.getOutputDirectory();
202 
203         assertTrue( FileUtils.fileExists( resourcesDir + "/package/test" ) );
204         assertTrue( FileUtils.fileExists( resourcesDir + "/file1.include" ) );
205         assertTrue( FileUtils.fileExists( resourcesDir + "/package/file1.include" ) );
206         assertFalse( FileUtils.fileExists( resourcesDir + "/notpackage/file1.include" ) );
207         assertFalse( FileUtils.fileExists( resourcesDir + "/notpackage/nottest/file.txt" ) );
208     }
209 
210     /**
211      * @throws Exception
212      */
213     public void testResourceExclude()
214         throws Exception
215     {
216         File testPom = new File( getBasedir(), defaultPomFilePath );
217         ResourcesMojo mojo = (ResourcesMojo) lookupMojo( "resources", testPom );
218         MavenProjectResourcesStub project = new MavenProjectResourcesStub( "resourceExclude" );
219         List resources = project.getBuild().getResources();
220         ;
221 
222         assertNotNull( mojo );
223 
224         project.addFile( "file1.include" );
225         project.addFile( "file2.exclude" );
226         project.addFile( "file3.nottest" );
227         project.addFile( "file4.txt" );
228         project.addFile( "package/file1.include" );
229         project.addFile( "package/file2.exclude" );
230         project.addFile( "package/file3.nottest" );
231         project.addFile( "package/file4.txt" );
232         project.addFile( "notpackage/file1.include" );
233         project.addFile( "notpackage/file2.exclude" );
234         project.addFile( "notpackage/file3.nottest" );
235         project.addFile( "notpackage/file4.txt" );
236         project.addFile( "package/test/file1.txt" );
237         project.addFile( "package/nottest/file2.txt" );
238         project.addFile( "notpackage/test/file1.txt" );
239         project.addFile( "notpackage/nottest/file.txt" );
240         project.setupBuildEnvironment();
241 
242         project.addExclude( "**/*.exclude" );
243         project.addExclude( "**/nottest*" );
244         project.addExclude( "**/notest" );
245         project.addExclude( "**/notpackage*" );
246         project.addExclude( "**/notpackage*/**" );
247 
248         setVariableValueToObject( mojo, "outputDirectory", new File( project.getBuild().getOutputDirectory() ) );
249         setVariableValueToObject( mojo, "project", project );
250         setVariableValueToObject( mojo, "resources", resources );
251         setVariableValueToObject( mojo, "buildFilters", new LinkedList() );
252         setVariableValueToObject( mojo, "useBuildFilters", Boolean.TRUE );
253         mojo.execute();
254 
255         String resourcesDir = project.getOutputDirectory();
256 
257         assertTrue( FileUtils.fileExists( resourcesDir + "/package/test" ) );
258         assertTrue( FileUtils.fileExists( resourcesDir + "/file1.include" ) );
259         assertTrue( FileUtils.fileExists( resourcesDir + "/package/file1.include" ) );
260         assertFalse( FileUtils.fileExists( resourcesDir + "/notpackage/file1.include" ) );
261         assertFalse( FileUtils.fileExists( resourcesDir + "/notpackage/nottest/file.txt" ) );
262     }
263 
264     /**
265      * @throws Exception
266      */
267     public void testResourceTargetPath()
268         throws Exception
269     {
270         File testPom = new File( getBasedir(), defaultPomFilePath );
271         ResourcesMojo mojo = (ResourcesMojo) lookupMojo( "resources", testPom );
272         MavenProjectResourcesStub project = new MavenProjectResourcesStub( "resourceTargetPath" );
273         List resources = project.getBuild().getResources();
274 
275         assertNotNull( mojo );
276 
277         project.setTargetPath( "org/apache/maven/plugin/test" );
278 
279         project.addFile( "file4.txt" );
280         project.addFile( "package/file3.nottest" );
281         project.addFile( "notpackage/file1.include" );
282         project.addFile( "package/test/file1.txt" );
283         project.addFile( "notpackage/test/file2.txt" );
284         project.setupBuildEnvironment();
285 
286         setVariableValueToObject( mojo, "outputDirectory", new File( project.getBuild().getOutputDirectory() ) );
287         setVariableValueToObject( mojo, "project", project );
288         setVariableValueToObject( mojo, "resources", resources );
289         setVariableValueToObject( mojo, "buildFilters", new LinkedList() );
290         setVariableValueToObject( mojo, "useBuildFilters", Boolean.TRUE );
291         mojo.execute();
292 
293         String resourcesDir = project.getOutputDirectory();
294 
295         assertTrue( FileUtils.fileExists( resourcesDir + "/org/apache/maven/plugin/test/file4.txt" ) );
296         assertTrue( FileUtils.fileExists( resourcesDir + "/org/apache/maven/plugin/test/package/file3.nottest" ) );
297         assertTrue( FileUtils.fileExists( resourcesDir + "/org/apache/maven/plugin/test/notpackage/file1.include" ) );
298         assertTrue( FileUtils.fileExists( resourcesDir + "/org/apache/maven/plugin/test/package/test" ) );
299         assertTrue( FileUtils.fileExists( resourcesDir + "/org/apache/maven/plugin/test/notpackage/test" ) );
300     }
301 
302     /**
303      * @throws Exception
304      */
305     public void testResourceSystemProperties_Filtering()
306         throws Exception
307     {
308         File testPom = new File( getBasedir(), defaultPomFilePath );
309         ResourcesMojo mojo = (ResourcesMojo) lookupMojo( "resources", testPom );
310         MavenProjectResourcesStub project = new MavenProjectResourcesStub( "resourceSystemProperties_Filtering" );
311         List resources = project.getBuild().getResources();
312 
313         assertNotNull( mojo );
314 
315         project.addFile( "file4.txt", "current-working-directory = ${user.dir}" );
316         project.setResourceFiltering( 0, true );
317         project.setupBuildEnvironment();
318 
319         // setVariableValueToObject(mojo,"encoding","UTF-8");
320         setVariableValueToObject( mojo, "project", project );
321         setVariableValueToObject( mojo, "resources", resources );
322         setVariableValueToObject( mojo, "outputDirectory", new File( project.getBuild().getOutputDirectory() ) );
323         setVariableValueToObject( mojo, "buildFilters", new LinkedList() );
324         setVariableValueToObject( mojo, "useBuildFilters", Boolean.TRUE );
325         setVariableValueToObject( mojo, "escapeWindowsPaths", Boolean.TRUE );
326         MavenSession mavenSession = new MavenSession( null, null, null, null, null, null, null, System.getProperties(),
327                                                       null );
328         setVariableValueToObject( mojo, "session", mavenSession );
329         mojo.execute();
330 
331         String resourcesDir = project.getOutputDirectory();
332 
333         File userDir = new File( System.getProperty( "user.dir" ) );
334         assertTrue( userDir.exists() );
335 
336         Properties props = new Properties();
337         props.load( new FileInputStream( new File( resourcesDir, "file4.txt" ) ) );
338         File fileFromFiltering = new File( props.getProperty( "current-working-directory" ) );
339         
340         assertTrue( fileFromFiltering.getAbsolutePath() + " does not exist.", fileFromFiltering.exists() );
341         assertEquals( userDir.getAbsolutePath(), fileFromFiltering.getAbsolutePath() );
342     }
343 
344     /**
345      * @throws Exception
346      */
347     public void testResourceProjectProperties_Filtering()
348         throws Exception
349     {
350         File testPom = new File( getBasedir(), defaultPomFilePath );
351         ResourcesMojo mojo = (ResourcesMojo) lookupMojo( "resources", testPom );
352         MavenProjectResourcesStub project = new MavenProjectResourcesStub( "resourceProjectProperties_Filtering" );
353         List resources = project.getBuild().getResources();
354 
355         assertNotNull( mojo );
356 
357         project.addFile( "file4.txt", "current working directory = ${user.dir}" );
358         project.setResourceFiltering( 0, true );
359         project.addProperty( "user.dir", "FPJ kami!!!" );
360         project.setupBuildEnvironment();
361 
362         // setVariableValueToObject(mojo,"encoding","UTF-8");
363         setVariableValueToObject( mojo, "project", project );
364         setVariableValueToObject( mojo, "resources", resources );
365         setVariableValueToObject( mojo, "outputDirectory", new File( project.getBuild().getOutputDirectory() ) );
366         setVariableValueToObject( mojo, "buildFilters", new LinkedList() );
367         setVariableValueToObject( mojo, "useBuildFilters", Boolean.TRUE );
368         mojo.execute();
369 
370         String resourcesDir = project.getOutputDirectory();
371         String checkString = "current working directory = FPJ kami!!!";
372 
373         assertContent( resourcesDir + "/file4.txt", checkString );
374     }
375 
376     /**
377      * @throws Exception
378      */
379     public void testProjectProperty_Filtering_PropertyDestination()
380         throws Exception
381     {
382         File testPom = new File( getBasedir(), defaultPomFilePath );
383         ResourcesMojo mojo = (ResourcesMojo) lookupMojo( "resources", testPom );
384         MavenProjectResourcesStub project = new MavenProjectResourcesStub(
385                                                                            "resourcePojectProperty_Filtering_PropertyDestination" );
386         List resources = project.getBuild().getResources();
387 
388         assertNotNull( mojo );
389 
390         project.addFile( "file4.properties", "current working directory=${description}" );
391         project.setResourceFiltering( 0, true );
392         project.setupBuildEnvironment();
393 
394         // setup dummy property
395         project.setDescription( "c:\\\\org\\apache\\test" );
396 
397         // setVariableValueToObject(mojo,"encoding","UTF-8");
398         setVariableValueToObject( mojo, "project", project );
399         setVariableValueToObject( mojo, "resources", resources );
400         setVariableValueToObject( mojo, "outputDirectory", new File( project.getBuild().getOutputDirectory() ) );
401         setVariableValueToObject( mojo, "buildFilters", new LinkedList() );
402         setVariableValueToObject( mojo, "useBuildFilters", Boolean.TRUE );
403         setVariableValueToObject( mojo, "escapeWindowsPaths", Boolean.TRUE );
404         mojo.execute();
405 
406         String resourcesDir = project.getOutputDirectory();
407         String checkString = "current working directory=c:\\\\org\\\\apache\\\\test";
408 
409         assertContent( resourcesDir + "/file4.properties", checkString );
410     }
411 
412     /**
413      * @throws Exception
414      */
415     public void testPropertyFiles_Filtering()
416         throws Exception
417     {
418         File testPom = new File( getBasedir(), defaultPomFilePath );
419         ResourcesMojo mojo = (ResourcesMojo) lookupMojo( "resources", testPom );
420         MavenProjectResourcesStub project = new MavenProjectResourcesStub( "resourcePropertyFiles_Filtering" );
421         List resources = project.getBuild().getResources();
422         LinkedList filterList = new LinkedList();
423 
424         assertNotNull( mojo );
425 
426         project.addFile( "file4.properties", "current working directory=${dir}" );
427         project.addFile( "filter.properties", "dir:testdir" );
428         project.setResourceFiltering( 0, true );
429         project.setupBuildEnvironment();
430         filterList.add( project.getResourcesDirectory() + "filter.properties" );
431 
432         // setVariableValueToObject(mojo,"encoding","UTF-8");
433         setVariableValueToObject( mojo, "project", project );
434         setVariableValueToObject( mojo, "resources", resources );
435         setVariableValueToObject( mojo, "outputDirectory", new File( project.getBuild().getOutputDirectory() ) );
436         setVariableValueToObject( mojo, "buildFilters", filterList );
437         setVariableValueToObject( mojo, "useBuildFilters", Boolean.TRUE );
438         mojo.execute();
439 
440         String resourcesDir = project.getOutputDirectory();
441         String checkString = "current working directory=testdir";
442 
443         assertContent( resourcesDir + "/file4.properties", checkString );
444     }
445 
446     /**
447      * @throws Exception
448      */
449     public void testPropertyFiles_Extra()
450         throws Exception
451     {
452         File testPom = new File( getBasedir(), defaultPomFilePath );
453         ResourcesMojo mojo = (ResourcesMojo) lookupMojo( "resources", testPom );
454         MavenProjectResourcesStub project = new MavenProjectResourcesStub( "resourcePropertyFiles_Extra" );
455         List resources = project.getBuild().getResources();
456         LinkedList filterList = new LinkedList();
457 
458         assertNotNull( mojo );
459 
460         project.addFile( "extra.properties", "current working directory=${dir}" );
461         project.addFile( "filter.properties", "dir:testdir" );
462         project.setResourceFiltering( 0, true );
463         project.setupBuildEnvironment();
464         filterList.add( project.getResourcesDirectory() + "filter.properties" );
465 
466         // setVariableValueToObject(mojo,"encoding","UTF-8");
467         setVariableValueToObject( mojo, "project", project );
468         setVariableValueToObject( mojo, "resources", resources );
469         setVariableValueToObject( mojo, "outputDirectory", new File( project.getBuild().getOutputDirectory() ) );
470         setVariableValueToObject( mojo, "filters", filterList );
471         setVariableValueToObject( mojo, "useBuildFilters", Boolean.TRUE );
472         mojo.execute();
473 
474         String resourcesDir = project.getOutputDirectory();
475         String checkString = "current working directory=testdir";
476 
477         assertContent( resourcesDir + "/extra.properties", checkString );
478     }
479 
480     /**
481      * @throws Exception
482      */
483     public void testPropertyFiles_MainAndExtra()
484         throws Exception
485     {
486         File testPom = new File( getBasedir(), defaultPomFilePath );
487         ResourcesMojo mojo = (ResourcesMojo) lookupMojo( "resources", testPom );
488         MavenProjectResourcesStub project = new MavenProjectResourcesStub( "resourcePropertyFiles_MainAndExtra" );
489         List resources = project.getBuild().getResources();
490         LinkedList filterList = new LinkedList();
491         LinkedList extraFilterList = new LinkedList();
492 
493         assertNotNull( mojo );
494 
495         project.addFile( "main-extra.properties", "current working directory=${dir}; old working directory=${dir2}" );
496         project.addFile( "filter.properties", "dir:testdir" );
497         project.addFile( "extra-filter.properties", "dir2:testdir2" );
498         project.setResourceFiltering( 0, true );
499         
500         project.cleanBuildEnvironment();
501         project.setupBuildEnvironment();
502         
503         filterList.add( project.getResourcesDirectory() + "filter.properties" );
504         extraFilterList.add( project.getResourcesDirectory() + "extra-filter.properties" );
505 
506         // setVariableValueToObject(mojo,"encoding","UTF-8");
507         setVariableValueToObject( mojo, "project", project );
508         setVariableValueToObject( mojo, "resources", resources );
509         setVariableValueToObject( mojo, "outputDirectory", new File( project.getBuild().getOutputDirectory() ) );
510         setVariableValueToObject( mojo, "buildFilters", filterList );
511         setVariableValueToObject( mojo, "filters", extraFilterList );
512         setVariableValueToObject( mojo, "useBuildFilters", Boolean.TRUE );
513         mojo.execute();
514 
515         String resourcesDir = project.getOutputDirectory();
516         String checkString = "current working directory=testdir; old working directory=testdir2";
517 
518         File file = new File( resourcesDir, "main-extra.properties" );
519         assertContent( file.getAbsolutePath(), checkString );
520     }
521 
522     /**
523      * Validates that a Filter token containing a project property will be resolved before the Filter is applied to the
524      * resources.
525      * 
526      * @throws Exception
527      */
528     public void testPropertyFiles_Filtering_TokensInFilters()
529         throws Exception
530     {
531         final File testPom = new File( getBasedir(), defaultPomFilePath );
532         final ResourcesMojo mojo = (ResourcesMojo) lookupMojo( "resources", testPom );
533         final MavenProjectResourcesStub project = new MavenProjectResourcesStub(
534                                                                                  "resourcePropertyFiles_Filtering_TokensInFilters" );
535         final List resources = project.getBuild().getResources();
536         final LinkedList filterList = new LinkedList();
537 
538         assertNotNull( mojo );
539 
540         project.addFile( "file4.properties", "current working directory=${filter.token}" );
541         project.addFile( "filter.properties", "filter.token=${pom-property}" );
542         project.setResourceFiltering( 0, true );
543         project.addProperty( "pom-property", "foobar" );
544         project.setupBuildEnvironment();
545         filterList.add( project.getResourcesDirectory() + "filter.properties" );
546 
547         // setVariableValueToObject(mojo,"encoding","UTF-8");
548         setVariableValueToObject( mojo, "project", project );
549         setVariableValueToObject( mojo, "resources", resources );
550         setVariableValueToObject( mojo, "outputDirectory", new File( project.getBuild().getOutputDirectory() ) );
551         setVariableValueToObject( mojo, "buildFilters", filterList );
552         setVariableValueToObject( mojo, "useBuildFilters", Boolean.TRUE );
553         mojo.execute();
554         final String resourcesDir = project.getOutputDirectory();
555 
556         final String checkString = "current working directory=foobar";
557 
558         assertContent( resourcesDir + "/file4.properties", checkString );
559     }
560 
561     public void testWindowsPathEscapingDisabled()
562         throws Exception
563     {
564         File testPom = new File( getBasedir(), defaultPomFilePath );
565         ResourcesMojo mojo = (ResourcesMojo) lookupMojo( "resources", testPom );
566         MavenProjectResourcesStub project = new MavenProjectResourcesStub( "windows-paths" );
567         List resources = project.getBuild().getResources();
568 
569         assertNotNull( mojo );
570 
571         project.getProperties().setProperty( "basePath", "C:\\Users\\Administrator" );
572         project.getProperties().setProperty( "docsPath", "${basePath}\\Documents" );
573 
574         project.addFile( "path-listing.txt", "base path is ${basePath}\ndocuments path is ${docsPath}" );
575         project.setResourceFiltering( 0, true );
576 
577         project.cleanBuildEnvironment();
578         project.setupBuildEnvironment();
579 
580         setVariableValueToObject( mojo, "project", project );
581         setVariableValueToObject( mojo, "resources", resources );
582         setVariableValueToObject( mojo, "outputDirectory", new File( project.getBuild().getOutputDirectory() ) );
583         setVariableValueToObject( mojo, "buildFilters", new LinkedList() );
584         setVariableValueToObject( mojo, "useBuildFilters", Boolean.TRUE );
585         setVariableValueToObject( mojo, "escapeWindowsPaths", Boolean.FALSE );
586 
587         mojo.execute();
588 
589         String resourcesDir = project.getOutputDirectory();
590 
591         assertTrue( FileUtils.fileExists( new File( resourcesDir, "path-listing.txt" ).getAbsolutePath() ) );
592 
593         assertEquals( "base path is C:\\Users\\Administrator\ndocuments path is C:\\Users\\Administrator\\Documents",
594                       FileUtils.fileRead( new File( resourcesDir, "path-listing.txt" ) ) );
595     }
596 
597     public void testWindowsPathEscapingEnabled()
598         throws Exception
599     {
600         File testPom = new File( getBasedir(), defaultPomFilePath );
601         ResourcesMojo mojo = (ResourcesMojo) lookupMojo( "resources", testPom );
602         MavenProjectResourcesStub project = new MavenProjectResourcesStub( "windows-paths" );
603         List resources = project.getBuild().getResources();
604 
605         assertNotNull( mojo );
606 
607         project.getProperties().setProperty( "basePath", "C:\\Users\\Administrator" );
608         project.getProperties().setProperty( "docsPath", "${basePath}\\Documents" );
609 
610         project.addFile( "path-listing.txt", "base path is ${basePath}\ndocuments path is ${docsPath}" );
611         project.setResourceFiltering( 0, true );
612 
613         project.cleanBuildEnvironment();
614         project.setupBuildEnvironment();
615 
616         setVariableValueToObject( mojo, "project", project );
617         setVariableValueToObject( mojo, "resources", resources );
618         setVariableValueToObject( mojo, "outputDirectory", new File( project.getBuild().getOutputDirectory() ) );
619         setVariableValueToObject( mojo, "buildFilters", new LinkedList() );
620         setVariableValueToObject( mojo, "useBuildFilters", Boolean.TRUE );
621 
622         setVariableValueToObject( mojo, "escapeWindowsPaths", Boolean.TRUE );
623 
624         mojo.execute();
625 
626         String resourcesDir = project.getOutputDirectory();
627 
628         assertTrue( FileUtils.fileExists( new File( resourcesDir, "path-listing.txt" ).getAbsolutePath() ) );
629 
630         assertEquals( "base path is C:\\\\Users\\\\Administrator\ndocuments path is C:\\\\Users\\\\Administrator\\\\Documents",
631                       FileUtils.fileRead( new File( resourcesDir, "path-listing.txt" ) ) );
632     }
633 
634     /**
635      * Ensures the file exists and its first line equals the given data.
636      */
637     private void assertContent( String fileName, String data )
638         throws IOException
639     {
640         assertTrue( FileUtils.fileExists( fileName ) );
641 
642         assertEquals( data, new BufferedReader( new FileReader( fileName ) ).readLine() );
643     }
644 
645 }