/*
* The Apache Software License, Version 1.1
*
* Copyright (c) 2003 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. The end-user documentation included with the redistribution, if
* any, must include the following acknowlegement:
* "This product includes software developed by the
* Apache Software Foundation (http://www.apache.org/)."
* Alternately, this acknowlegement may appear in the software itself,
* if and wherever such third-party acknowlegements normally appear.
*
* 4. The names "Ant" and "Apache Software
* Foundation" must not be used to endorse or promote products derived
* from this software without prior written permission. For written
* permission, please contact apache@apache.org.
*
* 5. Products derived from this software may not be called "Apache"
* nor may "Apache" appear in their names without prior written
* permission of the Apache Group.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation. For more
* information on the Apache Software Foundation, please see
* <http://www.apache.org/>.
*/
package org.apache.tools.ant.types.selectors;
// Java
import java.io.File;
import java.io.FileWriter;
import java.util.Comparator;
import java.util.Iterator;
import java.text.RuleBasedCollator;
// Ant
import org.apache.tools.ant.BuildException;
import org.apache.tools.ant.types.Parameter;
// The classes to test
import org.apache.tools.ant.types.selectors.modifiedselector.*;
/**
* Unit tests for ModifiedSelector.
*
* @author Jan Mat\u00e8rne
* @version 2003-09-13
* @since Ant 1.6
*/
public class ModifiedSelectorTest extends BaseSelectorTest {
/** Package of the CacheSelector classes. */
private static String pkg = "org.apache.tools.ant.types.selectors.modifiedselector";
public ModifiedSelectorTest(String name) {
super(name);
}
/**
* Factory method from base class. This should be overriden in child
* classes to return a specific Selector class (like here).
*/
public BaseSelector getInstance() {
return new ModifiedSelector();
}
/** Test right use of cache names. */
public void testValidateWrongCache() {
String name = "this-is-not-a-valid-cache-name";
try {
ModifiedSelector.CacheName cacheName = new ModifiedSelector.CacheName();
cacheName.setValue(name);
fail("CacheSelector.CacheName accepted invalid value.");
} catch (BuildException be) {
assertEquals(name + " is not a legal value for this attribute",
be.getMessage());
}
}
/** Test right use of cache names. */
public void testValidateWrongAlgorithm() {
String name = "this-is-not-a-valid-algorithm-name";
try {
ModifiedSelector.AlgorithmName algoName
= new ModifiedSelector.AlgorithmName();
algoName.setValue(name);
fail("CacheSelector.AlgorithmName accepted invalid value.");
} catch (BuildException be) {
assertEquals(name + " is not a legal value for this attribute",
be.getMessage());
}
}
/** Test right use of comparator names. */
public void testValidateWrongComparator() {
String name = "this-is-not-a-valid-comparator-name";
try {
ModifiedSelector.ComparatorName compName
= new ModifiedSelector.ComparatorName();
compName.setValue(name);
fail("ModifiedSelector.ComparatorName accepted invalid value.");
} catch (BuildException be) {
assertEquals(name + " is not a legal value for this attribute",
be.getMessage());
}
}
/**
* Propertycache must have a set 'cachefile' attribute.
* The default in ModifiedSelector "cache.properties" is set by the selector.
*/
public void testPropcacheInvalid() {
Cache cache = new PropertiesfileCache();
if (cache.isValid())
fail("PropertyfilesCache does not check its configuration.");
}
/**
* Tests whether the seldirs attribute is used.
*/
public void testSeldirs() {
ModifiedSelector s = (ModifiedSelector)getSelector();
try {
makeBed();
StringBuffer sbTrue = new StringBuffer();
StringBuffer sbFalse = new StringBuffer();
for (int i=0; i<filenames.length; i++) {
if (files[i].isDirectory()) {
sbTrue.append("T");
sbFalse.append("F");
} else {
sbTrue.append("T");
sbFalse.append("T");
}
}
s.setSeldirs(true);
performTests(s, sbTrue.toString());
s.getCache().delete();
s.setSeldirs(false);
performTests(s, sbFalse.toString());
s.getCache().delete();
} finally {
cleanupBed();
if (s!=null) s.getCache().delete();
}
}
/**
* Complex test scenario using default values (DigestAlgorithm with MD5,
* PropertiesfileCache with file=cache.properties, EqualComparator
* and update=true). <ol>
* <li> try fist time --> should select all </li>
* <li> try second time --> should select no files (only directories) </li>
* <li> modify timestamp of one file and content of a nother one </li>
* <li> try third time --> should select only the file with modified
* content </li>
*/
public void testScenario1() {
BFT bft = null;
ModifiedSelector s = null;
try {
//
// ***** initialize test environment (called "bed") *****
//
makeBed();
String results = null;
// Configure the selector - only defaults are used
s = (ModifiedSelector)getSelector();
//
// ***** First Run *****
// the first call should get all files, because nothing is in
// the cache
//
performTests(s, "TTTTTTTTTTTT");
//
// ***** Second Run *****
// the second call should get no files, because no content
// has changed
//
performTests(s, "TFFFFFFFFFFT");
//
// ***** make some files dirty *****
//
// these files are made dirty --> 3+4 with different content
String f2name = "tar/bz2/asf-logo-huge.tar.bz2";
String f3name = "asf-logo.gif.md5";
String f4name = "copy.filterset.filtered";
// AccessObject to the test-Ant-environment
bft = new BFT();
// give some values (via property file) to that environment
bft.writeProperties("f2name="+f2name);
bft.writeProperties("f3name="+f3name);
bft.writeProperties("f4name="+f4name);
// call the target for making the files dirty
bft.doTarget("modifiedselectortest-makeDirty");
//
// ***** Third Run *****
// third call should get only those files, which CONTENT changed
// (no timestamp changes required!)
results = selectionString(s);
//
// ***** Check the result *****
//
// Mark all files which should be selected as (T)rue and all others
// as (F)alse. Directories are always selected so they always are
// (T)rue.
StringBuffer expected = new StringBuffer();
for (int i=0; i<filenames.length; i++) {
String ch = "F";
if (files[i].isDirectory()) ch = "T";
// f2name shouldn't be selected: only timestamp has changed!
if (filenames[i].equalsIgnoreCase(f3name)) ch = "T";
if (filenames[i].equalsIgnoreCase(f4name)) ch = "T";
expected.append(ch);
}
assertEquals(
"Wrong files selected. Differing files: " // info text
+ resolve(diff(expected.toString(), results)), // list of files
expected.toString(), // expected result
results // result
);
} finally {
// cleanup the environment
cleanupBed();
if (s!=null) s.getCache().delete();
if (bft!=null) bft.deletePropertiesfile();
}
}
/**
* This scenario is based on scenario 1, but does not use any
* default value and its based on <custom> selector. Used values are:<ul>
* <li><b>Cache: </b> Propertyfile,
* cachefile={java.io.tmpdir}/mycache.txt </li>
* <li><b>Algorithm: </b> Digest
* algorithm=SHA, Provider=null </li>
* <li><b>Comparator: </b> java.text.RuleBasedCollator
* <li><b>Update: </b> true </li>
*/
public void testScenario2() {
ExtendSelector s = new ExtendSelector();
BFT bft = new BFT();
String cachefile = System.getProperty("java.io.tmpdir")+"/mycache.txt";
try {
makeBed();
s.setClassname("org.apache.tools.ant.types.selectors.modifiedselector.ModifiedSelector");
s.addParam(createParam("cache.cachefile", cachefile));
//s.addParam(createParam("algorithm.provider","---")); // i don't know any valid
s.addParam(createParam("cache","propertyfile"));
s.addParam(createParam("update","true"));
s.addParam(createParam("comparator","rule"));
s.addParam(createParam("algorithm.name","sha"));
s.addParam(createParam("algorithm","digest"));
// first and second run
performTests(s, "TTTTTTTTTTTT");
performTests(s, "TFFFFFFFFFFT");
// make dirty
String f2name = "tar/bz2/asf-logo-huge.tar.bz2";
String f3name = "asf-logo.gif.md5";
String f4name = "copy.filterset.filtered";
bft.writeProperties("f2name="+f2name);
bft.writeProperties("f3name="+f3name);
bft.writeProperties("f4name="+f4name);
bft.doTarget("modifiedselectortest-makeDirty");
// third run
String results = selectionString(s);
StringBuffer expected = new StringBuffer();
for (int i=0; i<filenames.length; i++) {
String ch = "F";
if (files[i].isDirectory()) ch = "T";
if (filenames[i].equalsIgnoreCase(f3name)) ch = "T";
if (filenames[i].equalsIgnoreCase(f4name)) ch = "T";
expected.append(ch);
}
assertEquals(
"Wrong files selected. Differing files: " // info text
+ resolve(diff(expected.toString(), results)), // list of files
expected.toString(), // expected result
results // result
);
} finally {
// cleanup the environment
cleanupBed();
(new java.io.File(cachefile)).delete();
if (bft!=null) bft.deletePropertiesfile();
}
}
/** Checks whether a cache file is created. */
public void testCreatePropertiesCacheDirect() {
File basedir = getSelector().getProject().getBaseDir();
File cachefile = new File(basedir, "cachefile.properties");
PropertiesfileCache cache = new PropertiesfileCache();
cache.setCachefile(cachefile);
cache.put("key", "value");
cache.save();
assertTrue("Cachefile not created.", cachefile.exists());
cache.delete();
assertFalse("Cachefile not deleted.", cachefile.exists());
}
/** Checks whether a cache file is created. */
public void testCreatePropertiesCacheViaModifiedSelector() {
File basedir = getSelector().getProject().getBaseDir();
File cachefile = new File(basedir, "cachefile.properties");
try {
// initialize test environment (called "bed")
makeBed();
// Configure the selector
ModifiedSelector s = (ModifiedSelector)getSelector();
s.addParam("cache.cachefile", cachefile);
ModifiedSelector.CacheName cacheName = new ModifiedSelector.CacheName();
cacheName.setValue("propertyfile");
s.setCache(cacheName);
s.setUpdate(true);
// does the selection
String results = selectionString(s);
// evaluate correctness
assertTrue("Cache file is not created.", cachefile.exists());
} finally {
cleanupBed();
if (cachefile!=null) cachefile.delete();
}
}
/**
* In earlier implementations there were problems with the <i>order</i>
* of the <param>s. The scenario was <pre>
* <custom class="ModifiedSelector">
* <param name="cache.cachefile" value="mycache.properties" />
* <param name="cache" value="propertyfiles" />
* </custom>
* </pre> It was important first to set the cache and then to set
* the cache's configuration parameters. That results in the reorganized
* configure() method of ModifiedSelector. This testcase tests that.
*/
public void testCreatePropertiesCacheViaCustomSelector() {
File cachefile = org.apache.tools.ant.util.FileUtils.newFileUtils()
.createTempFile("tmp-cache-", ".properties", null);
try {
// initialize test environment (called "bed")
makeBed();
// Configure the selector
ExtendSelector s = new ExtendSelector();
s.setClassname("org.apache.tools.ant.types.selectors.modifiedselector.ModifiedSelector");
s.addParam(createParam("update", "true"));
s.addParam(createParam("cache.cachefile", cachefile.getAbsolutePath()));
s.addParam(createParam("cache", "propertyfile"));
// does the selection
String results = selectionString(s);
// evaluate correctness
assertTrue("Cache file is not created.", cachefile.exists());
} finally {
cleanupBed();
if (cachefile!=null) cachefile.delete();
}
}
public void testEqualComparatorViaSelector() {
ModifiedSelector s = (ModifiedSelector)getSelector();
ModifiedSelector.ComparatorName compName = new ModifiedSelector.ComparatorName();
compName.setValue("equal");
s.setComparator(compName);
try {
performTests(s, "TTTTTTTTTTTT");
} finally {
s.getCache().delete();
}
}
public void testRuleComparatorViaSelector() {
ModifiedSelector s = (ModifiedSelector)getSelector();
ModifiedSelector.ComparatorName compName = new ModifiedSelector.ComparatorName();
compName.setValue("rule");
s.setComparator(compName);
try {
performTests(s, "TTTTTTTTTTTT");
} finally {
s.getCache().delete();
}
}
public void testHashvalueAlgorithm() {
HashvalueAlgorithm algo = new HashvalueAlgorithm();
doTest(algo);
}
public void testDigestAlgorithmMD5() {
DigestAlgorithm algo = new DigestAlgorithm();
algo.setAlgorithm("MD5");
doTest(algo);
}
public void testDigestAlgorithmSHA() {
DigestAlgorithm algo = new DigestAlgorithm();
algo.setAlgorithm("SHA");
doTest(algo);
}
public void testPropertyfileCache() {
PropertiesfileCache cache = new PropertiesfileCache();
File cachefile = new File("cache.properties");
cache.setCachefile(cachefile);
doTest(cache);
assertFalse("Cache file not deleted.", cachefile.exists());
}
public void testEqualComparator() {
EqualComparator comp = new EqualComparator();
doTest(comp);
}
public void testRuleComparator() {
RuleBasedCollator comp = (RuleBasedCollator)RuleBasedCollator.getInstance();
doTest(comp);
}
public void testScenarioCoreSelectorDefaults() {
doScenarioTest("modifiedselectortest-scenario-coreselector-defaults", "cache.properties");
}
public void testSceanrioCoreSelectorSettings() {
doScenarioTest("modifiedselectortest-scenario-coreselector-settings", "core.cache.properties");
}
public void testScenarioCustomSelectorSettings() {
doScenarioTest("modifiedselectortest-scenario-customselector-settings", "core.cache.properties");
}
public void doScenarioTest(String target, String cachefilename) {
BFT bft = new BFT();
bft.setUp();
File basedir = bft.getProject().getBaseDir();
File cachefile = new File(basedir, cachefilename);
try {
// do the actions
bft.doTarget("modifiedselectortest-scenario-clean");
bft.doTarget(target);
// the directories to check
File to1 = new File(basedir, "selectortest/to-1");
File to2 = new File(basedir, "selectortest/to-2");
File to3 = new File(basedir, "selectortest/to-3");
// do the checks
assertTrue("Cache file not created.", cachefile.exists());
assertTrue("Not enough files copied on first time.", to1.list().length>5);
assertTrue("Too much files copied on second time.", to2.list().length==0);
assertTrue("Too much files copied on third time.", to3.list().length==2);
// don't catch the JUnit exceptions
} finally {
bft.doTarget("modifiedselectortest-scenario-clean");
bft.deletePropertiesfile();
bft.tearDown();
cachefile.delete();
}
}
// ==================== Test interface semantic ===================
/**
* This method does some common test for algorithm implementations.
* An algorithm must return always the same value for the same file and
* it must not return <i>null</i>.
*
* @param algo configured test object
*/
protected void doTest(Algorithm algo) {
assertTrue("Algorithm not proper configured.", algo.isValid());
try {
makeBed();
for (int i=0; i<files.length; i++) {
File file = files[i]; // must not be a directory
if (file.isFile()) {
// get the Hashvalues
String hash1 = algo.getValue(file);
String hash2 = algo.getValue(file);
String hash3 = algo.getValue(file);
String hash4 = algo.getValue(file);
String hash5 = algo.getValue(new File(file.getAbsolutePath()));
// Assert !=null and equality
assertNotNull("Hashvalue was null for "+file.getAbsolutePath(), hash1);
assertNotNull("Hashvalue was null for "+file.getAbsolutePath(), hash2);
assertNotNull("Hashvalue was null for "+file.getAbsolutePath(), hash3);
assertNotNull("Hashvalue was null for "+file.getAbsolutePath(), hash4);
assertNotNull("Hashvalue was null for "+file.getAbsolutePath(), hash5);
assertEquals("getHashvalue() returned different value for "+file.getAbsolutePath(), hash1, hash2);
assertEquals("getHashvalue() returned different value for "+file.getAbsolutePath(), hash1, hash3);
assertEquals("getHashvalue() returned different value for "+file.getAbsolutePath(), hash1, hash4);
assertEquals("getHashvalue() returned different value for "+file.getAbsolutePath(), hash1, hash5);
}//if-isFile
}//for
} finally {
cleanupBed();
}
}
/**
* This method does some common test for cache implementations.
* A cache must return a stored value and a valid iterator.
* After calling the delete() the cache must be empty.
*
* @param algo configured test object
*/
protected void doTest(Cache cache) {
assertTrue("Cache not proper configured.", cache.isValid());
String key1 = "key1";
String value1 = "value1";
String key2 = "key2";
String value2 = "value2";
// given cache must be empty
Iterator it1 = cache.iterator();
assertFalse("Cache is not empty", it1.hasNext());
// cache must return a stored value
cache.put(key1, value1);
cache.put(key2, value2);
assertEquals("cache returned wrong value", value1, cache.get(key1));
assertEquals("cache returned wrong value", value2, cache.get(key2));
// test the iterator
Iterator it2 = cache.iterator();
Object returned = it2.next();
boolean ok = (key1.equals(returned) || key2.equals(returned));
String msg = "Iterator returned unexpected value."
+ " key1.equals(returned)="+key1.equals(returned)
+ " key2.equals(returned)="+key2.equals(returned)
+ " returned="+returned
+ " ok="+ok;
assertTrue(msg, ok);
// clear the cache
cache.delete();
Iterator it3 = cache.iterator();
assertFalse("Cache is not empty", it1.hasNext());
}
/**
* This method does some common test for comparator implementations.
*
* @param algo configured test object
*/
protected void doTest(Comparator comp) {
Object o1 = new String("string1");
Object o2 = new String("string2");
Object o3 = new String("string2"); // really "2"
assertTrue("Comparator gave wrong value.", comp.compare(o1, o2) != 0);
assertTrue("Comparator gave wrong value.", comp.compare(o1, o3) != 0);
assertTrue("Comparator gave wrong value.", comp.compare(o2, o3) == 0);
}
// ======================== Helper methods ========================
private Parameter createParam(String name, String value) {
Parameter p = new Parameter();
p.setName(name);
p.setValue(value);
return p;
}
private class BFT extends org.apache.tools.ant.BuildFileTest {
BFT() { super("nothing"); }
BFT(String name) {
super(name);
}
String propfile = "ModifiedSelectorTest.properties";
boolean isConfigured = false;
public void setUp() {
configureProject("src/etc/testcases/types/selectors.xml");
isConfigured = true;
}
public void tearDown() { }
public void doTarget(String target) {
if (!isConfigured) setUp();
executeTarget(target);
}
public void writeProperties(String line) {
if (!isConfigured) setUp();
File dir = getProject().getBaseDir();
File file = new File(dir, propfile);
try {
java.io.FileWriter out =
new java.io.FileWriter(file.getAbsolutePath(), true);
out.write(line);
out.write(System.getProperty("line.separator"));
out.flush();
out.close();
} catch (Exception e) {
e.printStackTrace();
}
}
public void deletePropertiesfile() {
if (!isConfigured) setUp();
new File(getProject().getBaseDir(), propfile).delete();
}
public org.apache.tools.ant.Project getProject() {
return super.getProject();
}
}//class-BFT
}//class-ModifiedSelectorTest