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

move apply tests to antunit, fixing bug 40331 in the process. 

git-svn-id: https://svn.apache.org/repos/asf/ant/core/trunk@450239 13f79535-47bb-0310-9956-ffa450edef68
master
Matthew Jason Benson 18 years ago
parent
ca55545c82
commit
ac221b3329
4 changed files with 743 additions and 1069 deletions
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. +0
    -470
      src/etc/testcases/taskdefs/exec/apply.xml
  2. +724
    -0
      src/tests/antunit/taskdefs/exec/apply-test.xml
  3. +19
    -0
      src/tests/antunit/taskdefs/exec/parrot.sh
  4. +0
    -599
      src/tests/junit/org/apache/tools/ant/taskdefs/ExecuteOnTest.java

+ 0
- 470
src/etc/testcases/taskdefs/exec/apply.xml View File

@@ -1,470 +0,0 @@
<project name="apply-test" basedir=".">
<target name="init">
<property environment="env"/>
<!-- UNIX -->
<available file="sh" filepath="${env.PATH}" property="sh.executable"/>
<!-- CYGWIN -->
<available file="sh.exe" filepath="${env.PATH}" property="sh.exe.executable"/>
<condition property="test.can.run">
<or>
<isset property="sh.executable"/>
<isset property="sh.exe.executable"/>
</or>
</condition>
<!-- UNIX -->
<available file="sed" filepath="${env.PATH}" property="sed.executable"/>
<!-- CYGWIN -->
<available file="sed.exe" filepath="${env.PATH}" property="sed.exe.executable"/>
<condition property="sed.can.run">
<or>
<isset property="sed.executable"/>
<isset property="sed.exe.executable"/>
</or>
</condition>
<!-- UNIX -->
<available file="echo" filepath="${env.PATH}" property="echo.executable"/>
<!-- CYGWIN -->
<available file="echo.exe" filepath="${env.PATH}" property="echo.exe.executable"/>
<condition property="echo.can.run">
<or>
<isset property="echo.executable"/>
<isset property="echo.exe.executable"/>
</or>
</condition>

<!-- UNIX -->
<available file="ls" filepath="${env.PATH}" property="ls.executable"/>
<!-- CYGWIN -->
<available file="ls.exe" filepath="${env.PATH}" property="ls.exe.executable"/>
<condition property="ls.can.run">
<or>
<isset property="ls.executable"/>
<isset property="ls.exe.executable"/>
</or>
</condition>
</target>

<target name="xyz">
<echo file="x">s/x/blah/g${line.separator}</echo>
<echo file="y">s/y/blah/g${line.separator}</echo>
<echo file="z">s/z/blah/g${line.separator}</echo>
<fileset id="xyz" dir="${basedir}" includes="x,y,z" />
<filelist id="xyzlist" dir="${basedir}" files="x,y,z" />
</target>

<target name="no-redirect" depends="init,xyz" if="test.can.run">
<apply executable="sh">
<arg value="parrot.sh"/>
<fileset refid="xyz" />
</apply>
</target>

<target name="redirect1" depends="init,xyz" if="test.can.run">
<apply executable="sh" output="redirect.out" append="true">
<arg value="parrot.sh"/>
<fileset refid="xyz" />
</apply>
</target>

<target name="redirect2" depends="init,xyz" if="test.can.run">
<apply executable="sh" output="redirect.out"
error="redirect.err" append="true">
<arg value="parrot.sh"/>
<fileset refid="xyz" />
</apply>
</target>

<target name="redirect3" depends="init,xyz" if="test.can.run">
<apply executable="sh" logerror="true" append="true"
output="redirect.out" outputproperty="redirect.out">
<arg value="parrot.sh"/>
<fileset refid="xyz" />
</apply>
</target>

<target name="redirect4" depends="init,xyz" if="test.can.run">
<apply executable="sh" append="true"
error="redirect.err" errorproperty="redirect.err"
output="redirect.out" outputproperty="redirect.out">
<arg value="parrot.sh"/>
<fileset refid="xyz" />
</apply>
</target>

<target name="redirect5" depends="init,xyz" if="sed.can.run">
<apply executable="sed" inputstring="x y z${line.separator}" append="true"
error="redirect.err" errorproperty="redirect.err"
output="redirect.out" outputproperty="redirect.out">
<arg value="-f" />
<fileset refid="xyz" />
</apply>
</target>

<target name="redirect6" depends="init,xyz" if="sed.can.run">
<echo file="redirect.in">x y z${line.separator}</echo>
<apply executable="sed" input="redirect.in" append="true"
error="redirect.err" errorproperty="redirect.err"
output="redirect.out" outputproperty="redirect.out">
<arg value="-f" />
<filelist refid="xyzlist" />
</apply>
</target>

<target name="redirect7" depends="init,xyz" if="sed.can.run">
<apply executable="sed" inputstring="x y z${line.separator}"
error="redirect.err" output="redirect.out"
outputproperty="redirect.out">
<arg value="-f" />
<fileset refid="xyz" />
</apply>
</target>
<target name="redirector1" description="fail"
depends="init,xyz" if="test.can.run">
<apply executable="sh">
<arg value="parrot.sh"/>
<fileset refid="xyz" />
<redirector output="redirector.out" />
<redirector output="whocares" />
</apply>
</target>

<target name="redirector2" depends="init,xyz" if="test.can.run">
<apply executable="sh">
<arg value="parrot.sh"/>
<fileset refid="xyz" />
<redirector output="redirector.out" append="true" />
</apply>
</target>

<target name="redirector3" depends="init,xyz" if="test.can.run">
<apply executable="sh">
<arg value="parrot.sh"/>
<fileset refid="xyz" />
<redirector append="true"
output="redirector.out" error="redirector.err" />
</apply>
</target>

<target name="redirector4" depends="init,xyz" if="test.can.run">
<apply executable="sh">
<arg value="parrot.sh"/>
<fileset refid="xyz" />
<redirector output="redirector.out" logerror="true"
append="true" outputproperty="redirector.out" />
</apply>
</target>

<target name="redirector5" depends="init,xyz" if="test.can.run">
<apply executable="sh">
<redirector error="redirector.err" errorproperty="redirector.err"
output="redirector.out" outputproperty="redirector.out"
append="true" />
<arg value="parrot.sh"/>
<fileset refid="xyz" />
</apply>
</target>

<target name="redirector6" depends="init,xyz" if="test.can.run">
<apply executable="sh">
<redirector append="true" outputproperty="redirector.out"
errorproperty="redirector.err">
<outputmapper type="merge" to="redirector.out" />
<errormapper type="merge" to="redirector.err" />
</redirector>
<arg value="parrot.sh" />
<filelist refid="xyzlist" />
</apply>
</target>

<target name="redirector7" depends="init,xyz" if="test.can.run">
<apply executable="sh">
<redirector append="true" outputproperty="redirector.out"
errorproperty="redirector.err">
<outputmapper type="merge" to="redirector.out" />
<errormapper type="merge" to="redirector.err" />
<errorfilterchain>
<replacestring from="err" to="ERROR!!!" />
</errorfilterchain>
</redirector>
<arg value="parrot.sh" />
<fileset refid="xyz" />
</apply>
</target>

<target name="redirector8" depends="init,xyz" if="sed.can.run">
<echo file="redirector.in">x y z${line.separator}</echo>
<apply executable="sed">
<redirector append="true" outputproperty="redirector.out"
errorproperty="redirector.err">
<inputmapper type="merge" to="redirector.in" />
<outputmapper type="merge" to="redirector.out" />
<errormapper type="merge" to="redirector.err" />
</redirector>
<arg value="-f" />
<fileset refid="xyz" />
</apply>
</target>

