youys
/
ant
Not watched
1
0
Fork 1
Code
Releases 0 Wiki Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain
Browse Source

attack of the tab police 

git-svn-id: https://svn.apache.org/repos/asf/ant/core/trunk@271645 13f79535-47bb-0310-9956-ffa450edef68
master
Steve Loughran 23 years ago
parent
0c3b95004d
commit
4f7581e3df
2 changed files with 144 additions and 129 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +18
    -3
      build.xml
  2. +126
    -126
      src/testcases/org/apache/tools/ant/taskdefs/ExecuteWatchdogTest.java

+ 18
- 3
build.xml View File

@@ -433,6 +433,7 @@
</condition>
</target>


<!--
===================================================================
Prepare the build
@@ -1084,6 +1085,20 @@
<java classname="org.apache.env.Which" taskname="which"/>
</target>

<!-- test to see if we are online or not. can take a while when we are off line, so
setting the property is a good shortcut-->
<target name="probe-offline">
<condition property="offline">
<or>
<isset property="offline"/>
<not>
<http url="http://www.apache.org/"/>
</not>
</or>
</condition>
<echo level="verbose" > offline=${offline}</echo>
</target>
<!--
===================================================================
Run testcase
@@ -1091,7 +1106,7 @@
-->
<target name="test" depends="run-tests" description="--> run JUnit tests"/>

<target name="run-tests" depends="dump-info,compile-tests" if="junit.present">
<target name="run-tests" depends="dump-info,compile-tests,probe-offline" if="junit.present">

<junit printsummary="${junit.summary}" haltonfailure="yes"
filtertrace="${junit.filtertrace}"
@@ -1137,8 +1152,8 @@
<patternset refid="needs.xslp" />

<!-- tests excluded if the test is run in offline mode -->
<patternset refid="onlinetests"/>
<patternset refid="onlinetests"/>
<!-- runtime dependencies that are different from compile
time dependencies -->
<exclude name="${optional.package}/ReplaceRegExpTest.java"


+ 126
- 126
src/testcases/org/apache/tools/ant/taskdefs/ExecuteWatchdogTest.java View File

