1 | /*
|
---|
2 | * Copyright 2000-2005 The Apache Software Foundation
|
---|
3 | *
|
---|
4 | * Licensed under the Apache License, Version 2.0 (the "License");
|
---|
5 | * you may not use this file except in compliance with the License.
|
---|
6 | * You may obtain a copy of the License at
|
---|
7 | *
|
---|
8 | * http://www.apache.org/licenses/LICENSE-2.0
|
---|
9 | *
|
---|
10 | * Unless required by applicable law or agreed to in writing, software
|
---|
11 | * distributed under the License is distributed on an "AS IS" BASIS,
|
---|
12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
---|
13 | * See the License for the specific language governing permissions and
|
---|
14 | * limitations under the License.
|
---|
15 | *
|
---|
16 | */
|
---|
17 |
|
---|
18 | package org.apache.tools.ant.taskdefs;
|
---|
19 |
|
---|
20 | import java.io.File;
|
---|
21 |
|
---|
22 | import junit.framework.AssertionFailedError;
|
---|
23 |
|
---|
24 | import org.apache.tools.ant.BuildEvent;
|
---|
25 | import org.apache.tools.ant.BuildFileTest;
|
---|
26 | import org.apache.tools.ant.BuildListener;
|
---|
27 | import org.apache.tools.ant.input.InputHandler;
|
---|
28 | import org.apache.tools.ant.input.PropertyFileInputHandler;
|
---|
29 | import org.apache.tools.ant.types.Path;
|
---|
30 |
|
---|
31 | /**
|
---|
32 | */
|
---|
33 | public class AntTest extends BuildFileTest {
|
---|
34 |
|
---|
35 | public AntTest(String name) {
|
---|
36 | super(name);
|
---|
37 | }
|
---|
38 |
|
---|
39 | public void setUp() {
|
---|
40 | configureProject("src/etc/testcases/taskdefs/ant.xml");
|
---|
41 | }
|
---|
42 |
|
---|
43 | public void tearDown() {
|
---|
44 | executeTarget("cleanup");
|
---|
45 | }
|
---|
46 |
|
---|
47 | public void test1() {
|
---|
48 | expectBuildException("test1", "recursive call");
|
---|
49 | }
|
---|
50 |
|
---|
51 | // target must be specified
|
---|
52 | public void test2() {
|
---|
53 | expectBuildException("test2", "required argument not specified");
|
---|
54 | }
|
---|
55 |
|
---|
56 | // Should fail since a recursion will occur...
|
---|
57 | public void test3() {
|
---|
58 | expectBuildException("test1", "recursive call");
|
---|
59 | }
|
---|
60 |
|
---|
61 | public void test4() {
|
---|
62 | expectBuildException("test4", "target attribute must not be empty");
|
---|
63 | }
|
---|
64 |
|
---|
65 | public void test4b() {
|
---|
66 | expectBuildException("test4b", "target doesn't exist");
|
---|
67 | }
|
---|
68 |
|
---|
69 | public void test5() {
|
---|
70 | executeTarget("test5");
|
---|
71 | }
|
---|
72 |
|
---|
73 | public void test6() {
|
---|
74 | executeTarget("test6");
|
---|
75 | }
|
---|
76 |
|
---|
77 | public void testExplicitBasedir1() {
|
---|
78 | File dir1 = getProjectDir();
|
---|
79 | File dir2 = project.resolveFile("..");
|
---|
80 | testBaseDirs("explicitBasedir1",
|
---|
81 | new String[] {dir1.getAbsolutePath(),
|
---|
82 | dir2.getAbsolutePath()
|
---|
83 | });
|
---|
84 | }
|
---|
85 |
|
---|
86 | public void testExplicitBasedir2() {
|
---|
87 | File dir1 = getProjectDir();
|
---|
88 | File dir2 = project.resolveFile("..");
|
---|
89 | testBaseDirs("explicitBasedir2",
|
---|
90 | new String[] {dir1.getAbsolutePath(),
|
---|
91 | dir2.getAbsolutePath()
|
---|
92 | });
|
---|
93 | }
|
---|
94 |
|
---|
95 | public void testInheritBasedir() {
|
---|
96 | String basedir = getProjectDir().getAbsolutePath();
|
---|
97 | testBaseDirs("inheritBasedir", new String[] {basedir, basedir});
|
---|
98 | }
|
---|
99 |
|
---|
100 | public void testDoNotInheritBasedir() {
|
---|
101 | File dir1 = getProjectDir();
|
---|
102 | File dir2 = project.resolveFile("ant");
|
---|
103 | String basedir = getProjectDir().getAbsolutePath();
|
---|
104 | testBaseDirs("doNotInheritBasedir",
|
---|
105 | new String[] {dir1.getAbsolutePath(),
|
---|
106 | dir2.getAbsolutePath()
|
---|
107 | });
|
---|
108 | }
|
---|
109 |
|
---|
110 | public void testBasedirTripleCall() {
|
---|
111 | File dir1 = getProjectDir();
|
---|
112 | File dir2 = project.resolveFile("ant");
|
---|
113 | testBaseDirs("tripleCall",
|
---|
114 | new String[] {dir1.getAbsolutePath(),
|
---|
115 | dir2.getAbsolutePath(),
|
---|
116 | dir1.getAbsolutePath()
|
---|
117 | });
|
---|
118 | }
|
---|
119 |
|
---|
120 | protected void testBaseDirs(String target, String[] dirs) {
|
---|
121 | BasedirChecker bc = new BasedirChecker(dirs);
|
---|
122 | project.addBuildListener(bc);
|
---|
123 | executeTarget(target);
|
---|
124 | AssertionFailedError ae = bc.getError();
|
---|
125 | if (ae != null) {
|
---|
126 | throw ae;
|
---|
127 | }
|
---|
128 | project.removeBuildListener(bc);
|
---|
129 | }
|
---|
130 |
|
---|
131 | public void testReferenceInheritance() {
|
---|
132 | Path p = Path.systemClasspath;
|
---|
133 | p.setProject(project);
|
---|
134 | project.addReference("path", p);
|
---|
135 | project.addReference("no-override", p);
|
---|
136 | testReference("testInherit", new String[] {"path", "path"},
|
---|
137 | new boolean[] {true, true}, p);
|
---|
138 | testReference("testInherit",
|
---|
139 | new String[] {"no-override", "no-override"},
|
---|
140 | new boolean[] {true, false}, p);
|
---|
141 | testReference("testInherit",
|
---|
142 | new String[] {"no-override", "no-override"},
|
---|
143 | new boolean[] {false, false}, null);
|
---|
144 | }
|
---|
145 |
|
---|
146 | public void testReferenceNoInheritance() {
|
---|
147 | Path p = Path.systemClasspath;
|
---|
148 | p.setProject(project);
|
---|
149 | project.addReference("path", p);
|
---|
150 | project.addReference("no-override", p);
|
---|
151 | testReference("testNoInherit", new String[] {"path", "path"},
|
---|
152 | new boolean[] {true, false}, p);
|
---|
153 | testReference("testNoInherit", new String[] {"path", "path"},
|
---|
154 | new boolean[] {false, true}, null);
|
---|
155 | testReference("testInherit",
|
---|
156 | new String[] {"no-override", "no-override"},
|
---|
157 | new boolean[] {true, false}, p);
|
---|
158 | testReference("testInherit",
|
---|
159 | new String[] {"no-override", "no-override"},
|
---|
160 | new boolean[] {false, false}, null);
|
---|
161 | }
|
---|
162 |
|
---|
163 | public void testReferenceRename() {
|
---|
164 | Path p = Path.systemClasspath;
|
---|
165 | p.setProject(project);
|
---|
166 | project.addReference("path", p);
|
---|
167 | testReference("testRename", new String[] {"path", "path"},
|
---|
168 | new boolean[] {true, false}, p);
|
---|
169 | testReference("testRename", new String[] {"path", "path"},
|
---|
170 | new boolean[] {false, true}, null);
|
---|
171 | testReference("testRename", new String[] {"newpath", "newpath"},
|
---|
172 | new boolean[] {false, true}, p);
|
---|
173 | }
|
---|
174 |
|
---|
175 | public void testInheritPath() {
|
---|
176 | executeTarget("testInheritPath");
|
---|
177 | }
|
---|
178 |
|
---|
179 | protected void testReference(String target, String[] keys,
|
---|
180 | boolean[] expect, Object value) {
|
---|
181 | ReferenceChecker rc = new ReferenceChecker(keys, expect, value);
|
---|
182 | project.addBuildListener(rc);
|
---|
183 | executeTarget(target);
|
---|
184 | AssertionFailedError ae = rc.getError();
|
---|
185 | if (ae != null) {
|
---|
186 | throw ae;
|
---|
187 | }
|
---|
188 | project.removeBuildListener(rc);
|
---|
189 | }
|
---|
190 |
|
---|
191 | public void testLogfilePlacement() {
|
---|
192 | File[] logFiles = new File[] {
|
---|
193 | getProject().resolveFile("test1.log"),
|
---|
194 | getProject().resolveFile("test2.log"),
|
---|
195 | getProject().resolveFile("ant/test3.log"),
|
---|
196 | getProject().resolveFile("ant/test4.log")
|
---|
197 | };
|
---|
198 | for (int i=0; i<logFiles.length; i++) {
|
---|
199 | assertTrue(logFiles[i].getName()+" doesn\'t exist",
|
---|
200 | !logFiles[i].exists());
|
---|
201 | }
|
---|
202 |
|
---|
203 | executeTarget("testLogfilePlacement");
|
---|
204 |
|
---|
205 | for (int i=0; i<logFiles.length; i++) {
|
---|
206 | assertTrue(logFiles[i].getName()+" exists",
|
---|
207 | logFiles[i].exists());
|
---|
208 | }
|
---|
209 | }
|
---|
210 |
|
---|
211 | public void testInputHandlerInheritance() {
|
---|
212 | InputHandler ih = new PropertyFileInputHandler();
|
---|
213 | getProject().setInputHandler(ih);
|
---|
214 | InputHandlerChecker ic = new InputHandlerChecker(ih);
|
---|
215 | getProject().addBuildListener(ic);
|
---|
216 | executeTarget("tripleCall");
|
---|
217 | AssertionFailedError ae = ic.getError();
|
---|
218 | if (ae != null) {
|
---|
219 | throw ae;
|
---|
220 | }
|
---|
221 | getProject().removeBuildListener(ic);
|
---|
222 | }
|
---|
223 |
|
---|
224 | public void testRefId() {
|
---|
225 | Path testPath = new Path(project);
|
---|
226 | testPath.createPath().setPath(System.getProperty("java.class.path"));
|
---|
227 | PropertyChecker pc =
|
---|
228 | new PropertyChecker("testprop",
|
---|
229 | new String[] {null,
|
---|
230 | testPath.toString()});
|
---|
231 | project.addBuildListener(pc);
|
---|
232 | executeTarget("testRefid");
|
---|
233 | AssertionFailedError ae = pc.getError();
|
---|
234 | if (ae != null) {
|
---|
235 | throw ae;
|
---|
236 | }
|
---|
237 | project.removeBuildListener(pc);
|
---|
238 | }
|
---|
239 |
|
---|
240 | public void testUserPropertyWinsInheritAll() {
|
---|
241 | getProject().setUserProperty("test", "7");
|
---|
242 | expectLogContaining("test-property-override-inheritall-start",
|
---|
243 | "The value of test is 7");
|
---|
244 | }
|
---|
245 |
|
---|
246 | public void testUserPropertyWinsNoInheritAll() {
|
---|
247 | getProject().setUserProperty("test", "7");
|
---|
248 | expectLogContaining("test-property-override-no-inheritall-start",
|
---|
249 | "The value of test is 7");
|
---|
250 | }
|
---|
251 |
|
---|
252 | public void testOverrideWinsInheritAll() {
|
---|
253 | expectLogContaining("test-property-override-inheritall-start",
|
---|
254 | "The value of test is 4");
|
---|
255 | }
|
---|
256 |
|
---|
257 | public void testOverrideWinsNoInheritAll() {
|
---|
258 | expectLogContaining("test-property-override-no-inheritall-start",
|
---|
259 | "The value of test is 4");
|
---|
260 | }
|
---|
261 |
|
---|
262 | public void testPropertySet() {
|
---|
263 | executeTarget("test-propertyset");
|
---|
264 | assertTrue(getLog().indexOf("test1 is ${test1}") > -1);
|
---|
265 | assertTrue(getLog().indexOf("test2 is ${test2}") > -1);
|
---|
266 | assertTrue(getLog().indexOf("test1.x is 1") > -1);
|
---|
267 | }
|
---|
268 |
|
---|
269 | public void testInfiniteLoopViaDepends() {
|
---|
270 | expectBuildException("infinite-loop-via-depends", "recursive call");
|
---|
271 | }
|
---|
272 |
|
---|
273 | public void testMultiSameProperty() {
|
---|
274 | expectLog("multi-same-property", "prop is two");
|
---|
275 | }
|
---|
276 |
|
---|
277 | public void testTopLevelTarget() {
|
---|
278 | expectLog("topleveltarget", "Hello world");
|
---|
279 | }
|
---|
280 |
|
---|
281 | public void testMultiplePropertyFileChildren() {
|
---|
282 | PropertyChecker pcBar = new PropertyChecker("bar",
|
---|
283 | new String[] {null, "Bar"});
|
---|
284 | PropertyChecker pcFoo = new PropertyChecker("foo",
|
---|
285 | new String[] {null, "Foo"});
|
---|
286 | project.addBuildListener(pcBar);
|
---|
287 | project.addBuildListener(pcFoo);
|
---|
288 | executeTarget("multiple-property-file-children");
|
---|
289 | AssertionFailedError aeBar = pcBar.getError();
|
---|
290 | if (aeBar != null) {
|
---|
291 | throw aeBar;
|
---|
292 | }
|
---|
293 | AssertionFailedError aeFoo = pcFoo.getError();
|
---|
294 | if (aeFoo != null) {
|
---|
295 | throw aeFoo;
|
---|
296 | }
|
---|
297 | project.removeBuildListener(pcBar);
|
---|
298 | project.removeBuildListener(pcFoo);
|
---|
299 | }
|
---|
300 |
|
---|
301 | public void testBlankTarget() {
|
---|
302 | expectBuildException("blank-target", "target name must not be empty");
|
---|
303 | }
|
---|
304 |
|
---|
305 | public void testMultipleTargets() {
|
---|
306 | expectLog("multiple-targets", "tadadctbdbtc");
|
---|
307 | }
|
---|
308 |
|
---|
309 | public void testMultipleTargets2() {
|
---|
310 | expectLog("multiple-targets-2", "dadctb");
|
---|
311 | }
|
---|
312 |
|
---|
313 | private class BasedirChecker implements BuildListener {
|
---|
314 | private String[] expectedBasedirs;
|
---|
315 | private int calls = 0;
|
---|
316 | private AssertionFailedError error;
|
---|
317 |
|
---|
318 | BasedirChecker(String[] dirs) {
|
---|
319 | expectedBasedirs = dirs;
|
---|
320 | }
|
---|
321 |
|
---|
322 | public void buildStarted(BuildEvent event) {}
|
---|
323 | public void buildFinished(BuildEvent event) {}
|
---|
324 | public void targetFinished(BuildEvent event){}
|
---|
325 | public void taskStarted(BuildEvent event) {}
|
---|
326 | public void taskFinished(BuildEvent event) {}
|
---|
327 | public void messageLogged(BuildEvent event) {}
|
---|
328 |
|
---|
329 | public void targetStarted(BuildEvent event) {
|
---|
330 | if (event.getTarget().getName().equals("")) {
|
---|
331 | return;
|
---|
332 | }
|
---|
333 | if (error == null) {
|
---|
334 | try {
|
---|
335 | assertEquals(expectedBasedirs[calls++],
|
---|
336 | event.getProject().getBaseDir().getAbsolutePath());
|
---|
337 | } catch (AssertionFailedError e) {
|
---|
338 | error = e;
|
---|
339 | }
|
---|
340 | }
|
---|
341 | }
|
---|
342 |
|
---|
343 | AssertionFailedError getError() {
|
---|
344 | return error;
|
---|
345 | }
|
---|
346 |
|
---|
347 | }
|
---|
348 |
|
---|
349 | private class ReferenceChecker implements BuildListener {
|
---|
350 | private String[] keys;
|
---|
351 | private boolean[] expectSame;
|
---|
352 | private Object value;
|
---|
353 | private int calls = 0;
|
---|
354 | private AssertionFailedError error;
|
---|
355 |
|
---|
356 | ReferenceChecker(String[] keys, boolean[] expectSame, Object value) {
|
---|
357 | this.keys = keys;
|
---|
358 | this.expectSame = expectSame;
|
---|
359 | this.value = value;
|
---|
360 | }
|
---|
361 |
|
---|
362 | public void buildStarted(BuildEvent event) {}
|
---|
363 | public void buildFinished(BuildEvent event) {}
|
---|
364 | public void targetFinished(BuildEvent event){}
|
---|
365 | public void taskStarted(BuildEvent event) {}
|
---|
366 | public void taskFinished(BuildEvent event) {}
|
---|
367 | public void messageLogged(BuildEvent event) {}
|
---|
368 |
|
---|
369 | public void targetStarted(BuildEvent event) {
|
---|
370 | if (event.getTarget().getName().equals("")) {
|
---|
371 | return;
|
---|
372 | }
|
---|
373 | if (error == null) {
|
---|
374 | try {
|
---|
375 | String msg =
|
---|
376 | "Call " + calls + " refid=\'" + keys[calls] + "\'";
|
---|
377 | if (value == null) {
|
---|
378 | Object o = event.getProject().getReference(keys[calls]);
|
---|
379 | if (expectSame[calls++]) {
|
---|
380 | assertNull(msg, o);
|
---|
381 | } else {
|
---|
382 | assertNotNull(msg, o);
|
---|
383 | }
|
---|
384 | } else {
|
---|
385 | // a rather convoluted equals() test
|
---|
386 | Path expect = (Path) value;
|
---|
387 | Path received = (Path) event.getProject().getReference(keys[calls]);
|
---|
388 | boolean shouldBeEqual = expectSame[calls++];
|
---|
389 | if (received == null) {
|
---|
390 | assertTrue(msg, !shouldBeEqual);
|
---|
391 | } else {
|
---|
392 | String[] l1 = expect.list();
|
---|
393 | String[] l2 = received.list();
|
---|
394 | if (l1.length == l2.length) {
|
---|
395 | for (int i=0; i<l1.length; i++) {
|
---|
396 | if (!l1[i].equals(l2[i])) {
|
---|
397 | assertTrue(msg, !shouldBeEqual);
|
---|
398 | }
|
---|
399 | }
|
---|
400 | assertTrue(msg, shouldBeEqual);
|
---|
401 | } else {
|
---|
402 | assertTrue(msg, !shouldBeEqual);
|
---|
403 | }
|
---|
404 | }
|
---|
405 | }
|
---|
406 | } catch (AssertionFailedError e) {
|
---|
407 | error = e;
|
---|
408 | }
|
---|
409 | }
|
---|
410 | }
|
---|
411 |
|
---|
412 | AssertionFailedError getError() {
|
---|
413 | return error;
|
---|
414 | }
|
---|
415 |
|
---|
416 | }
|
---|
417 |
|
---|
418 | private class InputHandlerChecker implements BuildListener {
|
---|
419 | private InputHandler ih;
|
---|
420 | private AssertionFailedError error;
|
---|
421 |
|
---|
422 | InputHandlerChecker(InputHandler value) {
|
---|
423 | ih = value;
|
---|
424 | }
|
---|
425 |
|
---|
426 | public void buildStarted(BuildEvent event) {
|
---|
427 | check(event);
|
---|
428 | }
|
---|
429 | public void buildFinished(BuildEvent event) {
|
---|
430 | check(event);
|
---|
431 | }
|
---|
432 | public void targetFinished(BuildEvent event) {
|
---|
433 | check(event);
|
---|
434 | }
|
---|
435 | public void taskStarted(BuildEvent event) {
|
---|
436 | check(event);
|
---|
437 | }
|
---|
438 | public void taskFinished(BuildEvent event) {
|
---|
439 | check(event);
|
---|
440 | }
|
---|
441 | public void messageLogged(BuildEvent event) {
|
---|
442 | check(event);
|
---|
443 | }
|
---|
444 |
|
---|
445 | public void targetStarted(BuildEvent event) {
|
---|
446 | check(event);
|
---|
447 | }
|
---|
448 |
|
---|
449 | private void check(BuildEvent event) {
|
---|
450 | if (error == null) {
|
---|
451 | try {
|
---|
452 | assertNotNull(event.getProject().getInputHandler());
|
---|
453 | assertSame(ih, event.getProject().getInputHandler());
|
---|
454 | } catch (AssertionFailedError e) {
|
---|
455 | error = e;
|
---|
456 | }
|
---|
457 | }
|
---|
458 | }
|
---|
459 |
|
---|
460 | AssertionFailedError getError() {
|
---|
461 | return error;
|
---|
462 | }
|
---|
463 |
|
---|
464 | }
|
---|
465 |
|
---|
466 | private class PropertyChecker implements BuildListener {
|
---|
467 | private String[] expectedValues;
|
---|
468 | private String key;
|
---|
469 | private int calls = 0;
|
---|
470 | private AssertionFailedError error;
|
---|
471 |
|
---|
472 | PropertyChecker(String key, String[] values) {
|
---|
473 | this.key = key;
|
---|
474 | this.expectedValues = values;
|
---|
475 | }
|
---|
476 |
|
---|
477 | public void buildStarted(BuildEvent event) {}
|
---|
478 | public void buildFinished(BuildEvent event) {}
|
---|
479 | public void targetFinished(BuildEvent event){}
|
---|
480 | public void taskStarted(BuildEvent event) {}
|
---|
481 | public void taskFinished(BuildEvent event) {}
|
---|
482 | public void messageLogged(BuildEvent event) {}
|
---|
483 |
|
---|
484 | public void targetStarted(BuildEvent event) {
|
---|
485 | if (event.getTarget().getName().equals("")) {
|
---|
486 | return;
|
---|
487 | }
|
---|
488 | if (calls >= expectedValues.length) {
|
---|
489 | error = new AssertionFailedError("Unexpected invocation of"
|
---|
490 | + " target "
|
---|
491 | + event.getTarget().getName());
|
---|
492 | }
|
---|
493 |
|
---|
494 | if (error == null) {
|
---|
495 | try {
|
---|
496 | assertEquals(expectedValues[calls++],
|
---|
497 | event.getProject().getProperty(key));
|
---|
498 | } catch (AssertionFailedError e) {
|
---|
499 | error = e;
|
---|
500 | }
|
---|
501 | }
|
---|
502 | }
|
---|
503 |
|
---|
504 | AssertionFailedError getError() {
|
---|
505 | return error;
|
---|
506 | }
|
---|
507 |
|
---|
508 | }
|
---|
509 |
|
---|
510 |
|
---|
511 | }
|
---|