<target name="redirector9" depends="init,xyz" if="sed.can.run">
<echo file="redirector.in">x before y before z${line.separator}</echo>
<apply executable="sed">
<redirector outputproperty="redirector.out"
errorproperty="redirector.err" append="true">
<inputfilterchain>
<replacestring from="before" to="after" />
</inputfilterchain>
<inputmapper type="merge" to="redirector.in" />
<outputmapper type="merge" to="redirector.out" />
<errormapper type="merge" to="redirector.err" />
</redirector>
<arg value="-f" />
<fileset refid="xyz" />
</apply>
</target>

<target name="redirector10" depends="init,xyz" if="sed.can.run">
<echo file="redirector.in">x before y before z${line.separator}</echo>
<apply executable="sed">
<redirector outputproperty="redirector.out"
errorproperty="redirector.err" append="true">
<outputfilterchain>
<replacestring from="before" to="after" />
</outputfilterchain>
<outputmapper type="merge" to="redirector.out" />
<errormapper type="merge" to="redirector.err" />
</redirector>
<arg value="-f" />
<srcfile />
<arg value="redirector.in"/>
<filelist refid="xyzlist" />
</apply>
</target>

<target name="redirector11" depends="init,xyz" if="sed.can.run">
<apply executable="sed">
<redirector outputproperty="redirector.out"
errorproperty="redirector.err"
inputstring="x before y before z${line.separator}"
append="true">
<inputfilterchain>
<replacestring from="before" to="after" />
</inputfilterchain>
<outputmapper type="merge" to="redirector.out" />
<errormapper type="merge" to="redirector.err" />
</redirector>
<arg value="-f" />
<fileset refid="xyz" />
</apply>
</target>

<target name="redirector12" depends="init,xyz" if="sed.can.run">
<echo file="redirector.in">x before y before z${line.separator}</echo>
<apply executable="sed" output="redirector.out" error="redirector.err">
<redirector outputproperty="redirector.out"
errorproperty="redirector.err" append="true">
<outputfilterchain>
<replacestring from="before" to="after" />
</outputfilterchain>
<outputmapper type="glob" from="nomatch" to="nomatchout" />
<errormapper type="glob" from="nomatch" to="nomatcherr" />
</redirector>
<arg value="-f" />
<srcfile />
<arg value="redirector.in"/>
<filelist refid="xyzlist" />
</apply>
</target>

<target name="redirector13" depends="init,xyz" if="test.can.run">
<apply executable="sh">
<redirector>
<outputfilterchain>
<replacestring from="out" to="OUTPUT???" />
</outputfilterchain>
<errorfilterchain>
<replacestring from="err" to="ERROR!!!" />
</errorfilterchain>
</redirector>
<arg value="parrot.sh" />
<fileset refid="xyz" />
</apply>
</target>

<target name="redirector14" depends="init,xyz" if="sed.can.run">
<echo file="redirector.in">z before y before x${line.separator}</echo>
<apply executable="sed">
<redirector append="true"
inputstring="x before y before z${line.separator}">
<outputfilterchain>
<replacestring from="before" to="after" />
</outputfilterchain>
<inputmapper type="glob" from="x" to="redirector.in" />
<outputmapper type="glob" from="y" to="redirector.out" />
<errormapper type="glob" from="z" to="redirector.err" />
</redirector>
<arg value="-f" />
<fileset refid="xyz" />
</apply>
</target>

<target name="redirector14b" depends="init,xyz" if="sed.can.run">
<apply executable="sed">
<redirector append="true"
inputstring="x before y before z${line.separator}">
<outputfilterchain>
<replacestring from="before" to="after" />
</outputfilterchain>
<inputmapper type="glob" from="x" to="redirector.in" />
<outputmapper type="glob" from="y" to="redirector.out" />
<errormapper type="glob" from="z" to="redirector.err" />
</redirector>
<arg value="-f" />
<fileset file="y" />
</apply>
</target>

<target name="pad">
<condition property="pad" value="">
<or>
<not>
<os family="dos" />
</not>
<not>
<or>
<equals arg1="${ant.java.version}" arg2="1.1" />
<equals arg1="${ant.java.version}" arg2="1.2" />
</or>
</not>
</or>
</condition>

<condition property="pad" value=" ">
<and>
<os family="dos" />
<or>
<equals arg1="${ant.java.version}" arg2="1.1" />
<equals arg1="${ant.java.version}" arg2="1.2" />
</or>
</and>
</condition>

</target>

<target name="ignoremissing" depends="init,xyz,pad" if="echo.can.run">
<filelist id="xylist" dir="${basedir}" files="x,y" />
<delete file="z" />

<pathconvert property="xy" pathsep="${pad}${line.separator}">
<path>
<filelist refid="xylist" />
</path>
</pathconvert>

<pathconvert property="xyz" pathsep="${pad}${line.separator}">
<path>
<filelist refid="xyzlist" />
</path>
</pathconvert>

<apply executable="echo" ignoremissing="true"
outputproperty="ignoretrue" append="true">
<filelist refid="xyzlist" />
</apply>

<apply executable="echo" ignoremissing="false"
outputproperty="ignorefalse" append="true">
<filelist refid="xyzlist" />
</apply>

<fail>
<condition>
<not>
<and>
<equals arg1="${xy}${pad}" arg2="${ignoretrue}" />
<equals arg1="${xyz}${pad}" arg2="${ignorefalse}" />
</and>
</not>
</condition>
</fail>
</target>

<target name="force" depends="init,xyz,pad" if="echo.can.run">
<presetdef name="ekko">
<apply executable="echo" append="true" dest="${basedir}">
<filelist refid="xyzlist" />
<mapper type="identity" />
</apply>
</presetdef>

<pathconvert property="xyz" pathsep="${pad}${line.separator}">
<path>
<filelist refid="xyzlist" />
</path>
</pathconvert>

<ekko outputproperty="foo" />
<ekko outputproperty="bar" force="true" />

<fail>
<condition>
<not>
<and>
<equals arg1="${foo}" arg2="" />
<equals arg1="${bar}" arg2="${xyz}" />
</and>
</not>
</condition>
</fail>
</target>

<target name="testNoDest" depends="init,xyz" if="echo.can.run">
<presetdef name="ekko">
<apply executable="echo" addsourcefile="false" force="true">
<filelist dir="${basedir}" files="x" />
<globmapper from="*" to="${basedir}/*" />
<targetfile />
</apply>
</presetdef>
<ekko outputproperty="dest" dest="${basedir}" />
<ekko outputproperty="nodest" />
<fail>
<condition>
<or>
<available file="${dest}" />
<not>
<available file="${nodest}" />
</not>
</or>
</condition>
</fail>
</target>

<target name="lsPath" depends="init" if="ls.can.run">
<apply executable="ls" parallel="false" outputproperty="foo"
force="true" dest="${basedir}" append="true" type="both">
<path>
<pathelement path="${env.PATH}"/>
</path>
<identitymapper/>
</apply>
</target>

<target name="lsPathParallel" depends="init" if="ls.can.run">
<apply executable="ls" parallel="true" outputproperty="foo"
force="true" dest="${basedir}" append="true" type="both">
<path>
<pathelement path="${env.PATH}"/>
</path>
<identitymapper/>
</apply>
</target>

<target name="cleanup" depends="xyz">
<delete>
<fileset refid="xyz" />
<fileset dir="${basedir}" includes="redirect.*" />
<fileset dir="${basedir}" includes="redirector.*" />
</delete>
</target>
</project>

+ 724
- 0
src/tests/antunit/taskdefs/exec/apply-test.xml View File