@@ -67,33 +67,33 @@ import java.io.*;
*/
public class ExecuteWatchdogTest extends TestCase {

private final static int TIME_OUT = 5000;
private final static int TIME_OUT = 5000;

private final static String TEST_CLASSPATH = getTestClassPath();
private final static String TEST_CLASSPATH = getTestClassPath();

private final static int CLOCK_ERROR=200;
private final static int TIME_OUT_TEST=TIME_OUT-CLOCK_ERROR;
private ExecuteWatchdog watchdog;
public ExecuteWatchdogTest(String name) {
super(name);
}
protected void setUp(){
watchdog = new ExecuteWatchdog(TIME_OUT);
}
/**
* Dangerous method to obtain the classpath for the test. This is
* severely tighted to the build.xml properties.
*/
private static String getTestClassPath(){
String classpath = System.getProperty("build.tests");
if (classpath == null) {
System.err.println("WARNING: 'build.tests' property is not available !");
classpath = System.getProperty("java.class.path");
}
private ExecuteWatchdog watchdog;
public ExecuteWatchdogTest(String name) {
super(name);
}
protected void setUp(){
watchdog = new ExecuteWatchdog(TIME_OUT);
}
/**
* Dangerous method to obtain the classpath for the test. This is
* severely tighted to the build.xml properties.
*/
private static String getTestClassPath(){
String classpath = System.getProperty("build.tests");
if (classpath == null) {
System.err.println("WARNING: 'build.tests' property is not available !");
classpath = System.getProperty("java.class.path");
}

// JDK 1.1 needs classes.zip in -classpath argument
if (Project.getJavaVersion() == Project.JAVA_1_1) {
@@ -103,108 +103,108 @@ public class ExecuteWatchdogTest extends TestCase {
+ File.separator + "classes.zip";
}

return classpath;
}
private Process getProcess(int timetorun) throws Exception {
String[] cmdArray = {
"java", "-classpath", TEST_CLASSPATH,
TimeProcess.class.getName(), String.valueOf(timetorun)
};
//System.out.println("Testing with classpath: " + System.getProperty("java.class.path"));
return Runtime.getRuntime().exec(cmdArray);
}
private String getErrorOutput(Process p) throws Exception {
BufferedReader err = new BufferedReader( new InputStreamReader(p.getErrorStream()) );
StringBuffer buf = new StringBuffer();
String line;
while ( (line = err.readLine()) != null){
buf.append(line);
}
return buf.toString();
}
private int waitForEnd(Process p) throws Exception {
int retcode = p.waitFor();
if (retcode != 0){
String err = getErrorOutput(p);
if (err.length() > 0){
System.err.println("ERROR:");
System.err.println(err);
}
}
return retcode;
}
public void testNoTimeOut() throws Exception {
Process process = getProcess(TIME_OUT/2);
watchdog.start(process);
int retCode = waitForEnd(process);
assertTrue("process should not have been killed", !watchdog.killedProcess());
assertEquals(0, retCode);
}
// test that the watchdog ends the process
public void testTimeOut() throws Exception {
Process process = getProcess(TIME_OUT*2);
long now = System.currentTimeMillis();
watchdog.start(process);
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);
}
// test a process that runs and failed
public void testFailed() throws Exception {
Process process = getProcess(-1); // process should abort
watchdog.start(process);
int retCode = process.waitFor();
assertTrue("process should not have been killed", !watchdog.killedProcess());
assertTrue("return code is invalid: " + retCode, retCode!=0);
}
public void testManualStop() throws Exception {
final Process process = getProcess(TIME_OUT*2);
watchdog.start(process);
// I assume that starting this takes less than TIME_OUT/2 ms...
Thread thread = new Thread(){
public void run(){
try {
process.waitFor();
} catch(InterruptedException e){
// not very nice but will do the job
fail("process interrupted in thread");
}
}
};
thread.start();
// 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();
// wait for the thread to die, should be the end of the process
thread.join();
// process should be dead and well finished
assertEquals(0, process.exitValue());
assertTrue("process should not have been killed", !watchdog.killedProcess());
}
public static class TimeProcess {
public static void main(String[] args) throws Exception {
int time = Integer.parseInt(args[0]);
if (time < 1) {
throw new IllegalArgumentException("Invalid time: " + time);
}
Thread.sleep(time);
}
}
return classpath;
}
private Process getProcess(int timetorun) throws Exception {
String[] cmdArray = {
"java", "-classpath", TEST_CLASSPATH,
TimeProcess.class.getName(), String.valueOf(timetorun)
};
//System.out.println("Testing with classpath: " + System.getProperty("java.class.path"));
return Runtime.getRuntime().exec(cmdArray);
}
private String getErrorOutput(Process p) throws Exception {
BufferedReader err = new BufferedReader( new InputStreamReader(p.getErrorStream()) );
StringBuffer buf = new StringBuffer();
String line;
while ( (line = err.readLine()) != null){
buf.append(line);
}
return buf.toString();
}
private int waitForEnd(Process p) throws Exception {
int retcode = p.waitFor();
if (retcode != 0){
String err = getErrorOutput(p);
if (err.length() > 0){
System.err.println("ERROR:");
System.err.println(err);
}
}
return retcode;
}
public void testNoTimeOut() throws Exception {
Process process = getProcess(TIME_OUT/2);
watchdog.start(process);
int retCode = waitForEnd(process);
assertTrue("process should not have been killed", !watchdog.killedProcess());
assertEquals(0, retCode);
}
// test that the watchdog ends the process
public void testTimeOut() throws Exception {
Process process = getProcess(TIME_OUT*2);
long now = System.currentTimeMillis();
watchdog.start(process);
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);
}
// test a process that runs and failed
public void testFailed() throws Exception {
Process process = getProcess(-1); // process should abort
watchdog.start(process);
int retCode = process.waitFor();
assertTrue("process should not have been killed", !watchdog.killedProcess());
assertTrue("return code is invalid: " + retCode, retCode!=0);
}
public void testManualStop() throws Exception {
final Process process = getProcess(TIME_OUT*2);
watchdog.start(process);
// I assume that starting this takes less than TIME_OUT/2 ms...
Thread thread = new Thread(){
public void run(){
try {
process.waitFor();
} catch(InterruptedException e){
// not very nice but will do the job
fail("process interrupted in thread");
}
}
};
thread.start();
// 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();
// wait for the thread to die, should be the end of the process
thread.join();
// process should be dead and well finished
assertEquals(0, process.exitValue());
assertTrue("process should not have been killed", !watchdog.killedProcess());
}
public static class TimeProcess {
public static void main(String[] args) throws Exception {
int time = Integer.parseInt(args[0]);
if (time < 1) {
throw new IllegalArgumentException("Invalid time: " + time);
}
Thread.sleep(time);
}
}
}

Write Preview
Loading…
Cancel
Save