source: other-projects/trunk/gs3-release-maker/apache-ant-1.6.5/src/testcases/org/apache/tools/ant/types/selectors/ModifiedSelectorTest.java@ 14627

Last change on this file since 14627 was 14627, checked in by oranfry, 17 years ago

initial import of the gs3-release-maker
File size: 23.7 KB
Line 
1/*
2 * Copyright 2003-2004 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
18package org.apache.tools.ant.types.selectors;
19
20
21// Java
22import java.io.File;
23import java.io.FileWriter;
24import java.util.Comparator;
25import java.util.Iterator;
26import java.text.RuleBasedCollator;
27
28// Ant
29import org.apache.tools.ant.BuildException;
30import org.apache.tools.ant.types.Parameter;
31
32// The classes to test
33import org.apache.tools.ant.types.selectors.modifiedselector.*;
34
35
36/**
37 * Unit tests for ModifiedSelector.
38 *
39 * @version 2003-09-13
40 * @since Ant 1.6
41 */
42public class ModifiedSelectorTest extends BaseSelectorTest {
43
44 /** Package of the CacheSelector classes. */
45 private static String pkg = "org.apache.tools.ant.types.selectors.modifiedselector";
46
47
48 public ModifiedSelectorTest(String name) {
49 super(name);
50 }
51
52
53 /**
54 * Factory method from base class. This should be overriden in child
55 * classes to return a specific Selector class (like here).
56 */
57 public BaseSelector getInstance() {
58 return new ModifiedSelector();
59 }
60
61
62 /** Test right use of cache names. */
63 public void testValidateWrongCache() {
64 String name = "this-is-not-a-valid-cache-name";
65 try {
66 ModifiedSelector.CacheName cacheName = new ModifiedSelector.CacheName();
67 cacheName.setValue(name);
68 fail("CacheSelector.CacheName accepted invalid value.");
69 } catch (BuildException be) {
70 assertEquals(name + " is not a legal value for this attribute",
71 be.getMessage());
72 }
73 }
74
75
76 /** Test right use of cache names. */
77 public void testValidateWrongAlgorithm() {
78 String name = "this-is-not-a-valid-algorithm-name";
79 try {
80 ModifiedSelector.AlgorithmName algoName
81 = new ModifiedSelector.AlgorithmName();
82 algoName.setValue(name);
83 fail("CacheSelector.AlgorithmName accepted invalid value.");
84 } catch (BuildException be) {
85 assertEquals(name + " is not a legal value for this attribute",
86 be.getMessage());
87 }
88 }
89
90
91 /** Test right use of comparator names. */
92 public void testValidateWrongComparator() {
93 String name = "this-is-not-a-valid-comparator-name";
94 try {
95 ModifiedSelector.ComparatorName compName
96 = new ModifiedSelector.ComparatorName();
97 compName.setValue(name);
98 fail("ModifiedSelector.ComparatorName accepted invalid value.");
99 } catch (BuildException be) {
100 assertEquals(name + " is not a legal value for this attribute",
101 be.getMessage());
102 }
103 }
104
105
106 /**
107 * Propertycache must have a set 'cachefile' attribute.
108 * The default in ModifiedSelector "cache.properties" is set by the selector.
109 */
110 public void testPropcacheInvalid() {
111 Cache cache = new PropertiesfileCache();
112 if (cache.isValid())
113 fail("PropertyfilesCache does not check its configuration.");
114 }
115
116
117 /**
118 * Tests whether the seldirs attribute is used.
119 */
120 public void testSeldirs() {
121 ModifiedSelector s = (ModifiedSelector)getSelector();
122 try {
123 makeBed();
124
125 StringBuffer sbTrue = new StringBuffer();
126 StringBuffer sbFalse = new StringBuffer();
127 for (int i=0; i<filenames.length; i++) {
128 if (files[i].isDirectory()) {
129 sbTrue.append("T");
130 sbFalse.append("F");
131 } else {
132 sbTrue.append("T");
133 sbFalse.append("T");
134 }
135 }
136
137
138 s.setSeldirs(true);
139 performTests(s, sbTrue.toString());
140 s.getCache().delete();
141
142 s.setSeldirs(false);
143 performTests(s, sbFalse.toString());
144 s.getCache().delete();
145
146 } finally {
147 cleanupBed();
148 if (s!=null) s.getCache().delete();
149 }
150 }
151
152
153 /**
154 * Complex test scenario using default values (DigestAlgorithm with MD5,
155 * PropertiesfileCache with file=cache.properties, EqualComparator
156 * and update=true). <ol>
157 * <li> try fist time --> should select all </li>
158 * <li> try second time --> should select no files (only directories) </li>
159 * <li> modify timestamp of one file and content of a nother one </li>
160 * <li> try third time --> should select only the file with modified
161 * content </li>
162 */
163 public void testScenario1() {
164 BFT bft = null;
165 ModifiedSelector s = null;
166 try {
167 //
168 // ***** initialize test environment (called "bed") *****
169 //
170 makeBed();
171 String results = null;
172
173 // Configure the selector - only defaults are used
174 s = (ModifiedSelector)getSelector();
175
176 //
177 // ***** First Run *****
178 // the first call should get all files, because nothing is in
179 // the cache
180 //
181 performTests(s, "TTTTTTTTTTTT");
182
183 //
184 // ***** Second Run *****
185 // the second call should get no files, because no content
186 // has changed
187 //
188 performTests(s, "TFFFFFFFFFFT");
189
190 //
191 // ***** make some files dirty *****
192 //
193
194 // these files are made dirty --> 3+4 with different content
195 String f2name = "tar/bz2/asf-logo-huge.tar.bz2";
196 String f3name = "asf-logo.gif.md5";
197 String f4name = "copy.filterset.filtered";
198
199 // AccessObject to the test-Ant-environment
200 bft = new BFT();
201 // give some values (via property file) to that environment
202 bft.writeProperties("f2name="+f2name);
203 bft.writeProperties("f3name="+f3name);
204 bft.writeProperties("f4name="+f4name);
205 // call the target for making the files dirty
206 bft.doTarget("modifiedselectortest-makeDirty");
207
208
209 //
210 // ***** Third Run *****
211 // third call should get only those files, which CONTENT changed
212 // (no timestamp changes required!)
213 results = selectionString(s);
214
215 //
216 // ***** Check the result *****
217 //
218
219 // Mark all files which should be selected as (T)rue and all others
220 // as (F)alse. Directories are always selected so they always are
221 // (T)rue.
222 StringBuffer expected = new StringBuffer();
223 for (int i=0; i<filenames.length; i++) {
224 String ch = "F";
225 if (files[i].isDirectory()) ch = "T";
226 // f2name shouldn't be selected: only timestamp has changed!
227 if (filenames[i].equalsIgnoreCase(f3name)) ch = "T";
228 if (filenames[i].equalsIgnoreCase(f4name)) ch = "T";
229 expected.append(ch);
230 }
231
232 assertEquals(
233 "Wrong files selected. Differing files: " // info text
234 + resolve(diff(expected.toString(), results)), // list of files
235 expected.toString(), // expected result
236 results // result
237 );
238
239 } finally {
240 // cleanup the environment
241 cleanupBed();
242 if (s!=null) s.getCache().delete();
243 if (bft!=null) bft.deletePropertiesfile();
244 }
245 }
246
247
248
249 /**
250 * This scenario is based on scenario 1, but does not use any
251 * default value and its based on <custom> selector. Used values are:<ul>
252 * <li><b>Cache: </b> Propertyfile,
253 * cachefile={java.io.tmpdir}/mycache.txt </li>
254 * <li><b>Algorithm: </b> Digest
255 * algorithm=SHA, Provider=null </li>
256 * <li><b>Comparator: </b> java.text.RuleBasedCollator
257 * <li><b>Update: </b> true </li>
258 */
259 public void testScenario2() {
260 ExtendSelector s = new ExtendSelector();
261 BFT bft = new BFT();
262 String cachefile = System.getProperty("java.io.tmpdir")+"/mycache.txt";
263 try {
264 makeBed();
265
266 s.setClassname("org.apache.tools.ant.types.selectors.modifiedselector.ModifiedSelector");
267
268 s.addParam(createParam("cache.cachefile", cachefile));
269 //s.addParam(createParam("algorithm.provider","---")); // i don't know any valid
270 s.addParam(createParam("cache","propertyfile"));
271 s.addParam(createParam("update","true"));
272 s.addParam(createParam("comparator","rule"));
273 s.addParam(createParam("algorithm.name","sha"));
274 s.addParam(createParam("algorithm","digest"));
275
276 // first and second run
277 performTests(s, "TTTTTTTTTTTT");
278 performTests(s, "TFFFFFFFFFFT");
279 // make dirty
280 String f2name = "tar/bz2/asf-logo-huge.tar.bz2";
281 String f3name = "asf-logo.gif.md5";
282 String f4name = "copy.filterset.filtered";
283 bft.writeProperties("f2name="+f2name);
284 bft.writeProperties("f3name="+f3name);
285 bft.writeProperties("f4name="+f4name);
286 bft.doTarget("modifiedselectortest-makeDirty");
287 // third run
288 String results = selectionString(s);
289 StringBuffer expected = new StringBuffer();
290 for (int i=0; i<filenames.length; i++) {
291 String ch = "F";
292 if (files[i].isDirectory()) ch = "T";
293 if (filenames[i].equalsIgnoreCase(f3name)) ch = "T";
294 if (filenames[i].equalsIgnoreCase(f4name)) ch = "T";
295 expected.append(ch);
296 }
297 assertEquals(
298 "Wrong files selected. Differing files: " // info text
299 + resolve(diff(expected.toString(), results)), // list of files
300 expected.toString(), // expected result
301 results // result
302 );
303 } finally {
304 // cleanup the environment
305 cleanupBed();
306 (new java.io.File(cachefile)).delete();
307 if (bft!=null) bft.deletePropertiesfile();
308 }
309 }
310
311
312 /** Checks whether a cache file is created. */
313 public void testCreatePropertiesCacheDirect() {
314 File basedir = getSelector().getProject().getBaseDir();
315 File cachefile = new File(basedir, "cachefile.properties");
316
317 PropertiesfileCache cache = new PropertiesfileCache();
318 cache.setCachefile(cachefile);
319
320 cache.put("key", "value");
321 cache.save();
322
323 assertTrue("Cachefile not created.", cachefile.exists());
324
325 cache.delete();
326 assertFalse("Cachefile not deleted.", cachefile.exists());
327 }
328
329
330 /** Checks whether a cache file is created. */
331 public void testCreatePropertiesCacheViaModifiedSelector() {
332 File basedir = getSelector().getProject().getBaseDir();
333 File cachefile = new File(basedir, "cachefile.properties");
334 try {
335
336 // initialize test environment (called "bed")
337 makeBed();
338
339 // Configure the selector
340 ModifiedSelector s = (ModifiedSelector)getSelector();
341 s.addParam("cache.cachefile", cachefile);
342
343 ModifiedSelector.CacheName cacheName = new ModifiedSelector.CacheName();
344 cacheName.setValue("propertyfile");
345 s.setCache(cacheName);
346
347 s.setUpdate(true);
348
349 // does the selection
350 String results = selectionString(s);
351
352 // evaluate correctness
353 assertTrue("Cache file is not created.", cachefile.exists());
354 } finally {
355 cleanupBed();
356 if (cachefile!=null) cachefile.delete();
357 }
358 }
359
360
361 /**
362 * In earlier implementations there were problems with the <i>order</i>
363 * of the <param>s. The scenario was <pre>
364 * <custom class="ModifiedSelector">
365 * <param name="cache.cachefile" value="mycache.properties" />
366 * <param name="cache" value="propertyfiles" />
367 * </custom>
368 * </pre> It was important first to set the cache and then to set
369 * the cache's configuration parameters. That results in the reorganized
370 * configure() method of ModifiedSelector. This testcase tests that.
371 */
372 public void testCreatePropertiesCacheViaCustomSelector() {
373 File cachefile = org.apache.tools.ant.util.FileUtils.newFileUtils()
374 .createTempFile("tmp-cache-", ".properties", null);
375 try {
376 // initialize test environment (called "bed")
377 makeBed();
378
379 // Configure the selector
380
381 ExtendSelector s = new ExtendSelector();
382 s.setClassname("org.apache.tools.ant.types.selectors.modifiedselector.ModifiedSelector");
383 s.addParam(createParam("update", "true"));
384 s.addParam(createParam("cache.cachefile", cachefile.getAbsolutePath()));
385 s.addParam(createParam("cache", "propertyfile"));
386
387 // does the selection
388 String results = selectionString(s);
389
390 // evaluate correctness
391 assertTrue("Cache file is not created.", cachefile.exists());
392 } finally {
393 cleanupBed();
394 if (cachefile!=null) cachefile.delete();
395 }
396 }
397
398
399 public void testEqualComparatorViaSelector() {
400 ModifiedSelector s = (ModifiedSelector)getSelector();
401 ModifiedSelector.ComparatorName compName = new ModifiedSelector.ComparatorName();
402 compName.setValue("equal");
403 s.setComparator(compName);
404 try {
405 performTests(s, "TTTTTTTTTTTT");
406 } finally {
407 s.getCache().delete();
408 }
409 }
410
411
412 public void testRuleComparatorViaSelector() {
413 ModifiedSelector s = (ModifiedSelector)getSelector();
414 ModifiedSelector.ComparatorName compName = new ModifiedSelector.ComparatorName();
415 compName.setValue("rule");
416 s.setComparator(compName);
417 try {
418 performTests(s, "TTTTTTTTTTTT");
419 } finally {
420 s.getCache().delete();
421 }
422 }
423
424
425 public void testHashvalueAlgorithm() {
426 HashvalueAlgorithm algo = new HashvalueAlgorithm();
427 doTest(algo);
428 }
429
430 public void testDigestAlgorithmMD5() {
431 DigestAlgorithm algo = new DigestAlgorithm();
432 algo.setAlgorithm("MD5");
433 doTest(algo);
434 }
435
436 public void testDigestAlgorithmSHA() {
437 DigestAlgorithm algo = new DigestAlgorithm();
438 algo.setAlgorithm("SHA");
439 doTest(algo);
440 }
441
442
443 public void testPropertyfileCache() {
444 PropertiesfileCache cache = new PropertiesfileCache();
445 File cachefile = new File("cache.properties");
446 cache.setCachefile(cachefile);
447 doTest(cache);
448 assertFalse("Cache file not deleted.", cachefile.exists());
449 }
450
451
452 public void testEqualComparator() {
453 EqualComparator comp = new EqualComparator();
454 doTest(comp);
455 }
456
457
458 public void testRuleComparator() {
459 RuleBasedCollator comp = (RuleBasedCollator)RuleBasedCollator.getInstance();
460 doTest(comp);
461 }
462
463
464 public void testScenarioCoreSelectorDefaults() {
465 doScenarioTest("modifiedselectortest-scenario-coreselector-defaults", "cache.properties");
466 }
467
468
469
470 public void testSceanrioCoreSelectorSettings() {
471 doScenarioTest("modifiedselectortest-scenario-coreselector-settings", "core.cache.properties");
472 }
473
474
475 public void testScenarioCustomSelectorSettings() {
476 doScenarioTest("modifiedselectortest-scenario-customselector-settings", "core.cache.properties");
477 }
478
479
480 public void doScenarioTest(String target, String cachefilename) {
481 BFT bft = new BFT();
482 bft.setUp();
483 File basedir = bft.getProject().getBaseDir();
484 File cachefile = new File(basedir, cachefilename);
485 try {
486 // do the actions
487 bft.doTarget("modifiedselectortest-scenario-clean");
488 bft.doTarget(target);
489
490 // the directories to check
491 File to1 = new File(basedir, "selectortest/to-1");
492 File to2 = new File(basedir, "selectortest/to-2");
493 File to3 = new File(basedir, "selectortest/to-3");
494
495 // do the checks
496 assertTrue("Cache file not created.", cachefile.exists());
497 assertTrue("Not enough files copied on first time.", to1.list().length>5);
498 assertTrue("Too much files copied on second time.", to2.list().length==0);
499 assertTrue("Too much files copied on third time.", to3.list().length==2);
500 // don't catch the JUnit exceptions
501 } finally {
502 bft.doTarget("modifiedselectortest-scenario-clean");
503 bft.deletePropertiesfile();
504 bft.tearDown();
505 cachefile.delete();
506 }
507 }
508
509
510 // ==================== Test interface semantic ===================
511
512
513 /**
514 * This method does some common test for algorithm implementations.
515 * An algorithm must return always the same value for the same file and
516 * it must not return <i>null</i>.
517 *
518 * @param algo configured test object
519 */
520 protected void doTest(Algorithm algo) {
521 assertTrue("Algorithm not proper configured.", algo.isValid());
522 try {
523 makeBed();
524
525 for (int i=0; i<files.length; i++) {
526 File file = files[i]; // must not be a directory
527 if (file.isFile()) {
528 // get the Hashvalues
529 String hash1 = algo.getValue(file);
530 String hash2 = algo.getValue(file);
531 String hash3 = algo.getValue(file);
532 String hash4 = algo.getValue(file);
533 String hash5 = algo.getValue(new File(file.getAbsolutePath()));
534
535 // Assert !=null and equality
536 assertNotNull("Hashvalue was null for "+file.getAbsolutePath(), hash1);
537 assertNotNull("Hashvalue was null for "+file.getAbsolutePath(), hash2);
538 assertNotNull("Hashvalue was null for "+file.getAbsolutePath(), hash3);
539 assertNotNull("Hashvalue was null for "+file.getAbsolutePath(), hash4);
540 assertNotNull("Hashvalue was null for "+file.getAbsolutePath(), hash5);
541 assertEquals("getHashvalue() returned different value for "+file.getAbsolutePath(), hash1, hash2);
542 assertEquals("getHashvalue() returned different value for "+file.getAbsolutePath(), hash1, hash3);
543 assertEquals("getHashvalue() returned different value for "+file.getAbsolutePath(), hash1, hash4);
544 assertEquals("getHashvalue() returned different value for "+file.getAbsolutePath(), hash1, hash5);
545 }//if-isFile
546 }//for
547 } finally {
548 cleanupBed();
549 }
550 }
551
552
553 /**
554 * This method does some common test for cache implementations.
555 * A cache must return a stored value and a valid iterator.
556 * After calling the delete() the cache must be empty.
557 *
558 * @param algo configured test object
559 */
560 protected void doTest(Cache cache) {
561 assertTrue("Cache not proper configured.", cache.isValid());
562
563 String key1 = "key1";
564 String value1 = "value1";
565 String key2 = "key2";
566 String value2 = "value2";
567
568 // given cache must be empty
569 Iterator it1 = cache.iterator();
570 assertFalse("Cache is not empty", it1.hasNext());
571
572 // cache must return a stored value
573 cache.put(key1, value1);
574 cache.put(key2, value2);
575 assertEquals("cache returned wrong value", value1, cache.get(key1));
576 assertEquals("cache returned wrong value", value2, cache.get(key2));
577
578 // test the iterator
579 Iterator it2 = cache.iterator();
580 Object returned = it2.next();
581 boolean ok = (key1.equals(returned) || key2.equals(returned));
582 String msg = "Iterator returned unexpected value."
583 + " key1.equals(returned)="+key1.equals(returned)
584 + " key2.equals(returned)="+key2.equals(returned)
585 + " returned="+returned
586 + " ok="+ok;
587 assertTrue(msg, ok);
588
589 // clear the cache
590 cache.delete();
591 Iterator it3 = cache.iterator();
592 assertFalse("Cache is not empty", it1.hasNext());
593 }
594
595
596 /**
597 * This method does some common test for comparator implementations.
598 *
599 * @param algo configured test object
600 */
601 protected void doTest(Comparator comp) {
602 Object o1 = new String("string1");
603 Object o2 = new String("string2");
604 Object o3 = new String("string2"); // really "2"
605
606 assertTrue("Comparator gave wrong value.", comp.compare(o1, o2) != 0);
607 assertTrue("Comparator gave wrong value.", comp.compare(o1, o3) != 0);
608 assertTrue("Comparator gave wrong value.", comp.compare(o2, o3) == 0);
609 }
610
611
612 // ======================== Helper methods ========================
613
614
615 private Parameter createParam(String name, String value) {
616 Parameter p = new Parameter();
617 p.setName(name);
618 p.setValue(value);
619 return p;
620 }
621
622
623 private class BFT extends org.apache.tools.ant.BuildFileTest {
624 BFT() { super("nothing"); }
625 BFT(String name) {
626 super(name);
627 }
628 String propfile = "ModifiedSelectorTest.properties";
629
630 boolean isConfigured = false;
631
632 public void setUp() {
633 configureProject("src/etc/testcases/types/selectors.xml");
634 isConfigured = true;
635 }
636
637 public void tearDown() { }
638
639 public void doTarget(String target) {
640 if (!isConfigured) setUp();
641 executeTarget(target);
642 }
643
644 public void writeProperties(String line) {
645 if (!isConfigured) setUp();
646 File dir = getProject().getBaseDir();
647 File file = new File(dir, propfile);
648 try {
649 java.io.FileWriter out =
650 new java.io.FileWriter(file.getAbsolutePath(), true);
651 out.write(line);
652 out.write(System.getProperty("line.separator"));
653 out.flush();
654 out.close();
655 } catch (Exception e) {
656 e.printStackTrace();
657 }
658 }
659
660 public void deletePropertiesfile() {
661 if (!isConfigured) setUp();
662 new File(getProject().getBaseDir(), propfile).delete();
663 }
664
665 public org.apache.tools.ant.Project getProject() {
666 return super.getProject();
667 }
668 }//class-BFT
669
670}//class-ModifiedSelectorTest
Note: See TracBrowser for help on using the repository browser.