http://git-wip-us.apache.org/repos/asf/ant/blob/84fe46d6/src/tests/antunit/taskdefs/exec/exec-test.xml
----------------------------------------------------------------------
diff --git a/src/tests/antunit/taskdefs/exec/exec-test.xml 
b/src/tests/antunit/taskdefs/exec/exec-test.xml
index b4e7f52..25b0088 100644
--- a/src/tests/antunit/taskdefs/exec/exec-test.xml
+++ b/src/tests/antunit/taskdefs/exec/exec-test.xml
@@ -16,20 +16,20 @@
   limitations under the License.
 -->
 <project name="exec-test" default="antunit" 
xmlns:au="antlib:org.apache.ant.antunit">
-    <import file="../../antunit-base.xml"/>
+    <import file="../../antunit-base.xml" />
 
     <macrodef name="assert-trimmed-resource-content">
-        <attribute name="content"/>
-        <attribute name="astext" default="true"/>
-        <element name="resource" implicit="true"/>
+        <attribute name="content" />
+        <attribute name="astext" default="true" />
+        <element name="resource" implicit="true" />
         <sequential>
             <au:assertTrue>
                 <resourcesmatch astext="@{astext}">
-                    <string value="@{content}"/>
+                    <string value="@{content}" />
                     <concat>
-                        <resource/>
+                        <resource />
                         <filterchain>
-                            <trim/>
+                            <trim />
                         </filterchain>
                     </concat>
                 </resourcesmatch>
@@ -38,78 +38,78 @@
     </macrodef>
 
     <target name="setUp">
-        <mkdir dir="${input}"/>
-        <mkdir dir="${output}"/>
-        <property environment="env"/>
+        <mkdir dir="${input}" />
+        <mkdir dir="${output}" />
+        <property environment="env" />
         <!-- UNIX -->
-        <available file="sh" filepath="${env.PATH}" property="sh.executable"/>
+        <available file="sh" filepath="${env.PATH}" property="sh.executable" />
         <!-- CYGWIN -->
-        <available file="sh.exe" filepath="${env.PATH}" 
property="sh.exe.executable"/>
+        <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"/>
+                <isset property="sh.executable" />
+                <isset property="sh.exe.executable" />
             </or>
         </condition>
         <!-- UNIX -->
-        <available file="wc" filepath="${env.PATH}" property="wc.executable"/>
+        <available file="wc" filepath="${env.PATH}" property="wc.executable" />
         <!-- CYGWIN -->
-        <available file="wc.exe" filepath="${env.PATH}" 
property="wc.exe.executable"/>
+        <available file="wc.exe" filepath="${env.PATH}" 
property="wc.exe.executable" />
         <condition property="wc.can.run">
             <or>
-                <isset property="wc.executable"/>
-                <isset property="wc.exe.executable"/>
+                <isset property="wc.executable" />
+                <isset property="wc.exe.executable" />
             </or>
         </condition>
         <!-- UNIX -->
-        <available file="cat" filepath="${env.PATH}" 
property="cat.executable"/>
+        <available file="cat" filepath="${env.PATH}" property="cat.executable" 
/>
         <!-- CYGWIN -->
-        <available file="cat.exe" filepath="${env.PATH}" 
property="cat.exe.executable"/>
+        <available file="cat.exe" filepath="${env.PATH}" 
property="cat.exe.executable" />
         <condition property="cat.can.run">
             <or>
-                <isset property="cat.executable"/>
-                <isset property="cat.exe.executable"/>
+                <isset property="cat.executable" />
+                <isset property="cat.exe.executable" />
             </or>
         </condition>
     </target>
 
     <target name="test-no-redirect" depends="setUp" if="test.can.run">
         <exec executable="sh">
-            <arg value="parrot.sh"/>
-            <arg value="${ant.file}"/>
+            <arg value="parrot.sh" />
+            <arg value="${ant.file}" />
         </exec>
-        <au:assertLogContains text="${ant.file} out"/>
-        <au:assertLogContains text="${ant.file} err"/>
+        <au:assertLogContains text="${ant.file} out" />
+        <au:assertLogContains text="${ant.file} err" />
     </target>
 
     <target name="test-redirect-output" depends="setUp" if="test.can.run">
         <exec executable="sh" output="${output}/redirect.out">
-            <arg value="parrot.sh"/>
-            <arg value="${ant.file}"/>
+            <arg value="parrot.sh" />
+            <arg value="${ant.file}" />
         </exec>
         <au:assertTrue>
             <resourcesmatch astext="true">
                 <string>${ant.file} out${line.separator}${ant.file} 
err</string>
-                <file file="${output}/redirect.out"/>
+                <file file="${output}/redirect.out" />
             </resourcesmatch>
         </au:assertTrue>
     </target>
 
     <target name="test-redirect-output-error" depends="setUp" 
if="test.can.run">
         <exec executable="sh" output="${output}/redirect.out" 
error="${output}/redirect.err">
-            <arg value="parrot.sh"/>
-            <arg value="${ant.file}"/>
+            <arg value="parrot.sh" />
+            <arg value="${ant.file}" />
         </exec>
         <au:assertTrue>
             <resourcesmatch astext="true">
                 <string>${ant.file} out</string>
-                <file file="${output}/redirect.out"/>
+                <file file="${output}/redirect.out" />
             </resourcesmatch>
         </au:assertTrue>
         <au:assertTrue>
             <resourcesmatch astext="true">
                 <string>${ant.file} err</string>
-                <file file="${output}/redirect.err"/>
+                <file file="${output}/redirect.err" />
             </resourcesmatch>
         </au:assertTrue>
     </target>
@@ -117,17 +117,17 @@
     <target name="test-redirect-output-outputproperty-logerror" 
depends="setUp" if="test.can.run">
         <exec executable="sh" logerror="true"
               output="${output}/redirect.out" outputproperty="redirect.out">
-            <arg value="parrot.sh"/>
-            <arg value="${ant.file}"/>
+            <arg value="parrot.sh" />
+            <arg value="${ant.file}" />
         </exec>
         <au:assertTrue>
             <resourcesmatch astext="true">
                 <string>${ant.file} out</string>
-                <file file="${output}/redirect.out"/>
-                <propertyresource name="redirect.out"/>
+                <file file="${output}/redirect.out" />
+                <propertyresource name="redirect.out" />
             </resourcesmatch>
         </au:assertTrue>
-        <au:assertLogContains text="${ant.file} err"/>
+        <au:assertLogContains text="${ant.file} err" />
     </target>
 
     <target name="test-redirect-output-outputproperty-error-errorproperty"
@@ -135,21 +135,21 @@
         <exec executable="sh"
               error="${output}/redirect.err" errorproperty="redirect.err"
               output="${output}/redirect.out" outputproperty="redirect.out">
-            <arg value="parrot.sh"/>
-            <arg value="${ant.file}"/>
+            <arg value="parrot.sh" />
+            <arg value="${ant.file}" />
         </exec>
         <au:assertTrue>
             <resourcesmatch astext="true">
                 <string>${ant.file} out</string>
-                <file file="${output}/redirect.out"/>
-                <propertyresource name="redirect.out"/>
+                <file file="${output}/redirect.out" />
+                <propertyresource name="redirect.out" />
             </resourcesmatch>
         </au:assertTrue>
         <au:assertTrue>
             <resourcesmatch astext="true">
                 <string>${ant.file} err</string>
-                <file file="${output}/redirect.err"/>
-                <propertyresource name="redirect.err"/>
+                <file file="${output}/redirect.err" />
+                <propertyresource name="redirect.err" />
             </resourcesmatch>
         </au:assertTrue>
     </target>
@@ -159,19 +159,19 @@
         <exec executable="wc" inputstring="x y z"
               error="${output}/redirect.err" errorproperty="redirect.err"
               output="${output}/redirect.out" outputproperty="redirect.out">
-            <arg value="-w"/>
+            <arg value="-w" />
         </exec>
         <au:assertTrue>
             <length length="0">
-                <file file="${output}/redirect.err"/>
-                <propertyresource name="redirect.err"/>
+                <file file="${output}/redirect.err" />
+                <propertyresource name="redirect.err" />
             </length>
         </au:assertTrue>
         <assert-trimmed-resource-content content="3">
-            <file file="${output}/redirect.out"/>
+            <file file="${output}/redirect.out" />
         </assert-trimmed-resource-content>
         <assert-trimmed-resource-content content="3">
-            <propertyresource name="redirect.out"/>
+            <propertyresource name="redirect.out" />
         </assert-trimmed-resource-content>
     </target>
 
@@ -181,19 +181,19 @@
         <exec executable="wc" input="${input}/redirect.in"
               error="${output}/redirect.err" errorproperty="redirect.err"
               output="${output}/redirect.out" outputproperty="redirect.out">
-            <arg value="-w"/>
+            <arg value="-w" />
         </exec>
         <au:assertTrue>
             <length length="0">
-                <file file="${output}/redirect.err"/>
-                <propertyresource name="redirect.err"/>
+                <file file="${output}/redirect.err" />
+                <propertyresource name="redirect.err" />
             </length>
         </au:assertTrue>
         <assert-trimmed-resource-content content="3">
-            <file file="${output}/redirect.out"/>
+            <file file="${output}/redirect.out" />
         </assert-trimmed-resource-content>
         <assert-trimmed-resource-content content="3">
-            <propertyresource name="redirect.out"/>
+            <propertyresource name="redirect.out" />
         </assert-trimmed-resource-content>
     </target>
 
@@ -202,22 +202,22 @@
         <exec executable="wc" inputstring="x y z"
               error="${output}/redirect.err"
               output="${output}/redirect.out" outputproperty="redirect.out">
-            <arg value="-w"/>
+            <arg value="-w" />
         </exec>
         <au:assertTrue>
             <length length="0">
-                <file file="${output}/redirect.err"/>
+                <file file="${output}/redirect.err" />
             </length>
         </au:assertTrue>
         <concat>
-            <file file="${output}/redirect.out"/>
-            <propertyresource name="redirect.out"/>
+            <file file="${output}/redirect.out" />
+            <propertyresource name="redirect.out" />
         </concat>
         <assert-trimmed-resource-content content="3">
-            <file file="${output}/redirect.out"/>
+            <file file="${output}/redirect.out" />
         </assert-trimmed-resource-content>
         <assert-trimmed-resource-content content="3">
-            <propertyresource name="redirect.out"/>
+            <propertyresource name="redirect.out" />
         </assert-trimmed-resource-content>
     </target>
 
@@ -225,85 +225,85 @@
             depends="setUp" if="test.can.run">
         <au:expectfailure>
             <exec executable="sh">
-                <arg value="parrot.sh"/>
-                <arg value="${ant.file}"/>
-                <redirector output="${output}/redirector.out"/>
-                <redirector output="whocares"/>
+                <arg value="parrot.sh" />
+                <arg value="${ant.file}" />
+                <redirector output="${output}/redirector.out" />
+                <redirector output="whocares" />
             </exec>
         </au:expectfailure>
     </target>
 
     <target name="test-redirector-output" depends="setUp" if="test.can.run">
         <exec executable="sh">
-            <arg value="parrot.sh"/>
-            <arg value="${ant.file}"/>
-            <redirector output="${output}/redirector.out"/>
+            <arg value="parrot.sh" />
+            <arg value="${ant.file}" />
+            <redirector output="${output}/redirector.out" />
         </exec>
         <au:assertTrue>
             <resourcesmatch astext="true">
                 <string>${ant.file} out${line.separator}${ant.file} 