@@ -0,0 +1,724 @@
<project name="apply-test" xmlns:au="antlib:org.apache.ant.antunit">
<property environment="env" />
<!-- UNIX -->
<available file="sh" filepath="${env.PATH}" property="sh.executable" />
<!-- CYGWIN -->
<available file="sh.exe" filepath="${env.PATH}" property="sh.exe.executable" />
<condition property="test.can.run">
<or>
<isset property="sh.executable" />
<isset property="sh.exe.executable" />
</or>
</condition>
<!-- UNIX -->
<available file="sed" filepath="${env.PATH}" property="sed.executable" />
<!-- CYGWIN -->
<available file="sed.exe" filepath="${env.PATH}" property="sed.exe.executable" />
<condition property="sed.can.run">
<or>
<isset property="sed.executable" />
<isset property="sed.exe.executable" />
</or>
</condition>
<!-- UNIX -->
<available file="echo" filepath="${env.PATH}" property="echo.executable" />
<!-- CYGWIN -->
<available file="echo.exe" filepath="${env.PATH}" property="echo.exe.executable" />
<condition property="echo.can.run">
<or>
<isset property="echo.executable" />
<isset property="echo.exe.executable" />
</or>
</condition>

<!-- UNIX -->
<available file="ls" filepath="${env.PATH}" property="ls.executable" />
<!-- CYGWIN -->
<available file="ls.exe" filepath="${env.PATH}" property="ls.exe.executable" />
<!-- piggyback the name of the executable here -->
<condition property="ls.can.run" value="ls">
<isset property="ls.executable" />
</condition>
<condition property="ls.can.run" value="ls.exe">
<isset property="ls.exe.executable" />
</condition>

<property name="eol" value="${line.separator}" />

<macrodef name="rcat">
<attribute name="refid" />
<sequential>
<echo>@@{refid}=@{refid}</echo>
<concat><resources refid="@{refid}" /></concat>
</sequential>
</macrodef>

<macrodef name="assertEmptyFile">
<attribute name="file" />
<sequential>
<au:assertTrue>
<and>
<available file="@{file}" type="file" />
<length length="0" file="@{file}" />
</and>
</au:assertTrue>
</sequential>
</macrodef>

<target name="xyz">
<echo file="x">s/x/blah/g${eol}</echo>
<echo file="y">s/y/blah/g${eol}</echo>
<echo file="z">s/z/blah/g${eol}</echo>
<fileset id="xyz" dir="${basedir}" includes="x,y,z" />
<filelist id="xyzlist" dir="${basedir}" files="x,y,z" />
<property name="x" location="x" />
<property name="y" location="y" />
<property name="z" location="z" />
</target>

<target name="testNoRedirect" depends="xyz" if="test.can.run">
<apply executable="sh">
<arg value="parrot.sh" />
<fileset refid="xyz" />
</apply>

<au:assertLogContains text="${x} out" />
<au:assertLogContains text="${y} out" />
<au:assertLogContains text="${z} out" />
<au:assertLogContains text="${x} err" />
<au:assertLogContains text="${y} err" />
<au:assertLogContains text="${z} err" />

<!--

The original junit test also verified that x out happened before
y out, and y out happened before z out; likewise with err output.
I added the antunit:logcontent resource hoping that would help,
but I think we need a way to filter (copy) resources first.
THAT necessitates the string-to-resource coding we are currently
discussing on the dev list IMO. MJB, 9/22/2006

-->

</target>

<target name="testRedirect1" depends="xyz" if="test.can.run">
<apply executable="sh" output="redirect.out" append="true">
<arg value="parrot.sh" />
<fileset refid="xyz" />
</apply>

<au:assertTrue>
<resourcecount count="1">
<restrict id="results">
<file file="redirect.out" />
<and xmlns="antlib:org.apache.tools.ant.types.resources.selectors">
<contains text="${x} out" />
<contains text="${y} out" />
<contains text="${z} out" />
<contains text="${x} err" />
<contains text="${y} err" />
<contains text="${z} err" />
</and>
</restrict>
</resourcecount>
</au:assertTrue>

</target>

<target name="testRedirect2" depends="xyz" if="test.can.run">
<apply executable="sh" output="redirect.out"
error="redirect.err" append="true">
<arg value="parrot.sh" />
<fileset refid="xyz" />
</apply>

<au:assertTrue>
<and>
<resourcesmatch astext="true">
<string value="${x} out${eol}${y} out${eol}${z} out" />
<file file="redirect.out" />
</resourcesmatch>
<resourcesmatch astext="true">
<string value="${x} err${eol}${y} err${eol}${z} err" />
<file file="redirect.err" />
</resourcesmatch>
</and>
</au:assertTrue>
</target>

<target name="testRedirect3" depends="xyz" if="test.can.run">
<apply executable="sh" logerror="true" append="true"
output="redirect.out" outputproperty="redirect3.out">
<arg value="parrot.sh" />
<fileset refid="xyz" />
</apply>

<au:assertTrue>
<resourcesmatch astext="true">
<string value="${x} out${eol}${y} out${eol}${z} out" />
<file file="redirect.out" />
<propertyresource name="redirect3.out" />
</resourcesmatch>
</au:assertTrue>

<au:assertLogContains text="${x} err" />
<au:assertLogContains text="${y} err" />
<au:assertLogContains text="${z} err" />
</target>

<target name="testRedirect4" depends="xyz" if="test.can.run">
<apply executable="sh" append="true"
error="redirect.err" errorproperty="redirect4.err"
output="redirect.out" outputproperty="redirect4.out">
<arg value="parrot.sh" />
<fileset refid="xyz" />
</apply>

<au:assertTrue>
<and>
<resourcesmatch astext="true">
<string value="${x} out${eol}${y} out${eol}${z} out" />
<file file="redirect.out" />
<propertyresource name="redirect4.out" />
</resourcesmatch>
<resourcesmatch astext="true">
<string value="${x} err${eol}${y} err${eol}${z} err" />
<file file="redirect.err" />
<propertyresource name="redirect4.err" />
</resourcesmatch>
</and>
</au:assertTrue>
</target>

<target name="testRedirect5" depends="xyz" if="sed.can.run">
<apply executable="sed" inputstring="x y z${eol}" append="true"
error="redirect.err" errorproperty="redirect5.err"
output="redirect.out" outputproperty="redirect5.out">
<arg value="-f" />
<fileset refid="xyz" />
</apply>

<au:assertTrue>
<and>
<resourcesmatch astext="true">
<propertyresource name="redirect5.out" />
<string value="blah y z${eol}x blah z${eol}x y blah" />
<file file="redirect.out" />
</resourcesmatch>
<equals arg1="${redirect5.err}" arg2="" />
</and>
</au:assertTrue>
<assertEmptyFile file="redirect.err" />
</target>

<target name="testRedirect6" depends="xyz" if="sed.can.run">
<echo file="redirect.in">x y z${eol}</echo>
<apply executable="sed" input="redirect.in" append="true"
error="redirect.err" errorproperty="redirect6.err"
output="redirect.out" outputproperty="redirect6.out">
<arg value="-f" />
<filelist refid="xyzlist" />
</apply>

<au:assertTrue>
<and>
<resourcesmatch astext="true">
<propertyresource name="redirect6.out" />
<string value="blah y z${eol}x blah z${eol}x y blah" />
<file file="redirect.out" />
</resourcesmatch>
<equals arg1="${redirect6.err}" arg2="" />
<length length="0"><file file="redirect.err" /></length>
</and>
</au:assertTrue>
</target>

