@@ -0,0 +1,13 @@ | |||
<?xml version="1.0" encoding="UTF-8"?> | |||
<fileset-config file-format-version="1.2.0" simple-config="true" sync-formatter="false"> | |||
<local-check-config name="Ant Checkstyle Config" location="src/etc/checkstyle/checkstyle-config" type="project" description=""> | |||
<property name="config.dir" value="${basedir}/src/etc/checkstyle"/> | |||
<additional-data name="protect-config-file" value="true"/> | |||
</local-check-config> | |||
<fileset name="Ant Checkstyle config" enabled="true" check-config-name="Ant Checkstyle Config" local="true"> | |||
<file-match-pattern match-pattern="^src.main.*.java$" include-pattern="true"/> | |||
<file-match-pattern match-pattern="^src.etc.testcases.*.java$" include-pattern="true"/> | |||
<file-match-pattern match-pattern="^src.tests.*.java$" include-pattern="true"/> | |||
</fileset> | |||
</fileset-config> |
@@ -1,4 +1,5 @@ | |||
<?xml version="1.0"?> | |||
<?xml version="1.0" encoding="UTF-8"?> | |||
<!DOCTYPE module PUBLIC "-//Puppy Crawl//DTD Check Configuration 1.3//EN" "http://www.puppycrawl.com/dtds/configuration_1_3.dtd"> | |||
<!-- | |||
Licensed to the Apache Software Foundation (ASF) under one or more | |||
contributor license agreements. See the NOTICE file distributed with | |||
@@ -15,7 +16,6 @@ | |||
See the License for the specific language governing permissions and | |||
limitations under the License. | |||
--> | |||
<!DOCTYPE module PUBLIC "-//Puppy Crawl//DTD Check Configuration 1.1//EN" "http://www.puppycrawl.com/dtds/configuration_1_1.dtd"> | |||
<module name="Checker"> | |||
@@ -65,6 +65,7 @@ | |||
<module name="LineLength"> | |||
<property name="max" value="100"/> | |||
<property name="ignorePattern" value="^ *\* *[^ ]+$"/> | |||
<property name="tabWidth" value="4"/> | |||
</module> | |||
<module name="MethodLength"/> | |||
<module name="ParameterNumber"/> | |||
@@ -1,4 +1,4 @@ | |||
/* | |||
/* | |||
* Licensed to the Apache Software Foundation (ASF) under one or more | |||
* contributor license agreements. See the NOTICE file distributed with | |||
* this work for additional information regarding copyright ownership. | |||
@@ -13,7 +13,7 @@ | |||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |||
* See the License for the specific language governing permissions and | |||
* limitations under the License. | |||
* | |||
* | |||
*/ | |||
package test; | |||
@@ -22,21 +22,22 @@ import org.apache.tools.ant.TaskContainer; | |||
import org.apache.tools.ant.BuildException; | |||
import org.apache.tools.ant.types.FileSet; | |||
import org.apache.tools.ant.taskdefs.Echo; | |||
import java.util.*; | |||
import java.util.Enumeration; | |||
import java.util.Vector; | |||
public class SpecialSeq extends Task implements TaskContainer { | |||
/** Optional Vector holding the nested tasks */ | |||
private Vector nestedTasks = new Vector(); | |||
private FileSet fileset; | |||
private Echo nestedEcho; | |||
/** | |||
* Add a nested task. | |||
* <p> | |||
* | |||
* @param nestedTask Nested task to execute | |||
* <p> | |||
*/ | |||
public void addTask(Task nestedTask) { | |||
nestedTasks.addElement(nestedTask); | |||
@@ -60,7 +61,7 @@ public class SpecialSeq extends Task implements TaskContainer { | |||
public void addFileset(FileSet fileset) { | |||
this.fileset = fileset; | |||
} | |||
public void addNested(Echo nestedEcho) { | |||
this.nestedEcho = nestedEcho; | |||
} | |||
@@ -31,7 +31,7 @@ public class ClassToJavadoc { | |||
* @see java.lang.Object#toString() | |||
*/ | |||
public String toString() { return this.getClass().getName(); } | |||
/** | |||
* @return An arbitrary string. | |||
*/ | |||
@@ -19,6 +19,5 @@ package test; | |||
public class ContainsOnlyInner { | |||
void method1() { | |||
System.out.println(Outer.Inner.class); | |||
} | |||
} | |||
} | |||
@@ -39,7 +39,7 @@ public class AntTimestamp implements RemoteTimestamp { | |||
* @throws RemoteException | |||
*/ | |||
public long when() throws RemoteException { | |||
Calendar cal=Calendar.getInstance(); | |||
Calendar cal = Calendar.getInstance(); | |||
return DateUtils.getPhaseOfMoon(cal); | |||
} | |||
} |
@@ -21,6 +21,6 @@ import java.rmi.RemoteException; | |||
* this is the interface we remote | |||
*/ | |||
public interface RemoteTimestamp extends Remote { | |||
long when() throws RemoteException ; | |||
long when() throws RemoteException; | |||
} | |||
@@ -31,14 +31,14 @@ public class AssertionTest extends TestCase { | |||
try { | |||
assert true == false; | |||
fail("expected an assertion"); | |||
} catch(AssertionError asserto) { | |||
} catch (AssertionError asserto) { | |||
//if we got here, all was well | |||
} | |||
} | |||
public void testAssertNotRaised() { | |||
assert(2+2==4); | |||
assert(2 + 2 == 4); | |||
} | |||
@@ -19,7 +19,7 @@ prop\ttwo=contains\ttab | |||
prop\nthree=contains\nnewline | |||
prop\rfour=contains\rcarraige return | |||
prop\rfour=contains\rcarriage return | |||
prop\ffive=contains\fform feed | |||
@@ -1181,7 +1181,7 @@ public class Javac extends MatchingTask { | |||
scanDir(srcDir, destDir != null ? destDir : srcDir, files); | |||
} | |||
} | |||
private void collectFileListFromModulePath() { | |||
final FileUtils fu = FileUtils.getFileUtils(); | |||
for (String pathElement : moduleSourcepath.list()) { | |||
@@ -36,7 +36,7 @@ import java.util.BitSet; | |||
* <pre> | |||
* CompressCommons | |||
* Commons Compress | |||
* CompressCommons | |||
* CompressCommons | |||
* essCommons Compr | |||
* mmons CompressCo | |||
* mons CompressCom | |||
@@ -251,7 +251,7 @@ class BlockSort { | |||
* bucket 'ra' with sort index 5. The fully sorted order then becomes. | |||
* | |||
* fmap = { 5, 3, 0, 4, 1, 2 } | |||
* | |||
* | |||
*/ | |||
/** | |||
@@ -261,12 +261,12 @@ class BlockSort { | |||
* @param eclass points from the index of a character inside the | |||
* block to the first index in fmap that contains the | |||
* bucket of its suffix that is sorted in this step. | |||
* @param lo lower boundary of the fmap-interval to be sorted | |||
* @param hi upper boundary of the fmap-interval to be sorted | |||
* @param lo lower boundary of the fmap-interval to be sorted | |||
* @param hi upper boundary of the fmap-interval to be sorted | |||
*/ | |||
private void fallbackSimpleSort(int[] fmap, | |||
int[] eclass, | |||
int lo, | |||
private void fallbackSimpleSort(int[] fmap, | |||
int[] eclass, | |||
int lo, | |||
int hi) { | |||
if (lo == hi) { | |||
return; | |||
@@ -336,12 +336,12 @@ class BlockSort { | |||
* @param eclass points from the index of a character inside the | |||
* block to the first index in fmap that contains the | |||
* bucket of its suffix that is sorted in this step. | |||
* @param loSt lower boundary of the fmap-interval to be sorted | |||
* @param hiSt upper boundary of the fmap-interval to be sorted | |||
* @param loSt lower boundary of the fmap-interval to be sorted | |||
* @param hiSt upper boundary of the fmap-interval to be sorted | |||
*/ | |||
private void fallbackQSort3(int[] fmap, | |||
int[] eclass, | |||
int loSt, | |||
private void fallbackQSort3(int[] fmap, | |||
int[] eclass, | |||
int loSt, | |||
int hiSt) { | |||
int lo, unLo, ltLo, hi, unHi, gtHi, n; | |||
@@ -359,16 +359,16 @@ class BlockSort { | |||
} | |||
/* LBZ2: Random partitioning. Median of 3 sometimes fails to | |||
avoid bad cases. Median of 9 seems to help but | |||
avoid bad cases. Median of 9 seems to help but | |||
looks rather expensive. This too seems to work but | |||
is cheaper. Guidance for the magic constants | |||
is cheaper. Guidance for the magic constants | |||
7621 and 32768 is taken from Sedgewick's algorithms | |||
book, chapter 35. | |||
*/ | |||
r = ((r * 7621) + 1) % 32768; | |||
long r3 = r % 3, med; | |||
if (r3 == 0) { | |||
med = eclass[fmap[lo]]; | |||
med = eclass[fmap[lo]]; | |||
} else if (r3 == 1) { | |||
med = eclass[fmap[(lo + hi) >>> 1]]; | |||
} else { | |||
@@ -386,10 +386,10 @@ class BlockSort { | |||
break; | |||
} | |||
n = eclass[fmap[unLo]] - (int) med; | |||
if (n == 0) { | |||
fswap(fmap, unLo, ltLo); | |||
ltLo++; unLo++; | |||
continue; | |||
if (n == 0) { | |||
fswap(fmap, unLo, ltLo); | |||
ltLo++; unLo++; | |||
continue; | |||
} | |||
if (n > 0) { | |||
break; | |||
@@ -402,9 +402,9 @@ class BlockSort { | |||
} | |||
n = eclass[fmap[unHi]] - (int) med; | |||
if (n == 0) { | |||
fswap(fmap, unHi, gtHi); | |||
gtHi--; unHi--; | |||
continue; | |||
fswap(fmap, unHi, gtHi); | |||
gtHi--; unHi--; | |||
continue; | |||
} | |||
if (n < 0) { | |||
break; | |||
@@ -510,7 +510,7 @@ class BlockSort { | |||
--*/ | |||
/*-- LBZ2: set sentinel bits for block-end detection --*/ | |||
for (i = 0; i < 32; i++) { | |||
for (i = 0; i < 32; i++) { | |||
bhtab.set(nblock + 2 * i); | |||
bhtab.clear(nblock + 2 * i + 1); | |||
} | |||
@@ -40,7 +40,7 @@ import java.io.InputStream; | |||
* source stream via the single byte {@link java.io.InputStream#read() | |||
* read()} method exclusively. Thus you should consider to use a | |||
* buffered source stream.</p> | |||
* | |||
* | |||
* <p>Instances of this class are not threadsafe.</p> | |||
*/ | |||
public class CBZip2InputStream extends InputStream implements BZip2Constants { | |||
@@ -173,7 +173,7 @@ public class CBZip2InputStream extends InputStream implements BZip2Constants { | |||
/* | |||
* (non-Javadoc) | |||
* | |||
* | |||
* @see java.io.InputStream#read(byte[], int, int) | |||
*/ | |||
@Override | |||
@@ -261,7 +261,7 @@ public class CBZip2InputStream extends InputStream implements BZip2Constants { | |||
if (null == in) { | |||
throw new IOException("No InputStream"); | |||
} | |||
if (isFirstStream) { | |||
if (in.available() == 0) { | |||
throw new IOException("Empty InputStream"); | |||
@@ -1059,4 +1059,3 @@ public class CBZip2InputStream extends InputStream implements BZip2Constants { | |||
} | |||
} | |||
@@ -63,10 +63,10 @@ abstract public class BaseTask extends Task { | |||
FILE_UTILS.close(outputStream); | |||
} | |||
} | |||
abstract protected void doit( | |||
InputStream is, OutputStream os) throws Exception; | |||
private void assertAttribute(File file, String attributeName) { | |||
if (file == null) { | |||
throw new BuildException("Required attribute " + attributeName | |||
@@ -74,5 +74,3 @@ abstract public class BaseTask extends Task { | |||
} | |||
} | |||
} | |||
@@ -28,4 +28,3 @@ public class UUDecodeTask extends BaseTask { | |||
new UUDecoder().decodeBuffer(is, os); | |||
} | |||
} | |||
@@ -34,7 +34,8 @@ public class AntAssert { | |||
*/ | |||
public static void assertContains(String message, String needle, String haystack) { | |||
String formattedMessage = (message == null ? "" : message + " "); | |||
assertTrue(formattedMessage + String.format("expected message containing: <%s> but got: <%s>", needle, haystack), haystack.contains(needle)); | |||
assertTrue(formattedMessage + String.format("expected message containing: <%s> but got: <%s>", | |||
needle, haystack), haystack.contains(needle)); | |||
} | |||
/** | |||
@@ -55,7 +56,8 @@ public class AntAssert { | |||
*/ | |||
public static void assertNotContains(String message, String needle, String haystack) { | |||
String formattedMessage = (message == null ? "" : message + " "); | |||
assertFalse(formattedMessage + String.format("expected message not to contain: <%s> but got: <%s>", needle, haystack), haystack.contains(needle)); | |||
assertFalse(formattedMessage + String.format("expected message not to contain: <%s> but got: <%s>", | |||
needle, haystack), haystack.contains(needle)); | |||
} | |||
/** | |||
@@ -55,6 +55,7 @@ public class AntClassLoaderDelegationTest { | |||
private static final String TEST_RESOURCE | |||
= "apache/tools/ant/IncludeTest.class"; | |||
@SuppressWarnings("resource") | |||
@Test | |||
public void testFindResources() throws Exception { | |||
// This path should contain the class files for these testcases: | |||
@@ -81,6 +82,7 @@ public class AntClassLoaderDelegationTest { | |||
enum2List(acl.getResources(TEST_RESOURCE))); | |||
} | |||
@SuppressWarnings("resource") | |||
@Test | |||
public void testFindIsolateResources() throws Exception { | |||
String buildTestcases = System.getProperty("build.tests"); | |||
@@ -99,16 +101,17 @@ public class AntClassLoaderDelegationTest { | |||
Arrays.asList(new URL[] {urlFromPath}), | |||
enum2List(acl.getResources(TEST_RESOURCE))); | |||
} | |||
private static List enum2List(Enumeration e) { | |||
return Collections.list(e); | |||
} | |||
/** Special loader that just knows how to find TEST_RESOURCE. */ | |||
private static final class ParentLoader extends ClassLoader { | |||
public ParentLoader() {} | |||
public ParentLoader() { | |||
} | |||
protected Enumeration findResources(String name) throws IOException { | |||
if (name.equals(TEST_RESOURCE)) { | |||
return Collections.enumeration( | |||
@@ -118,7 +121,7 @@ public class AntClassLoaderDelegationTest { | |||
return Collections.enumeration(Collections.EMPTY_SET); | |||
} | |||
} | |||
} | |||
} |
@@ -207,6 +207,7 @@ public class AntClassLoaderTest { | |||
* @see <a href="https://issues.apache.org/bugzilla/show_bug.cgi?id=46752"> | |||
* https://issues.apache.org/bugzilla/show_bug.cgi?id=46752</a> | |||
*/ | |||
@SuppressWarnings("resource") | |||
@Test | |||
public void testGetResources() throws IOException { | |||
AntClassLoader acl = new AntClassLoader(new EmptyLoader(), null, | |||
@@ -28,8 +28,8 @@ import org.junit.rules.ExternalResource; | |||
/** | |||
* Provides access for JUnit tests to execute Ant targets and access execution details (i.e logs). | |||
* | |||
* Example usage: | |||
* <code> | |||
* <p>Example usage:</p> | |||
* <pre> | |||
* public class MyTest { | |||
* | |||
* \@Rule | |||
@@ -42,7 +42,7 @@ import org.junit.rules.ExternalResource; | |||
* | |||
* \@Test | |||
* public void testSuccess() { | |||
* rule.executeTarget("passingTaget"); | |||
* rule.executeTarget("passingTarget"); | |||
* assertEquals("Incorrect log message", "[taskName] Action Complete", rule.getLog()); | |||
* } | |||
* | |||
@@ -57,7 +57,7 @@ import org.junit.rules.ExternalResource; | |||
* } | |||
* | |||
* } | |||
* </code> | |||
* </pre> | |||
*/ | |||
public class BuildFileRule extends ExternalResource { | |||
@@ -102,8 +102,7 @@ public class BuildFileRule extends ExternalResource { | |||
/** | |||
* Gets any messages that have been logged during the current execution, unless | |||
* the logging level has been set above the log level defined in the message. | |||
* | |||
* Only valid if configureProject() has been called. | |||
* <p>Only valid if configureProject() has been called.</p> | |||
* @return the content of the log. | |||
*/ | |||
public String getFullLog() { | |||
@@ -159,7 +158,7 @@ public class BuildFileRule extends ExternalResource { | |||
File antFile = new File(System.getProperty("root"), filename); | |||
project.setProperty("ant.processid", ProcessUtil.getProcessId("<Process>")); | |||
project.setProperty("ant.threadname", Thread.currentThread().getName()); | |||
project.setUserProperty("ant.file" , antFile.getAbsolutePath()); | |||
project.setUserProperty("ant.file", antFile.getAbsolutePath()); | |||
project.addBuildListener(new AntTestListener(logLevel)); | |||
ProjectHelper.configureProject(project, antFile); | |||
} | |||
@@ -217,7 +216,7 @@ public class BuildFileRule extends ExternalResource { | |||
protected static class AntOutputStream extends OutputStream { | |||
private StringBuffer buffer; | |||
public AntOutputStream( StringBuffer buffer ) { | |||
public AntOutputStream(StringBuffer buffer) { | |||
this.buffer = buffer; | |||
} | |||
@@ -301,9 +300,9 @@ public class BuildFileRule extends ExternalResource { | |||
return; | |||
} | |||
if (event.getPriority() == Project.MSG_INFO || | |||
event.getPriority() == Project.MSG_WARN || | |||
event.getPriority() == Project.MSG_ERR) { | |||
if (event.getPriority() == Project.MSG_INFO | |||
|| event.getPriority() == Project.MSG_WARN | |||
|| event.getPriority() == Project.MSG_ERR) { | |||
logBuffer.append(event.getMessage()); | |||
} | |||
fullLogBuffer.append(event.getMessage()); | |||
@@ -19,6 +19,7 @@ | |||
package org.apache.tools.ant; | |||
import java.io.File; | |||
import java.io.OutputStream; | |||
import java.io.PrintStream; | |||
import java.net.URL; | |||
@@ -139,28 +140,28 @@ public abstract class BuildFileTest extends TestCase { | |||
/** | |||
* Assert that the given substring is in the output messages. | |||
* @param message Print this message if the test fails. Defaults to | |||
* a meaningful text if <tt>null</tt> is passed. | |||
* @param message Print this message if the test fails. Defaults to | |||
* a meaningful text if <tt>null</tt> is passed. | |||
* @since Ant1.7 | |||
*/ | |||
public void assertOutputContaining(String message, String substring) { | |||
String realOutput = getOutput(); | |||
String realMessage = (message != null) | |||
? message | |||
String realMessage = (message != null) | |||
? message | |||
: "expecting output to contain \"" + substring + "\" output was \"" + realOutput + "\""; | |||
assertTrue(realMessage, realOutput.indexOf(substring) >= 0); | |||
} | |||
/** | |||
* Assert that the given substring is not in the output messages. | |||
* @param message Print this message if the test fails. Defaults to | |||
* a meaningful text if <tt>null</tt> is passed. | |||
* @param message Print this message if the test fails. Defaults to | |||
* a meaningful text if <tt>null</tt> is passed. | |||
* @since Ant1.7 | |||
*/ | |||
public void assertOutputNotContaining(String message, String substring) { | |||
String realOutput = getOutput(); | |||
String realMessage = (message != null) | |||
? message | |||
String realMessage = (message != null) | |||
? message | |||
: "expecting output to not contain \"" + substring + "\" output was \"" + realOutput + "\""; | |||
assertFalse(realMessage, realOutput.indexOf(substring) >= 0); | |||
} | |||
@@ -209,7 +210,7 @@ public abstract class BuildFileTest extends TestCase { | |||
*/ | |||
public void assertDebuglogContaining(String substring) { | |||
String realLog = getFullLog(); | |||
assertTrue("expecting debug log to contain \"" + substring | |||
assertTrue("expecting debug log to contain \"" + substring | |||
+ "\" log was \"" | |||
+ realLog + "\"", | |||
realLog.indexOf(substring) >= 0); | |||
@@ -268,7 +269,7 @@ public abstract class BuildFileTest extends TestCase { | |||
} | |||
private String cleanBuffer(StringBuffer buffer) { | |||
StringBuffer cleanedBuffer = new StringBuffer(); | |||
StringBuilder cleanedBuffer = new StringBuilder(); | |||
for (int i = 0; i < buffer.length(); i++) { | |||
char ch = buffer.charAt(i); | |||
if (ch != '\r') { | |||
@@ -299,7 +300,7 @@ public abstract class BuildFileTest extends TestCase { | |||
project = new Project(); | |||
project.init(); | |||
File antFile = new File(System.getProperty("root"), filename); | |||
project.setUserProperty("ant.file" , antFile.getAbsolutePath()); | |||
project.setUserProperty("ant.file", antFile.getAbsolutePath()); | |||
// set two new properties to allow to build unique names when running multithreaded tests | |||
project.setProperty("ant.processid", ProcessUtil.getProcessId("<Process>")); | |||
project.setProperty("ant.threadname", Thread.currentThread().getName()); | |||
@@ -480,7 +481,7 @@ public abstract class BuildFileTest extends TestCase { | |||
* @param resource the resource to retrieve its url. | |||
* @throws junit.framework.AssertionFailedError if the resource is not found. | |||
*/ | |||
public URL getResource(String resource){ | |||
public URL getResource(String resource) { | |||
URL url = getClass().getResource(resource); | |||
assertNotNull("Could not find resource :" + resource, url); | |||
return url; | |||
@@ -489,10 +490,10 @@ public abstract class BuildFileTest extends TestCase { | |||
/** | |||
* an output stream which saves stuff to our buffer. | |||
*/ | |||
protected static class AntOutputStream extends java.io.OutputStream { | |||
protected static class AntOutputStream extends OutputStream { | |||
private StringBuffer buffer; | |||
public AntOutputStream( StringBuffer buffer ) { | |||
public AntOutputStream(StringBuffer buffer) { | |||
this.buffer = buffer; | |||
} | |||
@@ -580,9 +581,9 @@ public abstract class BuildFileTest extends TestCase { | |||
return; | |||
} | |||
if (event.getPriority() == Project.MSG_INFO || | |||
event.getPriority() == Project.MSG_WARN || | |||
event.getPriority() == Project.MSG_ERR) { | |||
if (event.getPriority() == Project.MSG_INFO | |||
|| event.getPriority() == Project.MSG_WARN | |||
|| event.getPriority() == Project.MSG_ERR) { | |||
logBuffer.append(event.getMessage()); | |||
} | |||
fullLogBuffer.append(event.getMessage()); | |||
@@ -56,7 +56,7 @@ public class CaseTest { | |||
try { | |||
buildRule.executeTarget("taskcase"); | |||
fail("Build exception should have been thrown due to case sensitivity of name"); | |||
} catch(BuildException ex) { | |||
} catch (BuildException ex) { | |||
assertContains("Task names should be case sensitive", "Problem: failed to create task or type ecHO", ex.getMessage()); | |||
} | |||
} | |||
@@ -34,6 +34,7 @@ public class DefaultLoggerTest { | |||
return m.toString(); | |||
} | |||
@SuppressWarnings("serial") | |||
@Test | |||
public void testThrowableMessage() throws Exception { // #43398 | |||
BuildException be = new BuildException("oops", new Location("build.xml", 1, 0)); | |||
@@ -21,8 +21,8 @@ package org.apache.tools.ant; | |||
import static org.junit.Assert.assertEquals; | |||
import static org.junit.Assert.assertFalse; | |||
import static org.junit.Assert.assertTrue; | |||
import static org.junit.Assume.assumeTrue; | |||
import static org.junit.Assume.assumeFalse; | |||
import static org.junit.Assume.assumeTrue; | |||
import java.io.File; | |||
import java.io.IOException; | |||
@@ -62,7 +62,7 @@ public class DirectoryScannerTest { | |||
ds.setBasedir(new File(buildRule.getProject().getProperty("output"))); | |||
ds.setIncludes(new String[] {"alpha"}); | |||
ds.scan(); | |||
compareFiles(ds, new String[] {} ,new String[] {"alpha"}); | |||
compareFiles(ds, new String[] {}, new String[] {"alpha"}); | |||
} | |||
@Test | |||
@@ -244,7 +244,7 @@ public class DirectoryScannerTest { | |||
* Only supports test on Linux at the moment because Java has | |||
* no real notion of symlinks built in, so an os-specfic call | |||
* to Runtime.exec() must be made to create a link to test against. | |||
* @throws InterruptedException | |||
* @throws InterruptedException if something goes wrong | |||
*/ | |||
@Test | |||
public void testSetFollowLinks() throws IOException, InterruptedException { | |||
@@ -276,13 +276,13 @@ public class DirectoryScannerTest { | |||
boolean haveZipPackage = false; | |||
boolean haveTaskdefsPackage = false; | |||
String[] included = ds.getIncludedDirectories(); | |||
for (int i=0; i<included.length; i++) { | |||
if (included[i].equals("zip")) { | |||
String[] includeds = ds.getIncludedDirectories(); | |||
for (String included : includeds) { | |||
if (included.equals("zip")) { | |||
haveZipPackage = true; | |||
} else if (included[i].equals("ThisIsALink" | |||
+ File.separator | |||
+ "taskdefs")) { | |||
} else if (included.equals("ThisIsALink" | |||
+ File.separator | |||
+ "taskdefs")) { | |||
haveTaskdefsPackage = true; | |||
} | |||
} | |||
@@ -291,9 +291,7 @@ public class DirectoryScannerTest { | |||
// bypass the excludes. | |||
assertTrue("(1) zip package included", haveZipPackage); | |||
assertTrue("(1) taskdefs package included", | |||
haveTaskdefsPackage); | |||
assertTrue("(1) taskdefs package included", haveTaskdefsPackage); | |||
ds = new DirectoryScanner(); | |||
ds.setFollowSymlinks(false); | |||
@@ -304,19 +302,18 @@ public class DirectoryScannerTest { | |||
haveZipPackage = false; | |||
haveTaskdefsPackage = false; | |||
included = ds.getIncludedDirectories(); | |||
for (int i=0; i<included.length; i++) { | |||
if (included[i].equals("zip")) { | |||
includeds = ds.getIncludedDirectories(); | |||
for (String included : includeds) { | |||
if (included.equals("zip")) { | |||
haveZipPackage = true; | |||
} else if (included[i].equals("ThisIsALink" | |||
+ File.separator | |||
+ "taskdefs")) { | |||
} else if (included.equals("ThisIsALink" | |||
+ File.separator | |||
+ "taskdefs")) { | |||
haveTaskdefsPackage = true; | |||
} | |||
} | |||
assertTrue("(2) zip package included", haveZipPackage); | |||
assertTrue("(2) taskdefs package not included", | |||
!haveTaskdefsPackage); | |||
assertFalse("(2) taskdefs package not included", haveTaskdefsPackage); | |||
} finally { | |||
if (!linkFile.delete()) { | |||
@@ -491,7 +488,7 @@ public class DirectoryScannerTest { | |||
buildRule.getProject().executeTarget("extended-setup"); | |||
DirectoryScanner ds = new DirectoryScanner(); | |||
String tmpdir = buildRule.getProject().getProperty("output").replace( | |||
File.separatorChar, '/') ; | |||
File.separatorChar, '/'); | |||
ds.setIncludes(new String[] {tmpdir + "/alpha/beta/**/*", | |||
tmpdir + "/delta/*"}); | |||
ds.setExcludes(new String[] {"**/beta.xml"}); | |||
@@ -516,28 +513,28 @@ public class DirectoryScannerTest { | |||
private void compareFiles(DirectoryScanner ds, String[] expectedFiles, | |||
String[] expectedDirectories) { | |||
String includedFiles[] = ds.getIncludedFiles(); | |||
String includedDirectories[] = ds.getIncludedDirectories(); | |||
String[] includedFiles = ds.getIncludedFiles(); | |||
String[] includedDirectories = ds.getIncludedDirectories(); | |||
assertEquals("file present: ", expectedFiles.length, | |||
includedFiles.length); | |||
assertEquals("directories present: ", expectedDirectories.length, | |||
includedDirectories.length); | |||
TreeSet<String> files = new TreeSet<String>(); | |||
for (int counter = 0; counter < includedFiles.length; counter++) { | |||
files.add(includedFiles[counter].replace(File.separatorChar, '/')); | |||
for (String includedFile : includedFiles) { | |||
files.add(includedFile.replace(File.separatorChar, '/')); | |||
} | |||
TreeSet<String> directories = new TreeSet<String>(); | |||
for (int counter = 0; counter < includedDirectories.length; counter++) { | |||
directories.add(includedDirectories[counter] | |||
.replace(File.separatorChar, '/')); | |||
for (String includedDirectory : includedDirectories) { | |||
directories.add(includedDirectory | |||
.replace(File.separatorChar, '/')); | |||
} | |||
String currentfile; | |||
Iterator<String> i = files.iterator(); | |||
int counter = 0; | |||
while (i.hasNext()) { | |||
currentfile = (String) i.next(); | |||
currentfile = i.next(); | |||
assertEquals(expectedFiles[counter], currentfile); | |||
counter++; | |||
} | |||
@@ -545,7 +542,7 @@ public class DirectoryScannerTest { | |||
Iterator<String> dirit = directories.iterator(); | |||
counter = 0; | |||
while (dirit.hasNext()) { | |||
currentdirectory = (String) dirit.next(); | |||
currentdirectory = dirit.next(); | |||
assertEquals(expectedDirectories[counter], currentdirectory); | |||
counter++; | |||
} | |||
@@ -53,12 +53,24 @@ public class ExecutorTest implements BuildListener { | |||
public void targetStarted(BuildEvent event) { | |||
targetCount++; | |||
} | |||
public void buildStarted(BuildEvent event) {} | |||
public void buildFinished(BuildEvent event) {} | |||
public void targetFinished(BuildEvent event) {} | |||
public void taskStarted(BuildEvent event) {} | |||
public void taskFinished(BuildEvent event) {} | |||
public void messageLogged(BuildEvent event) {} | |||
public void buildStarted(BuildEvent event) { | |||
} | |||
public void buildFinished(BuildEvent event) { | |||
} | |||
public void targetFinished(BuildEvent event) { | |||
} | |||
public void taskStarted(BuildEvent event) { | |||
} | |||
public void taskFinished(BuildEvent event) { | |||
} | |||
public void messageLogged(BuildEvent event) { | |||
} | |||
@Before | |||
public void setUp() { | |||
@@ -50,7 +50,7 @@ public class ExtendedTaskdefTest { | |||
try { | |||
buildRule.executeTarget("testRun"); | |||
fail("BuildException should have been thrown"); | |||
} catch(BuildException ex) { | |||
} catch (BuildException ex) { | |||
assertContains("exception thrown by the subclass", "executing the Foo task", ex.getMessage()); | |||
} | |||
} | |||
@@ -60,7 +60,7 @@ public class ExtendedTaskdefTest { | |||
try { | |||
buildRule.executeTarget("testRun2"); | |||
fail("BuildException should have been thrown"); | |||
} catch(BuildException ex) { | |||
} catch (BuildException ex) { | |||
assertContains("exception thrown by the subclass", "executing the Foo task", ex.getMessage()); | |||
} | |||
} | |||
@@ -58,7 +58,6 @@ public class FileUtilities { | |||
} | |||
} | |||
/** | |||
* Modified the timestamp on a file so it's <tt>seconds</tt> earlier than it was before. Where <tt>file</tt> | |||
* is a directory, this function recurses into all child files (and directories) and reduces their modified | |||
@@ -66,7 +65,7 @@ public class FileUtilities { | |||
* @param file the file to change, or the directory to change then recurse into | |||
* @param seconds how many seconds to roll the timestamp back by | |||
*/ | |||
public static void rollbackTimetamps(File file, long seconds) { | |||
public static void rollbackTimestamps(File file, long seconds) { | |||
if (null == file || !file.exists()) { | |||
return; | |||
} | |||
@@ -80,7 +79,7 @@ public class FileUtilities { | |||
return; | |||
} | |||
for (File child : children) { | |||
rollbackTimetamps(child, seconds); | |||
rollbackTimestamps(child, seconds); | |||
} | |||
} | |||
} | |||
@@ -19,8 +19,8 @@ | |||
package org.apache.tools.ant; | |||
import java.io.File; | |||
import java.lang.reflect.Method; | |||
import java.lang.reflect.InvocationTargetException; | |||
import java.lang.reflect.Method; | |||
import java.util.Enumeration; | |||
import java.util.HashMap; | |||
import java.util.Hashtable; | |||
@@ -28,6 +28,7 @@ import java.util.Iterator; | |||
import java.util.List; | |||
import java.util.Locale; | |||
import java.util.Map; | |||
import org.apache.tools.ant.taskdefs.condition.Os; | |||
import org.junit.Before; | |||
import org.junit.ComparisonFailure; | |||
@@ -96,7 +97,8 @@ public class IntrospectionHelperTest { | |||
ih = IntrospectionHelper.getHelper(String.class); | |||
try { | |||
m = ih.getAddTextMethod(); | |||
} catch (BuildException e) {} | |||
} catch (BuildException e) { | |||
} | |||
} | |||
@Test | |||
@@ -219,7 +221,7 @@ public class IntrospectionHelperTest { | |||
Class expect = (Class) elemMap.get(name); | |||
assertNotNull("Support for "+name+" in IntrospectioNHelperTest?", | |||
expect); | |||
assertEquals("Return type of "+name, expect, ih.getElementType(name)); | |||
assertEquals("Return type of " + name, expect, ih.getElementType(name)); | |||
elemMap.remove(name); | |||
} | |||
assertTrue("Found all", elemMap.isEmpty()); | |||
@@ -244,7 +246,8 @@ public class IntrospectionHelperTest { | |||
try { | |||
actualMap.clear(); | |||
//TODO we should be asserting a value somewhere in here | |||
} catch (UnsupportedOperationException e) {} | |||
} catch (UnsupportedOperationException e) { | |||
} | |||
} | |||
@Test | |||
@@ -274,7 +277,8 @@ public class IntrospectionHelperTest { | |||
return null; | |||
} | |||
public void createThree() {} | |||
public void createThree() { | |||
} | |||
public Object[] createFour() { | |||
return null; | |||
@@ -292,19 +296,24 @@ public class IntrospectionHelperTest { | |||
throw new NullPointerException(); | |||
} | |||
public void addSeven(String s, String s2) {} | |||
public void addSeven(String s, String s2) { | |||
} | |||
public void addEight() {} | |||
public void addEight() { | |||
} | |||
public String addNine(String s) { | |||
return null; | |||
} | |||
public void addTen(String[] s) {} | |||
public void addTen(String[] s) { | |||
} | |||
public void addEleven(int i) {} | |||
public void addEleven(int i) { | |||
} | |||
public void addTwelve(Class c) {} | |||
public void addTwelve(Class c) { | |||
} | |||
public void addThirteen(StringBuffer sb) { | |||
sb.append("test"); | |||
@@ -376,7 +385,7 @@ public class IntrospectionHelperTest { | |||
ih.setAttribute(p, this, "ten", "2"); | |||
try { | |||
ih.setAttribute(p, this, "ten", "3"); | |||
fail(projectBasedir+"2 shouldn't be equals to "+projectBasedir+"3"); | |||
fail(projectBasedir + "2 shouldn't be equals to " + projectBasedir + "3"); | |||
} catch (BuildException be) { | |||
assertTrue(be.getCause() instanceof AssertionError); | |||
} | |||
@@ -515,7 +524,8 @@ public class IntrospectionHelperTest { | |||
try { | |||
actualMap.clear(); | |||
//TODO we should be asserting a value somewhere in here | |||
} catch (UnsupportedOperationException e) {} | |||
} catch (UnsupportedOperationException e) { | |||
} | |||
} | |||
@Test | |||
@@ -565,13 +575,17 @@ public class IntrospectionHelperTest { | |||
return 0; | |||
} | |||
public void setThree() {} | |||
public void setThree() { | |||
} | |||
public void setFour(String s1, String s2) {} | |||
public void setFour(String s1, String s2) { | |||
} | |||
public void setFive(String[] s) {} | |||
public void setFive(String[] s) { | |||
} | |||
public void setSix(Project p) {} | |||
public void setSix(Project p) { | |||
} | |||
public void setSeven(String s) { | |||
assertEquals("2", s); | |||
@@ -588,11 +602,11 @@ public class IntrospectionHelperTest { | |||
public void setTen(File f) { | |||
String path = f.getAbsolutePath(); | |||
if (Os.isFamily("unix") || Os.isFamily("openvms")) { | |||
assertEquals(projectBasedir+"2", path); | |||
assertEquals(projectBasedir + "2", path); | |||
} else if (Os.isFamily("netware")) { | |||
assertEquals(projectBasedir+"2", path.toLowerCase(Locale.US)); | |||
assertEquals(projectBasedir + "2", path.toLowerCase(Locale.US)); | |||
} else { | |||
assertEquals(":"+projectBasedir+"2", | |||
assertEquals(":" + projectBasedir + "2", | |||
path.toLowerCase(Locale.US).substring(1)); | |||
} | |||
} | |||
@@ -32,17 +32,29 @@ public class MockBuildListener implements BuildListener { | |||
this.project = project; | |||
} | |||
public void buildStarted(BuildEvent event) {} | |||
public void buildFinished(BuildEvent event) {} | |||
public void targetStarted(BuildEvent event) {} | |||
public void targetFinished(BuildEvent event) {} | |||
public void taskStarted(BuildEvent event) {} | |||
public void taskFinished(BuildEvent event) {} | |||
public void buildStarted(BuildEvent event) { | |||
} | |||
public void buildFinished(BuildEvent event) { | |||
} | |||
public void targetStarted(BuildEvent event) { | |||
} | |||
public void targetFinished(BuildEvent event) { | |||
} | |||
public void taskStarted(BuildEvent event) { | |||
} | |||
public void taskFinished(BuildEvent event) { | |||
} | |||
public void messageLogged(final BuildEvent actual) { | |||
if(actual.getPriority()==Project.MSG_DEBUG) | |||
if (actual.getPriority() == Project.MSG_DEBUG) { | |||
return; | |||
assertTrue("unexpected messageLogged: "+actual.getMessage(), !buffer.isEmpty()); | |||
} | |||
assertTrue("unexpected messageLogged: "+ actual.getMessage(), !buffer.isEmpty()); | |||
assertEquals("unexpected project ", project, actual.getProject()); | |||
BuildEvent expected = (BuildEvent) buffer.elementAt(0); | |||
@@ -78,7 +78,7 @@ public class ProjectHelperRepositoryTest { | |||
public void testNoDefaultContructor() throws Exception { | |||
class IncrrectHelper extends ProjectHelper { | |||
// the default constructor is not visible to ant here | |||
// the default constructor is not visible to ant here | |||
} | |||
ProjectHelperRepository repo = ProjectHelperRepository.getInstance(); | |||
@@ -89,7 +89,7 @@ public class ProjectTest { | |||
*/ | |||
String driveSpec = "C:"; | |||
String driveSpecLower = "c:"; | |||
assertEqualsIgnoreDriveCase(driveSpecLower + "\\", | |||
p.resolveFile(driveSpec + "/", null).getPath()); | |||
assertEqualsIgnoreDriveCase(driveSpecLower + "\\", | |||
@@ -168,8 +168,8 @@ public class ProjectTest { | |||
private void assertEqualsIgnoreDriveCase(String s1, String s2) { | |||
if ((Os.isFamily("dos") || Os.isFamily("netware")) | |||
&& s1.length() >= 1 && s2.length() >= 1) { | |||
StringBuffer sb1 = new StringBuffer(s1); | |||
StringBuffer sb2 = new StringBuffer(s2); | |||
StringBuilder sb1 = new StringBuilder(s1); | |||
StringBuilder sb2 = new StringBuilder(s2); | |||
sb1.setCharAt(0, Character.toUpperCase(s1.charAt(0))); | |||
sb2.setCharAt(0, Character.toUpperCase(s2.charAt(0))); | |||
assertEquals(sb1.toString(), sb2.toString()); | |||
@@ -184,9 +184,9 @@ public class ProjectTest { | |||
try { | |||
mbl.addBuildEvent(message, Project.MSG_ERR); | |||
p.addTaskDefinition(dummyName, taskClass); | |||
fail("expected BuildException(\""+message+"\", Project.MSG_ERR) when adding task " + taskClass); | |||
} | |||
catch(BuildException e) { | |||
fail(String.format("expected BuildException(\"%s\", Project.MSG_ERR) when adding task %s", | |||
message, taskClass)); | |||
} catch (BuildException e) { | |||
assertEquals(message, e.getMessage()); | |||
mbl.assertEmpty(); | |||
assertTrue(!p.getTaskDefinitions().containsKey(dummyName)); | |||
@@ -203,23 +203,27 @@ public class ProjectTest { | |||
assertEquals(DummyTaskOkNonTask.class, p.getTaskDefinitions().get("OkNonTask")); | |||
mbl.assertEmpty(); | |||
assertTaskDefFails(DummyTaskPrivate.class, DummyTaskPrivate.class + " is not public"); | |||
assertTaskDefFails(DummyTaskPrivate.class, | |||
DummyTaskPrivate.class + " is not public"); | |||
assertTaskDefFails(DummyTaskProtected.class, | |||
DummyTaskProtected.class + " is not public"); | |||
assertTaskDefFails(DummyTaskPackage.class, DummyTaskPackage.class + " is not public"); | |||
assertTaskDefFails(DummyTaskAbstract.class, DummyTaskAbstract.class + " is abstract"); | |||
assertTaskDefFails(DummyTaskInterface.class, DummyTaskInterface.class + " is abstract"); | |||
assertTaskDefFails(DummyTaskWithoutDefaultConstructor.class, "No public no-arg constructor in " + DummyTaskWithoutDefaultConstructor.class); | |||
assertTaskDefFails(DummyTaskWithoutPublicConstructor.class, "No public no-arg constructor in " + DummyTaskWithoutPublicConstructor.class); | |||
assertTaskDefFails(DummyTaskWithoutExecute.class, "No public execute() in " + DummyTaskWithoutExecute.class); | |||
assertTaskDefFails(DummyTaskWithNonPublicExecute.class, "No public execute() in " + DummyTaskWithNonPublicExecute.class); | |||
mbl.addBuildEvent("return type of execute() should be void but was \"int\" in " + DummyTaskWithNonVoidExecute.class, Project.MSG_WARN); | |||
DummyTaskProtected.class + " is not public"); | |||
assertTaskDefFails(DummyTaskPackage.class, | |||
DummyTaskPackage.class + " is not public"); | |||
assertTaskDefFails(DummyTaskAbstract.class, | |||
DummyTaskAbstract.class + " is abstract"); | |||
assertTaskDefFails(DummyTaskInterface.class, | |||
DummyTaskInterface.class + " is abstract"); | |||
assertTaskDefFails(DummyTaskWithoutDefaultConstructor.class, | |||
"No public no-arg constructor in " + DummyTaskWithoutDefaultConstructor.class); | |||
assertTaskDefFails(DummyTaskWithoutPublicConstructor.class, | |||
"No public no-arg constructor in " + DummyTaskWithoutPublicConstructor.class); | |||
assertTaskDefFails(DummyTaskWithoutExecute.class, | |||
"No public execute() in " + DummyTaskWithoutExecute.class); | |||
assertTaskDefFails(DummyTaskWithNonPublicExecute.class, | |||
"No public execute() in " + DummyTaskWithNonPublicExecute.class); | |||
mbl.addBuildEvent("return type of execute() should be void but was \"int\" in " | |||
+ DummyTaskWithNonVoidExecute.class, Project.MSG_WARN); | |||
p.addTaskDefinition("NonVoidExecute", DummyTaskWithNonVoidExecute.class); | |||
mbl.assertEmpty(); | |||
assertEquals(DummyTaskWithNonVoidExecute.class, p.getTaskDefinitions().get("NonVoidExecute")); | |||
@@ -271,12 +275,18 @@ public class ProjectTest { | |||
throws InterruptedException { | |||
final String FOO = "foo", BAR = "bar"; | |||
p.addBuildListener(new BuildListener() { | |||
public void buildStarted(BuildEvent event) {} | |||
public void buildFinished(BuildEvent event) {} | |||
public void targetStarted(BuildEvent event) {} | |||
public void targetFinished(BuildEvent event) {} | |||
public void taskStarted(BuildEvent event) {} | |||
public void taskFinished(BuildEvent event) {} | |||
public void buildStarted(BuildEvent event) { | |||
} | |||
public void buildFinished(BuildEvent event) { | |||
} | |||
public void targetStarted(BuildEvent event) { | |||
} | |||
public void targetFinished(BuildEvent event) { | |||
} | |||
public void taskStarted(BuildEvent event) { | |||
} | |||
public void taskFinished(BuildEvent event) { | |||
} | |||
public void messageLogged(final BuildEvent actual) { | |||
assertEquals(FOO, actual.getMessage()); | |||
// each of the following lines would cause an | |||
@@ -309,19 +319,25 @@ public class ProjectTest { | |||
} | |||
private class DummyTaskPrivate extends Task { | |||
public DummyTaskPrivate() {} | |||
public void execute() {} | |||
@SuppressWarnings("unused") | |||
public DummyTaskPrivate() { | |||
} | |||
public void execute() { | |||
} | |||
} | |||
protected class DummyTaskProtected extends Task { | |||
public DummyTaskProtected() {} | |||
public void execute() {} | |||
public DummyTaskProtected() { | |||
} | |||
public void execute() { | |||
} | |||
} | |||
class DummyTaskPackage extends Task { | |||
public DummyTaskPackage() {} | |||
public void execute() {} | |||
public DummyTaskPackage() { | |||
} | |||
public void execute() { | |||
} | |||
} | |||
} | |||
} |
@@ -28,7 +28,7 @@ public class TaskContainerTest { | |||
@Rule | |||
public BuildFileRule buildRule = new BuildFileRule(); | |||
@Before | |||
public void setUp() { | |||
buildRule.configureProject("src/etc/testcases/core/taskcontainer.xml"); | |||
@@ -57,17 +57,22 @@ public class UnknownElementTest { | |||
@Ignore("Previously disabled through naming convention") | |||
public void XtestTaskFinishedEvent() { | |||
buildRule.getProject().addBuildListener(new BuildListener() { | |||
public void buildStarted(BuildEvent event) {} | |||
public void buildFinished(BuildEvent event) {} | |||
public void targetStarted(BuildEvent event) {} | |||
public void targetFinished(BuildEvent event) {} | |||
public void buildStarted(BuildEvent event) { | |||
} | |||
public void buildFinished(BuildEvent event) { | |||
} | |||
public void targetStarted(BuildEvent event) { | |||
} | |||
public void targetFinished(BuildEvent event) { | |||
} | |||
public void taskStarted(BuildEvent event) { | |||
assertTaskProperties(event.getTask()); | |||
} | |||
public void taskFinished(BuildEvent event) { | |||
assertTaskProperties(event.getTask()); | |||
} | |||
public void messageLogged(BuildEvent event) {} | |||
public void messageLogged(BuildEvent event) { | |||
} | |||
private void assertTaskProperties(Task ue) { | |||
assertNotNull(ue); | |||
assertTrue(ue instanceof UnknownElement); | |||
@@ -111,5 +116,3 @@ public class UnknownElementTest { | |||
} | |||
} | |||
} | |||
@@ -43,32 +43,28 @@ public class ConcatFilterTest { | |||
+ "Line 1" + lSep | |||
+ "Line 2" + lSep | |||
+ "Line 3" + lSep | |||
+ "Line 4" + lSep | |||
; | |||
+ "Line 4" + lSep; | |||
private static final String FILE_PREPEND = | |||
"Line 1" + lSep | |||
+ "Line 2" + lSep | |||
+ "Line 3" + lSep | |||
+ "Line 4" + lSep | |||
+ "Line 5" + lSep | |||
; | |||
+ "Line 5" + lSep; | |||
private static final String FILE_APPEND_WITH = | |||
"Line 57" + lSep | |||
+ "Line 58" + lSep | |||
+ "Line 59" + lSep | |||
+ "Line 60" + lSep | |||
+ "this-should-be-the-last-line" + lSep | |||
; | |||
+ "this-should-be-the-last-line" + lSep; | |||
private static final String FILE_APPEND = | |||
"Line 56" + lSep | |||
+ "Line 57" + lSep | |||
+ "Line 58" + lSep | |||
+ "Line 59" + lSep | |||
+ "Line 60" + lSep | |||
; | |||
+ "Line 60" + lSep; | |||
@Rule | |||
public BuildFileRule buildRule = new BuildFileRule(); | |||
@@ -49,8 +49,6 @@ public class DynamicFilterTest { | |||
assertContains("hellO wOrld", content); | |||
} | |||
public static class CustomFilter implements ChainableReader { | |||
char replace = 'x'; | |||
char with = 'y'; | |||
@@ -65,14 +63,13 @@ public class DynamicFilterTest { | |||
public Reader chain(final Reader rdr) { | |||
return new BaseFilterReader(rdr) { | |||
public int read() | |||
throws IOException | |||
{ | |||
public int read() throws IOException { | |||
int c = in.read(); | |||
if (c == replace) | |||
if (c == replace) { | |||
return with; | |||
else | |||
} else { | |||
return c; | |||
} | |||
} | |||
}; | |||
} | |||
@@ -38,7 +38,7 @@ public class HeadTailTest { | |||
@Rule | |||
public BuildFileRule buildRule = new BuildFileRule(); | |||
@Before | |||
public void setUp() { | |||
buildRule.configureProject("src/etc/testcases/filters/head-tail.xml"); | |||
@@ -32,10 +32,9 @@ import static org.junit.Assert.assertEquals; | |||
public class LineContainsTest { | |||
@Rule | |||
public BuildFileRule buildRule = new BuildFileRule(); | |||
@Before | |||
public void setUp() { | |||
buildRule.configureProject("src/etc/testcases/filters/build.xml"); | |||
@@ -251,9 +251,7 @@ public class TokenFilterTest { | |||
// Helper methods | |||
// ----------------------------------------------------- | |||
private String getFileString(String filename) | |||
throws IOException | |||
{ | |||
private String getFileString(String filename) throws IOException { | |||
Reader r = null; | |||
try { | |||
r = new FileReader(FILE_UTILS.resolveFile(buildRule.getProject().getBaseDir(),filename)); | |||
@@ -265,9 +263,7 @@ public class TokenFilterTest { | |||
} | |||
public static class Capitalize | |||
implements TokenFilter.Filter | |||
{ | |||
public static class Capitalize implements TokenFilter.Filter { | |||
public String filter(String token) { | |||
if (token.length() == 0) | |||
return token; | |||
@@ -33,7 +33,8 @@ public class LocatorTest { | |||
private boolean windows; | |||
private boolean unix; | |||
private static final String LAUNCHER_JAR = "//morzine/slo/Java/Apache/ant/lib/ant-launcher.jar"; | |||
private static final String SHARED_JAR_URI = "jar:file:"+ LAUNCHER_JAR +"!/org/apache/tools/ant/launch/Launcher.class"; | |||
private static final String SHARED_JAR_URI = "jar:file:" + LAUNCHER_JAR + | |||
"!/org/apache/tools/ant/launch/Launcher.class"; | |||
@Before | |||
@@ -84,8 +85,8 @@ public class LocatorTest { | |||
/** | |||
* this isnt really a valid URI, except maybe in IE | |||
* @throws Exception | |||
* this isn't really a valid URI, except maybe in IE | |||
* @throws Exception if something goes wrong | |||
*/ | |||
public void testNetworkURI() throws Exception { | |||
resolveTo("file:\\\\PC03\\jclasses\\lib\\ant-1.7.0.jar", "" | |||
@@ -126,7 +127,7 @@ public class LocatorTest { | |||
*/ | |||
@Test | |||
public void testAntOnRemoteShare() throws Throwable { | |||
String resolved=Locator.fromJarURI(SHARED_JAR_URI); | |||
String resolved = Locator.fromJarURI(SHARED_JAR_URI); | |||
assertResolved(SHARED_JAR_URI, LAUNCHER_JAR, resolved, unix); | |||
assertResolved(SHARED_JAR_URI, LAUNCHER_JAR.replace('/', '\\'), | |||
resolved, windows); | |||
@@ -67,4 +67,4 @@ public class AntLikeTasksAtTopLevelTest { | |||
} | |||
} | |||
}// AntLikeTasksAtTopLevelTest | |||
} |
@@ -45,7 +45,7 @@ import static org.junit.Assert.fail; | |||
/** | |||
*/ | |||
public class AntTest { | |||
@Rule | |||
public BuildFileRule buildRule = new BuildFileRule(); | |||
@@ -415,12 +415,23 @@ public class AntTest { | |||
expectedBasedirs = dirs; | |||
} | |||
public void buildStarted(BuildEvent event) {} | |||
public void buildFinished(BuildEvent event) {} | |||
public void targetFinished(BuildEvent event){} | |||
public void taskStarted(BuildEvent event) {} | |||
public void taskFinished(BuildEvent event) {} | |||
public void messageLogged(BuildEvent event) {} | |||
public void buildStarted(BuildEvent event) { | |||
} | |||
public void buildFinished(BuildEvent event) { | |||
} | |||
public void targetFinished(BuildEvent event) { | |||
} | |||
public void taskStarted(BuildEvent event) { | |||
} | |||
public void taskFinished(BuildEvent event) { | |||
} | |||
public void messageLogged(BuildEvent event) { | |||
} | |||
public void targetStarted(BuildEvent event) { | |||
if (event.getTarget().getName().equals("")) { | |||
@@ -455,12 +466,23 @@ public class AntTest { | |||
this.value = value; | |||
} | |||
public void buildStarted(BuildEvent event) {} | |||
public void buildFinished(BuildEvent event) {} | |||
public void targetFinished(BuildEvent event){} | |||
public void taskStarted(BuildEvent event) {} | |||
public void taskFinished(BuildEvent event) {} | |||
public void messageLogged(BuildEvent event) {} | |||
public void buildStarted(BuildEvent event) { | |||
} | |||
public void buildFinished(BuildEvent event) { | |||
} | |||
public void targetFinished(BuildEvent event) { | |||
} | |||
public void taskStarted(BuildEvent event) { | |||
} | |||
public void taskFinished(BuildEvent event) { | |||
} | |||
public void messageLogged(BuildEvent event) { | |||
} | |||
public void targetStarted(BuildEvent event) { | |||
if (event.getTarget().getName().equals("")) { | |||
@@ -488,7 +510,7 @@ public class AntTest { | |||
String[] l1 = expect.list(); | |||
String[] l2 = received.list(); | |||
if (l1.length == l2.length) { | |||
for (int i=0; i<l1.length; i++) { | |||
for (int i = 0; i < l1.length; i++) { | |||
if (!l1[i].equals(l2[i])) { | |||
assertTrue(msg, !shouldBeEqual); | |||
} | |||
@@ -570,12 +592,23 @@ public class AntTest { | |||
this.expectedValues = values; | |||
} | |||
public void buildStarted(BuildEvent event) {} | |||
public void buildFinished(BuildEvent event) {} | |||
public void targetFinished(BuildEvent event){} | |||
public void taskStarted(BuildEvent event) {} | |||
public void taskFinished(BuildEvent event) {} | |||
public void messageLogged(BuildEvent event) {} | |||
public void buildStarted(BuildEvent event) { | |||
} | |||
public void buildFinished(BuildEvent event) { | |||
} | |||
public void targetFinished(BuildEvent event) { | |||
} | |||
public void taskStarted(BuildEvent event) { | |||
} | |||
public void taskFinished(BuildEvent event) { | |||
} | |||
public void messageLogged(BuildEvent event) { | |||
} | |||
public void targetStarted(BuildEvent event) { | |||
if (event.getTarget().getName().equals("")) { | |||
@@ -19,8 +19,8 @@ | |||
package org.apache.tools.ant.taskdefs; | |||
import org.apache.tools.ant.BuildFileRule; | |||
import org.apache.tools.ant.Task; | |||
import org.apache.tools.ant.Project; | |||
import org.apache.tools.ant.Task; | |||
import org.junit.Assume; | |||
import org.junit.Before; | |||
import org.junit.Rule; | |||
@@ -42,11 +42,11 @@ public class AntlibTest { | |||
/** | |||
* only do the antlib tests if we are in the same JVM as ant. | |||
* @return | |||
* @return boolean | |||
*/ | |||
private boolean isSharedJVM() { | |||
String property = System.getProperty("tests.and.ant.share.classloader"); | |||
return property!=null && Project.toBoolean(property); | |||
return property != null && Project.toBoolean(property); | |||
} | |||
@Test | |||
@@ -89,7 +89,7 @@ public class AntlibTest { | |||
Assume.assumeTrue("Test requires shared JVM", isSharedJVM()); | |||
buildRule.executeTarget("antlib_uri_auto2"); | |||
} | |||
public static class MyTask extends Task { | |||
public void execute() { | |||
log("MyTask called"); | |||
@@ -103,4 +103,3 @@ public class AntlibTest { | |||
} | |||
} | |||
@@ -34,10 +34,10 @@ import static org.junit.Assert.fail; | |||
*/ | |||
public class AvailableTest { | |||
@Rule | |||
public BuildFileRule buildRule = new BuildFileRule(); | |||
@Before | |||
public void setUp() { | |||
buildRule.configureProject("src/etc/testcases/taskdefs/available.xml"); | |||
@@ -19,6 +19,8 @@ | |||
package org.apache.tools.ant.taskdefs; | |||
import java.io.File; | |||
import java.io.IOException; | |||
import org.apache.tools.ant.BuildFileRule; | |||
import org.apache.tools.ant.FileUtilities; | |||
import org.junit.Before; | |||
@@ -43,16 +45,16 @@ public class BUnzip2Test { | |||
} | |||
@Test | |||
public void testRealTest() throws java.io.IOException { | |||
public void testRealTest() throws IOException { | |||
testRealTest("realTest"); | |||
} | |||
@Test | |||
public void testRealTestWithResource() throws java.io.IOException { | |||
public void testRealTestWithResource() throws IOException { | |||
testRealTest("realTestWithResource"); | |||
} | |||
private void testRealTest(String target) throws java.io.IOException { | |||
private void testRealTest(String target) throws IOException { | |||
buildRule.executeTarget(target); | |||
assertEquals("File content mismatch after bunzip2", | |||
FileUtilities.getFileContents(new File(outputDir, "asf-logo-huge-from-gzip.tar")), | |||
@@ -60,7 +62,7 @@ public class BUnzip2Test { | |||
} | |||
@Test | |||
public void testDocumentationClaimsOnCopy() throws java.io.IOException { | |||
public void testDocumentationClaimsOnCopy() throws IOException { | |||
testRealTest("testDocumentationClaimsOnCopy"); | |||
} | |||
} |
@@ -101,12 +101,12 @@ public class BZip2Test { | |||
} | |||
@Test | |||
public void testResource(){ | |||
public void testResource() { | |||
buildRule.executeTarget("realTestWithResource"); | |||
} | |||
@Test | |||
public void testDateCheck(){ | |||
public void testDateCheck() { | |||
buildRule.executeTarget("testDateCheck"); | |||
String log = buildRule.getLog(); | |||
assertTrue( | |||
@@ -18,7 +18,7 @@ | |||
package org.apache.tools.ant.taskdefs; | |||
import java.io.*; | |||
import java.io.File; | |||
import org.apache.tools.ant.BuildException; | |||
import org.apache.tools.ant.BuildFileRule; | |||
@@ -44,7 +44,7 @@ public class CVSPassTest { | |||
":pserver:anoncvs@xml.apache.org:/home/cvspublic Ay=0=h<Z"; | |||
private static final String TIGRIS_URL = | |||
":pserver:guest@cvs.tigris.org:/cvs AIbdZ,"; | |||
@Rule | |||
public final BuildFileRule buildRule = new BuildFileRule(); | |||
@@ -56,20 +56,20 @@ public class CVSPassTest { | |||
@Test | |||
public void testNoCVSRoot() { | |||
try{ | |||
try { | |||
buildRule.executeTarget("test1"); | |||
fail("BuildException not thrown"); | |||
}catch(BuildException e){ | |||
} catch (BuildException e) { | |||
assertEquals("cvsroot is required", e.getMessage()); | |||
} | |||
} | |||
@Test | |||
public void testNoPassword() { | |||
try{ | |||
try { | |||
buildRule.executeTarget("test2"); | |||
fail("BuildException not thrown"); | |||
}catch(BuildException e){ | |||
} catch (BuildException e) { | |||
assertEquals("password is required", e.getMessage()); | |||
} | |||
} | |||
@@ -84,10 +84,9 @@ public class CVSPassTest { | |||
buildRule.executeTarget("test3"); | |||
File f = new File(buildRule.getProject().getBaseDir(), "testpassfile.tmp"); | |||
assertTrue( "Passfile "+f+" not created", f.exists()); | |||
assertEquals(JAKARTA_URL+EOL, FileUtilities.getFileContents(f)); | |||
assertTrue("Passfile " + f + " not created", f.exists()); | |||
assertEquals(JAKARTA_URL + EOL, FileUtilities.getFileContents(f)); | |||
} | |||
@Test | |||
@@ -95,11 +94,9 @@ public class CVSPassTest { | |||
buildRule.executeTarget("test4"); | |||
File f = new File(buildRule.getProject().getBaseDir(), "testpassfile.tmp"); | |||
assertTrue( "Passfile "+f+" not created", f.exists()); | |||
assertTrue("Passfile " + f + " not created", f.exists()); | |||
assertEquals( | |||
JAKARTA_URL+ EOL+ | |||
TIGRIS_URL+ EOL, | |||
assertEquals(JAKARTA_URL + EOL+ TIGRIS_URL + EOL, | |||
FileUtilities.getFileContents(f)); | |||
} | |||
@@ -108,12 +105,9 @@ public class CVSPassTest { | |||
buildRule.executeTarget("test5"); | |||
File f = new File(buildRule.getProject().getBaseDir(), "testpassfile.tmp"); | |||
assertTrue( "Passfile "+f+" not created", f.exists()); | |||
assertTrue("Passfile " + f + " not created", f.exists()); | |||
assertEquals( | |||
JAKARTA_URL+ EOL+ | |||
XML_URL+ EOL+ | |||
TIGRIS_URL+ EOL, | |||
assertEquals(JAKARTA_URL + EOL + XML_URL + EOL+ TIGRIS_URL + EOL, | |||
FileUtilities.getFileContents(f)); | |||
} | |||
} |
@@ -18,19 +18,19 @@ | |||
package org.apache.tools.ant.taskdefs; | |||
import java.io.IOException; | |||
import org.apache.tools.ant.BuildFileRule; | |||
import org.junit.After; | |||
import org.junit.Before; | |||
import org.junit.Rule; | |||
import org.junit.Test; | |||
import java.io.IOException; | |||
public class ChecksumTest { | |||
@Rule | |||
public BuildFileRule buildRule = new BuildFileRule(); | |||
@Before | |||
public void setUp() { | |||
buildRule.configureProject("src/etc/testcases/taskdefs/checksum.xml"); | |||
@@ -96,7 +96,7 @@ public class ConcatTest { | |||
try { | |||
buildRule.executeTarget("test2"); | |||
fail("BuildException should have been thrown - Invalid destination file"); | |||
} catch(BuildException ex) { | |||
} catch (BuildException ex) { | |||
//TODO assert value | |||
} | |||
} | |||
@@ -192,7 +192,7 @@ public class ConcatTest { | |||
File file2 = new File(buildRule.getProject().getBaseDir(), tempFile2); | |||
final long newSize = file2.length(); | |||
assertEquals(origSize*2, newSize); | |||
assertEquals(origSize * 2, newSize); | |||
} | |||
@@ -267,9 +267,7 @@ public class ConcatTest { | |||
* Check if fixlastline works | |||
*/ | |||
@Test | |||
public void testfixlastline() | |||
throws IOException | |||
{ | |||
public void testfixlastline() throws IOException { | |||
buildRule.executeTarget("testfixlastline"); | |||
assertContains("end of line" + System.getProperty("line.separator") + "This has", | |||
FileUtilities.getFileContents(buildRule.getProject(), "concat.line4")); | |||
@@ -279,14 +277,11 @@ public class ConcatTest { | |||
* Check if fixlastline works with eol | |||
*/ | |||
@Test | |||
public void testfixlastlineeol() | |||
throws IOException | |||
{ | |||
public void testfixlastlineeol() throws IOException { | |||
buildRule.executeTarget("testfixlastlineeol"); | |||
assertContains("end of line\rThis has", FileUtilities.getFileContents(buildRule.getProject(), "concat.linecr")); | |||
} | |||
@Test | |||
public void testTranscoding() throws IOException { | |||
buildRule.executeTarget("testTranscoding"); | |||
@@ -299,10 +294,9 @@ public class ConcatTest { | |||
// ------------------------------------------------------ | |||
// Helper methods - should be in a utility class | |||
// ----------------------------------------------------- | |||
private void expectFileContainsx( | |||
String target, String filename, String contains) | |||
throws IOException | |||
{ | |||
@SuppressWarnings("unused") | |||
private void expectFileContainsx(String target, String filename, String contains) | |||
throws IOException { | |||
buildRule.executeTarget(target); | |||
String content = FileUtilities.getFileContents(buildRule.getProject(), filename); | |||
assertTrue( | |||
@@ -311,5 +305,4 @@ public class ConcatTest { | |||
" but got " + content, content.indexOf(contains) > -1); | |||
} | |||
} |
@@ -72,7 +72,7 @@ public class ConditionTest { | |||
try { | |||
buildRule.executeTarget("condition-empty"); | |||
fail("BuildException should have been thrown - no conditions"); | |||
} catch(BuildException ex) { | |||
} catch (BuildException ex) { | |||
assertEquals("You must nest a condition into <condition>", ex.getMessage()); | |||
} | |||
} | |||
@@ -255,7 +255,7 @@ public class ConditionTest { | |||
try { | |||
buildRule.executeTarget("contains-incomplete1"); | |||
fail("BuildException should have been thrown - Missing contains attribute"); | |||
} catch(BuildException ex) { | |||
} catch (BuildException ex) { | |||
assertEquals("both string and substring are required in contains", ex.getMessage()); | |||
} | |||
} | |||
@@ -265,7 +265,7 @@ public class ConditionTest { | |||
try { | |||
buildRule.executeTarget("contains-incomplete2"); | |||
fail("BuildException should have been thrown - Missing contains attribute"); | |||
} catch(BuildException ex) { | |||
} catch (BuildException ex) { | |||
assertEquals("both string and substring are required in contains", ex.getMessage()); | |||
} | |||
} | |||
@@ -293,7 +293,7 @@ public class ConditionTest { | |||
try { | |||
buildRule.executeTarget("istrue-incomplete"); | |||
fail("BuildException should have been thrown - Missing attribute"); | |||
} catch(BuildException ex) { | |||
} catch (BuildException ex) { | |||
assertEquals("Nothing to test for truth", ex.getMessage()); | |||
} | |||
} | |||
@@ -322,7 +322,7 @@ public class ConditionTest { | |||
try { | |||
buildRule.executeTarget("isfalse-incomplete"); | |||
fail("BuildException should have been thrown - Missing attribute"); | |||
} catch(BuildException ex) { | |||
} catch (BuildException ex) { | |||
assertEquals("Nothing to test for falsehood", ex.getMessage()); | |||
} | |||
} | |||
@@ -60,7 +60,7 @@ public class CopyTest { | |||
public void test1() { | |||
buildRule.executeTarget("test1"); | |||
File f = new File(buildRule.getProject().getProperty("output"), "copytest1.tmp"); | |||
if ( !f.exists()) { | |||
if (!f.exists()) { | |||
fail("Copy failed"); | |||
} | |||
} | |||
@@ -69,7 +69,7 @@ public class CopyTest { | |||
public void test2() { | |||
buildRule.executeTarget("test2"); | |||
File f = new File(buildRule.getProject().getProperty("output"), "copytest1dir/copy.xml"); | |||
if ( !f.exists()) { | |||
if (!f.exists()) { | |||
fail("Copy failed"); | |||
} | |||
} | |||
@@ -79,7 +79,7 @@ public class CopyTest { | |||
buildRule.executeTarget("test3"); | |||
File file3 = new File(buildRule.getProject().getProperty("output"), "copytest3.tmp"); | |||
//rollback file timestamp instead of delaying test | |||
FileUtilities.rollbackTimetamps(file3, 3); | |||
FileUtilities.rollbackTimestamps(file3, 3); | |||
buildRule.executeTarget("test3Part2"); | |||
assertTrue(file3.exists()); | |||
@@ -91,19 +91,19 @@ public class CopyTest { | |||
assertTrue(file3c.exists()); | |||
//file length checks rely on touch generating a zero byte file | |||
if(file3.length()==0) { | |||
if (file3.length()==0) { | |||
fail("could not overwrite an existing, older file"); | |||
} | |||
if(file3c.length()!=0) { | |||
if (file3c.length()!=0) { | |||
fail("could not force overwrite an existing, newer file"); | |||
} | |||
if(file3b.length()==0) { | |||
if (file3b.length()==0) { | |||
fail("unexpectedly overwrote an existing, newer file"); | |||
} | |||
//file time checks for java1.2+ | |||
assertTrue(file3a.lastModified()==file3.lastModified()); | |||
assertTrue(file3c.lastModified()<file3a.lastModified()); | |||
assertTrue(file3a.lastModified() == file3.lastModified()); | |||
assertTrue(file3c.lastModified() < file3a.lastModified()); | |||
} | |||
@@ -197,9 +197,9 @@ public class CopyTest { | |||
@Test | |||
public void testFileResourcePlain() { | |||
buildRule.executeTarget("testFileResourcePlain"); | |||
File file1 = new File(buildRule.getProject().getProperty("to.dir")+"/file1.txt"); | |||
File file2 = new File(buildRule.getProject().getProperty("to.dir")+"/file2.txt"); | |||
File file3 = new File(buildRule.getProject().getProperty("to.dir")+"/file3.txt"); | |||
File file1 = new File(buildRule.getProject().getProperty("to.dir") + "/file1.txt"); | |||
File file2 = new File(buildRule.getProject().getProperty("to.dir") + "/file2.txt"); | |||
File file3 = new File(buildRule.getProject().getProperty("to.dir") + "/file3.txt"); | |||
assertTrue(file1.exists()); | |||
assertTrue(file2.exists()); | |||
assertTrue(file3.exists()); | |||
@@ -209,9 +209,9 @@ public class CopyTest { | |||
@Test | |||
public void testFileResourceWithMapper() { | |||
buildRule.executeTarget("testFileResourceWithMapper"); | |||
File file1 = new File(buildRule.getProject().getProperty("to.dir")+"/file1.txt.bak"); | |||
File file2 = new File(buildRule.getProject().getProperty("to.dir")+"/file2.txt.bak"); | |||
File file3 = new File(buildRule.getProject().getProperty("to.dir")+"/file3.txt.bak"); | |||
File file1 = new File(buildRule.getProject().getProperty("to.dir") + "/file1.txt.bak"); | |||
File file2 = new File(buildRule.getProject().getProperty("to.dir") + "/file2.txt.bak"); | |||
File file3 = new File(buildRule.getProject().getProperty("to.dir") + "/file3.txt.bak"); | |||
assertTrue(file1.exists()); | |||
assertTrue(file2.exists()); | |||
assertTrue(file3.exists()); | |||
@@ -220,7 +220,7 @@ public class CopyTest { | |||
@Test | |||
public void testFileResourceWithFilter() { | |||
buildRule.executeTarget("testFileResourceWithFilter"); | |||
File file1 = new File(buildRule.getProject().getProperty("to.dir")+"/fileNR.txt"); | |||
File file1 = new File(buildRule.getProject().getProperty("to.dir") + "/fileNR.txt"); | |||
assertTrue(file1.exists()); | |||
try { | |||
String file1Content = FileUtils.readFully(new FileReader(file1)); | |||
@@ -233,9 +233,9 @@ public class CopyTest { | |||
@Test | |||
public void testPathAsResource() { | |||
buildRule.executeTarget("testPathAsResource"); | |||
File file1 = new File(buildRule.getProject().getProperty("to.dir")+"/file1.txt"); | |||
File file2 = new File(buildRule.getProject().getProperty("to.dir")+"/file2.txt"); | |||
File file3 = new File(buildRule.getProject().getProperty("to.dir")+"/file3.txt"); | |||
File file1 = new File(buildRule.getProject().getProperty("to.dir") + "/file1.txt"); | |||
File file2 = new File(buildRule.getProject().getProperty("to.dir") + "/file2.txt"); | |||
File file3 = new File(buildRule.getProject().getProperty("to.dir") + "/file3.txt"); | |||
assertTrue(file1.exists()); | |||
assertTrue(file2.exists()); | |||
assertTrue(file3.exists()); | |||
@@ -244,9 +244,9 @@ public class CopyTest { | |||
@Test | |||
public void testZipfileset() { | |||
buildRule.executeTarget("testZipfileset"); | |||
File file1 = new File(buildRule.getProject().getProperty("to.dir")+"/file1.txt"); | |||
File file2 = new File(buildRule.getProject().getProperty("to.dir")+"/file2.txt"); | |||
File file3 = new File(buildRule.getProject().getProperty("to.dir")+"/file3.txt"); | |||
File file1 = new File(buildRule.getProject().getProperty("to.dir") + "/file1.txt"); | |||
File file2 = new File(buildRule.getProject().getProperty("to.dir") + "/file2.txt"); | |||
File file3 = new File(buildRule.getProject().getProperty("to.dir") + "/file3.txt"); | |||
assertTrue(file1.exists()); | |||
assertTrue(file2.exists()); | |||
assertTrue(file3.exists()); | |||
@@ -285,7 +285,7 @@ public class CopyTest { | |||
* Tests that the {@code copy} task doesn't corrupt the source file, if the target of the copy operation is a symlink | |||
* to the source file being copied | |||
* | |||
* @throws Exception | |||
* @throws Exception if something goes wrong | |||
* @see <a href="https://bz.apache.org/bugzilla/show_bug.cgi?id=60644">issue 60644</a> | |||
*/ | |||
@Test | |||
@@ -79,7 +79,7 @@ public class CopydirTest { | |||
@Test | |||
public void test5() { | |||
buildRule.executeTarget("test5"); | |||
java.io.File f = new java.io.File(new File(buildRule.getProject().getProperty("output")), "taskdefs.tmp"); | |||
File f = new File(new File(buildRule.getProject().getProperty("output")), "taskdefs.tmp"); | |||
if (!f.exists() || !f.isDirectory()) { | |||
fail("Copy failed"); | |||
@@ -157,13 +157,13 @@ public class DefaultExcludesTest { | |||
private void assertArrayContentsEquals(String message, String[] expected, String[] actual) { | |||
// check that both arrays have the same size | |||
assertEquals(message + " : string array length match", expected.length, actual.length); | |||
for (int counter=0; counter < expected.length; counter++) { | |||
for (String element : expected) { | |||
boolean found = false; | |||
for (int i = 0; !found && i < actual.length; i++) { | |||
found |= expected[counter].equals(actual[i]); | |||
found |= element.equals(actual[i]); | |||
} | |||
assertTrue(message + " : didn't find element " | |||
+ expected[counter] + " in array match", found); | |||
+ element + " in array match", found); | |||
} | |||
} | |||
@@ -46,7 +46,7 @@ public class DirnameTest { | |||
try { | |||
buildRule.executeTarget("test1"); | |||
fail("Build exception should have been thrown as property attribute is required"); | |||
} catch(BuildException ex) { | |||
} catch (BuildException ex) { | |||
assertEquals("property attribute required", ex.getMessage()); | |||
} | |||
} | |||
@@ -56,7 +56,7 @@ public class DirnameTest { | |||
try { | |||
buildRule.executeTarget("test2"); | |||
fail("Build exception should have been thrown as file attribute is required"); | |||
} catch(BuildException ex) { | |||
} catch (BuildException ex) { | |||
assertEquals("file attribute required", ex.getMessage()); | |||
} | |||
} | |||
@@ -66,7 +66,7 @@ public class DirnameTest { | |||
try { | |||
buildRule.executeTarget("test3"); | |||
fail("Build exception should have been thrown as property attribute is required"); | |||
} catch(BuildException ex) { | |||
} catch (BuildException ex) { | |||
assertEquals("property attribute required", ex.getMessage()); | |||
} | |||
} | |||
@@ -50,7 +50,7 @@ public class EchoTest { | |||
echo.setProject(p); | |||
echo.setTaskName("testLogBlankEcho"); | |||
echo.execute(); | |||
assertEquals("[testLogBlankEcho] ", logger.lastLoggedMessage ); | |||
assertEquals("[testLogBlankEcho] ", logger.lastLoggedMessage); | |||
} | |||
@Test | |||
@@ -67,15 +67,14 @@ public class EchoTest { | |||
echo.setFile(removeThis); | |||
echo.setEncoding("UTF-8"); | |||
echo.execute(); | |||
String x = FileUtils.readFully(new InputStreamReader(new FileInputStream(removeThis), "UTF-8" )); | |||
String x = FileUtils.readFully(new InputStreamReader(new FileInputStream(removeThis), "UTF-8")); | |||
assertEquals(x,"\u00e4\u00a9"); | |||
} | |||
@After | |||
public void tearDown() { | |||
if (removeThis != null && removeThis.exists()) { | |||
if (!removeThis.delete()) | |||
{ | |||
if (!removeThis.delete()) { | |||
removeThis.deleteOnExit(); | |||
} | |||
} | |||
@@ -83,7 +82,7 @@ public class EchoTest { | |||
private class EchoTestLogger extends DefaultLogger { | |||
String lastLoggedMessage; | |||
/** | |||
* Create a new EchoTestLogger. | |||
*/ | |||
@@ -100,6 +99,6 @@ public class EchoTest { | |||
protected void log(String message) { | |||
this.lastLoggedMessage = message; | |||
} | |||
} | |||
} |
@@ -37,15 +37,15 @@ public class ExecuteJavaTest { | |||
private final static int TIME_OUT = 5000; | |||
private final static int CLOCK_ERROR=200; | |||
private final static int TIME_OUT_TEST=TIME_OUT-CLOCK_ERROR; | |||
private final static int CLOCK_ERROR = 200; | |||
private final static int TIME_OUT_TEST = TIME_OUT - CLOCK_ERROR; | |||
private ExecuteJava ej; | |||
private Project project; | |||
private Path cp; | |||
@Before | |||
public void setUp(){ | |||
public void setUp() { | |||
ej = new ExecuteJava(); | |||
ej.setTimeout((long)TIME_OUT); | |||
project = new Project(); | |||
@@ -64,7 +64,7 @@ public class ExecuteJavaTest { | |||
@Test | |||
public void testNoTimeOut() throws Exception { | |||
Commandline cmd = getCommandline(TIME_OUT/2); | |||
Commandline cmd = getCommandline(TIME_OUT / 2); | |||
ej.setJavaCommand(cmd); | |||
ej.execute(project); | |||
assertTrue("process should not have been killed", !ej.killedProcess()); | |||
@@ -73,24 +73,24 @@ public class ExecuteJavaTest { | |||
// test that the watchdog ends the process | |||
@Test | |||
public void testTimeOut() throws Exception { | |||
Commandline cmd = getCommandline(TIME_OUT*2); | |||
Commandline cmd = getCommandline(TIME_OUT * 2); | |||
ej.setJavaCommand(cmd); | |||
long now = System.currentTimeMillis(); | |||
ej.execute(project); | |||
long elapsed = System.currentTimeMillis() - now; | |||
assertTrue("process should have been killed", ej.killedProcess()); | |||
assertTrue("elapse time of "+elapsed | |||
+" ms is less than timeout value of "+TIME_OUT_TEST+" ms", | |||
assertTrue("elapse time of " + elapsed | |||
+ " ms is less than timeout value of " + TIME_OUT_TEST + " ms", | |||
elapsed >= TIME_OUT_TEST); | |||
assertTrue("elapse time of "+elapsed | |||
+" ms is greater than run value of "+(TIME_OUT*2)+" ms", | |||
elapsed < TIME_OUT*2); | |||
assertTrue("elapse time of " + elapsed | |||
+ " ms is greater than run value of " + (TIME_OUT * 2) + " ms", | |||
elapsed < TIME_OUT * 2); | |||
} | |||
@Test | |||
public void testNoTimeOutForked() throws Exception { | |||
Commandline cmd = getCommandline(TIME_OUT/2); | |||
Commandline cmd = getCommandline(TIME_OUT / 2); | |||
ej.setJavaCommand(cmd); | |||
ej.fork(cp); | |||
assertTrue("process should not have been killed", !ej.killedProcess()); | |||
@@ -99,26 +99,26 @@ public class ExecuteJavaTest { | |||
// test that the watchdog ends the process | |||
@Test | |||
public void testTimeOutForked() throws Exception { | |||
Commandline cmd = getCommandline(TIME_OUT*2); | |||
Commandline cmd = getCommandline(TIME_OUT * 2); | |||
ej.setJavaCommand(cmd); | |||
long now = System.currentTimeMillis(); | |||
ej.fork(cp); | |||
long elapsed = System.currentTimeMillis() - now; | |||
assertTrue("process should have been killed", ej.killedProcess()); | |||
assertTrue("elapse time of "+elapsed | |||
+" ms is less than timeout value of "+TIME_OUT_TEST+" ms", | |||
assertTrue("elapse time of " + elapsed | |||
+ " ms is less than timeout value of " + TIME_OUT_TEST + " ms", | |||
elapsed >= TIME_OUT_TEST); | |||
assertTrue("elapse time of "+elapsed | |||
+" ms is greater than run value of "+(TIME_OUT*2)+" ms", | |||
elapsed < TIME_OUT*2); | |||
assertTrue("elapse time of " + elapsed | |||
+ " ms is greater than run value of " + (TIME_OUT * 2) + " ms", | |||
elapsed < TIME_OUT * 2); | |||
} | |||
/** | |||
* Dangerous method to obtain the classpath for the test. This is | |||
* severely tighted to the build.xml properties. | |||
*/ | |||
private static String getTestClassPath(){ | |||
private static String getTestClassPath() { | |||
String classpath = System.getProperty("build.tests"); | |||
if (classpath == null) { | |||
System.err.println("WARNING: 'build.tests' property is not available !"); | |||
@@ -40,13 +40,13 @@ public class ExecuteWatchdogTest { | |||
private final static String TEST_CLASSPATH = getTestClassPath(); | |||
private final static int CLOCK_ERROR=200; | |||
private final static long TIME_OUT_TEST=TIME_OUT-CLOCK_ERROR; | |||
private final static int CLOCK_ERROR = 200; | |||
private final static long TIME_OUT_TEST = TIME_OUT - CLOCK_ERROR; | |||
private ExecuteWatchdog watchdog; | |||
@Before | |||
public void setUp(){ | |||
public void setUp() { | |||
watchdog = new ExecuteWatchdog(TIME_OUT); | |||
} | |||
@@ -54,7 +54,7 @@ public class ExecuteWatchdogTest { | |||
* Dangerous method to obtain the classpath for the test. This is | |||
* severely tied to the build.xml properties. | |||
*/ | |||
private static String getTestClassPath(){ | |||
private static String getTestClassPath() { | |||
String classpath = System.getProperty("build.tests"); | |||
if (classpath == null) { | |||
System.err.println("WARNING: 'build.tests' property is not available !"); | |||
@@ -74,10 +74,10 @@ public class ExecuteWatchdogTest { | |||
} | |||
private String getErrorOutput(Process p) throws Exception { | |||
BufferedReader err = new BufferedReader( new InputStreamReader(p.getErrorStream()) ); | |||
StringBuffer buf = new StringBuffer(); | |||
BufferedReader err = new BufferedReader(new InputStreamReader(p.getErrorStream())); | |||
StringBuilder buf = new StringBuilder(); | |||
String line; | |||
while ( (line = err.readLine()) != null){ | |||
while ((line = err.readLine()) != null) { | |||
buf.append(line); | |||
} | |||
return buf.toString(); | |||
@@ -85,9 +85,9 @@ public class ExecuteWatchdogTest { | |||
private int waitForEnd(Process p) throws Exception { | |||
int retcode = p.waitFor(); | |||
if (retcode != 0){ | |||
if (retcode != 0) { | |||
String err = getErrorOutput(p); | |||
if (err.length() > 0){ | |||
if (err.length() > 0) { | |||
System.err.println("ERROR:"); | |||
System.err.println(err); | |||
} | |||
@@ -97,25 +97,28 @@ public class ExecuteWatchdogTest { | |||
@Test | |||
public void testNoTimeOut() throws Exception { | |||
Process process = getProcess(TIME_OUT/2); | |||
Process process = getProcess(TIME_OUT / 2); | |||
watchdog.start(process); | |||
int retCode = waitForEnd(process); | |||
assertTrue("process should not have been killed", !watchdog.killedProcess()); | |||
assertFalse("process should not have been killed", watchdog.killedProcess()); | |||
assertFalse(Execute.isFailure(retCode)); | |||
} | |||
// test that the watchdog ends the process | |||
@Test | |||
public void testTimeOut() throws Exception { | |||
Process process = getProcess(TIME_OUT*2); | |||
Process process = getProcess(TIME_OUT * 2); | |||
long now = System.currentTimeMillis(); | |||
watchdog.start(process); | |||
int retCode = process.waitFor(); | |||
@SuppressWarnings("unused") | |||
int retCode = process.waitFor(); | |||
long elapsed = System.currentTimeMillis() - now; | |||
assertTrue("process should have been killed", watchdog.killedProcess()); | |||
// assertTrue("return code is invalid: " + retCode, retCode!=0); | |||
assertTrue("elapse time of "+elapsed+" ms is less than timeout value of "+TIME_OUT_TEST+" ms", elapsed >= TIME_OUT_TEST); | |||
assertTrue("elapse time of "+elapsed+" ms is greater than run value of "+(TIME_OUT*2)+" ms", elapsed < TIME_OUT*2); | |||
// assertNotEquals("return code is invalid: " + retCode, retCode, 0); | |||
assertTrue("elapse time of " + elapsed + " ms is less than timeout value of " + TIME_OUT_TEST + " ms", | |||
elapsed >= TIME_OUT_TEST); | |||
assertTrue("elapse time of " + elapsed + " ms is greater than run value of " + (TIME_OUT * 2) + " ms", | |||
elapsed < TIME_OUT * 2); | |||
} | |||
// test a process that runs and failed | |||
@@ -130,7 +133,7 @@ public class ExecuteWatchdogTest { | |||
@Test | |||
public void testManualStop() throws Exception { | |||
final Process process = getProcess(TIME_OUT*2); | |||
final Process process = getProcess(TIME_OUT * 2); | |||
watchdog.start(process); | |||
// I assume that starting this takes less than TIME_OUT/2 ms... | |||
@@ -146,8 +149,8 @@ public class ExecuteWatchdogTest { | |||
}; | |||
thread.start(); | |||
// wait for TIME_OUT/2, there should be about TIME_OUT/2 ms remaining before timeout | |||
thread.join(TIME_OUT/2); | |||
// wait for TIME_OUT / 2, there should be about TIME_OUT / 2 ms remaining before timeout | |||
thread.join(TIME_OUT / 2); | |||
// now stop the watchdog. | |||
watchdog.stop(); | |||
@@ -43,7 +43,7 @@ public class FailTest { | |||
public void test1() { | |||
try { | |||
buildRule.executeTarget("test1"); | |||
fail("it is required to fail :-)") ; | |||
fail("it is required to fail :-)"); | |||
} catch (BuildException ex) { | |||
assertEquals("No message", ex.getMessage()); | |||
} | |||
@@ -53,7 +53,7 @@ public class FailTest { | |||
public void test2() { | |||
try { | |||
buildRule.executeTarget("test2"); | |||
fail("it is required to fail :-)") ; | |||
fail("it is required to fail :-)"); | |||
} catch (BuildException ex) { | |||
assertEquals("test2", ex.getMessage()); | |||
} | |||
@@ -63,7 +63,7 @@ public class FailTest { | |||
public void testText() { | |||
try { | |||
buildRule.executeTarget("testText"); | |||
fail("it is required to fail :-)") ; | |||
fail("it is required to fail :-)"); | |||
} catch (BuildException ex) { | |||
assertEquals("testText", ex.getMessage()); | |||
} | |||
@@ -75,7 +75,7 @@ public class FailTest { | |||
buildRule.getProject().setProperty("foo", ""); | |||
try { | |||
buildRule.executeTarget("testIf"); | |||
fail("testIf must fail if foo has been set") ; | |||
fail("testIf must fail if foo has been set"); | |||
} catch (BuildException ex) { | |||
//TODO assert result | |||
} | |||
@@ -85,7 +85,7 @@ public class FailTest { | |||
public void testUnless() { | |||
try { | |||
buildRule.executeTarget("testUnless"); | |||
fail("testUnless must fail unless foo has been set") ; | |||
fail("testUnless must fail unless foo has been set"); | |||
} catch (BuildException ex) { | |||
//TODO assert rules | |||
} | |||
@@ -106,7 +106,7 @@ public class FailTest { | |||
buildRule.getProject().setProperty("if", ""); | |||
try { | |||
buildRule.executeTarget("testIfAndUnless"); | |||
fail("expect fail on defined(if)") ; | |||
fail("expect fail on defined(if)"); | |||
} catch (BuildException ex) { | |||
assertEquals("if=if and unless=unless", ex.getMessage()); | |||
} | |||
@@ -129,7 +129,7 @@ public class FailTest { | |||
public void testNested1() { | |||
try { | |||
buildRule.executeTarget("testNested1"); | |||
fail("it is required to fail :-)") ; | |||
fail("it is required to fail :-)"); | |||
} catch (BuildException ex) { | |||
assertEquals("condition satisfied", ex.getMessage()); | |||
} | |||
@@ -144,7 +144,7 @@ public class FailTest { | |||
public void testNested3() { | |||
try { | |||
buildRule.executeTarget("testNested3"); | |||
fail("it is required to fail :-)") ; | |||
fail("it is required to fail :-)"); | |||
} catch (BuildException ex) { | |||
assertEquals("testNested3", ex.getMessage()); | |||
} | |||
@@ -156,13 +156,13 @@ public class FailTest { | |||
+ "not permitted in conjunction with if/unless attributes"; | |||
char[] c = {'a', 'b', 'c'}; | |||
StringBuffer target = new StringBuffer("testNested4x"); | |||
StringBuilder target = new StringBuilder("testNested4x"); | |||
for (int i = 0; i < c.length; i++) { | |||
target.setCharAt(target.length() - 1, c[i]); | |||
try { | |||
buildRule.executeTarget(target.toString()); | |||
fail("it is required to fail :-)") ; | |||
fail("it is required to fail :-)"); | |||
} catch (BuildException ex) { | |||
assertEquals(specificMessage, ex.getMessage()); | |||
} | |||
@@ -173,7 +173,7 @@ public class FailTest { | |||
public void testNested5() { | |||
try { | |||
buildRule.executeTarget("testNested5"); | |||
fail("it is required to fail :-)") ; | |||
fail("it is required to fail :-)"); | |||
} catch (BuildException ex) { | |||
assertEquals("Only one nested condition is allowed.", ex.getMessage()); | |||
} | |||
@@ -183,7 +183,7 @@ public class FailTest { | |||
public void testNested6() { | |||
try { | |||
buildRule.executeTarget("testNested6"); | |||
fail("it is required to fail :-)") ; | |||
fail("it is required to fail :-)"); | |||
} catch (BuildException ex) { | |||
assertEquals("testNested6\ntestNested6\ntestNested6", ex.getMessage()); | |||
} | |||
@@ -194,13 +194,13 @@ public class FailTest { | |||
String specificMessage = "A single nested condition is required."; | |||
char[] c = {'a', 'b'}; | |||
StringBuffer target = new StringBuffer("testNested7x"); | |||
StringBuilder target = new StringBuilder("testNested7x"); | |||
for (int i = 0; i < c.length; i++) { | |||
target.setCharAt(target.length() - 1, c[i]); | |||
try { | |||
buildRule.executeTarget(target.toString()); | |||
fail("it is required to fail :-)") ; | |||
fail("it is required to fail :-)"); | |||
} catch (BuildException ex) { | |||
assertEquals(specificMessage, ex.getMessage()); | |||
} | |||
@@ -126,19 +126,19 @@ public class FilterTest { | |||
String line = null; | |||
File f = new File(buildRule.getProject().getBaseDir(), filteredFile); | |||
if (!f.exists()) { | |||
fail("filter test"+testNumber+" failed"); | |||
fail("filter test" + testNumber + " failed"); | |||
} else { | |||
BufferedReader in = null; | |||
try { | |||
in = new BufferedReader(new FileReader(f)); | |||
} catch (FileNotFoundException fnfe) { | |||
fail("filter test"+testNumber+" failed, filtered file: " + f.toString() + " not found"); | |||
fail("filter test" + testNumber + " failed, filtered file: " + f.toString() + " not found"); | |||
} | |||
try { | |||
line = in.readLine(); | |||
in.close(); | |||
} catch (IOException ioe) { | |||
fail("filter test"+testNumber+" failed. IOException while reading filtered file: " + ioe); | |||
fail("filter test" + testNumber + " failed. IOException while reading filtered file: " + ioe); | |||
} | |||
} | |||
f.delete(); | |||
@@ -234,7 +234,7 @@ public class FixCrLfTest { | |||
public void assertEqualContent(File expect, File result) | |||
throws AssertionFailedError, IOException { | |||
if (!result.exists()) { | |||
fail("Expected file "+result+" doesn\'t exist"); | |||
fail("Expected file " + result + " doesn\'t exist"); | |||
} | |||
InputStream inExpect = null; | |||
@@ -17,6 +17,8 @@ | |||
*/ | |||
package org.apache.tools.ant.taskdefs; | |||
import java.io.IOException; | |||
import org.apache.tools.ant.BuildException; | |||
import org.apache.tools.ant.BuildFileRule; | |||
import org.apache.tools.ant.FileUtilities; | |||
@@ -64,28 +66,28 @@ public class GUnzipTest { | |||
} | |||
@Test | |||
public void testRealTest() throws java.io.IOException { | |||
public void testRealTest() throws IOException { | |||
testRealTest("realTest"); | |||
} | |||
@Test | |||
public void testRealTestWithResource() throws java.io.IOException { | |||
public void testRealTestWithResource() throws IOException { | |||
testRealTest("realTestWithResource"); | |||
} | |||
private void testRealTest(String target) throws java.io.IOException { | |||
private void testRealTest(String target) throws IOException { | |||
buildRule.executeTarget(target); | |||
assertEquals(FileUtilities.getFileContents(buildRule.getProject().resolveFile("../asf-logo.gif")), | |||
FileUtilities.getFileContents(buildRule.getProject().resolveFile("asf-logo.gif"))); | |||
} | |||
@Test | |||
public void testTestGzipTask() throws java.io.IOException { | |||
public void testTestGzipTask() throws IOException { | |||
testRealTest("testGzipTask"); | |||
} | |||
@Test | |||
public void testDocumentationClaimsOnCopy() throws java.io.IOException { | |||
public void testDocumentationClaimsOnCopy() throws IOException { | |||
testRealTest("testDocumentationClaimsOnCopy"); | |||
} | |||
} |
@@ -82,7 +82,7 @@ public class GzipTest { | |||
} | |||
@Test | |||
public void testGZip(){ | |||
public void testGZip() { | |||
buildRule.executeTarget("realTest"); | |||
String log = buildRule.getLog(); | |||
assertTrue("Expecting message starting with 'Building:' but got '" | |||
@@ -92,12 +92,12 @@ public class GzipTest { | |||
} | |||
@Test | |||
public void testResource(){ | |||
public void testResource() { | |||
buildRule.executeTarget("realTestWithResource"); | |||
} | |||
@Test | |||
public void testDateCheck(){ | |||
public void testDateCheck() { | |||
buildRule.executeTarget("testDateCheck"); | |||
String log = buildRule.getLog(); | |||
assertTrue( | |||
@@ -106,7 +106,7 @@ public class GzipTest { | |||
} | |||
@After | |||
public void tearDown(){ | |||
public void tearDown() { | |||
buildRule.executeTarget("cleanup"); | |||
} | |||
@@ -90,8 +90,9 @@ public class ImportTest { | |||
try { | |||
buildRule.executeTarget("do-import"); | |||
fail("Build exception should have been thrown as import only allowed in top level task"); | |||
} catch(BuildException ex) { | |||
assertContains( "not a top level task", "import only allowed as a top-level task", ex.getMessage()); | |||
} catch (BuildException ex) { | |||
assertContains("not a top level task", "import only allowed as a top-level task", | |||
ex.getMessage()); | |||
} | |||
} | |||
@@ -111,7 +112,8 @@ public class ImportTest { | |||
"src/etc/testcases/taskdefs/import/same_target.xml"); | |||
fail("Expected build exception"); | |||
} catch (BuildException ex) { | |||
assertContains("Message did not contain expected contents", "Duplicate target", ex.getMessage()); | |||
assertContains("Message did not contain expected contents", "Duplicate target", | |||
ex.getMessage()); | |||
} | |||
} | |||
@@ -137,7 +137,7 @@ public class JarTest { | |||
// move the modified date back a couple of seconds rather than delay the test on each run | |||
Assume.assumeTrue(jarFile.setLastModified(jarFile.lastModified() | |||
- (FileUtils.getFileUtils().getFileTimestampGranularity() * 3))); | |||
- FileUtils.getFileUtils().getFileTimestampGranularity() * 3)); | |||
long jarModifiedDate = jarFile.lastModified(); | |||
buildRule.executeTarget(secondTarget); | |||
@@ -169,13 +169,13 @@ public class JarTest { | |||
private void testRecreate(String firstTarget, String secondTarget) { | |||
//Move the modified date on all input back a couple of seconds rather then delay the test to achieve a similar effect | |||
FileUtilities.rollbackTimetamps(buildRule.getProject().getBaseDir(), 5); | |||
FileUtilities.rollbackTimestamps(buildRule.getProject().getBaseDir(), 5); | |||
buildRule.executeTarget(firstTarget); | |||
File jarFile = new File(getOutputDir(), tempJar); | |||
//Move the modified date back a couple of seconds rather then delay the test to achieve a similar effect | |||
FileUtilities.rollbackTimetamps(buildRule.getOutputDir(), 5); | |||
FileUtilities.rollbackTimestamps(buildRule.getOutputDir(), 5); | |||
long jarModifiedDate = jarFile.lastModified(); | |||
buildRule.executeTarget(secondTarget); | |||
@@ -334,7 +334,7 @@ public class JarTest { | |||
public void testNoVersionInfoFail() { | |||
try { | |||
buildRule.executeTarget("testNoVersionInfoFail"); | |||
fail("BuildException expected: Manifest Implemention information missing."); | |||
fail("BuildException expected: Manifest Implementation information missing."); | |||
} catch (BuildException ex) { | |||
assertContains("No Implementation-Title set.", ex.getMessage()); | |||
} | |||
@@ -343,33 +343,33 @@ public class JarTest { | |||
@Test | |||
public void testNoVersionInfoIgnore() { | |||
buildRule.executeTarget("testNoVersionInfoIgnore"); | |||
assertTrue(buildRule.getFullLog().indexOf("No Implementation-Title set.") > -1 ); | |||
assertTrue(buildRule.getFullLog().indexOf("No Implementation-Version set.") > -1 ); | |||
assertTrue(buildRule.getFullLog().indexOf("No Implementation-Vendor set.") > -1 ); | |||
assertTrue(buildRule.getFullLog().indexOf("No Implementation-Title set.") > -1); | |||
assertTrue(buildRule.getFullLog().indexOf("No Implementation-Version set.") > -1); | |||
assertTrue(buildRule.getFullLog().indexOf("No Implementation-Vendor set.") > -1); | |||
} | |||
@Test | |||
public void testNoVersionInfoWarn() { | |||
buildRule.executeTarget("testNoVersionInfoWarn"); | |||
assertTrue(buildRule.getLog().indexOf("No Implementation-Title set.") > -1 ); | |||
assertTrue(buildRule.getLog().indexOf("No Implementation-Version set.") > -1 ); | |||
assertTrue(buildRule.getLog().indexOf("No Implementation-Vendor set.") > -1 ); | |||
assertTrue(buildRule.getLog().indexOf("No Implementation-Title set.") > -1); | |||
assertTrue(buildRule.getLog().indexOf("No Implementation-Version set.") > -1); | |||
assertTrue(buildRule.getLog().indexOf("No Implementation-Vendor set.") > -1); | |||
} | |||
@Test | |||
public void testNoVersionInfoNoStrict() { | |||
buildRule.executeTarget("testNoVersionInfoNoStrict"); | |||
assertFalse(buildRule.getLog().indexOf("No Implementation-Title set.") > -1 ); | |||
assertFalse(buildRule.getLog().indexOf("No Implementation-Version set.") > -1 ); | |||
assertFalse(buildRule.getLog().indexOf("No Implementation-Vendor set.") > -1 ); | |||
assertFalse(buildRule.getLog().indexOf("No Implementation-Title set.") > -1); | |||
assertFalse(buildRule.getLog().indexOf("No Implementation-Version set.") > -1); | |||
assertFalse(buildRule.getLog().indexOf("No Implementation-Vendor set.") > -1); | |||
} | |||
@Test | |||
public void testHasVersionInfo() { | |||
buildRule.executeTarget("testHasVersionInfo"); | |||
assertFalse(buildRule.getLog().indexOf("No Implementation-Title set.") > -1 ); | |||
assertFalse(buildRule.getLog().indexOf("No Implementation-Version set.") > -1 ); | |||
assertFalse(buildRule.getLog().indexOf("No Implementation-Vendor set.") > -1 ); | |||
assertFalse(buildRule.getLog().indexOf("No Implementation-Title set.") > -1); | |||
assertFalse(buildRule.getLog().indexOf("No Implementation-Version set.") > -1); | |||
assertFalse(buildRule.getLog().indexOf("No Implementation-Vendor set.") > -1); | |||
} | |||
} |
@@ -78,14 +78,15 @@ public class JavaTest { | |||
//final String propname="tests-classpath.value"; | |||
//String testClasspath=System.getProperty(propname); | |||
//System.out.println("Test cp="+testClasspath); | |||
String runFatal=System.getProperty("junit.run.fatal.tests"); | |||
if(runFatal!=null) | |||
runFatalTests=true; | |||
//System.out.println("Test cp=" + testClasspath); | |||
String runFatal = System.getProperty("junit.run.fatal.tests"); | |||
if (runFatal != null) { | |||
runFatalTests = true; | |||
} | |||
} | |||
@Test | |||
public void testNoJarNoClassname(){ | |||
public void testNoJarNoClassname() { | |||
try { | |||
buildRule.executeTarget("testNoJarNoClassname"); | |||
fail("Build exception should have been thrown - parameter validation"); | |||
@@ -173,20 +174,20 @@ public class JavaTest { | |||
assertEquals("Command line should have 5 elements", 5, cmdLine.length); | |||
assertEquals("Last command line element should be java argument: " + arg, | |||
arg, | |||
cmdLine[cmdLine.length-1]); | |||
cmdLine[cmdLine.length - 1]); | |||
assertEquals("The command line element at index 3 should be module name: " + moduleName, | |||
moduleName, | |||
cmdLine[cmdLine.length-2]); | |||
cmdLine[cmdLine.length - 2]); | |||
assertEquals("The command line element at index 2 should be -m", | |||
"-m", | |||
cmdLine[cmdLine.length-3]); | |||
cmdLine[cmdLine.length - 3]); | |||
} | |||
@Test | |||
public void testModuleAndClassnameCommandLine() { | |||
final String moduleName = "TestModule"; //NOI18N | |||
final String className = "org.apache.Test"; //NOI18N | |||
final String moduleClassPair= String.format("%s/%s", moduleName, className); | |||
final String moduleClassPair = String.format("%s/%s", moduleName, className); | |||
final String arg = "appArg"; //NOI18N | |||
final Java java = new Java(); | |||
java.setFork(true); | |||
@@ -199,13 +200,13 @@ public class JavaTest { | |||
assertEquals("Command line should have 5 elements", 5, cmdLine.length); | |||
assertEquals("Last command line element should be java argument: " + arg, | |||
arg, | |||
cmdLine[cmdLine.length-1]); | |||
cmdLine[cmdLine.length - 1]); | |||
assertEquals("The command line element at index 3 should be module class pair: " + moduleClassPair, | |||
moduleClassPair, | |||
cmdLine[cmdLine.length-2]); | |||
cmdLine[cmdLine.length - 2]); | |||
assertEquals("The command line element at index 2 should be -m", | |||
"-m", | |||
cmdLine[cmdLine.length-3]); | |||
cmdLine[cmdLine.length - 3]); | |||
} | |||
@Test | |||
@@ -395,7 +396,7 @@ public class JavaTest { | |||
// wait a little bit for the task to wait for input | |||
Thread.sleep(100); | |||
// write some stuff in the input stream to be catched by the input task | |||
// write some stuff in the input stream to be caught by the input task | |||
out.write("foo\n".getBytes()); | |||
out.flush(); | |||
try { | |||
@@ -459,21 +460,21 @@ public class JavaTest { | |||
* argv[1] = string to print to System.err (optional) | |||
*/ | |||
public static void main(String[] argv) { | |||
int exitCode=0; | |||
if(argv.length>0) { | |||
int exitCode = 0; | |||
if (argv.length > 0) { | |||
try { | |||
exitCode=Integer.parseInt(argv[0]); | |||
} catch(NumberFormatException nfe) { | |||
exitCode=-1; | |||
exitCode = Integer.parseInt(argv[0]); | |||
} catch (NumberFormatException nfe) { | |||
exitCode = -1; | |||
} | |||
} | |||
if(argv.length>1) { | |||
if (argv.length > 1) { | |||
System.out.println(argv[1]); | |||
} | |||
if(argv.length>2) { | |||
if (argv.length > 2) { | |||
System.err.println(argv[2]); | |||
} | |||
if(exitCode!=0) { | |||
if (exitCode != 0) { | |||
System.exit(exitCode); | |||
} | |||
} | |||
@@ -503,8 +504,7 @@ public class JavaTest { | |||
if (argv.length >= 1) { | |||
sleepTime = Integer.parseInt(argv[0]); | |||
} | |||
if (argv.length >= 2) | |||
{ | |||
if (argv.length >= 2) { | |||
logFile = argv[1]; | |||
} | |||
OutputStreamWriter out = null; | |||
@@ -515,9 +515,13 @@ public class JavaTest { | |||
FileOutputStream fos = new FileOutputStream(dest); | |||
out = new OutputStreamWriter(fos); | |||
out.write("bye bye\n"); | |||
} catch (Exception ex) {} | |||
finally { | |||
try {out.close();} catch (IOException ioe) {}} | |||
} catch (Exception ex) { | |||
} finally { | |||
try { | |||
out.close(); | |||
} catch (IOException ioe) { | |||
} | |||
} | |||
} | |||
} | |||
@@ -304,7 +304,7 @@ public class JavacTest { | |||
final File tmp = new File(System.getProperty("java.io.tmpdir")); //NOI18N | |||
final File destDir = new File(tmp, String.format("%stestMP%d", | |||
getClass().getName(), | |||
System.currentTimeMillis()/1000)); | |||
System.currentTimeMillis() / 1000)); | |||
destDir.mkdirs(); | |||
try { | |||
final Path p = new Path(project); | |||
@@ -38,19 +38,16 @@ public class LoadFileTest { | |||
@Rule | |||
public final BuildFileRule buildRule = new BuildFileRule(); | |||
@Before | |||
public void setUp() { | |||
buildRule.configureProject("src/etc/testcases/taskdefs/loadfile.xml"); | |||
} | |||
@After | |||
public void tearDown() { | |||
buildRule.executeTarget("cleanup"); | |||
} | |||
/** | |||
* A unit test for JUnit | |||
*/ | |||
@@ -64,7 +61,6 @@ public class LoadFileTest { | |||
} | |||
} | |||
/** | |||
* A unit test for JUnit | |||
*/ | |||
@@ -78,7 +74,6 @@ public class LoadFileTest { | |||
} | |||
} | |||
/** | |||
* A unit test for JUnit | |||
*/ | |||
@@ -96,32 +91,27 @@ public class LoadFileTest { | |||
* A unit test for JUnit | |||
*/ | |||
@Test | |||
public void testFailOnError() | |||
throws BuildException { | |||
public void testFailOnError() throws BuildException { | |||
buildRule.executeTarget("testFailOnError"); | |||
assertNull(buildRule.getProject().getProperty("testFailOnError")); | |||
} | |||
/** | |||
* A unit test for JUnit | |||
*/ | |||
@Test | |||
public void testLoadAFile() | |||
throws BuildException { | |||
public void testLoadAFile() throws BuildException { | |||
buildRule.executeTarget("testLoadAFile"); | |||
if(buildRule.getProject().getProperty("testLoadAFile").indexOf("eh?")<0) { | |||
fail("property is not all in the file"); | |||
} | |||
} | |||
/** | |||
* A unit test for JUnit | |||
*/ | |||
@Test | |||
public void testLoadAFileEnc() | |||
throws BuildException { | |||
public void testLoadAFileEnc() throws BuildException { | |||
buildRule.executeTarget("testLoadAFileEnc"); | |||
assertNotNull("file load files", buildRule.getProject().getProperty("testLoadAFileEnc")); | |||
} | |||
@@ -130,8 +120,7 @@ public class LoadFileTest { | |||
* A unit test for JUnit | |||
*/ | |||
@Test | |||
public void testEvalProps() | |||
throws BuildException { | |||
public void testEvalProps() throws BuildException { | |||
buildRule.executeTarget("testEvalProps"); | |||
if(buildRule.getProject().getProperty("testEvalProps").indexOf("rain")<0) { | |||
fail("property eval broken"); | |||
@@ -142,8 +131,7 @@ public class LoadFileTest { | |||
* Test FilterChain and FilterReaders | |||
*/ | |||
@Test | |||
public void testFilterChain() | |||
throws BuildException { | |||
public void testFilterChain() throws BuildException { | |||
buildRule.executeTarget("testFilterChain"); | |||
if(buildRule.getProject().getProperty("testFilterChain").indexOf("World!")<0) { | |||
fail("Filter Chain broken"); | |||
@@ -154,8 +142,7 @@ public class LoadFileTest { | |||
* Test StripJavaComments filterreader functionality. | |||
*/ | |||
@Test | |||
public final void testStripJavaComments() | |||
throws BuildException { | |||
public final void testStripJavaComments() throws BuildException { | |||
buildRule.executeTarget("testStripJavaComments"); | |||
final String expected = buildRule.getProject().getProperty("expected"); | |||
final String generated = buildRule.getProject().getProperty("testStripJavaComments"); | |||
@@ -100,7 +100,7 @@ public class MakeUrlTest { | |||
/** | |||
* test that we can round trip by opening a url that exists | |||
* | |||
* @throws IOException | |||
* @throws IOException if something goes wrong | |||
*/ | |||
@Test | |||
public void testRoundTrip() throws IOException { | |||
@@ -142,8 +142,8 @@ public class MakeUrlTest { | |||
/** | |||
* assert that a property ends with | |||
* | |||
* @param property | |||
* @param ending | |||
* @param property String | |||
* @param ending String | |||
*/ | |||
private void assertPropertyEndsWith(String property, String ending) { | |||
String result = getProperty(property); | |||
@@ -167,8 +167,8 @@ public class MakeUrlTest { | |||
/** | |||
* get a property from the project | |||
* | |||
* @param property | |||
* @return | |||
* @param property String | |||
* @return String | |||
*/ | |||
protected String getProperty(String property) { | |||
return buildRule.getProject().getProperty(property); | |||
@@ -17,7 +17,6 @@ | |||
*/ | |||
package org.apache.tools.ant.taskdefs; | |||
import static org.apache.tools.ant.AntAssert.assertContains; | |||
import static org.junit.Assert.assertEquals; | |||
import static org.junit.Assert.assertNull; | |||
@@ -231,8 +230,8 @@ public class ManifestClassPathTest { | |||
} else { | |||
altDriveLetter = "C"; | |||
} | |||
new java.io.File(altDriveLetter + ":/foo.txt").getCanonicalPath(); | |||
} catch (java.io.IOException e) { | |||
new File(altDriveLetter + ":/foo.txt").getCanonicalPath(); | |||
} catch (IOException e) { | |||
Assume.assumeNoException("Drive " + altDriveLetter + ": doesn't exist or is not ready", e); | |||
} | |||
buildRule.getProject().setProperty("altDriveLetter", altDriveLetter); | |||
@@ -58,11 +58,11 @@ public class ManifestTest { | |||
"OfCourseTheAnswerIsThatIsWhatTheSpecRequiresAndIfAnythingHas" + | |||
"AProblemWithThatItIsNotABugInAnt"; | |||
public static final String LONG_70_NAME | |||
public static final String LONG_70_NAME | |||
= "ThisNameIsJustSeventyCharactersWhichIsAllowedAccordingToTheSpecsFiller"; | |||
public static final String LONG_68_NAME | |||
public static final String LONG_68_NAME | |||
= "ThisNameIsJustSixtyEightCharactersWhichIsAllowedAccordingToTheSpecsX"; | |||
public static final String NOT_LONG_NAME | |||
public static final String NOT_LONG_NAME | |||
= "NameIsJustUnderSeventyCharactersWhichIsAllowedAccordingTheSpec"; | |||
public static final String VALUE = "NOT_LONG"; | |||
@@ -134,9 +134,8 @@ public class ManifestTest { | |||
@Test | |||
public void test5() { | |||
buildRule.executeTarget("test5"); | |||
String output = buildRule.getLog(); | |||
boolean hasWarning = output.indexOf("Manifest warning: \"Name\" attributes should not occur in the main section") != -1; | |||
assertTrue("Expected warning about Name in main section", hasWarning); | |||
assertTrue("Expected warning about Name in main section", buildRule.getLog() | |||
.contains("Manifest warning: \"Name\" attributes should not occur in the main section")); | |||
} | |||
/** | |||
@@ -150,9 +149,8 @@ public class ManifestTest { | |||
} catch (BuildException ex) { | |||
assertContains("Invalid Manifest", ex.getMessage()); | |||
} | |||
String output = buildRule.getLog(); | |||
boolean hasWarning = output.indexOf("Manifest sections should start with a \"Name\" attribute") != -1; | |||
assertTrue("Expected warning about section not starting with Name: attribute", hasWarning); | |||
assertTrue("Expected warning about section not starting with Name: attribute", buildRule.getLog() | |||
.contains("Manifest sections should start with a \"Name\" attribute")); | |||
} | |||
@@ -162,9 +160,8 @@ public class ManifestTest { | |||
@Test | |||
public void test7() { | |||
buildRule.executeTarget("test7"); | |||
boolean hasWarning = buildRule.getLog().indexOf(Manifest.ERROR_FROM_FORBIDDEN) != -1; | |||
assertTrue("Expected warning about From: attribute", hasWarning); | |||
assertTrue("Expected warning about From: attribute", buildRule.getLog() | |||
.contains(Manifest.ERROR_FROM_FORBIDDEN)); | |||
} | |||
/** | |||
@@ -245,7 +242,8 @@ public class ManifestTest { | |||
buildRule.executeTarget("test13"); | |||
fail("BuildException expected: Duplicate Attribute"); | |||
} catch (BuildException ex) { | |||
assertContains("The attribute \"Test\" may not occur more than once in the same section", ex.getMessage()); | |||
assertContains("The attribute \"Test\" may not occur more than once in the same section", | |||
ex.getMessage()); | |||
} | |||
} | |||
@@ -269,9 +267,9 @@ public class ManifestTest { | |||
public void testLongLine() throws IOException, ManifestException { | |||
Project p = buildRule.getProject(); | |||
p.setUserProperty("test.longline", LONG_LINE); | |||
p.setUserProperty("test.long68name" , LONG_68_NAME); | |||
p.setUserProperty("test.long70name" , LONG_70_NAME); | |||
p.setUserProperty("test.notlongname" , NOT_LONG_NAME); | |||
p.setUserProperty("test.long68name", LONG_68_NAME); | |||
p.setUserProperty("test.long70name", LONG_70_NAME); | |||
p.setUserProperty("test.notlongname", NOT_LONG_NAME); | |||
p.setUserProperty("test.value", VALUE); | |||
buildRule.executeTarget("testLongLine"); | |||
@@ -17,6 +17,8 @@ | |||
*/ | |||
package org.apache.tools.ant.taskdefs; | |||
import java.io.File; | |||
import org.apache.tools.ant.BuildException; | |||
import org.apache.tools.ant.BuildFileRule; | |||
import org.junit.Before; | |||
@@ -60,7 +62,7 @@ public class MkdirTest { | |||
@Test | |||
public void test3() { | |||
buildRule.executeTarget("test3"); | |||
java.io.File f = new java.io.File(buildRule.getProject().getProperty("output"), "testdir.tmp"); | |||
File f = new File(buildRule.getProject().getProperty("output"), "testdir.tmp"); | |||
if (!f.exists() || !f.isDirectory()) { | |||
fail("mkdir failed"); | |||
} else { | |||
@@ -35,7 +35,7 @@ import static org.junit.Assert.assertTrue; | |||
* | |||
*/ | |||
public class MoveTest { | |||
@Rule | |||
public final BuildFileRule buildRule = new BuildFileRule(); | |||
@@ -28,7 +28,7 @@ import org.junit.Test; | |||
/** | |||
*/ | |||
public class MultiMapTest { | |||
@Rule | |||
public final BuildFileRule buildRule = new BuildFileRule(); | |||
@@ -68,12 +68,17 @@ public class MultiMapTest { | |||
} | |||
public static class TestMapper implements FileNameMapper { | |||
public TestMapper() {} | |||
public void setFrom(String from) {} | |||
public void setTo(String to) {} | |||
public TestMapper() { | |||
} | |||
public void setFrom(String from) { | |||
} | |||
public void setTo(String to) { | |||
} | |||
public String[] mapFileName(final String source_file_name) { | |||
return new String[] { | |||
source_file_name, source_file_name+".copy2" }; | |||
return new String[] {source_file_name, source_file_name + ".copy2"}; | |||
} | |||
} | |||
} |
@@ -46,7 +46,7 @@ public class ParallelTest { | |||
/** Standard property value for the fail test */ | |||
public final static String FAILURE_MESSAGE = "failure"; | |||
/** the build fiel associated with this test */ | |||
/** the build file associated with this test */ | |||
public final static String TEST_BUILD_FILE | |||
= "src/etc/testcases/taskdefs/parallel.xml"; | |||
@@ -36,7 +36,7 @@ public class PathConvertTest { | |||
private static final String BUILD_PATH = "src/etc/testcases/taskdefs/"; | |||
private static final String BUILD_FILENAME = "pathconvert.xml"; | |||
private static final String BUILD_FILE = BUILD_PATH + BUILD_FILENAME; | |||
@Before | |||
public void setUp() { | |||
buildRule.configureProject(BUILD_FILE); | |||
@@ -66,8 +66,7 @@ public class PropertyTest { | |||
try { | |||
buildRule.executeTarget("test3"); | |||
fail("Did not throw exception on circular exception"); | |||
} | |||
catch (BuildException e) { | |||
} catch (BuildException e) { | |||
assertTrue("Circular definition not detected - ", | |||
e.getMessage().indexOf("was circularly defined") != -1); | |||
} | |||
@@ -101,8 +100,7 @@ public class PropertyTest { | |||
try { | |||
buildRule.executeTarget("prefix.fail"); | |||
fail("Did not throw exception on invalid use of prefix"); | |||
} | |||
catch (BuildException e) { | |||
} catch (BuildException e) { | |||
assertContains("Prefix allowed on non-resource/file load - ", | |||
"Prefix is only valid", e.getMessage()); | |||
} | |||
@@ -99,8 +99,8 @@ public class ProtectedJarMethodsTest { | |||
@Test | |||
public void testFindJarNameLongestMatchWins() { | |||
assertEquals("lib/foo", | |||
Jar.findJarName("lib/foo", | |||
new String[] {"foo", "lib/foo", | |||
Jar.findJarName("lib/foo", | |||
new String[] {"foo", "lib/foo", | |||
"lib/bar/foo"})); | |||
} | |||
} |
@@ -32,7 +32,7 @@ import static org.junit.Assert.assertTrue; | |||
/** | |||
*/ | |||
public class RecorderTest { | |||
@Rule | |||
public final BuildFileRule buildRule = new BuildFileRule(); | |||
@@ -153,7 +153,7 @@ public class ReplaceTest { | |||
public void assertEqualContent(File expect, File result) | |||
throws AssertionFailedError, IOException { | |||
if (!result.exists()) { | |||
fail("Expected file "+result+" doesn\'t exist"); | |||
fail("Expected file " + result + " doesn\'t exist"); | |||
} | |||
InputStream inExpect = null; | |||
@@ -282,7 +282,7 @@ public class RmicAdvancedTest { | |||
public void NotestFailingAdapter() throws Exception { | |||
try { | |||
buildRule.executeTarget("testFailingAdapter"); | |||
fail("Expected failures to propogate"); | |||
fail("Expected failures to propagate"); | |||
} catch (BuildException ex) { | |||
AntAssert.assertContains(Rmic.ERROR_RMIC_FAILED, ex.getMessage()); | |||
} | |||
@@ -291,7 +291,7 @@ public class RmicAdvancedTest { | |||
/** | |||
* test that version 1.1 stubs are good | |||
* @throws Exception | |||
* @throws Exception if something goes wrong | |||
*/ | |||
@Test | |||
public void testVersion11() throws Exception { | |||
@@ -300,7 +300,7 @@ public class RmicAdvancedTest { | |||
/** | |||
* test that version 1.1 stubs are good | |||
* @throws Exception | |||
* @throws Exception if something goes wrong | |||
*/ | |||
@Test | |||
public void testVersion11Dest() throws Exception { | |||
@@ -310,7 +310,7 @@ public class RmicAdvancedTest { | |||
/** | |||
* test that version 1.2 stubs are good | |||
* | |||
* @throws Exception | |||
* @throws Exception if something goes wrong | |||
*/ | |||
@Test | |||
public void testVersion12() throws Exception { | |||
@@ -320,7 +320,7 @@ public class RmicAdvancedTest { | |||
/** | |||
* test that version 1.2 stubs are good | |||
* | |||
* @throws Exception | |||
* @throws Exception if something goes wrong | |||
*/ | |||
@Test | |||
public void testVersion12Dest() throws Exception { | |||
@@ -330,7 +330,7 @@ public class RmicAdvancedTest { | |||
/** | |||
* test that version compat stubs are good | |||
* | |||
* @throws Exception | |||
* @throws Exception if something goes wrong | |||
*/ | |||
@Test | |||
public void testVersionCompat() throws Exception { | |||
@@ -340,7 +340,7 @@ public class RmicAdvancedTest { | |||
/** | |||
* test that version compat stubs are good | |||
* | |||
* @throws Exception | |||
* @throws Exception if something goes wrong | |||
*/ | |||
@Test | |||
public void testVersionCompatDest() throws Exception { | |||
@@ -372,7 +372,7 @@ public class RmicAdvancedTest { | |||
/** | |||
* test that passes -Xnew to sun's rmic running in a different VM. | |||
* | |||
* @throws Exception | |||
* @throws Exception if something goes wrong | |||
*/ | |||
@Test | |||
public void testXnewForked() throws Exception { | |||
@@ -382,7 +382,7 @@ public class RmicAdvancedTest { | |||
/** | |||
* test that passes -Xnew to sun's rmic running in a different VM. | |||
* | |||
* @throws Exception | |||
* @throws Exception if something goes wrong | |||
*/ | |||
@Test | |||
public void testXnewForkedDest() throws Exception { | |||
@@ -392,7 +392,7 @@ public class RmicAdvancedTest { | |||
/** | |||
* test that runs the new xnew compiler adapter. | |||
* | |||
* @throws Exception | |||
* @throws Exception if something goes wrong | |||
*/ | |||
@Test | |||
public void testXnewCompiler() throws Exception { | |||
@@ -402,7 +402,7 @@ public class RmicAdvancedTest { | |||
/** | |||
* test that runs the new xnew compiler adapter. | |||
* | |||
* @throws Exception | |||
* @throws Exception if something goes wrong | |||
*/ | |||
@Test | |||
public void testXnewCompilerDest() throws Exception { | |||
@@ -412,7 +412,7 @@ public class RmicAdvancedTest { | |||
/** | |||
* test that verifies that IDL compiles. | |||
* | |||
* @throws Exception | |||
* @throws Exception if something goes wrong | |||
*/ | |||
@Test | |||
public void testIDL() throws Exception { | |||
@@ -422,7 +422,7 @@ public class RmicAdvancedTest { | |||
/** | |||
* test that verifies that IDL compiles. | |||
* | |||
* @throws Exception | |||
* @throws Exception if something goes wrong | |||
*/ | |||
@Test | |||
public void testIDLDest() throws Exception { | |||
@@ -432,7 +432,7 @@ public class RmicAdvancedTest { | |||
/** | |||
* test that verifies that IIOP compiles. | |||
* | |||
* @throws Exception | |||
* @throws Exception if something goes wrong | |||
*/ | |||
@Test | |||
public void testIIOP() throws Exception { | |||
@@ -442,7 +442,7 @@ public class RmicAdvancedTest { | |||
/** | |||
* test that verifies that IIOP compiles. | |||
* | |||
* @throws Exception | |||
* @throws Exception if something goes wrong | |||
*/ | |||
@Test | |||
public void testIIOPDest() throws Exception { | |||
@@ -88,7 +88,7 @@ public class RmicTest { | |||
// check defaults | |||
String compiler = rmic.getCompiler(); | |||
assertNotNull(compiler); | |||
assertEquals("expected sun or kaffe, but found "+compiler,compiler,"default"); | |||
assertEquals("expected sun or kaffe, but found " + compiler, compiler,"default"); | |||
project.setNewProperty("build.rmic", "weblogic"); | |||
compiler = rmic.getCompiler(); | |||
@@ -26,8 +26,8 @@ import java.io.File; | |||
import java.net.URL; | |||
import java.util.logging.Logger; | |||
import org.apache.tools.ant.Project; | |||
import org.apache.tools.ant.BuildException; | |||
import org.apache.tools.ant.Project; | |||
import org.junit.Before; | |||
import org.junit.Ignore; | |||
import org.junit.Test; | |||
@@ -70,13 +70,13 @@ public class SQLExecTest { | |||
// simple test to ensure that the caching does work... | |||
@Test | |||
public void testDriverCaching(){ | |||
public void testDriverCaching() { | |||
SQLExec sql = createTask(getProperties(NULL)); | |||
assertTrue(!SQLExec.getLoaderMap().containsKey(NULL_DRIVER)); | |||
try { | |||
sql.execute(); | |||
fail("BuildException should have been thrown"); | |||
} catch (BuildException e){ | |||
} catch (BuildException e) { | |||
assertContains("No suitable Driver", e.getMessage()); | |||
} | |||
assertTrue(SQLExec.getLoaderMap().containsKey(NULL_DRIVER)); | |||
@@ -104,13 +104,13 @@ public class SQLExecTest { | |||
@Ignore | |||
@Test | |||
public void testOracle(){ | |||
public void testOracle() { | |||
doMultipleCalls(1000, ORACLE, true, false); | |||
} | |||
@Ignore | |||
@Test | |||
public void testMySQL(){ | |||
public void testMySQL() { | |||
doMultipleCalls(1000, MYSQL, true, false); | |||
} | |||
@@ -122,15 +122,15 @@ public class SQLExecTest { | |||
* @param caching should caching be enabled ? | |||
* @param catchexception true to catch exception for each call, false if not. | |||
*/ | |||
protected void doMultipleCalls(int calls, int database, boolean caching, boolean catchexception){ | |||
protected void doMultipleCalls(int calls, int database, boolean caching, boolean catchexception) { | |||
Properties props = getProperties(database); | |||
for (int i = 0; i < calls; i++){ | |||
for (int i = 0; i < calls; i++) { | |||
SQLExec sql = createTask(props); | |||
sql.setCaching(caching); | |||
try { | |||
sql.execute(); | |||
} catch (BuildException e){ | |||
if (!catchexception){ | |||
} catch (BuildException e) { | |||
if (!catchexception) { | |||
throw e; | |||
} | |||
} | |||
@@ -141,15 +141,15 @@ public class SQLExecTest { | |||
* Create a task from a set of properties | |||
* @see #getProperties(int) | |||
*/ | |||
protected SQLExec createTask(Properties props){ | |||
protected SQLExec createTask(Properties props) { | |||
SQLExec sql = new SQLExec(); | |||
sql.setProject( new Project() ); | |||
sql.setDriver( props.getProperty(DRIVER) ); | |||
sql.setUserid( props.getProperty(USER) ); | |||
sql.setPassword( props.getProperty(PASSWORD) ); | |||
sql.setUrl( props.getProperty(URL) ); | |||
sql.createClasspath().setLocation( new File(props.getProperty(PATH)) ); | |||
sql.addText( props.getProperty(SQL) ); | |||
sql.setProject(new Project()); | |||
sql.setDriver(props.getProperty(DRIVER)); | |||
sql.setUserid(props.getProperty(USER)); | |||
sql.setPassword(props.getProperty(PASSWORD)); | |||
sql.setUrl(props.getProperty(URL)); | |||
sql.createClasspath().setLocation(new File(props.getProperty(PATH))); | |||
sql.addText(props.getProperty(SQL)); | |||
return sql; | |||
} | |||
@@ -157,7 +157,7 @@ public class SQLExecTest { | |||
* try to find the path from a resource (jar file or directory name) | |||
* so that it can be used as a classpath to load the resource. | |||
*/ | |||
protected String findResourcePath(String resource){ | |||
protected String findResourcePath(String resource) { | |||
resource = resource.replace('.', '/') + ".class"; | |||
URL url = getClass().getClassLoader().getResource(resource); | |||
if (url == null) { | |||
@@ -180,9 +180,9 @@ public class SQLExecTest { | |||
* tweak this to make it run or add your own database. | |||
* The driver lib should be dropped into the system classloader. | |||
*/ | |||
protected Properties getProperties(int database){ | |||
protected Properties getProperties(int database) { | |||
Properties props = null; | |||
switch (database){ | |||
switch (database) { | |||
case ORACLE: | |||
props = getProperties("oracle.jdbc.driver.OracleDriver", "test", "test", "jdbc:oracle:thin:@127.0.0.1:1521:orcl"); | |||
break; | |||
@@ -201,7 +201,7 @@ public class SQLExecTest { | |||
} | |||
/** helper method to build properties */ | |||
protected Properties getProperties(String driver, String user, String pwd, String url){ | |||
protected Properties getProperties(String driver, String user, String pwd, String url) { | |||
Properties props = new Properties(); | |||
props.put(DRIVER, driver); | |||
props.put(USER, user); | |||
@@ -33,8 +33,7 @@ public class SleepTest { | |||
public final BuildFileRule buildRule = new BuildFileRule(); | |||
private final static String TASKDEFS_DIR = "src/etc/testcases/taskdefs/"; | |||
private final static int ERROR_RANGE=1000; | |||
private final static int ERROR_RANGE = 1000; | |||
@Before | |||
public void setUp() { | |||
@@ -43,34 +42,34 @@ public class SleepTest { | |||
@Test | |||
public void test1() { | |||
Timer timer=new Timer(); | |||
Timer timer = new Timer(); | |||
buildRule.executeTarget("test1"); | |||
timer.stop(); | |||
assertTrue(timer.time()>=0); | |||
assertTrue(timer.time() >= 0); | |||
} | |||
@Test | |||
public void test2() { | |||
Timer timer=new Timer(); | |||
Timer timer = new Timer(); | |||
buildRule.executeTarget("test2"); | |||
timer.stop(); | |||
assertTrue(timer.time()>=0); | |||
assertTrue(timer.time() >= 0); | |||
} | |||
@Test | |||
public void test3() { | |||
Timer timer=new Timer(); | |||
Timer timer = new Timer(); | |||
buildRule.executeTarget("test3"); | |||
timer.stop(); | |||
assertTrue(timer.time()>=(2000-ERROR_RANGE)); | |||
assertTrue(timer.time() >= (2000 - ERROR_RANGE)); | |||
} | |||
@Test | |||
public void test4() { | |||
Timer timer=new Timer(); | |||
Timer timer = new Timer(); | |||
buildRule.executeTarget("test3"); | |||
timer.stop(); | |||
assertTrue(timer.time()>=(2000-ERROR_RANGE) && timer.time()<60000); | |||
assertTrue(timer.time() >= (2000 - ERROR_RANGE) && timer.time() < 60000); | |||
} | |||
@Test | |||
@@ -85,10 +84,10 @@ public class SleepTest { | |||
@Test | |||
public void test6() { | |||
Timer timer=new Timer(); | |||
Timer timer = new Timer(); | |||
buildRule.executeTarget("test6"); | |||
timer.stop(); | |||
assertTrue(timer.time()<2000); | |||
assertTrue(timer.time() < 2000); | |||
} | |||
@@ -96,23 +95,23 @@ public class SleepTest { | |||
* inner timer class | |||
*/ | |||
private static class Timer { | |||
long start=0; | |||
long stop=0; | |||
long start = 0; | |||
long stop = 0; | |||
public Timer() { | |||
start(); | |||
} | |||
public void start() { | |||
start=System.currentTimeMillis(); | |||
start = System.currentTimeMillis(); | |||
} | |||
public void stop() { | |||
stop=System.currentTimeMillis(); | |||
stop = System.currentTimeMillis(); | |||
} | |||
public long time() { | |||
return stop-start; | |||
return stop - start; | |||
} | |||
} | |||
@@ -64,7 +64,7 @@ public class StyleTest { | |||
public void testTransferParameterSet() throws Exception { | |||
expectFileContains("testTransferParameterSet", // target | |||
buildRule.getOutputDir().getAbsoluteFile() + "/out.xml", // file | |||
"set='myvalue'"); // exptected string | |||
"set='myvalue'"); // expected string | |||
} | |||
@Test | |||
@@ -207,8 +207,7 @@ public class StyleTest { | |||
private void expectFileContains( | |||
String target, String filename, String contains) | |||
throws IOException | |||
{ | |||
throws IOException { | |||
buildRule.executeTarget(target); | |||
assertFileContains(filename, contains); | |||
} | |||
@@ -84,7 +84,7 @@ public class SubAntTest { | |||
}); | |||
} | |||
@Test | |||
public void testMultipleTargets() { | |||
buildRule.executeTarget("multipleTargets"); | |||
@@ -93,13 +93,13 @@ public class SubAntTest { | |||
assertContains("test2-one", buildRule.getLog()); | |||
assertContains("test2-two", buildRule.getLog()); | |||
} | |||
@Test | |||
public void testMultipleTargetsOneDoesntExist_FOEfalse() { | |||
buildRule.executeTarget("multipleTargetsOneDoesntExist_FOEfalse"); | |||
assertContains("Target \"three\" does not exist in the project \"subant\"", buildRule.getLog()); | |||
} | |||
@Test | |||
public void testMultipleTargetsOneDoesntExist_FOEtrue() { | |||
try { | |||
@@ -130,12 +130,23 @@ public class SubAntTest { | |||
expectedBasedirs = dirs; | |||
} | |||
public void buildStarted(BuildEvent event) {} | |||
public void buildFinished(BuildEvent event) {} | |||
public void targetFinished(BuildEvent event){} | |||
public void taskStarted(BuildEvent event) {} | |||
public void taskFinished(BuildEvent event) {} | |||
public void messageLogged(BuildEvent event) {} | |||
public void buildStarted(BuildEvent event) { | |||
} | |||
public void buildFinished(BuildEvent event) { | |||
} | |||
public void targetFinished(BuildEvent event) { | |||
} | |||
public void taskStarted(BuildEvent event) { | |||
} | |||
public void taskFinished(BuildEvent event) { | |||
} | |||
public void messageLogged(BuildEvent event) { | |||
} | |||
public void targetStarted(BuildEvent event) { | |||
if (event.getTarget().getName().equals("")) { | |||
@@ -17,13 +17,13 @@ | |||
*/ | |||
package org.apache.tools.ant.taskdefs; | |||
import java.text.SimpleDateFormat; | |||
import java.util.Calendar; | |||
import java.util.TimeZone; | |||
import java.util.Date; | |||
import java.text.SimpleDateFormat; | |||
import java.util.TimeZone; | |||
import org.apache.tools.ant.Project; | |||
import org.apache.tools.ant.Location; | |||
import org.apache.tools.ant.Project; | |||
import org.junit.Before; | |||
import org.junit.Test; | |||
@@ -59,7 +59,7 @@ public class TStampTest { | |||
String today = project.getProperty("today"); | |||
SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss z"); | |||
sdf.setTimeZone( TimeZone.getTimeZone("GMT") ); | |||
sdf.setTimeZone(TimeZone.getTimeZone("GMT")); | |||
String expected = sdf.format(date); | |||
assertEquals(expected, today); | |||
@@ -68,7 +68,7 @@ public class TStampTest { | |||
/** | |||
* verifies that custom props have priority over the | |||
* originals | |||
* @throws Exception | |||
* @throws Exception if something goes wrong | |||
*/ | |||
@Test | |||
public void testWriteOrder() throws Exception { | |||
@@ -81,7 +81,7 @@ public class TStampTest { | |||
String today = project.getProperty("TODAY"); | |||
SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss z"); | |||
sdf.setTimeZone( TimeZone.getTimeZone("GMT") ); | |||
sdf.setTimeZone(TimeZone.getTimeZone("GMT")); | |||
String expected = sdf.format(date); | |||
assertEquals(expected, today); | |||
@@ -91,13 +91,13 @@ public class TStampTest { | |||
/** | |||
* verifies that custom props have priority over the | |||
* originals | |||
* @throws Exception | |||
* @throws Exception if something goes wrong | |||
*/ | |||
@Test | |||
public void testPrefix() throws Exception { | |||
tstamp.setPrefix("prefix"); | |||
tstamp.execute(); | |||
String prop= project.getProperty("prefix.DSTAMP"); | |||
String prop = project.getProperty("prefix.DSTAMP"); | |||
assertNotNull(prop); | |||
} | |||
@@ -110,7 +110,7 @@ public class TStampTest { | |||
tstamp.setPrefix("prefix"); | |||
tstamp.execute(); | |||
String prop= project.getProperty("prefix.format"); | |||
String prop = project.getProperty("prefix.format"); | |||
assertNotNull(prop); | |||
} | |||
@@ -165,7 +165,7 @@ public class TarTest { | |||
File f1 | |||
= new File(buildRule.getProject().getProperty("output"), "untar/test8.xml"); | |||
if (! f1.exists()) { | |||
fail("The fullpath attribute or the preserveLeadingSlashes attribute does not work propertly"); | |||
fail("The fullpath attribute or the preserveLeadingSlashes attribute does not work properly"); | |||
} | |||
} | |||
@@ -185,7 +185,7 @@ public class TarTest { | |||
File f1 | |||
= new File(buildRule.getProject().getProperty("output"), "untar/test10.xml"); | |||
if (! f1.exists()) { | |||
fail("The fullpath attribute or the preserveLeadingSlashes attribute does not work propertly"); | |||
fail("The fullpath attribute or the preserveLeadingSlashes attribute does not work properly"); | |||
} | |||
} | |||
@@ -195,7 +195,7 @@ public class TarTest { | |||
File f1 | |||
= new File(buildRule.getProject().getProperty("output"), "untar/test11.xml"); | |||
if (! f1.exists()) { | |||
fail("The fullpath attribute or the preserveLeadingSlashes attribute does not work propertly"); | |||
fail("The fullpath attribute or the preserveLeadingSlashes attribute does not work properly"); | |||
} | |||
} | |||
@@ -24,23 +24,17 @@ import org.junit.internal.AssumptionViolatedException; | |||
* Interactive Testcase for Processdestroyer. | |||
* | |||
*/ | |||
public class TestProcess | |||
implements Runnable | |||
{ | |||
public class TestProcess implements Runnable { | |||
private boolean run = true; | |||
private boolean done = false; | |||
public void shutdown() | |||
{ | |||
if (!done) | |||
{ | |||
public void shutdown() { | |||
if (!done) { | |||
System.out.println("shutting down TestProcess"); | |||
run = false; | |||
synchronized(this) | |||
{ | |||
while (!done) | |||
{ | |||
synchronized (this) { | |||
while (!done) { | |||
try { | |||
wait(); | |||
} catch (InterruptedException ie) { | |||
@@ -53,10 +47,8 @@ public class TestProcess | |||
} | |||
} | |||
public void run() | |||
{ | |||
for (int i = 0; i < 5 && run; i++) | |||
{ | |||
public void run() { | |||
for (int i = 0; i < 5 && run; i++) { | |||
System.out.println(Thread.currentThread().getName()); | |||
try { | |||
@@ -66,29 +58,23 @@ public class TestProcess | |||
} | |||
} | |||
synchronized(this) | |||
{ | |||
synchronized (this) { | |||
done = true; | |||
notifyAll(); | |||
} | |||
} | |||
public Thread getShutdownHook() | |||
{ | |||
public Thread getShutdownHook() { | |||
return new TestProcessShutdownHook(); | |||
} | |||
private class TestProcessShutdownHook | |||
extends Thread | |||
{ | |||
public void run() | |||
{ | |||
private class TestProcessShutdownHook extends Thread { | |||
public void run() { | |||
shutdown(); | |||
} | |||
} | |||
public static void main(String[] args) | |||
{ | |||
public static void main(String[] args) { | |||
TestProcess tp = new TestProcess(); | |||
new Thread(tp, "TestProcess thread").start(); | |||
Runtime.getRuntime().addShutdownHook(tp.getShutdownHook()); | |||
@@ -33,7 +33,7 @@ import static org.junit.Assert.assertTrue; | |||
import static org.junit.Assert.fail; | |||
public class TouchTest { | |||
@Rule | |||
public final BuildFileRule buildRule = new BuildFileRule(); | |||
@@ -56,7 +56,7 @@ public class TouchTest { | |||
public long getTargetTime() { | |||
File file = new File(System.getProperty("root"), TOUCH_FILE); | |||
if(!file.exists()) { | |||
if (!file.exists()) { | |||
throw new BuildException("failed to touch file " + file); | |||
} | |||
return file.lastModified(); | |||
@@ -94,7 +94,7 @@ public class TouchTest { | |||
*/ | |||
@Test | |||
public void testNow() { | |||
long now=System.currentTimeMillis(); | |||
long now = System.currentTimeMillis(); | |||
buildRule.executeTarget("testNow"); | |||
long time = getTargetTime(); | |||
assertTimesNearlyMatch(time,now,5000); | |||
@@ -179,8 +179,8 @@ public class TouchTest { | |||
/** | |||
* run a target to touch the test file; verify the timestamp is as expected | |||
* @param targetName | |||
* @param timestamp | |||
* @param targetName String | |||
* @param timestamp long | |||
*/ | |||
private void touchFile(String targetName, long timestamp) { | |||
buildRule.executeTarget(targetName); | |||
@@ -190,8 +190,8 @@ public class TouchTest { | |||
/** | |||
* assert that two times are within the current FS granularity; | |||
* @param timestamp | |||
* @param time | |||
* @param timestamp long | |||
* @param time long | |||
*/ | |||
public void assertTimesNearlyMatch(long timestamp,long time) { | |||
long granularity= FILE_UTILS.getFileTimestampGranularity(); | |||
@@ -200,9 +200,9 @@ public class TouchTest { | |||
/** | |||
* assert that two times are within a specified range | |||
* @param timestamp | |||
* @param time | |||
* @param range | |||
* @param timestamp long | |||
* @param time long | |||
* @param range long | |||
*/ | |||
private void assertTimesNearlyMatch(long timestamp, long time, long range) { | |||
assertTrue("Time " + timestamp + " is not within " + range + " ms of " | |||
@@ -20,8 +20,8 @@ package org.apache.tools.ant.taskdefs; | |||
import java.lang.reflect.Method; | |||
import org.apache.tools.ant.BuildFileRule; | |||
import org.apache.tools.ant.BuildException; | |||
import org.apache.tools.ant.BuildFileRule; | |||
import org.apache.tools.ant.Project; | |||
import org.apache.tools.ant.Task; | |||
import org.apache.tools.ant.TypeAdapter; | |||
@@ -116,8 +116,7 @@ public class TypeAdapterTest { | |||
} | |||
public static class RunnableAdapter | |||
extends Task implements TypeAdapter | |||
{ | |||
extends Task implements TypeAdapter { | |||
private String execMethodName = "run"; | |||
private Object proxy; | |||
@@ -128,14 +127,12 @@ public class TypeAdapterTest { | |||
String message = | |||
"return type of " + execMethodName + "() should be " | |||
+ "void but was \"" + execMethod.getReturnType() + | |||
"\" in " | |||
+ proxyClass; | |||
"\" in " + proxyClass; | |||
log(message, Project.MSG_WARN); | |||
} | |||
return execMethod; | |||
} catch (NoSuchMethodException e) { | |||
String message = "No public "+ execMethodName + | |||
"() method in " | |||
String message = "No public " + execMethodName + "() method in " | |||
+ proxyClass; | |||
log(message, Project.MSG_ERR); | |||
throw new BuildException(message); | |||
@@ -113,7 +113,7 @@ public class TypedefTest { | |||
} | |||
@Test | |||
public void testNoResourceOnErrorFailAll(){ | |||
public void testNoResourceOnErrorFailAll() { | |||
try { | |||
buildRule.executeTarget("noresourcefailall"); | |||
fail("BuildException expected: the requested resource does not exist"); | |||
@@ -123,13 +123,13 @@ public class TypedefTest { | |||
} | |||
@Test | |||
public void testNoResourceOnErrorFail(){ | |||
public void testNoResourceOnErrorFail() { | |||
buildRule.executeTarget("noresourcefail"); | |||
assertContains("Could not load definitions from resource ", buildRule.getLog()); | |||
} | |||
@Test | |||
public void testNoResourceOnErrorNotFail(){ | |||
public void testNoResourceOnErrorNotFail() { | |||
buildRule.executeTarget("noresourcenotfail"); | |||
assertContains("Could not load definitions from resource ", buildRule.getLog()); | |||
} | |||
@@ -25,6 +25,7 @@ import org.junit.Rule; | |||
import org.junit.Test; | |||
import java.io.File; | |||
import java.io.IOException; | |||
import static org.junit.Assert.assertEquals; | |||
import static org.junit.Assert.assertFalse; | |||
@@ -43,32 +44,32 @@ public class UntarTest { | |||
} | |||
@Test | |||
public void testRealTest() throws java.io.IOException { | |||
public void testRealTest() throws IOException { | |||
testLogoExtraction("realTest"); | |||
} | |||
@Test | |||
public void testRealGzipTest() throws java.io.IOException { | |||
public void testRealGzipTest() throws IOException { | |||
testLogoExtraction("realGzipTest"); | |||
} | |||
@Test | |||
public void testRealBzip2Test() throws java.io.IOException { | |||
public void testRealBzip2Test() throws IOException { | |||
testLogoExtraction("realBzip2Test"); | |||
} | |||
@Test | |||
public void testTestTarTask() throws java.io.IOException { | |||
public void testTestTarTask() throws IOException { | |||
testLogoExtraction("testTarTask"); | |||
} | |||
@Test | |||
public void testTestGzipTarTask() throws java.io.IOException { | |||
public void testTestGzipTarTask() throws IOException { | |||
testLogoExtraction("testGzipTarTask"); | |||
} | |||
@Test | |||
public void testTestBzip2TarTask() throws java.io.IOException { | |||
public void testTestBzip2TarTask() throws IOException { | |||
testLogoExtraction("testBzip2TarTask"); | |||
} | |||
@@ -91,11 +92,11 @@ public class UntarTest { | |||
} | |||
@Test | |||
public void testResourceCollection() throws java.io.IOException { | |||
public void testResourceCollection() throws IOException { | |||
testLogoExtraction("resourceCollection"); | |||
} | |||
private void testLogoExtraction(String target) throws java.io.IOException { | |||
private void testLogoExtraction(String target) throws IOException { | |||
buildRule.executeTarget(target); | |||
assertEquals(FileUtilities.getFileContents(buildRule.getProject().resolveFile("../asf-logo.gif")), | |||
FileUtilities.getFileContents(new File(buildRule.getProject().getProperty("output"), "untar/asf-logo.gif"))); | |||
@@ -74,14 +74,14 @@ public class UnzipTest { | |||
@Test | |||
public void testRealTest() throws java.io.IOException { | |||
public void testRealTest() throws IOException { | |||
buildRule.executeTarget("realTest"); | |||
assertLogoUncorrupted(); | |||
} | |||
/** | |||
* test that the logo gif file has not been corrupted | |||
* @throws IOException | |||
* @throws IOException if something goes wrong | |||
*/ | |||
private void assertLogoUncorrupted() throws IOException { | |||
assertEquals(FileUtilities.getFileContents(buildRule.getProject().resolveFile("../asf-logo.gif")), | |||
@@ -90,13 +90,13 @@ public class UnzipTest { | |||
} | |||
@Test | |||
public void testTestZipTask() throws java.io.IOException { | |||
public void testTestZipTask() throws IOException { | |||
buildRule.executeTarget("testZipTask"); | |||
assertLogoUncorrupted(); | |||
} | |||
@Test | |||
public void testTestUncompressedZipTask() throws java.io.IOException { | |||
public void testTestUncompressedZipTask() throws IOException { | |||
buildRule.executeTarget("testUncompressedZipTask"); | |||
assertLogoUncorrupted(); | |||
} | |||
@@ -204,7 +204,7 @@ public class UnzipTest { | |||
} | |||
/** | |||
* assert that a file doesnt exist, relative to the project | |||
* assert that a file doesn't exist, relative to the project | |||
* | |||
* @param message message if there is no mpatch | |||
* @param filename filename to resolve against the project | |||
@@ -43,7 +43,7 @@ public class UpToDateTest { | |||
File srcDir = buildRule.getProject().resolveFile("source"); | |||
assumeTrue("Could not change modification timestamp of source directory", | |||
srcDir.setLastModified(srcDir.lastModified() | |||
- (3 * FileUtils.getFileUtils().getFileTimestampGranularity()))); | |||
- 3 * FileUtils.getFileUtils().getFileTimestampGranularity())); | |||
} | |||
@After | |||
@@ -79,7 +79,7 @@ public class XmlPropertyTest { | |||
} | |||
@Test | |||
public void testNone () throws IOException { | |||
public void testNone() throws IOException { | |||
doTest("testNone", false, false, false, false, false); | |||
} | |||
@@ -89,47 +89,47 @@ public class XmlPropertyTest { | |||
} | |||
@Test | |||
public void testCollapse () throws IOException { | |||
public void testCollapse() throws IOException { | |||
doTest("testCollapse", false, true, false, false, false); | |||
} | |||
@Test | |||
public void testSemantic () throws IOException { | |||
public void testSemantic() throws IOException { | |||
doTest("testSemantic", false, false, true, false, false); | |||
} | |||
@Test | |||
public void testKeeprootCollapse () throws IOException { | |||
public void testKeeprootCollapse() throws IOException { | |||
doTest("testKeeprootCollapse", true, true, false, false, false); | |||
} | |||
@Test | |||
public void testKeeprootSemantic () throws IOException { | |||
public void testKeeprootSemantic() throws IOException { | |||
doTest("testKeeprootSemantic", true, false, true, false, false); | |||
} | |||
@Test | |||
public void testCollapseSemantic () throws IOException { | |||
public void testCollapseSemantic() throws IOException { | |||
doTest("testCollapseSemantic", false, true, true, false, false); | |||
} | |||
@Test | |||
public void testKeeprootCollapseSemantic () throws IOException { | |||
public void testKeeprootCollapseSemantic() throws IOException { | |||
doTest("testKeeprootCollapseSemantic", true, true, true, false, false); | |||
} | |||
@Test | |||
public void testInclude () throws IOException { | |||
public void testInclude() throws IOException { | |||
doTest("testInclude", false, false, false, true, false); | |||
} | |||
@Test | |||
public void testSemanticInclude () throws IOException { | |||
public void testSemanticInclude() throws IOException { | |||
doTest("testSemanticInclude", false, false, true, true, false); | |||
} | |||
@Test | |||
public void testSemanticLocal () throws IOException { | |||
public void testSemanticLocal() throws IOException { | |||
doTest("testSemanticInclude", false, false, true, false, true); | |||
} | |||
@@ -152,7 +152,7 @@ public class XmlPropertyTest { | |||
// What's the working directory? If local, then its the | |||
// folder of the input file. Otherwise, its the "current" dir.. | |||
File workingDir; | |||
if ( localRoot ) { | |||
if (localRoot) { | |||
workingDir = inputFile.getParentFile(); | |||
} else { | |||
workingDir = FILE_UTILS.resolveFile(new File("."), "."); | |||
@@ -206,13 +206,13 @@ public class XmlPropertyTest { | |||
* but some other properties may get set in the XmlProperty due | |||
* to generic Project/Task configuration. | |||
*/ | |||
private static void ensureProperties (String msg, File inputFile, | |||
private static void ensureProperties(String msg, File inputFile, | |||
File workingDir, Project p, | |||
Properties properties) { | |||
Hashtable xmlproperties = p.getProperties(); | |||
// Every key identified by the Properties must have been loaded. | |||
Enumeration propertyKeyEnum = properties.propertyNames(); | |||
while(propertyKeyEnum.hasMoreElements()){ | |||
Enumeration<?> propertyKeyEnum = properties.propertyNames(); | |||
while (propertyKeyEnum.hasMoreElements()) { | |||
String currentKey = propertyKeyEnum.nextElement().toString(); | |||
String assertMsg = msg + "-" + inputFile.getName() | |||
+ " Key=" + currentKey; | |||
@@ -227,10 +227,9 @@ public class XmlPropertyTest { | |||
// that the object was created with the given id. | |||
// We don't have an adequate way of testing the actual | |||
// *value* of the Path object, though... | |||
String id = currentKey; | |||
Object obj = p.getReferences().get(id); | |||
Object obj = p.getReferences().get(currentKey); | |||
if ( obj == null ) { | |||
if (obj == null) { | |||
fail(assertMsg + " Object ID does not exist."); | |||
} | |||
@@ -286,13 +285,10 @@ public class XmlPropertyTest { | |||
String currentKey = referenceKeyEnum.nextElement().toString(); | |||
Object currentValue = references.get(currentKey); | |||
if (currentValue instanceof Path) { | |||
} else if (currentValue instanceof String) { | |||
} else { | |||
if( ! currentKey.startsWith("ant.") ) { | |||
fail(msg + "-" + inputFile.getName() + " Key=" | |||
+ currentKey + " is not a recognized type."); | |||
} | |||
if (!(currentValue instanceof Path) && !(currentValue instanceof String) | |||
&& !currentKey.startsWith("ant.")) { | |||
fail(msg + "-" + inputFile.getName() + " Key=" | |||
+ currentKey + " is not a recognized type."); | |||
} | |||
} | |||
} | |||
@@ -301,7 +297,7 @@ public class XmlPropertyTest { | |||
* Munge the name of the input file to find an appropriate goldfile, | |||
* based on hardwired naming conventions. | |||
*/ | |||
private static File getGoldfile (File input, boolean keepRoot, | |||
private static File getGoldfile(File input, boolean keepRoot, | |||
boolean collapse, boolean semantic, | |||
boolean include, boolean localRoot) { | |||
// Substitute .xml with .properties | |||
@@ -358,14 +354,13 @@ public class XmlPropertyTest { | |||
return true; | |||
} else { | |||
return (file.getPath().indexOf("taskdefs") > 0 && | |||
file.getPath().toLowerCase().endsWith(".xml") ); | |||
file.getPath().toLowerCase().endsWith(".xml")); | |||
} | |||
} | |||
}; | |||
File[] files = startingDir.listFiles(filter); | |||
for (int i=0;i<files.length;i++) { | |||
File f = files[i]; | |||
for (File f : files) { | |||
if (!f.isDirectory()) { | |||
collect.addElement(f); | |||
} else { | |||
@@ -20,13 +20,12 @@ package org.apache.tools.ant.taskdefs; | |||
import java.io.ByteArrayInputStream; | |||
import java.io.File; | |||
import java.io.InputStream; | |||
import java.io.IOException; | |||
import java.io.InputStream; | |||
import java.util.Collections; | |||
import java.util.Iterator; | |||
import org.apache.tools.ant.types.Resource; | |||
import org.apache.tools.ant.types.ResourceCollection; | |||
import org.apache.tools.ant.types.resources.ZipResource; | |||
import org.apache.tools.zip.JarMarker; | |||
@@ -82,8 +81,12 @@ public class ZipExtraFieldTest { | |||
} | |||
}; | |||
testInstance.add(new ResourceCollection() { | |||
public boolean isFilesystemOnly() { return false; } | |||
public int size() { return 1; } | |||
public boolean isFilesystemOnly() { | |||
return false; | |||
} | |||
public int size() { | |||
return 1; | |||
} | |||
public Iterator<Resource> iterator() { | |||
return Collections.<Resource>singleton(r).iterator(); | |||
} | |||
@@ -101,7 +101,7 @@ public class ZipTest { | |||
@After | |||
public void tearDown() { | |||
try { | |||
if ( zfPrefixAddsDir != null) { | |||
if (zfPrefixAddsDir != null) { | |||
zfPrefixAddsDir.close(); | |||
} | |||
@@ -189,21 +189,25 @@ public class ZipTest { | |||
public void testEmptySkip() { | |||
buildRule.executeTarget("testEmptySkip"); | |||
} | |||
// Bugzilla Report 30365 | |||
@Test | |||
public void testZipEmptyDir() { | |||
buildRule.executeTarget("zipEmptyDir"); | |||
} | |||
// Bugzilla Report 40258 | |||
@Test | |||
public void testZipEmptyDirFilesOnly() { | |||
buildRule.executeTarget("zipEmptyDirFilesOnly"); | |||
} | |||
@Test | |||
public void testZipEmptyCreate() { | |||
buildRule.executeTarget("zipEmptyCreate"); | |||
assertContains("Note: creating empty", buildRule.getLog()); | |||
} | |||
// Bugzilla Report 25513 | |||
@Test | |||
public void testCompressionLevel() { | |||
@@ -40,7 +40,7 @@ import static org.junit.Assert.assertEquals; | |||
public class DefaultCompilerAdapterTest { | |||
private static class LogCapturingJavac extends Javac { | |||
private StringBuffer sb = new StringBuffer(); | |||
private StringBuilder sb = new StringBuilder(); | |||
public void log(String msg, int msgLevel) { | |||
sb.append(msg); | |||
} | |||
@@ -58,7 +58,9 @@ public class DefaultCompilerAdapterTest { | |||
return cmd; | |||
} | |||
public boolean execute() { return false; } | |||
public boolean execute() { | |||
return false; | |||
} | |||
/** | |||
* public to avoid classloader issues. | |||
@@ -70,7 +72,9 @@ public class DefaultCompilerAdapterTest { | |||
private static class SourceTargetHelperNoOverride extends DefaultCompilerAdapter { | |||
public boolean execute() { return false; } | |||
public boolean execute() { | |||
return false; | |||
} | |||
/** | |||
* public to avoid classloader issues. | |||
@@ -355,6 +359,7 @@ public class DefaultCompilerAdapterTest { | |||
src.mkdir(); | |||
final File java1 = createFile(src,"main/m1/lin/classes/org/apache/ant/tests/J1.java"); | |||
final File java2 = createFile(src,"main/m3/sol/classes/org/apache/ant/tests/J2.java"); | |||
@SuppressWarnings("unused") | |||
final File java3 = createFile(src,"main/m3/sol/classes/org/apache/ant/invisible/J3.java"); | |||
final File build = new File(workDir, "build"); | |||
build.mkdirs(); | |||
@@ -498,7 +503,7 @@ public class DefaultCompilerAdapterTest { | |||
final File destDir = new File(tmp, String.format("%s%s%d", | |||
getClass().getName(), | |||
testName, | |||
System.currentTimeMillis()/1000)); | |||
System.currentTimeMillis() / 1000)); | |||
destDir.mkdirs(); | |||
return destDir; | |||
} | |||
@@ -68,7 +68,7 @@ public class IsReachableTest { | |||
try { | |||
buildRule.executeTarget("testBoth"); | |||
fail("Build exception expected: error on two targets"); | |||
} catch(BuildException ex) { | |||
} catch (BuildException ex) { | |||
assertEquals(IsReachable.ERROR_BOTH_TARGETS, ex.getMessage()); | |||
} | |||
} | |||
@@ -78,7 +78,7 @@ public class IsReachableTest { | |||
try { | |||
buildRule.executeTarget("testNoTargets"); | |||
fail("Build exception expected: no params"); | |||
} catch(BuildException ex) { | |||
} catch (BuildException ex) { | |||
assertEquals(IsReachable.ERROR_NO_HOSTNAME, ex.getMessage()); | |||
} | |||
} | |||
@@ -88,7 +88,7 @@ public class IsReachableTest { | |||
try { | |||
buildRule.executeTarget("testBadTimeout"); | |||
fail("Build exception expected: error on -ve timeout"); | |||
} catch(BuildException ex) { | |||
} catch (BuildException ex) { | |||
assertEquals(IsReachable.ERROR_BAD_TIMEOUT, ex.getMessage()); | |||
} | |||
} | |||
@@ -99,7 +99,7 @@ public class IsReachableTest { | |||
try { | |||
buildRule.executeTarget("testFile"); | |||
fail("Build exception expected: error on file URL"); | |||
} catch(BuildException ex) { | |||
} catch (BuildException ex) { | |||
assertEquals(IsReachable.ERROR_NO_HOST_IN_URL, ex.getMessage()); | |||
} | |||
} | |||
@@ -29,7 +29,7 @@ import static org.junit.Assert.assertEquals; | |||
import static org.junit.Assert.fail; | |||
/** | |||
*/ | |||
public class ParserSupportsTest { | |||
@@ -20,9 +20,9 @@ package org.apache.tools.ant.taskdefs.cvslib; | |||
import org.junit.Test; | |||
import java.util.Calendar; | |||
import java.util.Date; | |||
import java.util.Locale; | |||
import java.util.TimeZone; | |||
import java.util.Date; | |||
import static org.junit.Assert.assertEquals; | |||
@@ -17,21 +17,21 @@ | |||
*/ | |||
package org.apache.tools.ant.taskdefs.cvslib; | |||
import java.util.Date; | |||
import java.io.PrintWriter; | |||
import java.io.OutputStreamWriter; | |||
import java.io.ByteArrayOutputStream; | |||
import java.io.ByteArrayInputStream; | |||
import java.io.ByteArrayOutputStream; | |||
import java.io.InputStream; | |||
import java.io.OutputStreamWriter; | |||
import java.io.PrintWriter; | |||
import java.util.Date; | |||
import org.apache.tools.ant.util.JAXPUtils; | |||
import org.junit.Test; | |||
import org.xml.sax.XMLReader; | |||
import org.xml.sax.InputSource; | |||
import org.xml.sax.Attributes; | |||
import org.xml.sax.ContentHandler; | |||
import org.xml.sax.SAXException; | |||
import org.xml.sax.InputSource; | |||
import org.xml.sax.Locator; | |||
import org.xml.sax.Attributes; | |||
import org.xml.sax.SAXException; | |||
import org.xml.sax.XMLReader; | |||
/** | |||
* Test for the cvslib ChangeLogWriter | |||
@@ -65,11 +65,12 @@ public class ChangeLogWriterTest { | |||
public void startDocument() throws SAXException { | |||
} | |||
public void characters(char ch[], int start, int length) throws SAXException { | |||
public void characters(char[] ch, int start, int length) throws SAXException { | |||
@SuppressWarnings("unused") | |||
String debug = new String(ch, start, length); | |||
} | |||
public void ignorableWhitespace(char ch[], int start, int length) throws SAXException { | |||
public void ignorableWhitespace(char[] ch, int start, int length) throws SAXException { | |||
} | |||
public void endPrefixMapping(String prefix) throws SAXException { | |||
@@ -24,14 +24,14 @@ public class A { | |||
System.out.println(a); | |||
} | |||
static A a=new A(); | |||
static A a = new A(); | |||
static { | |||
System.out.println("A CLASS INITIALIZATION"); | |||
} | |||
protected static void setA(A oa) { | |||
a=oa; | |||
a = oa; | |||
} | |||
public String toString() { | |||