err</string>
-                <file file="${output}/redirector.out"/>
+                <file file="${output}/redirector.out" />
             </resourcesmatch>
         </au:assertTrue>
     </target>
 
     <target name="test-redirector-output-error" depends="setUp" 
if="test.can.run">
         <exec executable="sh">
-            <arg value="parrot.sh"/>
-            <arg value="${ant.file}"/>
-            <redirector output="${output}/redirector.out" 
error="${output}/redirector.err"/>
+            <arg value="parrot.sh" />
+            <arg value="${ant.file}" />
+            <redirector output="${output}/redirector.out" 
error="${output}/redirector.err" />
         </exec>
         <au:assertTrue>
             <resourcesmatch astext="true">
                 <string>${ant.file} out</string>
-                <file file="${output}/redirector.out"/>
+                <file file="${output}/redirector.out" />
             </resourcesmatch>
         </au:assertTrue>
         <au:assertTrue>
             <resourcesmatch astext="true">
                 <string>${ant.file} err</string>
-                <file file="${output}/redirector.err"/>
+                <file file="${output}/redirector.err" />
             </resourcesmatch>
         </au:assertTrue>
     </target>
 
     <target name="test-redirector-output-outputproperty-logerror" 
depends="setUp" if="test.can.run">
         <exec executable="sh">
-            <arg value="parrot.sh"/>
-            <arg value="${ant.file}"/>
+            <arg value="parrot.sh" />
+            <arg value="${ant.file}" />
             <redirector output="${output}/redirector.out" logerror="true"
-                        outputproperty="redirector.out"/>
+                        outputproperty="redirector.out" />
         </exec>
         <au:assertTrue>
             <resourcesmatch astext="true">
                 <string>${ant.file} out</string>
-                <file file="${output}/redirector.out"/>
-                <propertyresource name="redirector.out"/>
+                <file file="${output}/redirector.out" />
+                <propertyresource name="redirector.out" />
             </resourcesmatch>
         </au:assertTrue>
-        <au:assertLogContains text="${ant.file} err"/>
+        <au:assertLogContains text="${ant.file} err" />
     </target>
 
     <target name="test-redirector-output-outputproperty-error-errorproperty"
             depends="setUp" if="test.can.run">
         <exec executable="sh">
             <redirector error="${output}/redirector.err" 
errorproperty="redirector.err"
-              output="${output}/redirector.out" 
outputproperty="redirector.out"/>
-            <arg value="parrot.sh"/>
-            <arg value="${ant.file}"/>
+              output="${output}/redirector.out" 
outputproperty="redirector.out" />
+            <arg value="parrot.sh" />
+            <arg value="${ant.file}" />
         </exec>
         <au:assertTrue>
             <resourcesmatch astext="true">
                 <string>${ant.file} out</string>
-                <file file="${output}/redirector.out"/>
-                <propertyresource name="redirector.out"/>
+                <file file="${output}/redirector.out" />
+                <propertyresource name="redirector.out" />
             </resourcesmatch>
         </au:assertTrue>
         <au:assertTrue>
             <resourcesmatch astext="true">
                 <string>${ant.file} err</string>
-                <file file="${output}/redirector.err"/>
-                <propertyresource name="redirector.err"/>
+                <file file="${output}/redirector.err" />
+                <propertyresource name="redirector.err" />
             </resourcesmatch>
         </au:assertTrue>
     </target>
@@ -313,24 +313,24 @@
         <exec executable="sh">
             <redirector outputproperty="redirector.out"
                         errorproperty="redirector.err">
-                <outputmapper type="merge" to="${output}/redirector.out"/>
-                <errormapper type="merge" to="${output}/redirector.err"/>
+                <outputmapper type="merge" to="${output}/redirector.out" />
+                <errormapper type="merge" to="${output}/redirector.err" />
             </redirector>
-            <arg value="parrot.sh"/>
-            <arg value="${ant.file}"/>
+            <arg value="parrot.sh" />
+            <arg value="${ant.file}" />
         </exec>
         <au:assertTrue>
             <resourcesmatch astext="true">
                 <string>${ant.file} out</string>
-                <file file="${output}/redirector.out"/>
-                <propertyresource name="redirector.out"/>
+                <file file="${output}/redirector.out" />
+                <propertyresource name="redirector.out" />
             </resourcesmatch>
         </au:assertTrue>
         <au:assertTrue>
             <resourcesmatch astext="true">
                 <string>${ant.file} err</string>
-                <file file="${output}/redirector.err"/>
-                <propertyresource name="redirector.err"/>
+                <file file="${output}/redirector.err" />
+                <propertyresource name="redirector.err" />
             </resourcesmatch>
         </au:assertTrue>
     </target>
@@ -340,27 +340,27 @@
         <exec executable="sh">
             <redirector outputproperty="redirector.out"
                         errorproperty="redirector.err">
-                <outputmapper type="merge" to="${output}/redirector.out"/>
-                <errormapper type="merge" to="${output}/redirector.err"/>
+                <outputmapper type="merge" to="${output}/redirector.out" />
+                <errormapper type="merge" to="${output}/redirector.err" />
                 <errorfilterchain>
-                    <replacestring from="err" to="ERROR!!!"/>
+                    <replacestring from="err" to="ERROR!!!" />
                 </errorfilterchain>
             </redirector>
-            <arg value="parrot.sh"/>
-            <arg value="${ant.file}"/>
+            <arg value="parrot.sh" />
+            <arg value="${ant.file}" />
         </exec>
         <au:assertTrue>
             <resourcesmatch astext="true">
                 <string>${ant.file} out</string>
-                <file file="${output}/redirector.out"/>
-                <propertyresource name="redirector.out"/>
+                <file file="${output}/redirector.out" />
+                <propertyresource name="redirector.out" />
             </resourcesmatch>
         </au:assertTrue>
         <au:assertTrue>
             <resourcesmatch astext="true">
                 <string>${ant.file} ERROR!!!</string>
-                <file file="${output}/redirector.err"/>
-                <propertyresource name="redirector.err"/>
+                <file file="${output}/redirector.err" />
+                <propertyresource name="redirector.err" />
             </resourcesmatch>
         </au:assertTrue>
     </target>
@@ -371,22 +371,22 @@
         <exec executable="wc">
             <redirector outputproperty="redirector.out"
                         errorproperty="redirector.err">
-                <inputmapper type="merge" to="${input}/redirector.in"/>
-                <outputmapper type="merge" to="${output}/redirector.out"/>
-                <errormapper type="merge" to="${output}/redirector.err"/>
+                <inputmapper type="merge" to="${input}/redirector.in" />
+                <outputmapper type="merge" to="${output}/redirector.out" />
+                <errormapper type="merge" to="${output}/redirector.err" />
             </redirector>
-            <arg value="-w"/>
+            <arg value="-w" />
         </exec>
         <assert-trimmed-resource-content content="3">
-            <file file="${output}/redirector.out"/>
+            <file file="${output}/redirector.out" />
         </assert-trimmed-resource-content>
         <assert-trimmed-resource-content content="3">
-            <propertyresource name="redirector.out"/>
+            <propertyresource name="redirector.out" />
         </assert-trimmed-resource-content>
         <au:assertTrue>
             <length length="0">
-                <file file="${output}/redirector.err"/>
-                <propertyresource name="redirector.err"/>
+                <file file="${output}/redirector.err" />
+                <propertyresource name="redirector.err" />
             </length>
         </au:assertTrue>
     </target>
@@ -398,24 +398,24 @@
             <redirector outputproperty="redirector.out"
                         errorproperty="redirector.err">
                 <inputfilterchain>
-                    <replacestring from="before" to="after"/>
+                    <replacestring from="before" to="after" />
                 </inputfilterchain>
-                <inputmapper type="merge" to="${input}/redirector.in"/>
-                <outputmapper type="merge" to="${output}/redirector.out"/>
-                <errormapper type="merge" to="${output}/redirector.err"/>
+                <inputmapper type="merge" to="${input}/redirector.in" />
+                <outputmapper type="merge" to="${output}/redirector.out" />
+                <errormapper type="merge" to="${output}/redirector.err" />
             </redirector>
         </exec>
         <au:assertTrue>
             <resourcesmatch astext="true">
-                <string value="blah after blah"/>
-                <file file="${output}/redirector.out"/>
-                <propertyresource name="redirector.out"/>
+                <string value="blah after blah" />
+                <file file="${output}/redirector.out" />
+                <propertyresource name="redirector.out" />
             </resourcesmatch>
         </au:assertTrue>
         <au:assertTrue>
             <length length="0">
-                <file file="${output}/redirector.err"/>
-                <propertyresource name="redirector.err"/>
+                <file file="${output}/redirector.err" />
+                <propertyresource name="redirector.err" />
             </length>
         </au:assertTrue>
     </target>
@@ -427,24 +427,24 @@
             <redirector outputproperty="redirector.out"
                         errorproperty="redirector.err">
                 <outputfilterchain>
-                    <replacestring from="before" to="after"/>
+                    <replacestring from="before" to="after" />
                 </outputfilterchain>
-                <outputmapper type="merge" to="${output}/redirector.out"/>
-                <errormapper type="merge" to="${output}/redirector.err"/>
+                <outputmapper type="merge" to="${output}/redirector.out" />
+                <errormapper type="merge" to="${output}/redirector.err" />
             </redirector>
-            <arg value="${input}/redirector.in"/>
+            <arg value="${input}/redirector.in" />
         </exec>
         <au:assertTrue>
             <resourcesmatch astext="true">
-                <string value="blah after blah"/>
-                <file file="${output}/redirector.out"/>
-                <propertyresource name="redirector.out"/>
+                <string value="blah after blah" />
+                <file file="${output}/redirector.out" />
+                <propertyresource name="redirector.out" />
             </resourcesmatch>
         </au:assertTrue>
         <au:assertTrue>
             <length length="0">
-                <file file="${output}/redirector.err"/>
-                <propertyresource name="redirector.err"/>
+                <file file="${output}/redirector.err" />
+                <propertyresource name="redirector.err" />
             </length>
         </au:assertTrue>
     </target>
@@ -456,23 +456,23 @@
                         errorproperty="redirector.err"
                         inputstring="blah before blah">
                 <inputfilterchain>
-                    <replacestring from="before" to="after"/>
+                    <replacestring from="before" to="after" />
                 </inputfilterchain>
-                <outputmapper type="merge" to="${output}/redirector.out"/>
-                <errormapper type="merge" to="${output}/redirector.err"/>
+                <outputmapper type="merge" to="${output}/redirector.out" />
+                <errormapper type="merge" to="${output}/redirector.err" />
             </redirector>
         </exec>
         <au:assertTrue>
             <resourcesmatch astext="true">
-                <string value="blah after blah"/>
-                <file file="${output}/redirector.out"/>
-                <propertyresource name="redirector.out"/>
+                <string value="blah after blah" />
+                <file file="${output}/redirector.out" />
+                <propertyresource name="redirector.out" />
             </resourcesmatch>
         </au:assertTrue>
         <au:assertTrue>
             <length length="0">
-                <file file="${output}/redirector.err"/>
-                <propertyresource name="redirector.err"/>
+                <file file="${output}/redirector.err" />
+                <propertyresource name="redirector.err" />
             </length>
         </au:assertTrue>
     </target>
@@ -484,29 +484,29 @@
             <redirector outputproperty="redirector.out"
                         errorproperty="redirector.err">
                 <outputfilterchain>
-                    <replacestring from="before" to="after"/>
+                    <replacestring from="before" to="after" />
                 </outputfilterchain>