<target name="testRedirect7" depends="xyz" if="sed.can.run">
<apply executable="sed" inputstring="x y z${eol}"
error="redirect.err" output="redirect.out"
outputproperty="redirect7.out">
<arg value="-f" />
<fileset refid="xyz" />
</apply>

<au:assertTrue>
<and>
<equals arg1="${redirect7.out}" arg2="blah y z" />
<resourcesmatch astext="true">
<file file="redirect.out" />
<string value="x y blah" />
</resourcesmatch>
</and>
</au:assertTrue>
<assertEmptyFile file="redirect.err" />
</target>

<target name="testRedirector1" description="fail"
depends="xyz" if="test.can.run">
<au:expectfailure
expectedmessage="cannot have &gt; 1 nested &lt;redirector&gt;s">
<apply executable="sh">
<arg value="parrot.sh" />
<fileset refid="xyz" />
<redirector output="redirector.out" />
<redirector output="whocares" />
</apply>
</au:expectfailure>
</target>

<target name="testRedirector2" depends="xyz" if="test.can.run">
<apply executable="sh">
<arg value="parrot.sh" />
<fileset refid="xyz" />
<redirector output="redirector.out" append="true" />
</apply>
<au:assertTrue>
<resourcecount count="1">
<restrict id="results">
<file file="redirector.out" />
<and xmlns="antlib:org.apache.tools.ant.types.resources.selectors">
<contains text="${x} out" />
<contains text="${y} out" />
<contains text="${z} out" />
<contains text="${x} err" />
<contains text="${y} err" />
<contains text="${z} err" />
</and>
</restrict>
</resourcecount>
</au:assertTrue>
</target>

<target name="testRedirector3" depends="xyz" if="test.can.run">
<apply executable="sh">
<arg value="parrot.sh" />
<fileset refid="xyz" />
<redirector append="true"
output="redirector.out" error="redirector.err" />
</apply>
<au:assertTrue>
<and>
<resourcesmatch astext="true">
<string value="${x} out${eol}${y} out${eol}${z} out" />
<file file="redirector.out" />
</resourcesmatch>
<resourcesmatch astext="true">
<string value="${x} err${eol}${y} err${eol}${z} err" />
<file file="redirector.err" />
</resourcesmatch>
</and>
</au:assertTrue>
</target>

<target name="testRedirector4" depends="xyz" if="test.can.run">
<apply executable="sh">
<arg value="parrot.sh" />
<fileset refid="xyz" />
<redirector output="redirector.out" logerror="true"
append="true" outputproperty="redirector4.out" />
</apply>

<au:assertTrue>
<resourcesmatch astext="true">
<string value="${x} out${eol}${y} out${eol}${z} out" />
<file file="redirector.out" />
<propertyresource name="redirector4.out" />
</resourcesmatch>
</au:assertTrue>

<au:assertLogContains text="${x} err" />
<au:assertLogContains text="${y} err" />
<au:assertLogContains text="${z} err" />
</target>

<target name="testRedirector5" depends="xyz" if="test.can.run">
<apply executable="sh">
<redirector error="redirector.err" errorproperty="redirector5.err"
output="redirector.out" outputproperty="redirector5.out"
append="true" />
<arg value="parrot.sh" />
<fileset refid="xyz" />
</apply>
<au:assertTrue>
<and>
<resourcesmatch astext="true">
<string value="${x} out${eol}${y} out${eol}${z} out" />
<file file="redirector.out" />
<propertyresource name="redirector5.out" />
</resourcesmatch>
<resourcesmatch astext="true">
<string value="${x} err${eol}${y} err${eol}${z} err" />
<file file="redirector.err" />
<propertyresource name="redirector5.err" />
</resourcesmatch>
</and>
</au:assertTrue>
</target>

<target name="testRedirector6" depends="xyz" if="test.can.run">
<apply executable="sh">
<redirector append="true" outputproperty="redirector6.out"
errorproperty="redirector6.err">
<outputmapper type="merge" to="redirector.out" />
<errormapper type="merge" to="redirector.err" />
</redirector>
<arg value="parrot.sh" />
<filelist refid="xyzlist" />
</apply>

<au:assertTrue>
<and>
<resourcesmatch astext="true">
<string value="${x} out${eol}${y} out${eol}${z} out" />
<file file="redirector.out" />
<propertyresource name="redirector6.out" />
</resourcesmatch>
<resourcesmatch astext="true">
<string value="${x} err${eol}${y} err${eol}${z} err" />
<file file="redirector.err" />
<propertyresource name="redirector6.err" />
</resourcesmatch>
</and>
</au:assertTrue>
</target>

<target name="testRedirector7" depends="xyz" if="test.can.run">
<apply executable="sh">
<redirector append="true" outputproperty="redirector7.out"
errorproperty="redirector7.err">
<outputmapper type="merge" to="redirector.out" />
<errormapper type="merge" to="redirector.err" />
<errorfilterchain>
<replacestring from="err" to="ERROR!!!" />
</errorfilterchain>
</redirector>
<arg value="parrot.sh" />
<fileset refid="xyz" />
</apply>

<au:assertTrue>
<and>
<resourcesmatch astext="true">
<string value="${x} out${eol}${y} out${eol}${z} out" />
<file file="redirector.out" />
<propertyresource name="redirector7.out" />
</resourcesmatch>
<resourcesmatch astext="true">
<string value="${x} ERROR!!!${eol}${y} ERROR!!!${eol}${z} ERROR!!!" />
<file file="redirector.err" />
<propertyresource name="redirector7.err" />
</resourcesmatch>
</and>
</au:assertTrue>
</target>

<target name="testRedirector8" depends="xyz" if="sed.can.run">
<echo file="redirector.in">x y z${eol}</echo>
<apply executable="sed">
<redirector append="true" outputproperty="redirector8.out"
errorproperty="redirector8.err">
<inputmapper type="merge" to="redirector.in" />
<outputmapper type="merge" to="redirector.out" />
<errormapper type="merge" to="redirector.err" />
</redirector>
<arg value="-f" />
<fileset refid="xyz" />
</apply>

<au:assertTrue>
<and>
<resourcesmatch astext="true">
<propertyresource name="redirector8.out" />
<string value="blah y z${eol}x blah z${eol}x y blah" />
<file file="redirector.out" />
</resourcesmatch>
<equals arg1="${redirector8.err}" arg2="" />
</and>
</au:assertTrue>
<assertEmptyFile file="redirector.err" />
</target>

<macrodef name="valRor9-12">
<attribute name="n" />
<sequential>
<au:assertTrue>
<and>
<equals arg1="" arg2="${redirector@{n}.err}" />
<resourcesmatch astext="true">
<string value="blah after y after z${eol}x after blah after z${eol}x after y after blah" />
<propertyresource name="redirector@{n}.out" />
<file file="redirector.out" />
</resourcesmatch>
</and>
</au:assertTrue>
<assertEmptyFile file="redirector.err" />
</sequential>
</macrodef>

<target name="testRedirector9" depends="xyz" if="sed.can.run">
<echo file="redirector.in">x before y before z${eol}</echo>
<apply executable="sed">
<redirector outputproperty="redirector9.out"
errorproperty="redirector9.err" append="true">
<inputfilterchain>
<replacestring from="before" to="after" />
</inputfilterchain>
<inputmapper type="merge" to="redirector.in" />
<outputmapper type="merge" to="redirector.out" />
<errormapper type="merge" to="redirector.err" />
</redirector>
<arg value="-f" />
<fileset refid="xyz" />
</apply>

<valRor9-12 n="9" />
</target>

