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