-                <outputmapper type="glob" from="nomatch" 
to="${output}/nomatchout"/>
-                <errormapper type="glob" from="nomatch" 
to="${output}/nomatcherr"/>
+                <outputmapper type="glob" from="nomatch" 
to="${output}/nomatchout" />
+                <errormapper type="glob" from="nomatch" 
to="${output}/nomatcherr" />
             </redirector>
-            <arg value="${input}/redirector.in"/>
+            <arg value="${input}/redirector.in" />
         </exec>
         <au:assertTrue>
             <resourcesmatch astext="true">
-                <string value="blah after blah"/>
-                <file file="${output}/redirector.out"/>
-                <propertyresource name="redirector.out"/>
+                <string value="blah after blah" />
+                <file file="${output}/redirector.out" />
+                <propertyresource name="redirector.out" />
             </resourcesmatch>
         </au:assertTrue>
         <au:assertTrue>
             <length length="0">
-                <file file="${output}/redirector.err"/>
-                <propertyresource name="redirector.err"/>
+                <file file="${output}/redirector.err" />
+                <propertyresource name="redirector.err" />
             </length>
         </au:assertTrue>
         <au:assertTrue>
             <resourcecount count="0">
-                <fileset dir="${output}" includes="nomatch???"/>
+                <fileset dir="${output}" includes="nomatch???" />
             </resourcecount>
         </au:assertTrue>
     </target>
@@ -516,17 +516,17 @@
         <exec executable="sh">
             <redirector>
                 <outputfilterchain>
-                    <replacestring from="out" to="OUTPUT???"/>
+                    <replacestring from="out" to="OUTPUT???" />
                 </outputfilterchain>
                 <errorfilterchain>
-                    <replacestring from="err" to="ERROR!!!"/>
+                    <replacestring from="err" to="ERROR!!!" />
                 </errorfilterchain>
             </redirector>
-            <arg value="parrot.sh"/>
-            <arg value="${ant.file}"/>
+            <arg value="parrot.sh" />
+            <arg value="${ant.file}" />
         </exec>
-        <au:assertLogContains text="${ant.file} OUTPUT???"/>
-        <au:assertLogContains text="${ant.file} ERROR!!!"/>
+        <au:assertLogContains text="${ant.file} OUTPUT???" />
+        <au:assertLogContains text="${ant.file} ERROR!!!" />
     </target>
 
     <target 
name="test-redirector-inputstring-outputfilterchain-outputmapper-errormapper"
@@ -534,25 +534,25 @@
         <exec executable="cat">
             <redirector inputstring="blah before blah">
                 <outputfilterchain>
-                    <replacestring from="before" to="after"/>
+                    <replacestring from="before" to="after" />
                 </outputfilterchain>
-                <outputmapper type="glob" from="nomatch" to="nomatchout"/>
-                <errormapper type="glob" from="nomatch" to="nomatcherr"/>
+                <outputmapper type="glob" from="nomatch" to="nomatchout" />
+                <errormapper type="glob" from="nomatch" to="nomatcherr" />
             </redirector>
         </exec>
-        <au:assertLogContains text="blah after blah"/>
+        <au:assertLogContains text="blah after blah" />
     </target>
 
     <target name="test-redirector-input-output-inputencoding-outputencoding"
             depends="setUp" if="cat.can.run">
         <exec executable="cat">
             <redirector input="input/iso8859-1" 
output="${output}/redirector.out"
-                        inputencoding="ISO8859_1" outputencoding="UTF8"/>
+                        inputencoding="ISO8859_1" outputencoding="UTF8" />
         </exec>
         <au:assertTrue>
             <resourcesmatch astext="true">
-                <file file="${output}/redirector.out"/>
-                <file file="expected/utf-8"/>
+                <file file="${output}/redirector.out" />
+                <file file="expected/utf-8" />
             </resourcesmatch>
         </au:assertTrue>
     </target>
@@ -560,12 +560,12 @@
     <target name="test-redirector-inputstring-output-error" depends="setUp" 
if="test.can.run">
         <exec executable="sh">
             <redirector inputstring="exit"
-                        output="${output}/redirector.out" 
error="${output}/redirector.err"/>
+                        output="${output}/redirector.out" 
error="${output}/redirector.err" />
         </exec>
         <au:assertTrue>
             <and>
-                <available file="${output}/redirector.out" type="file"/>
-                <available file="${output}/redirector.err" type="file"/>
+                <available file="${output}/redirector.out" type="file" />
+                <available file="${output}/redirector.err" type="file" />
             </and>
         </au:assertTrue>
     </target>
@@ -574,13 +574,13 @@
             depends="setUp" if="test.can.run">
         <exec executable="sh">
             <redirector inputstring="exit" createemptyfiles="false"
-                        output="${output}/redirector.out" 
error="${output}/redirector.err"/>
+                        output="${output}/redirector.out" 
error="${output}/redirector.err" />
         </exec>
         <au:assertTrue>
             <not>
                 <or>
-                    <available file="${output}/redirector.out" type="file"/>
-                    <available file="${output}/redirector.err" type="file"/>
+                    <available file="${output}/redirector.out" type="file" />
+                    <available file="${output}/redirector.err" type="file" />
                 </or>
             </not>
         </au:assertTrue>
@@ -588,15 +588,15 @@
 
     <target name="test-redirector-alwayslog-outputproperty" depends="setUp" 
if="test.can.run">
         <exec executable="sh">
-            <arg value="parrot.sh"/>
-            <arg value="${ant.file}"/>
+            <arg value="parrot.sh" />
+            <arg value="${ant.file}" />
             <redirector alwayslog="true" logerror="true"
-                        outputproperty="redirector.out"/>
+                        outputproperty="redirector.out" />
         </exec>
         <au:assertTrue>
-            <equals arg1="${ant.file} out" arg2="${redirector.out}"/>
+            <equals arg1="${ant.file} out" arg2="${redirector.out}" />
         </au:assertTrue>
-        <au:assertLogContains text="${ant.file} out"/>
+        <au:assertLogContains text="${ant.file} out" />
     </target>
 
     <!-- test will succeed as the OS wont match-->
@@ -615,11 +615,11 @@
       <exec executable="cmd.exe"
             failonerror="true"
             osFamily="winnt">
-            <arg value="/c"/>
-            <arg value="time /t"/>
+            <arg value="/c" />
+            <arg value="time /t" />
       </exec>
     </target>
-
+    
     <target name="testExecInconsistentSettings">
       <exec executable="nonexistent-program-we-expect"
             failonerror="true"
@@ -627,7 +627,7 @@
             os="linux unix">
       </exec>
     </target>
-
+    
     <target name="testDoesntWaitForChildren"
             
description="https://issues.apache.org/bugzilla/show_bug.cgi?id=5003";>
       <condition property="java"