<target name="testRedirector10" depends="xyz" if="sed.can.run">
<echo file="redirector.in">x before y before z${eol}</echo>
<apply executable="sed">
<redirector outputproperty="redirector10.out"
errorproperty="redirector10.err" append="true">
<outputfilterchain>
<replacestring from="before" to="after" />
</outputfilterchain>
<outputmapper type="merge" to="redirector.out" />
<errormapper type="merge" to="redirector.err" />
</redirector>
<arg value="-f" />
<srcfile />
<arg value="redirector.in" />
<filelist refid="xyzlist" />
</apply>

<valRor9-12 n="10" />
</target>

<target name="testRedirector11" depends="xyz" if="sed.can.run">
<apply executable="sed">
<redirector outputproperty="redirector11.out"
errorproperty="redirector11.err"
inputstring="x before y before z${eol}"
append="true">
<inputfilterchain>
<replacestring from="before" to="after" />
</inputfilterchain>
<outputmapper type="merge" to="redirector.out" />
<errormapper type="merge" to="redirector.err" />
</redirector>
<arg value="-f" />
<fileset refid="xyz" />
</apply>

<valRor9-12 n="11" />
</target>

<target name="testRedirector12" depends="xyz" if="sed.can.run">
<echo file="redirector.in">x before y before z${eol}</echo>
<apply executable="sed" output="redirector.out" error="redirector.err">
<redirector outputproperty="redirector12.out"
errorproperty="redirector12.err" append="true">
<outputfilterchain>
<replacestring from="before" to="after" />
</outputfilterchain>
<outputmapper type="glob" from="nomatch" to="nomatchout" />
<errormapper type="glob" from="nomatch" to="nomatcherr" />
</redirector>
<arg value="-f" />
<srcfile />
<arg value="redirector.in" />
<filelist refid="xyzlist" />
</apply>

<valRor9-12 n="12" />
</target>

<target name="testRedirector13" depends="xyz" if="test.can.run">
<apply executable="sh">
<redirector>
<outputfilterchain>
<replacestring from="out" to="OUTPUT???" />
</outputfilterchain>
<errorfilterchain>
<replacestring from="err" to="ERROR!!!" />
</errorfilterchain>
</redirector>
<arg value="parrot.sh" />
<fileset refid="xyz" />
</apply>

<au:assertLogContains text="${x} OUTPUT???" />
<au:assertLogContains text="${y} OUTPUT???" />
<au:assertLogContains text="${z} OUTPUT???" />
<au:assertLogContains text="${x} ERROR!!!" />
<au:assertLogContains text="${y} ERROR!!!" />
<au:assertLogContains text="${z} ERROR!!!" />
</target>

<target name="testRedirector14" depends="xyz" if="sed.can.run">
<echo file="redirector.in">z before y before x${eol}</echo>
<apply executable="sed">
<redirector append="true"
inputstring="x before y before z${eol}">
<outputfilterchain>
<replacestring from="before" to="after" />
</outputfilterchain>
<inputmapper type="glob" from="x" to="redirector.in" />
<outputmapper type="glob" from="y" to="redirector.out" />
<errormapper type="glob" from="z" to="redirector.err" />
</redirector>
<arg value="-f" />
<fileset refid="xyz" />
</apply>

<assertEmptyFile file="redirector.err" />

<au:assertTrue>
<and>
<resourcesmatch astext="true">
<string value="z after y after blahx after y after blah" />
<au:logcontent />
</resourcesmatch>
</and>
</au:assertTrue>
<au:assertTrue message="${logcontent}">
<and>
<resourcesmatch astext="true">
<string value="x after blah after z" />
<file file="redirector.out" />
</resourcesmatch>
</and>
</au:assertTrue>
</target>

<target name="pad">
<condition property="pad" value="">
<or>
<not>
<os family="dos" />
</not>
<not>
<or>
<equals arg1="${ant.java.version}" arg2="1.1" />
<equals arg1="${ant.java.version}" arg2="1.2" />
</or>
</not>
</or>
</condition>

<condition property="pad" value=" ">
<and>
<os family="dos" />
<or>
<equals arg1="${ant.java.version}" arg2="1.2" />
</or>
</and>
</condition>

</target>

<target name="testIgnoreMissing" depends="xyz,pad" if="echo.can.run">
<filelist id="xylist" dir="${basedir}" files="x,y" />
<delete file="z" />

<pathconvert property="xy" pathsep="${pad}${eol}" refid="xylist" />

<pathconvert property="xyz" pathsep="${pad}${eol}" refid="xyzlist" />

<apply executable="echo" ignoremissing="true"
outputproperty="ignoretrue" append="true">
<filelist refid="xyzlist" />
</apply>

<apply executable="echo" ignoremissing="false"
outputproperty="ignorefalse" append="true">
<filelist refid="xyzlist" />
</apply>

<au:assertTrue>
<and>
<equals arg1="${xy}${pad}" arg2="${ignoretrue}" />
<equals arg1="${xyz}${pad}" arg2="${ignorefalse}" />
</and>
</au:assertTrue>
</target>

<target name="testForce" depends="xyz,pad" if="echo.can.run">
<presetdef name="ekko">
<apply executable="echo" append="true" dest="${basedir}">
<filelist refid="xyzlist" />
<mapper type="identity" />
</apply>
</presetdef>

<pathconvert property="xyz" pathsep="${pad}${eol}" refid="xyzlist" />

<ekko outputproperty="foo" />
<ekko outputproperty="bar" force="true" />

<au:assertTrue>
<and>
<equals arg1="${foo}" arg2="" />
<equals arg1="${bar}" arg2="${xyz}" />
</and>
</au:assertTrue>
</target>

<target name="testNoDest" depends="xyz" if="echo.can.run">
<presetdef name="ekko">
<apply executable="echo" addsourcefile="false" force="true">
<filelist dir="${basedir}" files="x" />
<globmapper from="*" to="${basedir}/*" />
<targetfile />
</apply>
</presetdef>
<ekko outputproperty="dest" dest="${basedir}" />
<ekko outputproperty="nodest" />

<au:assertFileDoesntExist file="${dest}" />
<au:assertFileExists file="${nodest}" />
</target>

<target name="testLsPath" if="ls.can.run">
<apply executable="ls" parallel="false" outputproperty="lsPathOut"
force="true" dest="${basedir}" append="true" type="both">
<path path="${env.PATH}" />
<identitymapper/>
</apply>
<au:assertTrue>
<resourcecount count="1">
<restrict>
<propertyresource name="lsPathOut" />
<containsregexp expression="^${ls.can.run}$"
xmlns="antlib:org.apache.tools.ant.types.resources.selectors" />
</restrict>
</resourcecount>
</au:assertTrue>
</target>

<target name="testLsPathParallel" if="ls.can.run">
<apply executable="ls" parallel="true" outputproperty="lsPathParallelOut"
force="true" dest="${basedir}" append="true" type="both">
<path path="${env.PATH}" />
<identitymapper/>
</apply>
<au:assertTrue>
<resourcecount count="1">
<restrict>
<propertyresource name="lsPathParallelOut" />
<containsregexp expression="^${ls.can.run}$"
xmlns="antlib:org.apache.tools.ant.types.resources.selectors" />
</restrict>
</resourcecount>
</au:assertTrue>
</target>

<target name="tearDown">
<delete>
<fileset refid="xyz" />
<fileset dir="${basedir}" includes="redirect.*" />
<fileset dir="${basedir}" includes="redirector.*" />
</delete>
</target>
</project>

+ 19
- 0
src/tests/antunit/taskdefs/exec/parrot.sh View File

@@ -0,0 +1,19 @@
# 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.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License. You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# 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.
for arg in "$@" ; do
echo $arg out
sleep 1
echo $arg err>&2
done

+ 0
- 599
src/tests/junit/org/apache/tools/ant/taskdefs/ExecuteOnTest.java View File