@@ -687,8 +687,8 @@ public class Hello {
         </exec>
         <au:assertTrue>
             <resourcesmatch astext="true">
-                <file file="${output}/redirector.out"/>
-                <file file="${output}/expected"/>
+                <file file="${output}/redirector.out" />
+                <file file="${output}/expected" />
             </resourcesmatch>
         </au:assertTrue>
     </target>
@@ -701,8 +701,8 @@ public class Hello {
         </exec>
         <au:assertTrue>
             <resourcesmatch astext="true">
-                <file file="${output}/redirector.out"/>
-                <file file="${input}/redirector.in"/>
+                <file file="${output}/redirector.out" />
+                <file file="${input}/redirector.in" />
             </resourcesmatch>
         </au:assertTrue>
     </target>

http://git-wip-us.apache.org/repos/asf/ant/blob/84fe46d6/src/tests/antunit/taskdefs/fail-test.xml
----------------------------------------------------------------------
diff --git a/src/tests/antunit/taskdefs/fail-test.xml 
b/src/tests/antunit/taskdefs/fail-test.xml
index e9cca05..d525b73 100644
--- a/src/tests/antunit/taskdefs/fail-test.xml
+++ b/src/tests/antunit/taskdefs/fail-test.xml
@@ -18,7 +18,7 @@
 
 <project name="echo-test" default="antunit"
          xmlns:au="antlib:org.apache.ant.antunit">
-  <import file="../antunit-base.xml"/>
+  <import file="../antunit-base.xml" />
 
   <target name="testIfNotSet">
     <au:expectfailure>

http://git-wip-us.apache.org/repos/asf/ant/blob/84fe46d6/src/tests/antunit/taskdefs/get-test.xml
----------------------------------------------------------------------
diff --git a/src/tests/antunit/taskdefs/get-test.xml 
b/src/tests/antunit/taskdefs/get-test.xml
index 2e041e4..e7289e3 100644
--- a/src/tests/antunit/taskdefs/get-test.xml
+++ b/src/tests/antunit/taskdefs/get-test.xml
@@ -17,12 +17,12 @@
 -->
 
 <project name="get-test" default="antunit" 
xmlns:au="antlib:org.apache.ant.antunit">
-  <import file="../antunit-base.xml"/>
-
-  <property name="location" value="http://ant.apache.org/webtest/gettest"/>
+  <import file="../antunit-base.xml" />
 
+  <property name="location" value="http://ant.apache.org/webtest/gettest"; />
+    
   <target name="setUp">
-    <mkdir dir="${output}"/>
+    <mkdir dir="${output}" />
   </target>
 
   <target name="testSeeOtherRedirect">
@@ -30,70 +30,70 @@
       <au:assertTrue>
             <resourcecount count="1">
               <restrict>
-                <file file="${output}/other.tmp"/>
-                <contains text="seeother redirect succeeded"/>
+                <file file="${output}/other.tmp" />
+                <contains text="seeother redirect succeeded" />
               </restrict>
             </resourcecount>
           </au:assertTrue>
-    <au:assertLogContains text="other.txt moved to http"/>
+    <au:assertLogContains text="other.txt moved to http" />  
   </target>
-
+    
     <target name="testPermanentRedirect">
       <get  src="${location}/permanent.txt" dest="${output}/permanent.tmp"/>
         <au:assertTrue>
           <resourcecount count="1">
             <restrict>
-              <file file="${output}/permanent.tmp"/>
-              <contains text="permanent redirect succeeded"/>
+              <file file="${output}/permanent.tmp" />
+              <contains text="permanent redirect succeeded" />
             </restrict>
           </resourcecount>
         </au:assertTrue>
-        <au:assertLogContains text="permanent.txt permanently moved to http"/>
+        <au:assertLogContains text="permanent.txt permanently moved to http" />
     </target>
-
+    
     <target name="testTemporaryRedirect">
       <get  src="${location}/temp.txt" dest="${output}/temp.txt"/>
         <au:assertTrue>
           <resourcecount count="1">
             <restrict>
-              <file file="${output}/temp.txt"/>
-              <contains text="temporary redirect succeeded"/>
+              <file file="${output}/temp.txt" />
+              <contains text="temporary redirect succeeded" />
             </restrict>
           </resourcecount>
         </au:assertTrue>
-        <au:assertLogContains text="temp.txt moved to http"/>
+        <au:assertLogContains text="temp.txt moved to http" />
     </target>
-
+    
     <target name="testStatusCode307Redirect">
       <get  src="${location}/307.txt" dest="${output}/307.txt"/>
         <au:assertTrue>
           <resourcecount count="1">
             <restrict>
-              <file file="${output}/307.txt"/>
-              <contains text="307 status code redirect succeeded"/>
+              <file file="${output}/307.txt" />
+              <contains text="307 status code redirect succeeded" />
             </restrict>
           </resourcecount>
         </au:assertTrue>
-        <au:assertLogContains text="307.txt moved to http"/>
+        <au:assertLogContains text="307.txt moved to http" />
     </target>
-
+    
     <target name="test5LevelsOfRedirect">
       <get  src="${location}/redir5.txt" dest="${output}/redir5.tmp"/>
         <au:assertTrue>
           <resourcecount count="1">
             <restrict>
-              <file file="${output}/redir5.tmp"/>
-              <contains text="5 levels of redirect succeeded"/>
+              <file file="${output}/redir5.tmp" />
+              <contains text="5 levels of redirect succeeded" />
             </restrict>
           </resourcecount>
         </au:assertTrue>
 
-        <au:assertLogContains text="redir5.txt moved to http"/>
+        <au:assertLogContains text="redir5.txt moved to http" />
 
-        <au:assertLogContains text="redir5-4.txt moved to http"/>
+        <au:assertLogContains text="redir5-4.txt moved to http" />
     </target>
-
-
+    
+    
     <target name="testInfiniteRedirect" unless="jenkins">
       <au:expectfailure expectedmessage="More than 25 times redirected, giving 
up">
       <get  src="${location}/infinite.txt" dest="${output}/infinite.tmp"/>
@@ -102,8 +102,8 @@
 
 
     <target name="testNestedResources">
-      <get  dest="${output}/downloads">
-        <url url="http://ant.apache.org/index.html"/>
+      <get dest="${output}/downloads">
+        <url url="http://ant.apache.org/index.html"/> 
         <url url="http://ant.apache.org/faq.html"/>
       </get>
       <au:assertFileExists file="${output}/downloads/index.html"/>
@@ -115,12 +115,12 @@
     <au:assertTrue>
       <resourcecount count="1">
         <restrict>
-          <file file="${output}/other.tmp"/>
+          <file file="${output}/other.tmp" />
           <contains text="local redirect succeeded"/>
         </restrict>
       </resourcecount>
     </au:assertTrue>
-    <au:assertLogContains text="local.cgi moved to http"/>
+    <au:assertLogContains text="local.cgi moved to http" />  
   </target>
 
   <target name="testHttpToHttpsRedirect" description="Tests that a resource 
that's redirected

http://git-wip-us.apache.org/repos/asf/ant/blob/84fe46d6/src/tests/antunit/taskdefs/gunzip-test.xml
----------------------------------------------------------------------
diff --git a/src/tests/antunit/taskdefs/gunzip-test.xml 
b/src/tests/antunit/taskdefs/gunzip-test.xml
index 68c1114..e678eb0 100644
--- a/src/tests/antunit/taskdefs/gunzip-test.xml
+++ b/src/tests/antunit/taskdefs/gunzip-test.xml
@@ -16,12 +16,12 @@
   limitations under the License.
 -->
 <project default="antunit" xmlns:au="antlib:org.apache.ant.antunit">
-  <import file="../antunit-base.xml"/>
+  <import file="../antunit-base.xml" />
 
   <target name="setup">
     <mkdir dir="${output}"/>
   </target>
-
+  
   <target name="testWithFileResourceToFile" depends="setup">
     <gunzip dest="${output}/asf-logo.gif">
       <file file="../../../etc/testcases/taskdefs/expected/asf-logo.gif.gz"/>
@@ -59,3 +59,4 @@
   </target>
 
 </project>
+

http://git-wip-us.apache.org/repos/asf/ant/blob/84fe46d6/src/tests/antunit/taskdefs/gzip-test.xml
----------------------------------------------------------------------
diff --git a/src/tests/antunit/taskdefs/gzip-test.xml 
b/src/tests/antunit/taskdefs/gzip-test.xml
index f267a13..38f0a7a 100644
--- a/src/tests/antunit/taskdefs/gzip-test.xml
+++ b/src/tests/antunit/taskdefs/gzip-test.xml
@@ -18,19 +18,19 @@
 <project default="antunit" xmlns:au="antlib:org.apache.ant.antunit">
 
     <!-- note relies on antunit 1.1 -->
-    <import file="../antunit-base.xml"/>
+    <import file="../antunit-base.xml" />
 
     <target name="setUp">
-        <mkdir dir="${output}"/>
-        <mkdir dir="${output}/empty"/>
-        <touch file="${output}/fileone"/>
-        <touch file="${output}/filetwo"/>
+        <mkdir dir="${output}" />
+        <mkdir dir="${output}/empty" />
+        <touch file="${output}/fileone" />
+        <touch file="${output}/filetwo" />
     </target>
 
     <target name="testFailNone">
         <au:expectfailure expectedmessage="No resource selected, gzip needs 
exactly one resource." message="Should have thrown an exception">
             <gzip destfile="${output}/file.gz">
-                <fileset dir="${output}/empty"/>
+                <fileset dir="${output}/empty" />
             </gzip>
         </au:expectfailure>
     </target>
@@ -38,7 +38,7 @@
     <target name="testFailTwo">
         <au:expectfailure expectedmessage="gzip cannot handle multiple 
resources at once. (2 resources were selected.)" message="Should have thrown an 
exception">
             <gzip destfile="${output}/file.gz">
-                <fileset dir="${output}"/>
+                <fileset dir="${output}" />
             </gzip>
         </au:expectfailure>
     </target>

http://git-wip-us.apache.org/repos/asf/ant/blob/84fe46d6/src/tests/antunit/taskdefs/hostinfo-test.xml
----------------------------------------------------------------------
diff --git a/src/tests/antunit/taskdefs/hostinfo-test.xml 
b/src/tests/antunit/taskdefs/hostinfo-test.xml
index 267fa4f..a044b9b 100644
--- a/src/tests/antunit/taskdefs/hostinfo-test.xml
+++ b/src/tests/antunit/taskdefs/hostinfo-test.xml
@@ -18,25 +18,25 @@
 <project name="hostinfo-test" default="antunit"
          xmlns:au="antlib:org.apache.ant.antunit">
 
-  <import file="../antunit-base.xml"/>
-
-  <property name="undef-name" value="nonexistenthost.nonexistentdomain"/>
-  <property name="undef-hostname" value="nonexistenthost"/>
-  <property name="undef-domainname" value="nonexistentdomain"/>
-
-  <property name="undef-ip4" value="0.0.0.0"/>
-  <property name="undef-ip6" value="::"/>
-
-  <property name="xs4all-hostname" value="www.xs4all.nl"/>
-  <property name="xs4all-domain" value="xs4all.nl"/>
-  <property name="xs4all-realhost" value="www"/>
-  <property name="xs4all-ip4" value="194.109.6.92"/>
+  <import file="../antunit-base.xml" />
 
+  <property name="undef-name" value="nonexistenthost.nonexistentdomain" />
+  <property name="undef-hostname" value="nonexistenthost" />
+  <property name="undef-domainname" value="nonexistentdomain" />
+        
+  <property name="undef-ip4" value="0.0.0.0" />
+  <property name="undef-ip6" value="::" />
+      
+  <property name="xs4all-hostname" value="www.xs4all.nl" />
+  <property name="xs4all-domain" value="xs4all.nl" />
+  <property name="xs4all-realhost" value="www" />
+  <property name="xs4all-ip4" value="194.109.6.92" />
+    
   <target name="setUp">
   </target>
 
   <target name="testLocal" depends="setUp">
-    <hostinfo prefix="local"/>
+    <hostinfo prefix="local" />
       <!-- Do not know what to expect here, machine dependent -->
   </target>
 
@@ -46,19 +46,19 @@
       <au:assertEquals expected="${xs4all-domain}" actual="${DOMAIN}"/>
       <au:assertEquals expected="${xs4all-ip4}" actual="${ADDR4}"/>
     </target>
-
+    
     <target name="testReverse" depends="setUp">
       <hostinfo prefix="reverse" host="${xs4all-ip4}"/>
       <au:assertEquals expected="${xs4all-realhost}" actual="${reverse.NAME}"/>
       <au:assertEquals expected="${xs4all-domain}" actual="${reverse.DOMAIN}"/>
       <au:assertEquals expected="${xs4all-ip4}" actual="${reverse.ADDR4}"/>
     </target>
-
+    
     <target name="testUndef" depends="setUp">
       <hostinfo prefix="undef" host="${undef-name}"/>
       <au:assertEquals expected="${undef-hostname}" actual="${undef.NAME}"/>
       <au:assertEquals expected="${undef-domainname}" 
actual="${undef.DOMAIN}"/>
       <au:assertEquals expected="${undef-ip4}" actual="${undef.ADDR4}"/>
     </target>
-
+    
 </project>

http://git-wip-us.apache.org/repos/asf/ant/blob/84fe46d6/src/tests/antunit/taskdefs/import-test.xml
----------------------------------------------------------------------
diff --git a/src/tests/antunit/taskdefs/import-test.xml 
b/src/tests/antunit/taskdefs/import-test.xml
index f2ece68..f9e4b05 100644
--- a/src/tests/antunit/taskdefs/import-test.xml
+++ b/src/tests/antunit/taskdefs/import-test.xml
@@ -16,7 +16,7 @@
   limitations under the License.
 -->
 <project default="antunit" xmlns:au="antlib:org.apache.ant.antunit">
-  <import file="../antunit-base.xml"/>
+  <import file="../antunit-base.xml" />
 
   <import>
     <file file="importtests/a.xml"/>

http://git-wip-us.apache.org/repos/asf/ant/blob/84fe46d6/src/tests/antunit/taskdefs/import-url-test.xml
----------------------------------------------------------------------
diff --git a/src/tests/antunit/taskdefs/import-url-test.xml 
b/src/tests/antunit/taskdefs/import-url-test.xml
index e4fb84c..103ece3 100644
--- a/src/tests/antunit/taskdefs/import-url-test.xml
+++ b/src/tests/antunit/taskdefs/import-url-test.xml
@@ -16,7 +16,7 @@
   limitations under the License.
 -->
 <project default="antunit" xmlns:au="antlib:org.apache.ant.antunit">
-  <import file="../antunit-base.xml"/>
+  <import file="../antunit-base.xml" />
 
   <mkdir dir="${output}"/>
   <mkdir dir="${input}/a/b"/>

http://git-wip-us.apache.org/repos/asf/ant/blob/84fe46d6/src/tests/antunit/taskdefs/importtests/a.xml
----------------------------------------------------------------------
diff --git a/src/tests/antunit/taskdefs/importtests/a.xml 
b/src/tests/antunit/taskdefs/importtests/a.xml
index 4651f9a..6082990 100644
--- a/src/tests/antunit/taskdefs/importtests/a.xml
+++ b/src/tests/antunit/taskdefs/importtests/a.xml
@@ -20,3 +20,4 @@
     <property name="foo" value="bar"/>
   </target>
 </project>
+

http://git-wip-us.apache.org/repos/asf/ant/blob/84fe46d6/src/tests/antunit/taskdefs/importtests/b.xml
----------------------------------------------------------------------
diff --git a/src/tests/antunit/taskdefs/importtests/b.xml 
b/src/tests/antunit/taskdefs/importtests/b.xml
index 8fdfc11..546badf 100644
--- a/src/tests/antunit/taskdefs/importtests/b.xml
+++ b/src/tests/antunit/taskdefs/importtests/b.xml
@@ -20,3 +20,4 @@
     <property name="foo" value="baz"/>
   </target>
 </project>
+

http://git-wip-us.apache.org/repos/asf/ant/blob/84fe46d6/src/tests/antunit/taskdefs/importtests/override.xml
----------------------------------------------------------------------
diff --git a/src/tests/antunit/taskdefs/importtests/override.xml 
b/src/tests/antunit/taskdefs/importtests/override.xml
index 0afc5af..97fd320 100644
--- a/src/tests/antunit/taskdefs/importtests/override.xml
+++ b/src/tests/antunit/taskdefs/importtests/override.xml
@@ -22,3 +22,4 @@
 
   <target name="dummy" depends="setProperty"/>
 </project>
+

http://git-wip-us.apache.org/repos/asf/ant/blob/84fe46d6/src/tests/antunit/taskdefs/include-test.xml
----------------------------------------------------------------------
diff --git a/src/tests/antunit/taskdefs/include-test.xml 
b/src/tests/antunit/taskdefs/include-test.xml
index 19e0454..7e1a452 100644
--- a/src/tests/antunit/taskdefs/include-test.xml
+++ b/src/tests/antunit/taskdefs/include-test.xml
@@ -16,7 +16,7 @@
   limitations under the License.
 -->
 <project default="antunit" xmlns:au="antlib:org.apache.ant.antunit">
-  <import file="../antunit-base.xml"/>
+  <import file="../antunit-base.xml" />
 
  <include>
   <file file="importtests/a.xml"/>

http://git-wip-us.apache.org/repos/asf/ant/blob/84fe46d6/src/tests/antunit/taskdefs/jar-spi-test.xml
----------------------------------------------------------------------
diff --git a/src/tests/antunit/taskdefs/jar-spi-test.xml 
b/src/tests/antunit/taskdefs/jar-spi-test.xml
index 13316a1..c05311a 100644
--- a/src/tests/antunit/taskdefs/jar-spi-test.xml
+++ b/src/tests/antunit/taskdefs/jar-spi-test.xml
@@ -19,8 +19,8 @@
   <property name="jar.dir" location="jar_spi_dir"/>
   <property name="jar.src.dir" location="jar_spi_dir/src"/>
   <property name="jar.src.file" location="jar_spi_dir/src/a_file"/>
-
-  <available property="jdk1.4+" classname="java.lang.CharSequence"/>
+    
+  <available property="jdk1.4+" classname="java.lang.CharSequence"/>  
   <condition property="some.regexp.support">
     <or>
       <isset property="jdk1.4+"/>

http://git-wip-us.apache.org/repos/asf/ant/blob/84fe46d6/src/tests/antunit/taskdefs/jar-test.xml
----------------------------------------------------------------------
diff --git a/src/tests/antunit/taskdefs/jar-test.xml 
b/src/tests/antunit/taskdefs/jar-test.xml
index 4588e69..63646e2 100644
--- a/src/tests/antunit/taskdefs/jar-test.xml
+++ b/src/tests/antunit/taskdefs/jar-test.xml
@@ -16,31 +16,31 @@
   limitations under the License.
 -->
 <project default="antunit" xmlns:au="antlib:org.apache.ant.antunit">
-  <import file="../antunit-base.xml"/>
+  <import file="../antunit-base.xml" />
 
   <target name="testIndexOnlyUpdate">
     <mkdir dir="${output}"/>
-    <property name="index.jar" location="${output}/index.jar"/>
+    <property name="index.jar" location="${output}/index.jar" />
 
     <jar destfile="${index.jar}" index="false">
-      <fileset dir="${basedir}" includes="*-test.xml"/>
+      <fileset dir="${basedir}" includes="*-test.xml" />
     </jar>
     <au:assertTrue>
       <resourcecount count="0">
         <restrict>
-          <zipentry zipfile="${index.jar}" name="META-INF/INDEX.LIST"/>
-          <exists/>
+          <zipentry zipfile="${index.jar}" name="META-INF/INDEX.LIST" />
+          <exists />
         </restrict>
       </resourcecount>
     </au:assertTrue>
     <jar destfile="${index.jar}" index="true" update="true">
-      <fileset dir="${basedir}" includes="*-test.xml"/>
+      <fileset dir="${basedir}" includes="*-test.xml" />
     </jar>
     <au:assertTrue>
       <resourcecount count="1">
         <restrict>
-          <zipentry zipfile="${index.jar}" name="META-INF/INDEX.LIST"/>
-          <exists/>
+          <zipentry zipfile="${index.jar}" name="META-INF/INDEX.LIST" />
+          <exists />
         </restrict>
       </resourcecount>
     </au:assertTrue>
@@ -258,7 +258,7 @@ Main-Class: MyClass
     <property name="java9.classes"  value="${input}/build/classes9"/>
     <property name="java10.classes" value="${input}/build/classes10"/>
     <macrodef name="create">
-      <attribute name="version"/>
+      <attribute name="version" />
       <sequential>
         <local name="src"/>
         <local name="classes"/>
@@ -278,7 +278,7 @@ Main-Class: MyClass
     <create version="8"/>
     <create version="9"/>
     <create version="10"/>
-
+    
     <!-- Now create the MultiReleaseJar -->
     <jar destfile="${antunit.tmpdir}/mrjar.jar">
       <manifest>
@@ -292,7 +292,7 @@ Main-Class: MyClass
       <zipfileset prefix="META-INF/versions/9/" dir="${java9.classes}"/>
       <zipfileset prefix="META-INF/versions/10/" dir="${java10.classes}"/>
     </jar>
-
+    
     <!-- Now some tests -->
     <au:assertNestedResourceExists>
       <zipentry zipfile="${antunit.tmpdir}/mrjar.jar" 
name="META-INF/versions/9/org/apache/ant/test/MRJarTest.class"/>

http://git-wip-us.apache.org/repos/asf/ant/blob/84fe46d6/src/tests/antunit/taskdefs/java-test.xml
----------------------------------------------------------------------
diff --git a/src/tests/antunit/taskdefs/java-test.xml 
b/src/tests/antunit/taskdefs/java-test.xml
index 60068a9..db67316 100644
--- a/src/tests/antunit/taskdefs/java-test.xml
+++ b/src/tests/antunit/taskdefs/java-test.xml
@@ -16,7 +16,7 @@
   limitations under the License.
 -->
 <project default="antunit" xmlns:au="antlib:org.apache.ant.antunit">
-  <import file="../antunit-base.xml"/>
+  <import file="../antunit-base.xml" />
 
   <target name="-setUpWriterClass">
     <mkdir dir="${input}"/>
@@ -72,3 +72,4 @@ public class A {
   </target>
 
 </project>
+

http://git-wip-us.apache.org/repos/asf/ant/blob/84fe46d6/src/tests/antunit/taskdefs/javac-test.xml
----------------------------------------------------------------------
diff --git a/src/tests/antunit/taskdefs/javac-test.xml 
b/src/tests/antunit/taskdefs/javac-test.xml
index 0b9ffb8..7c1f462 100644
--- a/src/tests/antunit/taskdefs/javac-test.xml
+++ b/src/tests/antunit/taskdefs/javac-test.xml
@@ -16,11 +16,11 @@
   limitations under the License.
 -->
 <project default="antunit" xmlns:au="antlib:org.apache.ant.antunit">
-  <import file="../antunit-base.xml"/>
+  <import file="../antunit-base.xml" />
 
   <target name="setup">
-    <property name="javac-dir" location="${output}/javac-dir"/>
-    <property name="build-dir" location="${javac-dir}/build"/>
+    <property name="javac-dir" location="${output}/javac-dir" />
+    <property name="build-dir" location="${javac-dir}/build" />
     <presetdef name="testJavac">
       <javac srcdir="${javac-dir}/src" destdir="${javac-dir}/classes"
              includeantruntime="false"/>
@@ -28,67 +28,67 @@
   </target>
 
   <target name="test-includeDestClasses" depends="setup">
-    <property name="DATE" value="09/10/1999 4:30 pm"/>
-    <delete dir="${javac-dir}/src"/>
-    <mkdir dir="${javac-dir}/src"/>
+    <property name="DATE" value="09/10/1999 4:30 pm" />
+    <delete dir="${javac-dir}/src" />
+    <mkdir dir="${javac-dir}/src" />
     <echo file="${javac-dir}/src/A.java">
       public class A { B b;}
     </echo>
     <echo file="${javac-dir}/src/B.java">
       public class B { }
     </echo>
-    <delete dir="${javac-dir}/classes" quiet="yes"/>
-    <mkdir dir="${javac-dir}/classes"/>
-    <javac srcdir="${javac-dir}/src" destdir="${javac-dir}/classes"/>
-    <touch file="${javac-dir}/src/B.java" datetime="${DATE}"/>
-    <touch file="${javac-dir}/classes/B.class" datetime="${DATE}"/>
+    <delete dir="${javac-dir}/classes" quiet="yes" />
+    <mkdir dir="${javac-dir}/classes" />
+    <javac srcdir="${javac-dir}/src" destdir="${javac-dir}/classes" />
+    <touch file="${javac-dir}/src/B.java" datetime="${DATE}" />
+    <touch file="${javac-dir}/classes/B.class" datetime="${DATE}" />
     <!-- following should not update B.class -->
-    <delete quiet="yes" file="${javac-dir}/classes/A.class"/>
-    <javac srcdir="${javac-dir}/src" destdir="${javac-dir}/classes"/>
+    <delete quiet="yes" file="${javac-dir}/classes/A.class" />
+    <javac srcdir="${javac-dir}/src" destdir="${javac-dir}/classes" />
     <au:assertTrue>
       <isfileselected file="${javac-dir}/classes/B.class">
-        <date datetime="${DATE}" when="equal"/>
+        <date datetime="${DATE}" when="equal" />
       </isfileselected>
     </au:assertTrue>
     <!-- following should update B.class -->
-    <delete quiet="yes" file="${javac-dir}/classes/A.class"/>
-    <javac srcdir="${javac-dir}/src" destdir="${javac-dir}/classes" 
includeDestClasses="no"/>
+    <delete quiet="yes" file="${javac-dir}/classes/A.class" />
+    <javac srcdir="${javac-dir}/src" destdir="${javac-dir}/classes" 
includeDestClasses="no" />
     <au:assertFalse>
       <isfileselected file="${javac-dir}/classes/B.class">
-        <date datetime="${DATE}" when="equal"/>
+        <date datetime="${DATE}" when="equal" />
       </isfileselected>
     </au:assertFalse>
   </target>
 
   <target name="test-updated-property" depends="setup">
-    <delete quiet="yes" dir="${build-dir}"/>
-    <mkdir dir="${build-dir}"/>
-    <javac srcdir="javac-dir/good-src" destdir="${build-dir}" 
updatedProperty="classes-updated"/>
+    <delete quiet="yes" dir="${build-dir}" />
+    <mkdir dir="${build-dir}" />
+    <javac srcdir="javac-dir/good-src" destdir="${build-dir}" 
updatedProperty="classes-updated" />
     <au:assertTrue>
-      <equals arg1="${classes-updated}" arg2="true"/>
+      <equals arg1="${classes-updated}" arg2="true" />
     </au:assertTrue>
-    <javac srcdir="javac-dir/good-src" destdir="${build-dir}" 
updatedProperty="classes-updated-2"/>
+    <javac srcdir="javac-dir/good-src" destdir="${build-dir}" 
updatedProperty="classes-updated-2" />
     <au:assertFalse>
-      <isset property="classes-updated-2"/>
+      <isset property="classes-updated-2" />
     </au:assertFalse>
   </target>
 
   <target name="test-error-property" depends="setup">
-    <delete quiet="yes" dir="${build-dir}"/>
-    <mkdir dir="${build-dir}"/>
-    <javac srcdir="javac-dir/good-src" destdir="${build-dir}" 
failOnError="false" errorProperty="compile-failed"/>
+    <delete quiet="yes" dir="${build-dir}" />
+    <mkdir dir="${build-dir}" />
+    <javac srcdir="javac-dir/good-src" destdir="${build-dir}" 
failOnError="false" errorProperty="compile-failed" />
     <au:assertTrue>
-      <equals arg1="${compile-failed}" arg2="${compile-failed}"/>
+      <equals arg1="${compile-failed}" arg2="${compile-failed}" />
     </au:assertTrue>
-    <javac srcdir="javac-dir/bad-src" destdir="${build-dir}" 
failOnError="false" errorProperty="compile-failed"/>
+    <javac srcdir="javac-dir/bad-src" destdir="${build-dir}" 
failOnError="false" errorProperty="compile-failed" />
     <au:assertTrue>
-      <equals arg1="${compile-failed}" arg2="true"/>
+      <equals arg1="${compile-failed}" arg2="true" />
     </au:assertTrue>
   </target>
 
   <target name="setUpForPackageInfoJava" depends="setup">
-    <mkdir dir="${javac-dir}/src/a"/>
-    <mkdir dir="${build-dir}"/>
+    <mkdir dir="${javac-dir}/src/a" />
+    <mkdir dir="${build-dir}" />
     <echo file="${javac-dir}/src/a/package-info.java">
       <![CDATA[
 /**
@@ -96,53 +96,53 @@
  */
 ]]>
     </echo>
-    <javac srcdir="${javac-dir}/src" destdir="${build-dir}" 
updatedProperty="first-pass"/>
-    <au:assertPropertyEquals name="first-pass" value="true"/>
+    <javac srcdir="${javac-dir}/src" destdir="${build-dir}" 
updatedProperty="first-pass" />
+    <au:assertPropertyEquals name="first-pass" value="true" />
   </target>
 
   <target name="testPackageInfoJava"
           depends="setUpForPackageInfoJava"
           
description="https://issues.apache.org/bugzilla/show_bug.cgi?id=43114";>
     <!-- no changes, shouldn't recompile, the initial bug -->
-    <javac srcdir="${javac-dir}/src" destdir="${build-dir}" 
updatedProperty="second-pass"/>
+    <javac srcdir="${javac-dir}/src" destdir="${build-dir}" 
updatedProperty="second-pass" />
     <au:assertFalse>
-      <isset property="second-pass"/>
+      <isset property="second-pass" />
     </au:assertFalse>
-    <sleep seconds="2"/>
+    <sleep seconds="2" />
 
     <!-- change package-info.java but make containing target dir even
          more recent - the regression in Ant 1.7.1 -->
-    <touch file="${javac-dir}/src/a/package-info.java"/>
-    <sleep seconds="2"/>
+    <touch file="${javac-dir}/src/a/package-info.java" />
+    <sleep seconds="2" />
     <touch>
-      <file file="${build-dir}/a"/>
+      <file file="${build-dir}/a" />
     </touch>
-    <javac srcdir="${javac-dir}/src" destdir="${build-dir}" 
updatedProperty="third-pass"/>
-    <au:assertPropertyEquals name="third-pass" value="true"/>
+    <javac srcdir="${javac-dir}/src" destdir="${build-dir}" 
updatedProperty="third-pass" />
+    <au:assertPropertyEquals name="third-pass" value="true" />
   </target>
 
   <target name="testPackageInfoJavaNoDest"
           depends="setUpForPackageInfoJava"
           
description="https://issues.apache.org/bugzilla/show_bug.cgi?id=51947";>
-    <javac srcdir="${javac-dir}/src" updatedProperty="first-pass"/>
-    <au:assertPropertyEquals name="first-pass" value="true"/>
+    <javac srcdir="${javac-dir}/src" updatedProperty="first-pass" />
+    <au:assertPropertyEquals name="first-pass" value="true" />
 
     <!-- no changes, shouldn't recompile, the initial bug -->
-    <javac srcdir="${javac-dir}/src" updatedProperty="second-pass"/>
+    <javac srcdir="${javac-dir}/src" updatedProperty="second-pass" />
     <au:assertFalse>
-      <isset property="second-pass"/>
+      <isset property="second-pass" />
     </au:assertFalse>
-    <sleep seconds="2"/>
+    <sleep seconds="2" />
 
     <!-- change package-info.java but make containing target dir even
          more recent - the regression in Ant 1.7.1 -->
-    <touch file="${javac-dir}/src/a/package-info.java"/>
-    <sleep seconds="2"/>
+    <touch file="${javac-dir}/src/a/package-info.java" />
+    <sleep seconds="2" />
     <touch>
-      <file file="${javac-dir}/src/a"/>
+      <file file="${javac-dir}/src/a" />
     </touch>
-    <javac srcdir="${javac-dir}/src" updatedProperty="third-pass"/>
-    <au:assertPropertyEquals name="third-pass" value="true"/>
+    <javac srcdir="${javac-dir}/src" updatedProperty="third-pass" />
+    <au:assertPropertyEquals name="third-pass" value="true" />
   </target>
 
   <target name="testSuppressPackageInfoClass"
@@ -152,14 +152,14 @@
     <delete file="${build-dir}/a/package-info.class"/>
     <javac srcdir="${javac-dir}/src" destdir="${build-dir}"
            createMissingPackageInfoClass="false"
-           updatedProperty="second-pass"/>
-    <au:assertPropertyEquals name="second-pass" value="true"/>
+           updatedProperty="second-pass" />
+    <au:assertPropertyEquals name="second-pass" value="true" />
     <au:assertFileDoesntExist file="${build-dir}/a/package-info.class"/>
   </target>
 
   <target name="-create-javac-adapter" depends="setup">
-    <property name="adapter.dir" location="${output}/adapter"/>
-    <mkdir dir="${input}/org/example"/>
+    <property name="adapter.dir" location="${output}/adapter" />
+    <mkdir dir="${input}/org/example" />
     <echo file="${input}/org/example/Adapter.java">
       <![CDATA[
 package org.example;
@@ -174,41 +174,41 @@ public class Adapter implements CompilerAdapter {
     }
 }]]>
     </echo>
-    <mkdir dir="${resources}"/>
-    <javac srcdir="${input}" destdir="${resources}"/>
+    <mkdir dir="${resources}" />
+    <javac srcdir="${input}" destdir="${resources}" />
   </target>
 
   <target name="testCompilerNotFound" depends="-create-javac-adapter">
     <au:expectfailure>
-      <javac srcdir="${input}" destdir="${output}" 
compiler="org.example.Adapter"/>
+      <javac srcdir="${input}" destdir="${output}" 
compiler="org.example.Adapter" />
     </au:expectfailure>
-    <au:assertLogDoesntContain text="adapter called"/>
+    <au:assertLogDoesntContain text="adapter called" />
   </target>
 
   <target name="testCompilerClasspath" depends="-create-javac-adapter" 
description="https://issues.apache.org/bugzilla/show_bug.cgi?id=11143";>
-    <mkdir dir="${output}"/>
+    <mkdir dir="${output}" />
     <javac srcdir="${input}" destdir="${output}" 
compiler="org.example.Adapter">
-      <compilerclasspath location="${resources}"/>
+      <compilerclasspath location="${resources}" />
     </javac>
-    <au:assertLogContains text="adapter called"/>
+    <au:assertLogContains text="adapter called" />
   </target>
 
   <target name="testCompilerAsNestedElement" depends="-create-javac-adapter">
     <componentdef classname="org.example.Adapter" name="myjavac">
-      <classpath location="${resources}"/>
+      <classpath location="${resources}" />
     </componentdef>
-    <mkdir dir="${output}"/>
+    <mkdir dir="${output}" />
     <javac srcdir="${input}" destdir="${output}">
-      <myjavac/>
+      <myjavac />
     </javac>
-    <au:assertLogContains text="adapter called"/>
+    <au:assertLogContains text="adapter called" />
   </target>
 
   <target name="testSourceAttributes" depends="setup"
           xmlns:if="ant:if" xmlns:unless="ant:unless">
-    <delete dir="${javac-dir}/src"/>
-    <mkdir dir="${javac-dir}/src"/>
-    <mkdir dir="${javac-dir}/classes"/>
+    <delete dir="${javac-dir}/src" />
+    <mkdir dir="${javac-dir}/src" />
+    <mkdir dir="${javac-dir}/classes" />
     <echo file="${javac-dir}/src/A.java">
       public class A { }
     </echo>
@@ -223,27 +223,27 @@ public class Adapter implements CompilerAdapter {
       <delete dir="${javac-dir}/classes"/>
       <mkdir dir="${javac-dir}/classes"/>
     </sequential>
-
+    
     <sequential unless:set="jdk1.9+">
       <echo>JDK 1.8+</echo>
       <testJavac source="1.8"/>
       <delete dir="${javac-dir}/classes"/>
       <mkdir dir="${javac-dir}/classes"/>
     </sequential>
-
+            
     <sequential if:set="jdk9+">
       <echo>JDK 9+</echo>
       <testJavac source="9"/>
       <delete dir="${javac-dir}/classes"/>
       <mkdir dir="${javac-dir}/classes"/>
     </sequential>
-  </target>
-
+  </target>    
+       
   <target name="testTargetAttributes" depends="setup"
           xmlns:if="ant:if" xmlns:unless="ant:unless">
-    <delete dir="${javac-dir}/src"/>
-    <mkdir dir="${javac-dir}/src"/>
-    <mkdir dir="${javac-dir}/classes"/>
+    <delete dir="${javac-dir}/src" />
+    <mkdir dir="${javac-dir}/src" />
+    <mkdir dir="${javac-dir}/classes" />
     <echo file="${javac-dir}/src/A.java">
       public class A { }
     </echo>
@@ -258,7 +258,7 @@ public class Adapter implements CompilerAdapter {
       <delete dir="${javac-dir}/classes"/>
       <mkdir dir="${javac-dir}/classes"/>
     </sequential>
-
+            
     <sequential if:set="jdk9+">
       <echo>JDK 9+</echo>
       <testJavac source="9" target="9"/>
@@ -275,7 +275,7 @@ public class Adapter implements CompilerAdapter {
   </target>
 
   <target name="testJavacWithNativeHeaderGeneration" depends="setup">
-    <mkdir dir="${javac-dir}/src/org/example"/>
+    <mkdir dir="${javac-dir}/src/org/example" />
     <mkdir dir="${javac-dir}/classes"/>
     <mkdir dir="${javac-dir}/headers"/>
     <echo file="${javac-dir}/src/org/example/Foo.java">

http://git-wip-us.apache.org/repos/asf/ant/blob/84fe46d6/src/tests/antunit/taskdefs/javadoc-test.xml
----------------------------------------------------------------------
diff --git a/src/tests/antunit/taskdefs/javadoc-test.xml 
b/src/tests/antunit/taskdefs/javadoc-test.xml
index 4b34e6e..200082b 100644
--- a/src/tests/antunit/taskdefs/javadoc-test.xml
+++ b/src/tests/antunit/taskdefs/javadoc-test.xml
@@ -16,7 +16,7 @@
   limitations under the License.
 -->
 <project default="antunit" xmlns:au="antlib:org.apache.ant.antunit">
-  <import file="../antunit-base.xml"/>
+  <import file="../antunit-base.xml" />
 
   <target name="-makeTestClass">
     <macrodef name="mktest">

http://git-wip-us.apache.org/repos/asf/ant/blob/84fe46d6/src/tests/antunit/taskdefs/length-test.xml
----------------------------------------------------------------------
diff --git a/src/tests/antunit/taskdefs/length-test.xml 
b/src/tests/antunit/taskdefs/length-test.xml
index 3924c9e..acd5310 100644
--- a/src/tests/antunit/taskdefs/length-test.xml
+++ b/src/tests/antunit/taskdefs/length-test.xml
@@ -18,201 +18,201 @@
 <project name="length-test" default="antunit"
          xmlns:au="antlib:org.apache.ant.antunit">
 
-  <import file="../antunit-base.xml"/>
+  <import file="../antunit-base.xml" />
 
-  <property name="dir.a" location="${input}/a"/>
-  <property name="dir.b" location="${input}/b"/>
-  <property name="zipfile" location="${output}/lengthtest.zip"/>
+  <property name="dir.a" location="${input}/a" />
+  <property name="dir.b" location="${input}/b" />
+  <property name="zipfile" location="${output}/lengthtest.zip" />
 
   <target name="setUp">
-    <mkdir dir="${output}"/>
-    <mkdir dir="${dir.a}"/>
-    <mkdir dir="${dir.b}"/>
-    <property name="foo" location="${dir.a}/foo"/>
-    <property name="bar" location="${dir.b}/bar"/>
-    <echo file="${foo}" message="foo"/>
-    <echo file="${bar}" message="bar"/>
+    <mkdir dir="${output}" />
+    <mkdir dir="${dir.a}" />
+    <mkdir dir="${dir.b}" />
+    <property name="foo" location="${dir.a}/foo" />
+    <property name="bar" location="${dir.b}/bar" />
+    <echo file="${foo}" message="foo" />
+    <echo file="${bar}" message="bar" />
   </target>
 
   <target name="testEach" depends="setUp">
     <length mode="each" property="length.each">
-      <fileset id="fs" dir="${input}"/>
+      <fileset id="fs" dir="${input}" />
     </length>
-    <length string="${length.each}" property="length.length.each"/>
+    <length string="${length.each}" property="length.length.each" />
     <length string="${foo}${bar}........${line.separator}"
-            property="length.expected"/>
+            property="length.expected" />
 
     <au:assertTrue>
       <!-- test that both files are represented, and that the
            output is the expected length; do not assume order. -->
       <and>
-        <contains string="${length.each}" substring="${foo} : 3"/>
-        <contains string="${length.each}" substring="${bar} : 3"/>
-        <equals arg1="${length.length.each}" arg2="${length.expected}"/>
+        <contains string="${length.each}" substring="${foo} : 3" />
+        <contains string="${length.each}" substring="${bar} : 3" />
+        <equals arg1="${length.length.each}" arg2="${length.expected}" />
       </and>
     </au:assertTrue>
   </target>
 
   <target name="testEachCondition" depends="setUp">
     <length mode="each" property="length.each">
-      <fileset id="fs" dir="${input}"/>
+      <fileset id="fs" dir="${input}" />
     </length>
     <length string="${foo}${bar}........${line.separator}"
-            property="length.expected"/>
+            property="length.expected" />
     <au:assertTrue>
       <!-- test that both files are represented, and that the
            output is the expected length; do not assume order. -->
       <and>
-        <contains string="${length.each}" substring="${foo} : 3"/>
-        <contains string="${length.each}" substring="${bar} : 3"/>
-        <length string="${length.each}" length="${length.expected}"/>
+        <contains string="${length.each}" substring="${foo} : 3" />
+        <contains string="${length.each}" substring="${bar} : 3" />
+        <length string="${length.each}" length="${length.expected}" />
       </and>
     </au:assertTrue>
   </target>
 
   <target name="testAll" depends="setUp">
     <length property="length.all">
-      <fileset id="foo" file="${dir.a}/foo"/>
-      <fileset id="bar" file="${dir.b}/bar"/>
+      <fileset id="foo" file="${dir.a}/foo" />
+      <fileset id="bar" file="${dir.b}/bar" />
     </length>
     <au:assertTrue>
-      <equals arg1="6" arg2="${length.all}"/>
+      <equals arg1="6" arg2="${length.all}" />
     </au:assertTrue>
   </target>
 
   <target name="testAllCondition" depends="setUp">
     <au:assertTrue>
       <length length="6">
-        <fileset id="foo" file="${dir.a}/foo"/>
-        <fileset id="bar" file="${dir.b}/bar"/>
+        <fileset id="foo" file="${dir.a}/foo" />
+        <fileset id="bar" file="${dir.b}/bar" />
       </length>
     </au:assertTrue>
   </target>
 
   <target name="testFile" depends="setUp">
-    <length property="length.foo" file="${dir.a}/foo"/>
+    <length property="length.foo" file="${dir.a}/foo" />
     <au:assertTrue>
-      <equals arg1="3" arg2="${length.foo}"/>
+      <equals arg1="3" arg2="${length.foo}" />
     </au:assertTrue>
   </target>
 
   <target name="testFileCondition" depends="setUp">
     <au:assertTrue>
-      <length length="3" file="${dir.a}/foo"/>
+      <length length="3" file="${dir.a}/foo" />
     </au:assertTrue>
   </target>
 
   <target name="testBoth" depends="setUp">
     <length property="length.foo" file="${dir.a}/foo">
-      <fileset file="${dir.b}/bar"/>
+      <fileset file="${dir.b}/bar" />
     </length>
     <au:assertTrue>
-      <equals arg1="6" arg2="${length.foo}"/>
+      <equals arg1="6" arg2="${length.foo}" />
     </au:assertTrue>
   </target>
 
   <target name="testBothCondition" depends="setUp">
     <au:assertTrue>
       <length length="6" file="${dir.a}/foo">
-        <fileset file="${dir.b}/bar"/>
+        <fileset file="${dir.b}/bar" />
       </length>
     </au:assertTrue>
   </target>
 
   <target name="testDupes" depends="setUp">
     <length property="length.foo" file="${dir.a}/foo">
-      <fileset dir="${input}"/>
+      <fileset dir="${input}" />
     </length>
     <au:assertTrue>
-      <equals arg1="9" arg2="${length.foo}"/>
+      <equals arg1="9" arg2="${length.foo}" />
     </au:assertTrue>
   </target>
 
   <target name="testDupesCondition" depends="setUp">
     <au:assertTrue>
       <length length="9" file="${dir.a}/foo">
-        <fileset dir="${input}"/>
+        <fileset dir="${input}" />
       </length>
     </au:assertTrue>
   </target>
 
   <target name="testString">
-    <length string="foo" property="length.string"/>
+    <length string="foo" property="length.string" />
     <au:assertTrue>
-      <equals arg1="3" arg2="${length.string}"/>
+      <equals arg1="3" arg2="${length.string}" />
     </au:assertTrue>
   </target>
 
   <target name="testStringCondition">
     <au:assertTrue>
-      <length string="foo" length="3"/>
+      <length string="foo" length="3" />
     </au:assertTrue>
   </target>
 
   <target name="testTrimString">
-    <length string=" foo " trim="true" property="length.string"/>
+    <length string=" foo " trim="true" property="length.string" />
     <au:assertTrue>
-      <equals arg1="3" arg2="${length.string}"/>
+      <equals arg1="3" arg2="${length.string}" />
     </au:assertTrue>
   </target>
 
   <target name="testTrimStringCondition">
     <au:assertTrue>
-      <length string=" foo " trim="true" length="3"/>
+      <length string=" foo " trim="true" length="3" />
     </au:assertTrue>
   </target>
 
   <target name="testNoTrimString">
-    <length string=" foo " property="length.string"/>
+    <length string=" foo " property="length.string" />
     <au:assertTrue>
-      <equals arg1="5" arg2="${length.string}"/>
+      <equals arg1="5" arg2="${length.string}" />
     </au:assertTrue>
   </target>
 
   <target name="testNoTrimStringCondition">
     <au:assertTrue>
-      <length string=" foo " length="5"/>
+      <length string=" foo " length="5" />
     </au:assertTrue>
   </target>
 
   <target name="testTrimFile" description="should fail">
     <au:expectfailure>
-      <length file="${ant.file}" trim="false"/>
+      <length file="${ant.file}" trim="false" />
     </au:expectfailure>
   </target>
 
   <target name="testStringFile" description="should fail">
     <au:expectfailure>
-      <length string="foo" file="${ant.file}"/>
+      <length string="foo" file="${ant.file}" />
     </au:expectfailure>
   </target>
 
   <target name="testImmutable">
-    <length string="foo" property="length.string"/>
-    <length string="foobar" property="length.string"/>
+    <length string="foo" property="length.string" />
+    <length string="foobar" property="length.string" />
     <au:assertTrue>
-      <equals arg1="3" arg2="${length.string}"/>
+      <equals arg1="3" arg2="${length.string}" />
     </au:assertTrue>
   </target>
 
   <target name="zip" depends="setUp">
     <zip destfile="${zipfile}">
-      <fileset file="${foo}"/>
-      <fileset file="${bar}"/>
+      <fileset file="${foo}" />
+      <fileset file="${bar}" />
     </zip>
   </target>
 
   <target name="testZipFileSet" depends="zip">
     <length property="length.zipfile1">
-      <zipfileset src="${zipfile}"/>
+      <zipfileset src="${zipfile}" />
     </length>
     <length property="length.zipfile2">
-      <zipfileset src="${zipfile}" includes="bar"/>
+      <zipfileset src="${zipfile}" includes="bar" />
     </length>
     <au:assertTrue>
       <and>
-        <equals arg1="6" arg2="${length.zipfile1}"/>
-        <equals arg1="3" arg2="${length.zipfile2}"/>
+        <equals arg1="6" arg2="${length.zipfile1}" />
+        <equals arg1="3" arg2="${length.zipfile2}" />
       </and>
     </au:assertTrue>
   </target>
@@ -221,19 +221,19 @@
     <au:assertTrue>
       <and>
         <length length="6">
-          <zipfileset src="${zipfile}"/>
+          <zipfileset src="${zipfile}" />
         </length>
         <length length="3">
-          <zipfileset src="${zipfile}" includes="bar"/>
+          <zipfileset src="${zipfile}" includes="bar" />
         </length>
       </and>
     </au:assertTrue>
   </target>
 
   <target name="testResourceAttribute">
-    <string id="s" value="foo-bar-baz"/>
+    <string id="s" value="foo-bar-baz" />
     <au:assertTrue>
-      <length length="11" resource="${ant.refid:s}"/>
+      <length length="11" resource="${ant.refid:s}" />
     </au:assertTrue>
   </target>
 

http://git-wip-us.apache.org/repos/asf/ant/blob/84fe46d6/src/tests/antunit/taskdefs/loadproperties-test.xml
----------------------------------------------------------------------
diff --git a/src/tests/antunit/taskdefs/loadproperties-test.xml 
b/src/tests/antunit/taskdefs/loadproperties-test.xml
index bf92f76..04b53f1 100644
--- a/src/tests/antunit/taskdefs/loadproperties-test.xml
+++ b/src/tests/antunit/taskdefs/loadproperties-test.xml
@@ -17,11 +17,11 @@
 -->
 <project name="loadproperties-test" default="antunit" 
xmlns:au="antlib:org.apache.ant.antunit">
 
-  <import file="../antunit-base.xml"/>
+  <import file="../antunit-base.xml" />
 
   <target name="setUp">
-    <mkdir dir="${input}"/>
-    <property name="properties.tmp" location="${input}/properties.tmp"/>
+    <mkdir dir="${input}" />
+    <property name="properties.tmp" location="${input}/properties.tmp" />
   </target>
 
   <target name="test-basic">
@@ -30,9 +30,9 @@
 basic.bar=bar
 basic.baz=baz</string>
     </loadproperties>
-    <au:assertPropertyEquals name="basic.foo" value="foo"/>
-    <au:assertPropertyEquals name="basic.bar" value="bar"/>
-    <au:assertPropertyEquals name="basic.baz" value="baz"/>
+    <au:assertPropertyEquals name="basic.foo" value="foo" />
+    <au:assertPropertyEquals name="basic.bar" value="bar" />
+    <au:assertPropertyEquals name="basic.baz" value="baz" />
   </target>
 
   <target name="test-xref">
@@ -41,9 +41,9 @@ basic.baz=baz</string>
 xref.bar=$${xref.foo}
 xref.baz=$${xref.bar}</string>
     </loadproperties>
-    <au:assertPropertyEquals name="xref.foo" value="foo"/>
-    <au:assertPropertyEquals name="xref.bar" value="foo"/>
-    <au:assertPropertyEquals name="xref.baz" value="foo"/>
+    <au:assertPropertyEquals name="xref.foo" value="foo" />
+    <au:assertPropertyEquals name="xref.bar" value="foo" />
+    <au:assertPropertyEquals name="xref.baz" value="foo" />
   </target>
 
   <target name="test-xref-complex">
@@ -55,12 +55,12 @@ xref-complex.d=x
 
xref-complex.e=$${xref-complex.a}$${xref-complex.b}xref-complex.d$${xref-complex.c}
 xref-complex.f=$${xref-complex.e}</string>
     </loadproperties>
-    <au:assertPropertyEquals name="xref-complex.a" value="$$"/>
-    <au:assertPropertyEquals name="xref-complex.b" value="{"/>
-    <au:assertPropertyEquals name="xref-complex.c" value="}"/>
-    <au:assertPropertyEquals name="xref-complex.d" value="x"/>
-    <au:assertPropertyEquals name="xref-complex.e" value="$${xref-complex.d}"/>
-    <au:assertPropertyEquals name="xref-complex.f" value="$${xref-complex.d}"/>
+    <au:assertPropertyEquals name="xref-complex.a" value="$$" />
+    <au:assertPropertyEquals name="xref-complex.b" value="{" />
+    <au:assertPropertyEquals name="xref-complex.c" value="}" />
+    <au:assertPropertyEquals name="xref-complex.d" value="x" />
+    <au:assertPropertyEquals name="xref-complex.e" value="$${xref-complex.d}" 
/>
+    <au:assertPropertyEquals name="xref-complex.f" value="$${xref-complex.d}" 
/>
   </target>
 
   <target name="testEncoding"
@@ -93,16 +93,16 @@ http.@SERVER@ = ${server}
         <expandproperties/>
       </filterchain>
     </loadproperties>
-    <property name="server1.http.url"
+    <property name="server1.http.url" 
       value="http://${server1.http.server}:${server1.http.port}"/>
   </target>
 
   <target name="testLineCommentsWithoutFiltering">
     <loadproperties>
-      <string value="#foo=bar"/>
+      <string value="#foo=bar" />
     </loadproperties>
     <au:assertFalse>
-      <isset property="foo"/>
+      <isset property="foo" />
     </au:assertFalse>
   </target>
 
@@ -115,9 +115,9 @@ baz=${foo} ${bar}
     </loadproperties>
     <au:assertTrue>
       <and>
-        <equals arg1="foo" arg2="${prefixFromAttribute.foo}"/>
-        <equals arg1="bar" arg2="${prefixFromAttribute.bar}"/>
-        <equals arg1="foo bar" arg2="${prefixFromAttribute.baz}"/>
+        <equals arg1="foo" arg2="${prefixFromAttribute.foo}" />
+        <equals arg1="bar" arg2="${prefixFromAttribute.bar}" />
+        <equals arg1="foo bar" arg2="${prefixFromAttribute.baz}" />
       </and>
     </au:assertTrue>
   </target>
@@ -130,13 +130,13 @@ bar=bar
 baz=${foo} ${bar}
       </string>
       <filterchain>
-        <prefixlines prefix="prefixFromFilter."/>
+        <prefixlines prefix="prefixFromFilter." />
       </filterchain>
     </loadproperties>
     <au:assertTrue>
       <and>
-        <equals arg1="$${foo} $${bar}" arg2="${prefixFromFilter.baz}"/>
-        <isset property="prefixFromFilter."/>
+        <equals arg1="$${foo} $${bar}" arg2="${prefixFromFilter.baz}" />
+        <isset property="prefixFromFilter." />
       </and>
     </au:assertTrue>
   </target>
@@ -153,7 +153,7 @@ tpfr.c=@C@
 
   <presetdef name="assertPropertiesFromResourceOkay">
     <au:assertTrue>
-      <equals arg1="Abesea" arg2="${tpfr.a}${tpfr.b}${tpfr.c}"/>
+      <equals arg1="Abesea" arg2="${tpfr.a}${tpfr.b}${tpfr.c}" />
     </au:assertTrue>
   </presetdef>
 
@@ -169,14 +169,14 @@ tpfr.c=@C@
 
   <target name="testPropertiesFromFileSet" depends="write properties.tmp">
     <loadproperties>
-      <fileset file="${properties.tmp}"/>
+      <fileset file="${properties.tmp}" />
       <filterchain>
         <replacetokens>
           <token key="C" value="sea"/>
         </replacetokens>
       </filterchain>
     </loadproperties>
-    <assertPropertiesFromResourceOkay/>
+    <assertPropertiesFromResourceOkay />
   </target>
 
   <target name="testLastPropertyWins">
@@ -185,7 +185,7 @@ tpfr.c=@C@
 foo=bar</string>
     </loadproperties>
     <au:assertTrue>
-      <equals arg1="bar" arg2="${foo}"/>
+      <equals arg1="bar" arg2="${foo}" />
     </au:assertTrue>
   </target>
 

http://git-wip-us.apache.org/repos/asf/ant/blob/84fe46d6/src/tests/antunit/taskdefs/loadresource-test.xml
----------------------------------------------------------------------
diff --git a/src/tests/antunit/taskdefs/loadresource-test.xml 
b/src/tests/antunit/taskdefs/loadresource-test.xml
index b34efd3..814ded5 100644
--- a/src/tests/antunit/taskdefs/loadresource-test.xml
+++ b/src/tests/antunit/taskdefs/loadresource-test.xml
@@ -17,19 +17,19 @@
 -->
 <project default="antunit" xmlns:au="antlib:org.apache.ant.antunit">
 
-  <import file="../antunit-base.xml"/>
+  <import file="../antunit-base.xml" />
 
   <target name="test-resourceString">
     <loadresource property="p">
       <string value="one"/>
-    </loadresource>
+    </loadresource >
     <au:assertPropertyEquals name="p" value="one"/>
   </target>
 
   <target name="test-resourceSizeZero" description="Bug 42319">
     <loadresource property="p">
       <string value=""/>
-    </loadresource>
+    </loadresource >
     <au:assertTrue>
       <not>
         <isset property="p"/>

http://git-wip-us.apache.org/repos/asf/ant/blob/84fe46d6/src/tests/antunit/taskdefs/local-test.xml
----------------------------------------------------------------------
diff --git a/src/tests/antunit/taskdefs/local-test.xml 
b/src/tests/antunit/taskdefs/local-test.xml
index 2b07a8d..9c4e7b7 100644
--- a/src/tests/antunit/taskdefs/local-test.xml
+++ b/src/tests/antunit/taskdefs/local-test.xml
@@ -16,81 +16,81 @@
   limitations under the License.
 -->
 <project default="antunit" xmlns:au="antlib:org.apache.ant.antunit">
-  <import file="../antunit-base.xml"/>
+  <import file="../antunit-base.xml" />
 
-  <property name="foo" value="foo"/>
+  <property name="foo" value="foo" />
 
-  <local name="bar"/>
-  <property name="bar" value="bar"/>
-  <au:assertPropertyEquals name="bar" value="bar"/>
+  <local name="bar" />
+  <property name="bar" value="bar" />
+  <au:assertPropertyEquals name="bar" value="bar" />
 
   <target name="testGlobalLocal">
     <au:assertFalse>
-      <isset property="bar"/>
+      <isset property="bar" />
     </au:assertFalse>
   </target>
 
   <target name="testBaseline">
-    <au:assertPropertyEquals name="foo" value="foo"/>
+    <au:assertPropertyEquals name="foo" value="foo" />
   </target>
 
   <target name="testTarget">
-    <au:assertPropertyEquals name="foo" value="foo"/>
-    <local name="foo"/>
-    <property name="foo" value="foo.target"/>
-    <au:assertPropertyEquals name="foo" value="foo.target"/>
+    <au:assertPropertyEquals name="foo" value="foo" />
+    <local name="foo" />
+    <property name="foo" value="foo.target" />
+    <au:assertPropertyEquals name="foo" value="foo.target" />
   </target>
 
   <target name="testSequential">
     <sequential>
-      <local name="foo"/>
-      <property name="foo" value="foo.1"/>
+      <local name="foo" />
+      <property name="foo" value="foo.1" />
       <sequential>
-        <local name="foo"/>
-        <property name="foo" value="foo.2"/>
-        <au:assertPropertyEquals name="foo" value="foo.2"/>
+        <local name="foo" />
+        <property name="foo" value="foo.2" />
+        <au:assertPropertyEquals name="foo" value="foo.2" />
       </sequential>
-      <au:assertPropertyEquals name="foo" value="foo.1"/>
+      <au:assertPropertyEquals name="foo" value="foo.1" />
     </sequential>
-    <au:assertPropertyEquals name="foo" value="foo"/>
+    <au:assertPropertyEquals name="foo" value="foo" />
   </target>
 
   <target name="testParallel">
     <macrodef name="p">
-      <attribute name="value"/>
-      <attribute name="sleep" default="0"/>
+      <attribute name="value" />
+      <attribute name="sleep" default="0" />
       <sequential>
-        <local name="foo"/>
-        <sleep seconds="@{sleep}"/>
-        <property name="foo" value="@{value}"/>
-        <au:assertPropertyEquals name="foo" value="@{value}"/>
+        <local name="foo" />
+        <sleep seconds="@{sleep}" />
+        <property name="foo" value="@{value}" />
+        <au:assertPropertyEquals name="foo" value="@{value}" />
       </sequential>
     </macrodef>
     <parallel>
-      <p sleep="2" value="foo.a"/>
-      <au:assertPropertyEquals name="foo" value="foo"/>
-      <p sleep="1" value="foo.b"/>
-      <au:assertPropertyEquals name="foo" value="foo"/>
-      <p sleep="0" value="foo.c"/>
-      <au:assertPropertyEquals name="foo" value="foo"/>
+      <p sleep="2" value="foo.a" />
+      <au:assertPropertyEquals name="foo" value="foo" />
+      <p sleep="1" value="foo.b" />
+      <au:assertPropertyEquals name="foo" value="foo" />
+      <p sleep="0" value="foo.c" />
+      <au:assertPropertyEquals name="foo" value="foo" />
     </parallel>
-    <au:assertPropertyEquals name="foo" value="foo"/>
+    <au:assertPropertyEquals name="foo" value="foo" />
   </target>
 
   <target name="testMacrodef">
     <macrodef name="m">
       <sequential>
-        <local name="foo"/>
-        <property name="foo" value="foo.x"/>
-        <au:assertPropertyEquals name="foo" value="foo.x"/>
+        <local name="foo" />
+        <property name="foo" value="foo.x" />
+        <au:assertPropertyEquals name="foo" value="foo.x" />
       </sequential>
     </macrodef>
-    <m/>
-    <au:assertPropertyEquals name="foo" value="foo"/>
-    <m/>
-    <au:assertPropertyEquals name="foo" value="foo"/>
-    <m/>
-    <au:assertPropertyEquals name="foo" value="foo"/>
+    <m />
+    <au:assertPropertyEquals name="foo" value="foo" />
+    <m />
+    <au:assertPropertyEquals name="foo" value="foo" />
+    <m />
+    <au:assertPropertyEquals name="foo" value="foo" />
   </target>
 
 </project>

Reply via email to