@@ -1,599 +0,0 @@
/*
* 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.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* 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 org.apache.tools.ant.taskdefs;

import java.io.File;
import java.io.FileReader;
import java.io.IOException;

import org.apache.tools.ant.BuildFileTest;
import org.apache.tools.ant.util.FileUtils;

/**
* Unit test for the &lt;apply&gt; task.
*/
public class ExecuteOnTest extends BuildFileTest {
private static final String BUILD_PATH = "src/etc/testcases/taskdefs/exec/";
private static final String BUILD_FILE = BUILD_PATH + "apply.xml";
private static final String LINE_SEP = System.getProperty("line.separator");
public ExecuteOnTest(String name) {
super(name);
}

public void setUp() {
configureProject(BUILD_FILE);
}

public void tearDown() {
executeTarget("cleanup");
}

public void testNoRedirect() {
executeTarget("no-redirect");
if (getProject().getProperty("test.can.run") == null) {
return;
}

String log = getLog();
File x = getProject().resolveFile("x");
File y = getProject().resolveFile("y");
File z = getProject().resolveFile("z");
int xout = log.indexOf(x + " out");
int yout = log.indexOf(y + " out");
int zout = log.indexOf(z + " out");
int xerr = log.indexOf(x + " err");
int yerr = log.indexOf(y + " err");
int zerr = log.indexOf(z + " err");
assertFalse("xout=" + xout, xout < 0);
assertFalse("yout=" + yout, yout < 0);
assertFalse("zout=" + zout, zout < 0);
assertFalse("xerr=" + xerr, xerr < 0);
assertFalse("yerr=" + yerr, yerr < 0);
assertFalse("zerr=" + zerr, zerr < 0);
assertFalse("yout < xout", yout < xout);
assertFalse("zout < yout", zout < yout);
assertFalse("yerr < xerr", yerr < xerr);
assertFalse("zerr < yerr", zerr < yerr);
}

public void testRedirect1() throws IOException {
executeTarget("redirect1");
if (getProject().getProperty("test.can.run") == null) {
return;
}
String actualOut = getFileString("redirect.out");

File x = getProject().resolveFile("x");
File y = getProject().resolveFile("y");
File z = getProject().resolveFile("z");
int xout = actualOut.indexOf(x + " out");
int yout = actualOut.indexOf(y + " out");
int zout = actualOut.indexOf(z + " out");
int xerr = actualOut.indexOf(x + " err");
int yerr = actualOut.indexOf(y + " err");
int zerr = actualOut.indexOf(z + " err");
assertFalse("xout=" + xout, xout < 0);
assertFalse("yout=" + yout, yout < 0);
assertFalse("zout=" + zout, zout < 0);
assertFalse("xerr=" + xerr, xerr < 0);
assertFalse("yerr=" + yerr, yerr < 0);
assertFalse("zerr=" + zerr, zerr < 0);
assertFalse("yout < xout", yout < xout);
assertFalse("zout < yout", zout < yout);
assertFalse("yerr < xerr", yerr < xerr);
assertFalse("zerr < yerr", zerr < yerr);
}

public void testRedirect2() throws IOException {
executeTarget("redirect2");
if (getProject().getProperty("test.can.run") == null) {
return;
}
String actualOut = getFileString("redirect.out");
String actualErr = getFileString("redirect.err");

File x = getProject().resolveFile("x");
File y = getProject().resolveFile("y");
File z = getProject().resolveFile("z");
int xout = actualOut.indexOf(x + " out");
int yout = actualOut.indexOf(y + " out");
int zout = actualOut.indexOf(z + " out");
int xerr = actualErr.indexOf(x + " err");
int yerr = actualErr.indexOf(y + " err");
int zerr = actualErr.indexOf(z + " err");
assertFalse("xout=" + xout, xout < 0);
assertFalse("yout=" + yout, yout < 0);
assertFalse("zout=" + zout, zout < 0);
assertFalse("xerr=" + xerr, xerr < 0);
assertFalse("yerr=" + yerr, yerr < 0);
assertFalse("zerr=" + zerr, zerr < 0);
assertFalse("yout < xout", yout < xout);
assertFalse("zout < yout", zout < yout);
assertFalse("yerr < xerr", yerr < xerr);
assertFalse("zerr < yerr", zerr < yerr);
}

public void testRedirect3() throws IOException {
executeTarget("redirect3");
if (getProject().getProperty("test.can.run") == null) {
return;
}
String actualOut = getFileString("redirect.out");

File x = getProject().resolveFile("x");
File y = getProject().resolveFile("y");
File z = getProject().resolveFile("z");
int xout = actualOut.indexOf(x + " out");
int yout = actualOut.indexOf(y + " out");
int zout = actualOut.indexOf(z + " out");
int xerr = getLog().indexOf(x + " err");
int yerr = getLog().indexOf(y + " err");
int zerr = getLog().indexOf(z + " err");
assertFalse("xout=" + xout, xout < 0);
assertFalse("yout=" + yout, yout < 0);
assertFalse("zout=" + zout, zout < 0);
assertFalse("xerr=" + xerr, xerr < 0);
assertFalse("yerr=" + yerr, yerr < 0);
assertFalse("zerr=" + zerr, zerr < 0);
assertFalse("yout < xout", yout < xout);
assertFalse("zout < yout", zout < yout);
assertFalse("yerr < xerr", yerr < xerr);
assertFalse("zerr < yerr", zerr < yerr);

String outProperty = getProject().getProperty("redirect.out");
int pxout = outProperty.indexOf(x + " out");
int pyout = outProperty.indexOf(y + " out");
int pzout = outProperty.indexOf(z + " out");
assertFalse("pxout=" + pxout, pxout < 0);
assertFalse("pyout=" + pyout, pyout < 0);
assertFalse("pzout=" + pzout, pzout < 0);
assertFalse("pyout < pxout", pyout < pxout);
assertFalse("pzout < pyout", pzout < pyout);
}

public void testRedirect4() throws IOException {
executeTarget("redirect4");
if (getProject().getProperty("test.can.run") == null) {
return;
}
String actualOut = getFileString("redirect.out");
String actualErr = getFileString("redirect.err");

File x = getProject().resolveFile("x");
File y = getProject().resolveFile("y");
File z = getProject().resolveFile("z");
int xout = actualOut.indexOf(x + " out");
int yout = actualOut.indexOf(y + " out");
int zout = actualOut.indexOf(z + " out");
int xerr = actualErr.indexOf(x + " err");
int yerr = actualErr.indexOf(y + " err");
int zerr = actualErr.indexOf(z + " err");
assertFalse("xout=" + xout, xout < 0);
assertFalse("yout=" + yout, yout < 0);
assertFalse("zout=" + zout, zout < 0);
assertFalse("xerr=" + xerr, xerr < 0);
assertFalse("yerr=" + yerr, yerr < 0);
assertFalse("zerr=" + zerr, zerr < 0);
assertFalse("yout < xout", yout < xout);
assertFalse("zout < yout", zout < yout);
assertFalse("yerr < xerr", yerr < xerr);
assertFalse("zerr < yerr", zerr < yerr);

String outProperty = getProject().getProperty("redirect.out");
int pxout = outProperty.indexOf(x + " out");
int pyout = outProperty.indexOf(y + " out");
int pzout = outProperty.indexOf(z + " out");
assertFalse("pxout=" + pxout, pxout < 0);
assertFalse("pyout=" + pyout, pyout < 0);
assertFalse("pzout=" + pzout, pzout < 0);
assertFalse("pyout < pxout", pyout < pxout);
assertFalse("pzout < pyout", pzout < pyout);

String errorProperty = getProject().getProperty("redirect.err");
int pxerr = errorProperty.indexOf(x + " err");
int pyerr = errorProperty.indexOf(y + " err");
int pzerr = errorProperty.indexOf(z + " err");
assertFalse("pxerr=" + pxerr, pxerr < 0);
assertFalse("pyerr=" + pyerr, pyerr < 0);
assertFalse("pzerr=" + pzerr, pzerr < 0);
assertFalse("pyerr < pxerr", pyerr < pxerr);
assertFalse("pzerr < pyerr", pzerr < pyerr);
}

public void testRedirect5() throws IOException {
testRedirect5or6("redirect5");
}

public void testRedirect6() throws IOException {
testRedirect5or6("redirect6");
}

private void testRedirect5or6(String target) throws IOException {
executeTarget(target);
if (getProject().getProperty("sed.can.run") == null) {
return;
}

assertPropertyEquals("redirect.out", getProject().replaceProperties(
"blah y z${line.separator}x blah z${line.separator}x y blah"));
assertPropertyEquals("redirect.err", "");
assertEquals("unexpected output",
"blah y z\nx blah z\nx y blah\n", getFileString("redirect.out"));
assertNull("unexpected error output", getFileString("redirect.err"));
}

public void testRedirect7() throws IOException {
executeTarget("redirect7");
if (getProject().getProperty("sed.can.run") == null) {
return;
}

assertPropertyEquals("redirect.out", "blah y z");
assertPropertyUnset("redirect.err");
assertEquals("unexpected output",
"x y blah\n", getFileString("redirect.out"));
assertNull("unexpected error output", getFileString("redirect.err"));
}

public void testRedirector1() {
executeTarget("init");
if (getProject().getProperty("test.can.run") == null) {
return;
}
expectBuildException("redirector1", "cannot have > 1 nested <redirector>s");
}

public void testRedirector2() throws IOException {
executeTarget("redirector2");
if (getProject().getProperty("test.can.run") == null) {
return;
}

String actualOut = getFileString("redirector.out");

File x = getProject().resolveFile("x");
File y = getProject().resolveFile("y");
File z = getProject().resolveFile("z");
int xout = actualOut.indexOf(x + " out");
int yout = actualOut.indexOf(y + " out");
int zout = actualOut.indexOf(z + " out");
int xerr = actualOut.indexOf(x + " err");
int yerr = actualOut.indexOf(y + " err");
int zerr = actualOut.indexOf(z + " err");
assertFalse("xout=" + xout, xout < 0);
assertFalse("yout=" + yout, yout < 0);
assertFalse("zout=" + zout, zout < 0);
assertFalse("xerr=" + xerr, xerr < 0);
assertFalse("yerr=" + yerr, yerr < 0);
assertFalse("zerr=" + zerr, zerr < 0);
assertFalse("yout < xout", yout < xout);
assertFalse("zout < yout", zout < yout);
assertFalse("yerr < xerr", yerr < xerr);
assertFalse("zerr < yerr", zerr < yerr);
}

public void testRedirector3() throws IOException {
executeTarget("redirector3");
if (getProject().getProperty("test.can.run") == null) {
return;
}

String actualOut = getFileString("redirector.out");
String actualErr = getFileString("redirector.err");

File x = getProject().resolveFile("x");
File y = getProject().resolveFile("y");
File z = getProject().resolveFile("z");
int xout = actualOut.indexOf(x + " out");
int yout = actualOut.indexOf(y + " out");
int zout = actualOut.indexOf(z + " out");
int xerr = actualErr.indexOf(x + " err");
int yerr = actualErr.indexOf(y + " err");
int zerr = actualErr.indexOf(z + " err");
assertFalse("xout=" + xout, xout < 0);
assertFalse("yout=" + yout, yout < 0);
assertFalse("zout=" + zout, zout < 0);
assertFalse("xerr=" + xerr, xerr < 0);
assertFalse("yerr=" + yerr, yerr < 0);
assertFalse("zerr=" + zerr, zerr < 0);
assertFalse("yout < xout", yout < xout);
assertFalse("zout < yout", zout < yout);
assertFalse("yerr < xerr", yerr < xerr);
assertFalse("zerr < yerr", zerr < yerr);
}

public void testRedirector4() throws IOException {
executeTarget("redirector4");
if (getProject().getProperty("test.can.run") == null) {
return;
}
String actualOut = getFileString("redirector.out");

File x = getProject().resolveFile("x");
File y = getProject().resolveFile("y");
File z = getProject().resolveFile("z");
int xout = actualOut.indexOf(x + " out");
int yout = actualOut.indexOf(y + " out");
int zout = actualOut.indexOf(z + " out");
int xerr = getLog().indexOf(x + " err");
int yerr = getLog().indexOf(y + " err");
int zerr = getLog().indexOf(z + " err");
assertFalse("xout=" + xout, xout < 0);
assertFalse("yout=" + yout, yout < 0);
assertFalse("zout=" + zout, zout < 0);
assertFalse("xerr=" + xerr, xerr < 0);
assertFalse("yerr=" + yerr, yerr < 0);
assertFalse("zerr=" + zerr, zerr < 0);
assertFalse("yout < xout", yout < xout);
assertFalse("zout < yout", zout < yout);
assertFalse("yerr < xerr", yerr < xerr);
assertFalse("zerr < yerr", zerr < yerr);

String outProperty = getProject().getProperty("redirector.out");
int pxout = outProperty.indexOf(x + " out");
int pyout = outProperty.indexOf(y + " out");
int pzout = outProperty.indexOf(z + " out");
assertFalse("pxout=" + pxout, pxout < 0);
assertFalse("pyout=" + pyout, pyout < 0);
assertFalse("pzout=" + pzout, pzout < 0);
assertFalse("pyout < pxout", pyout < pxout);
assertFalse("pzout < pyout", pzout < pyout);
}

public void testRedirector5() throws IOException {
testRedirector5or6("redirector5");
}

public void testRedirector6() throws IOException {
testRedirector5or6("redirector6");
}

private void testRedirector5or6(String target) throws IOException {
executeTarget(target);
if (getProject().getProperty("test.can.run") == null) {
return;
}
String actualOut = getFileString("redirector.out");
String actualErr = getFileString("redirector.err");

File x = getProject().resolveFile("x");
File y = getProject().resolveFile("y");
File z = getProject().resolveFile("z");
int xout = actualOut.indexOf(x + " out");
int yout = actualOut.indexOf(y + " out");
int zout = actualOut.indexOf(z + " out");
int xerr = actualErr.indexOf(x + " err");
int yerr = actualErr.indexOf(y + " err");
int zerr = actualErr.indexOf(z + " err");
assertFalse("xout=" + xout, xout < 0);
assertFalse("yout=" + yout, yout < 0);
assertFalse("zout=" + zout, zout < 0);
assertFalse("xerr=" + xerr, xerr < 0);
assertFalse("yerr=" + yerr, yerr < 0);
assertFalse("zerr=" + zerr, zerr < 0);
assertFalse("yout < xout", yout < xout);
assertFalse("zout < yout", zout < yout);
assertFalse("yerr < xerr", yerr < xerr);
assertFalse("zerr < yerr", zerr < yerr);

String outProperty = getProject().getProperty("redirector.out");
int pxout = outProperty.indexOf(x + " out");
int pyout = outProperty.indexOf(y + " out");
int pzout = outProperty.indexOf(z + " out");
assertFalse("pxout=" + pxout, pxout < 0);
assertFalse("pyout=" + pyout, pyout < 0);
assertFalse("pzout=" + pzout, pzout < 0);
assertFalse("pyout < pxout", pyout < pxout);
assertFalse("pzout < pyout", pzout < pyout);

String errorProperty = getProject().getProperty("redirector.err");
int pxerr = errorProperty.indexOf(x + " err");
int pyerr = errorProperty.indexOf(y + " err");
int pzerr = errorProperty.indexOf(z + " err");
assertFalse("pxerr=" + pxerr, pxerr < 0);
assertFalse("pyerr=" + pyerr, pyerr < 0);
assertFalse("pzerr=" + pzerr, pzerr < 0);
assertFalse("pyerr < pxerr", pyerr < pxerr);
assertFalse("pzerr < pyerr", pzerr < pyerr);
}

public void testRedirector7() throws IOException {
executeTarget("redirector7");
if (getProject().getProperty("test.can.run") == null) {
return;
}
String actualOut = getFileString("redirector.out");
String actualErr = getFileString("redirector.err");

File x = getProject().resolveFile("x");
File y = getProject().resolveFile("y");
File z = getProject().resolveFile("z");
int xout = actualOut.indexOf(x + " out");
int yout = actualOut.indexOf(y + " out");
int zout = actualOut.indexOf(z + " out");
int xerr = actualErr.indexOf(x + " ERROR!!!");
int yerr = actualErr.indexOf(y + " ERROR!!!");
int zerr = actualErr.indexOf(z + " ERROR!!!");
assertFalse("xout=" + xout, xout < 0);
assertFalse("yout=" + yout, yout < 0);
assertFalse("zout=" + zout, zout < 0);
assertFalse("xerr=" + xerr, xerr < 0);
assertFalse("yerr=" + yerr, yerr < 0);
assertFalse("zerr=" + zerr, zerr < 0);
assertFalse("yout < xout", yout < xout);
assertFalse("zout < yout", zout < yout);
assertFalse("yerr < xerr", yerr < xerr);
assertFalse("zerr < yerr", zerr < yerr);

String outProperty = getProject().getProperty("redirector.out");
int pxout = outProperty.indexOf(x + " out");
int pyout = outProperty.indexOf(y + " out");
int pzout = outProperty.indexOf(z + " out");
assertFalse("pxout=" + pxout, pxout < 0);
assertFalse("pyout=" + pyout, pyout < 0);
assertFalse("pzout=" + pzout, pzout < 0);
assertFalse("pyout < pxout", pyout < pxout);
assertFalse("pzout < pyout", pzout < pyout);

String errorProperty = getProject().getProperty("redirector.err");
int pxerr = errorProperty.indexOf(x + " ERROR!!!");
int pyerr = errorProperty.indexOf(y + " ERROR!!!");
int pzerr = errorProperty.indexOf(z + " ERROR!!!");
assertFalse("pxerr=" + pxerr, pxerr < 0);
assertFalse("pyerr=" + pyerr, pyerr < 0);
assertFalse("pzerr=" + pzerr, pzerr < 0);
assertFalse("pyerr < pxerr", pyerr < pxerr);
assertFalse("pzerr < pyerr", pzerr < pyerr);
}

public void testRedirector8() throws IOException {
executeTarget("redirector8");
if (getProject().getProperty("sed.can.run") == null) {
return;
}

assertPropertyEquals("redirector.out", getProject().replaceProperties(
"blah y z${line.separator}x blah z${line.separator}x y blah"));
assertPropertyEquals("redirector.err", "");
assertEquals("unexpected output",
"blah y z\nx blah z\nx y blah\n", getFileString("redirector.out"));
assertNull("unexpected error output", getFileString("redirector.err"));
}

public void testRedirector9() throws IOException {
testRedirector9Thru12("redirector9");
}

public void testRedirector10() throws IOException {
testRedirector9Thru12("redirector10");
}

public void testRedirector11() throws IOException {
testRedirector9Thru12("redirector11");
}

public void testRedirector12() throws IOException {
testRedirector9Thru12("redirector12");
}

private void testRedirector9Thru12(String target) throws IOException {
executeTarget(target);
if (getProject().getProperty("sed.can.run") == null) {
return;
}

assertNull("unexpected error output", getFileString("redirector.err"));
assertPropertyEquals("redirector.out", getProject().replaceProperties(
"blah after y after z${line.separator}x after blah after z"
+ "${line.separator}x after y after blah"));
assertPropertyEquals("redirector.err", "");
assertEquals("unexpected output",
"blah after y after z\nx after blah after z"
+ "\nx after y after blah\n", getFileString("redirector.out"));
}

public void testRedirector13() {
executeTarget("redirector13");
if (getProject().getProperty("test.can.run") == null) {
return;
}
String log = getLog();
File x = getProject().resolveFile("x");
File y = getProject().resolveFile("y");
File z = getProject().resolveFile("z");
int xout = log.indexOf(x + " OUTPUT???");
int yout = log.indexOf(y + " OUTPUT???");
int zout = log.indexOf(z + " OUTPUT???");
int xerr = log.indexOf(x + " ERROR!!!");
int yerr = log.indexOf(y + " ERROR!!!");
int zerr = log.indexOf(z + " ERROR!!!");
assertFalse("xout=" + xout, xout < 0);
assertFalse("yout=" + yout, yout < 0);
assertFalse("zout=" + zout, zout < 0);
assertFalse("xerr=" + xerr, xerr < 0);
assertFalse("yerr=" + yerr, yerr < 0);
assertFalse("zerr=" + zerr, zerr < 0);
assertFalse("yout < xout", yout < xout);
assertFalse("zout < yout", zout < yout);
assertFalse("yerr < xerr", yerr < xerr);
assertFalse("zerr < yerr", zerr < yerr);
}

public void testRedirector14() throws IOException {
executeTarget("redirector14");
if (getProject().getProperty("sed.can.run") == null) {
return;
}

assertEquals("unexpected log content",
"z after y after blahx after y after blah", getLog());

assertEquals("unexpected redirector.out content",
"x after blah after z\n", getFileString("redirector.out"));

assertNull("unexpected redirector.err content", getFileString("redirector.err"));
}

public void testIgnoreMissing() {
executeTarget("ignoremissing");
}

public void testForce() {
executeTarget("force");
}

public void testNoDest() {
executeTarget("testNoDest");
}

public void testLsPath() {
testLsPath("lsPath");
}

public void testLsPathParallel() {
testLsPath("lsPathParallel");
}

private void testLsPath(String target) {
executeTarget(target);
if (getProject().getProperty("ls.can.run") == null) {
return;
}
String foo = getProject().getProperty("foo");
assertNotNull(foo);
int indNoExt = foo.indexOf("ls" + LINE_SEP);
int indExe = foo.indexOf("ls.exe" + LINE_SEP);
assertTrue(indNoExt >= 0 || indExe >= 0);
}

//borrowed from TokenFilterTest
private String getFileString(String filename) throws IOException {
String result = null;
FileReader reader = null;
try {
reader = new FileReader(getProject().resolveFile(filename));
result = FileUtils.readFully(reader);
} finally {
FileUtils.close(reader);
}
return result;
}

}

Write Preview
Loading…
Cancel
Save
Please read the following content carefully:

Dear OpenI User

Thank you for your continuous support to the Openl Qizhi Community AI Collaboration Platform. In order to protect your usage rights and ensure network security, we updated the Openl Qizhi Community AI Collaboration Platform Usage Agreement in January 2024. The updated agreement specifies that users are prohibited from using intranet penetration tools. After you click "Agree and continue", you can continue to use our services. Thank you for your cooperation and understanding.

For more agreement content, please refer to the《Openl Qizhi Community AI Collaboration Platform Usage Agreement》

Agree and continue
Disagree, exit