diff -r c7c26511138f -r 7c4a911dc066 buildframework/helium/sf/java/metadata/tests/antunit/test_regex.ant.xml
--- a/buildframework/helium/sf/java/metadata/tests/antunit/test_regex.ant.xml	Wed Jun 16 16:51:40 2010 +0300
+++ b/buildframework/helium/sf/java/metadata/tests/antunit/test_regex.ant.xml	Fri Aug 13 14:59:05 2010 +0300
@@ -37,59 +37,25 @@
     </hlm:metadatafilterset>
 
     <target name="setUp">
+        <echo>---=====================================---</echo>
+        <mkdir dir="${test.temp.dir}" />
+        <delete dir="${test.temp.dir}" />
         <mkdir dir="${test.temp.dir}" />
     </target>
     
-    <!-- Test categorization for sbs scanlog
-    -->
-    <target name="test-categorization">
-        <delete dir="${test.temp.dir}/categorization_db" failonerror="false" />
-        <echo message="categorization validation" />
-        <hlm:metadatarecord database="${test.temp.dir}/categorization_db">
-            <hlm:sbsmetadatainput cleanLogFile="${project.dir}/../data/categorization_clean.log">
-                <fileset dir="${project.dir}/../data/">
-                    <include  name="categorization.log"/>
-                </fileset>
-                <metadatafilterset refid="all-regex-filterfile" />
-            </hlm:sbsmetadatainput>
-        </hlm:metadatarecord>
-        <fmpp sourceFile="${project.dir}/../data/parsing_result.ini.ftl"
-                     outputfile="${test.temp.dir}/categorization_db_result.ini">
-            <data expandProperties="yes">
-                dbPath: ${test.temp.dir}/categorization_db
-                ant: antProperties()
-            </data>
-        </fmpp>
-        <property file="${test.temp.dir}/categorization_db_result.ini" />
-        <au:assertTrue message="Invalid number of logs">
-            <equals arg1="${number.of.logs}" arg2="1" />
-        </au:assertTrue>
-        <au:assertTrue message="Invalid number of logs">
-            <equals arg1="${number.of.execution.times}" arg2="1" />
-        </au:assertTrue>
-        <au:assertTrue message="Invalid number of logs">
-            <equals arg1="${execution.time.0}" arg2="226" />
-        </au:assertTrue>
-        <hlm:metadataCountSeverity severity="error" log="categorization.log" db="${test.temp.dir}/categorization_db" property="cleanlog_errors"/>
-        <echo>cleanlog_errors: ${cleanlog_errors}</echo>
-        <au:assertTrue>
-            <equals arg1="${cleanlog_errors}" arg2="2"/>
-        </au:assertTrue>
+    <target name="tearDown">
+        <delete dir="${test.temp.dir}" />
+        <echo>---=====================================---</echo>
     </target>
-    <!-- Test parser error
-    -->
+
     <!-- Test parser error
     -->
     <target name="parser-error">
-        <property name="metadata-read-db" value="${test.temp.dir}/log_all_filterfile_db"/>
-        <delete dir="${metadata-read-db}" failonerror="false"/>
         <echo message="all regular expression validation" />
-        <echo message="database:${metadata-read-db}" />
         <!-- do some checks that files are present and raise asserts if not present-->
         <au:assertFileExists file="${metadata-filterfile}" message="${metadata-filterfile} filter file does not exist"/>
-        <mkdir dir="${test.temp.dir}"/>
         
-        <hlm:metadatarecord database="${metadata-read-db}">
+        <hlm:metadatarecord database="${test.temp.dir}/metadata_db">
             <hlm:sbsmetadatainput>
                 <fileset dir="${project.dir}/../data/">
                     <include  name="all_regex_type.log"/>
@@ -99,20 +65,16 @@
         </hlm:metadatarecord>
         <!-- check we have created the DB file-->
         <au:assertTrue>
-            <available type="dir" file="${metadata-read-db}" />
+            <available type="dir" file="${test.temp.dir}/metadata_db" />
         </au:assertTrue>
     </target>
 
     <target name="parser-error1">
-        <property name="metadata-read-db" value="${test.temp.dir}/log_all_filterfile_db"/>
-        <delete dir="${metadata-read-db}" failonerror="false"/>
         <echo message="all regular expression validation" />
-        <echo message="database:${metadata-read-db}" />
         <!-- do some checks that files are present and raise asserts if not present-->
         <au:assertFileExists file="${metadata-filterfile}" message="${metadata-filterfile} filter file does not exist"/>
-        <mkdir dir="${test.temp.dir}"/>
         
-        <hlm:metadatarecord database="${metadata-read-db}">
+        <hlm:metadatarecord database="${test.temp.dir}/metadata_db">
             <hlm:sbsmetadatainput>
                 <fileset dir="${project.dir}/../data/">
                     <include  name="all_regex1_type.log"/>
@@ -122,11 +84,12 @@
         </hlm:metadatarecord>
         <!-- check we have created the DB file-->
         <au:assertTrue>
-            <available type="dir" file="${metadata-read-db}" />
+            <available type="dir" file="${test.temp.dir}/metadata_db" />
         </au:assertTrue>
     </target>
 
     <target name="test-parser-error-ant-call">
+        <echo>test-parser-error-ant-call</echo>
         <parallel>
             <antcall target="parser-error" />
             <antcall target="parser-error1" />
@@ -146,129 +109,16 @@
         </hlm:metadatarecord>
     </target>
 
-    <!-- Test categorization without cleanLogFile
-    -->
-    <target name="test-categorization-nocleanlog">
-        <delete dir="${test.temp.dir}/categorization_no_clean_db" failonerror="false" />
-        <echo message="categorization validation" />
-        <hlm:metadatarecord database="${test.temp.dir}/categorization_no_clean_db">
-            <hlm:sbsmetadatainput>
-                <fileset dir="${project.dir}/../data/">
-                    <include  name="categorization.log"/>
-                </fileset>
-                <metadatafilterset refid="all-regex-filterfile" />
-            </hlm:sbsmetadatainput>
-        </hlm:metadatarecord>
-        <hlm:metadataCountSeverity severity="error" log="categorization.log" db="${test.temp.dir}/categorization_no_clean_db" property="nocleanlog_errors"/>
-        <echo>test-categorization-nocleanlog: ${nocleanlog_errors}</echo>
-        <au:assertTrue>
-            <equals arg1="${nocleanlog_errors}" arg2="2"/>
-        </au:assertTrue>
-    </target>
-    <target name="test-categorization-component-check">
-        <delete dir="${test.temp.dir}/log-entry-category_component_check_db" failonerror="false" />
-        <echo message="component error check for categorization" />
-        <hlm:metadatarecord database="${test.temp.dir}/log-entry-category_component_check_db">
-            <hlm:sbsmetadatainput>
-                <fileset dir="${project.dir}/../data/">
-                    <include  name="categorization_compile.log"/>
-                </fileset>
-                <metadatafilterset refid="all-regex-filterfile" />
-            </hlm:sbsmetadatainput>
-        </hlm:metadatarecord>
-        <fmpp sourceFile="${project.dir}/../../src/templates/faults.txt.ftl"
-                     outputfile="${test.temp.dir}/faults.txt">
-            <freemarkerLinks expandProperties="yes">
-                macro: ${project.dir}/../../src/templates
-            </freemarkerLinks>
-            
-            <data expandProperties="yes">
-                dbPath: ${test.temp.dir}/log-entry-category_component_check_db
-                ant: antProperties()
-            </data>
-        </fmpp>
-        <loadfile property="componentlogEntry"
-              srcFile="${test.temp.dir}/faults.txt"/>
-        <au:assertMatches string="${componentlogEntry}" pattern="sf/app/organizer/group:error:2" 
-                     casesensitive="false"/>
-    </target>
-    
-    <target name="test-categorization-nocleanlog-failed-empty-recipe">
-        <delete dir="${test.temp.dir}/log-entry-failed-empty-recipe_db" failonerror="false" />
-        <echo message="categorization validation" />
-        <hlm:metadatarecord database="${test.temp.dir}/log-entry-failed-empty-recipe_db">
-            <hlm:sbsmetadatainput>
-                <fileset dir="${project.dir}/../data/">
-                    <include  name="categorization_failed_empty_recipe.log"/>
-                </fileset>
-                <metadatafilterset refid="all-regex-filterfile" />
-            </hlm:sbsmetadatainput>
-        </hlm:metadatarecord>
-        <hlm:metadataCountSeverity severity="error" log="categorization_failed_empty_recipe.log" db="${test.temp.dir}/log-entry-failed-empty-recipe_db" property="empty_nocleanlog_errors"/>
-        <au:assertTrue>
-            <equals arg1="${empty_nocleanlog_errors}" arg2="2"/>
-        </au:assertTrue>
-    </target>
 
-    <target name="test-categorization-nocleanlog-failed-error-in-recipe">
-        <delete dir="${test.temp.dir}/log-entry-failed-error-in-recipe_db" failonerror="false" />
-        <echo message="categorization validation" />
-        <hlm:metadatarecord database="${test.temp.dir}/log-entry-failed-error-in-recipe_db">
-            <hlm:sbsmetadatainput>
-                <fileset dir="${project.dir}/../data/">
-                    <include  name="categorization_failed_error_in_recipe.log"/>
-                </fileset>
-                <metadatafilterset refid="all-regex-filterfile" />
-            </hlm:sbsmetadatainput>
-        </hlm:metadatarecord>
-        <hlm:metadataCountSeverity severity="error" log="categorization_failed_error_in_recipe.log" db="${test.temp.dir}/log-entry-failed-error-in-recipe_db" property="empty_nocleanlog_errors1"/>
-        <au:assertTrue>
-            <equals arg1="${empty_nocleanlog_errors1}" arg2="2"/>
-        </au:assertTrue>
-    </target>
-
-<!-- 
-    <target name="test-log-entry-for-no-errors">
-        <delete dir="${test.temp.dir}/log-entry-for-no-error_db" failonerror="false" />
-        <echo message="categorization validation" />
-        <hlm:metadatarecord database="${test.temp.dir}/log-entry-for-no-error_db">
-            <hlm:sbsmetadatainput>
-                <fileset dir="${project.dir}/../data/">
-                    <include  name="noerror.log"/>
-                </fileset>
-                <metadatafilterset refid="all-regex-filterfile" />
-            </hlm:sbsmetadatainput>
-        </hlm:metadatarecord>
-        <fmpp sourceFile="${project.dir}/../../src/templates/general_category.txt.ftl"
-                     outputfile="${test.temp.dir}/general_category.txt">
-            <freemarkerLinks expandProperties="yes">
-                macro: ${project.dir}/../../src/templates/macro
-            </freemarkerLinks>
-            <data expandProperties="yes">
-                dbPath: ${test.temp.dir}/log-entry-for-no-error_db
-                ant: antProperties()
-            </data>
-        </fmpp>
-        <au:assertFileExists file="${test.temp.dir}/general_category.txt" message="Error in test cases"/>
-        <loadfile property="logEntry"
-              srcFile="${test.temp.dir}/general_category.txt"/>
-        <au:assertMatches string="${logEntry}" pattern="component : general : logfile : " 
-                     casesensitive="false"/>
-    </target>
-    -->
     <!-- Check for all the regular expression defined in the filter file,
     The log file contains text for matching regular expression.
     -->
     <target name="test-all-regex-filterfile">
-        <property name="metadata-read-db" value="${test.temp.dir}/log_all_filterfile_db"/>
-        <delete dir="${metadata-read-db}" failonerror="false"/>
         <echo message="all regular expression validation" />
-        <echo message="database:${metadata-read-db}" />
         <!-- do some checks that files are present and raise asserts if not present-->
         <au:assertFileExists file="${metadata-filterfile}" message="${metadata-filterfile} filter file does not exist"/>
-        <mkdir dir="${test.temp.dir}"/>
         
-        <hlm:metadatarecord database="${metadata-read-db}">
+        <hlm:metadatarecord database="${test.temp.dir}/metadata_db">
             <hlm:sbsmetadatainput>
                 <fileset dir="${project.dir}/../data/">
                     <include  name="*regex*.log"/>
@@ -278,50 +128,25 @@
         </hlm:metadatarecord>
         <!-- check we have created the DB file-->
         <au:assertTrue>
-            <available type="dir" file="${metadata-read-db}" />
+            <available type="dir" file="${test.temp.dir}/metadata_db" />
         </au:assertTrue>
     </target>
 
-    <!-- To verify some lengthy text for recipe tag from 
-    sbs metadata input.
-    -->
-    <target name="test-recipe-lengthy-text">
-        <property name="metadata-read-db" value="${test.temp.dir}/log_lengthy_text_db"/>
-        <au:assertFileExists file="${metadata-filterfile}" message="${metadata-filterfile} filter file does not exist"/>
-        <delete dir="${metadata-read-db}" failonerror="false"/>
-        <echo message="all regular expression validation" />
-        <echo message="database:${metadata-read-db}" />
-        <hlm:metadatarecord database="${metadata-read-db}">
-            <hlm:sbsmetadatainput>
-                <fileset dir="${project.dir}/../data/">
-                    <include  name="receipe*.log"/>
-                </fileset>
-                <metadatafilterset refid="all-regex-filterfile" />
-            </hlm:sbsmetadatainput>
-        </hlm:metadatarecord>
-        <au:assertTrue>
-            <available type="dir" file="${metadata-read-db}" />
-        </au:assertTrue>
-    </target>
 
     <!--modify the errors so regex=".*warning U4010" description="mingw error" is no longer 
     an error but a warning-->
     <hlm:metadatafilterset id="all-regex-combined">
-        <metadatafilter priority="WARNING" regex=".*warning U4010" description="mingw error" />
+        <metadatafilter severity="WARNING" regex=".*warning U4010" description="mingw error" />
         <metadatafilterset filterfile="${metadata-filterfile}" />
     </hlm:metadatafilterset>
 
     <property name="metadata-all-db" value="${test.temp.dir}/log_all_combined_db"/>
 
     <target name="test-all-regex-combined">
-        <property name="metadata-read-db" value="${test.temp.dir}/log_all_combined_db"/>
-        <delete dir="${metadata-read-db}" failonerror="false" />
         <echo message="all regular expression validation" />
-        <echo message="database:${metadata-read-db}" />
         <au:assertFileExists file="${metadata-filterfile}" message="${metadata-filterfile} filter file does not exist"/>
-        <mkdir dir="${test.temp.dir}"/>
 
-        <hlm:metadatarecord database="${metadata-read-db}">
+        <hlm:metadatarecord database="${test.temp.dir}/metadata_db">
             <hlm:sbsmetadatainput>
                 <fileset dir="${project.dir}/../data/">
                     <include  name="*regex*.log"/>
@@ -330,163 +155,80 @@
             </hlm:sbsmetadatainput>
         </hlm:metadatarecord>
         <au:assertTrue>
-            <available type="dir" file="${metadata-read-db}" />
+            <available type="dir" file="${test.temp.dir}/metadata_db" />
         </au:assertTrue>
     </target>
 
 
-    <property name="metadata-error-db" value="${test.temp.dir}/log_error_combined_db"/>
-    <!--create an invalid priority type, so contains message invalid 
-    priority and set to error as priority -->
-    <hlm:metadatafilterset id="all-regex-combined-error">
-        <metadatafilter priority="INCORRECT" regex=".*warning U4010" description="test error handling so incorrect priority" />
-        <metadatafilterset filterfile="${metadata-filterfile}" />
-    </hlm:metadatafilterset>
-    <!--create an invalid priority type, which contains warning invalid priority 
-    and continues with other data. 
+    <!--
+        create an invalid priority type, so contains message invalid 
+        priority and set to error as priority, validation is done by ant, 
+        and parsing of the xml build script will fail.
     -->
-    <target name="test-all-regex-combined-error">
-        <property name="metadata-read-db" value="${test.temp.dir}/log_error_combined_db"/>
-        <delete dir="${metadata-read-db}" failonerror="false" />
-        <echo message="all regular expression validation" />
-        <echo message="database:${metadata-read-db}" />
-        <au:assertFileExists file="${metadata-filterfile}" message="${metadata-filterfile} filter file does not exist"/>
-        <mkdir dir="${test.temp.dir}"/>
+    <target name="test-incorrect-severity-error">
+        <echo message="test-regex-validation-error" />
 
-        <hlm:metadatarecord database="${metadata-read-db}" >
-            <hlm:sbsmetadatainput>
-                <fileset dir="${project.dir}/../data/">
-                    <include  name="*regex*.log"/>
-                </fileset>
-                <metadatafilterset refid="all-regex-combined-error" />
-            </hlm:sbsmetadatainput>
-        </hlm:metadatarecord>
+        <au:expectfailure message="INCORRECT is not a legal value for this attribute">
+            <hlm:metadatarecord database="${test.temp.dir}/metadata_db" >
+                <hlm:textmetadatainput>
+                    <fileset dir="${project.dir}/../data/regex" includes="empty.log"/>
+                     <hlm:metadatafilterset id="all-regex-combined-error">
+                        <metadatafilter severity="INCORRECT" regex=".*warning U4010" description="test error handling so incorrect priority" />
+                    </hlm:metadatafilterset>
+                </hlm:textmetadatainput>
+            </hlm:metadatarecord>
+        </au:expectfailure>
         <!-- no need to check the DB file not present as it won't be-->
     </target>
-    <!--try to add a different different filter type but not add the parameter so has an error-->
-    <hlm:metadatafilterset id="all-regex-combined-no-priority">
-        <metadatafilter regex=".*warning U4010" description="test error handling so incorrect priority" />
-        <metadatafilterset filterfile="${metadata-filterfile}" />
-    </hlm:metadatafilterset>
+    
+    
+    
     <!--try to add a different different filter type but not add the parameter so has an error-->
     <target name="test-all-regex-combined-no-priority">
-        <property name="metadata-read-db" value="${test.temp.dir}/log_error_combined_db"/>
-        <delete dir="${metadata-read-db}" failonerror="false" />
-        <echo message="all regular expression validation" />
-        <echo message="database:${metadata-read-db}" />
-        <au:assertFileExists file="${metadata-filterfile}" message="${metadata-filterfile} filter file does not exist"/>
-        <mkdir dir="${test.temp.dir}"/>
-
-        <hlm:metadatarecord database="${metadata-read-db}">
-            <hlm:sbsmetadatainput>
-                <fileset dir="${project.dir}/../data/">
-                    <include  name="*regex*.log"/>
-                </fileset>
-                <metadatafilterset refid="all-regex-combined-no-priority" />
-            </hlm:sbsmetadatainput>
-        </hlm:metadatarecord>
-        <!-- no need to check the DB file not present as it won't be-->
+        <au:expectfailure message="Invalid filter have been found. Please check your configuration.">
+            <hlm:metadatarecord database="${test.temp.dir}/metadata_db">
+                <hlm:textmetadatainput>
+                    <fileset dir="${project.dir}/../data/regex" includes="empty.log" />
+                    <metadatafilterset refid="all-regex-combined-no-priority" />
+                    <!--try to add a different different filter type but not add the parameter so has an error -->
+                    <hlm:metadatafilterset>
+                        <metadatafilter severity="error" regex="^ERROR:.*" />
+                        <metadatafilter regex=".*warning U4010" description="test error handling so incorrect priority" />
+                        <metadatafilter severity="warning" regex="^WARNING*" />
+                    </hlm:metadatafilterset>
+                </hlm:textmetadatainput>
+            </hlm:metadatarecord>
+        </au:expectfailure>
     </target>
     
 
     <!--try to add a different different filter type but not add the parameter so has an error-->
-    <hlm:metadatafilterset id="all-regex-combined-no-regex">
-        <metadatafilter priority="INCORRECT" description="test error handling so incorrect priority" />
-        <metadatafilter priority="WARNING" description="test error handling so incorrect priority" />
-        <metadatafilterset filterfile="${metadata-filterfile}" />
-    </hlm:metadatafilterset>
-
-    <!--try to add a different different filter type but not add the parameter so has an error-->
     <target name="test-all-regex-combined-no-regex">
-        <property name="metadata-read-db" value="${test.temp.dir}/log_error_combined_db"/>
-        <delete dir="${metadata-read-db}" failonerror="false" />
         <echo message="all regular expression validation" />
-        <echo message="database:${metadata-read-db}" />
         <au:assertFileExists file="${metadata-filterfile}" message="${metadata-filterfile} filter file does not exist"/>
-        <mkdir dir="${test.temp.dir}"/>
 
-        <hlm:metadatarecord database="${metadata-read-db}">
-            <hlm:sbsmetadatainput>
-                <fileset dir="${project.dir}/../data/">
-                    <include  name="*regex*.log"/>
-                </fileset>
-                <metadatafilterset refid="all-regex-combined-no-regex" />
-            </hlm:sbsmetadatainput>
-        </hlm:metadatarecord>
+        <au:expectfailure message="INCORRECT is not a legal value for this attribute">
+            <hlm:metadatarecord database="${test.temp.dir}/metadata_db">
+                <hlm:sbsmetadatainput>
+                    <fileset dir="${project.dir}/../data/">
+                        <include  name="*regex*.log"/>
+                    </fileset>
+                    <hlm:metadatafilterset>
+                        <metadatafilter severity="INCORRECT" description="test error handling so incorrect priority" />
+                        <metadatafilter severity="WARNING" description="test error handling so incorrect priority" />
+                        <metadatafilterset filterfile="${metadata-filterfile}" />
+                    </hlm:metadatafilterset>
+                </hlm:sbsmetadatainput>
+            </hlm:metadatarecord>
+        </au:expectfailure>
         <!-- no need to check the DB file not present as it won't be-->
     </target>
+    
+    
     <hlm:metadatafilterset id="text_log_metadata_input">
         <metadatafilterset filterfile="${project.dir}/../data/common.csv" />
     </hlm:metadatafilterset>
 
-    <target name="test-text_log_metadata_input">
-        <property name="metadata-read-db" value="${test.temp.dir}/log_text_metadata_input_db"/>
-        <delete dir="${metadata-read-db}" failonerror="false" />
-        <echo message="text log metadata input validation" />
-        <echo message="database:${metadata-read-db}" />
-        <au:assertFileExists file="${metadata-filterfile}" message="${metadata-filterfile} filter file does not exist"/>
-        <mkdir dir="${test.temp.dir}"/>
-
-        <hlm:metadatarecord database="${metadata-read-db}">
-            <hlm:textmetadatainput>
-                <fileset dir="${project.dir}/../data/">
-                    <include  name="*_fixslashes*.log"/>
-                </fileset>
-                <metadatafilterset refid="text_log_metadata_input" />
-            </hlm:textmetadatainput>
-        </hlm:metadatarecord>
-        <au:assertTrue>
-            <available type="dir" file="${metadata-read-db}" />
-        </au:assertTrue>
-    </target>
-
-    <hlm:metadatafilterset id="abld_log_metadata_input">
-        <metadatafilter priority="WARNING" regex=".*warning U4010" description="mingw error" />
-        <metadatafilterset filterfile="${project.dir}/../data/common.csv" />
-    </hlm:metadatafilterset>
-
-
-    <target name="test-abld_log_metadata_input">
-        <property name="metadata-read-db" value="${test.temp.dir}/log_abld_metadata_input_db"/>
-        <delete dir="${test.temp.dir}/log_abld_metadata_input_db" failonerror="false" />
-        <echo message="abld log metadata input validation" />
-        <echo message="database:${metadata-read-db}" />
-        <au:assertFileExists file="${metadata-filterfile}" message="${metadata-filterfile} filter file does not exist"/>
-        <mkdir dir="${test.temp.dir}"/>
-
-        <hlm:metadatarecord database="${metadata-read-db}">
-            <hlm:abldmetadatainput>
-                <fileset dir="${project.dir}/../data/">
-                    <include  name="*sample_abld.log"/>
-                </fileset>
-                <metadatafilterset refid="abld_log_metadata_input" />
-            </hlm:abldmetadatainput>
-        </hlm:metadatarecord>
-        <au:assertTrue>
-            <available type="dir" file="${metadata-read-db}" />
-        </au:assertTrue>
-    </target>
-
-
-    <target name="test-policy_metadata_input">
-        <property name="metadata-read-db" value="${test.temp.dir}/log_policy_metadata_input_db"/>
-        <delete dir="${metadata-read-db}" failonerror="false" />
-        <echo message="policy metadata input validation" />
-        <echo message="database:${metadata-read-db}" />
-        <au:assertFileExists file="${metadata-filterfile}" message="${metadata-filterfile} filter file does not exist"/>
-        <mkdir dir="${test.temp.dir}"/>
-
-        <hlm:metadatarecord database="${metadata-read-db}">
-            <hlm:policymetadatainput>
-                <fileset dir="${project.dir}/../data/">
-                    <include  name="*policy*.log"/>
-                </fileset>
-            </hlm:policymetadatainput>
-        </hlm:metadatarecord>
-        <au:assertTrue>
-            <available type="dir" file="${metadata-read-db}" />
-        </au:assertTrue>
-    </target>
 
     <hlm:metadatafilterset id="ant_log_metadata_input">
         <metadatafilterset filterfile="${project.dir}/../data/common.csv" />
@@ -494,14 +236,10 @@
 
 
     <target name="test-ant_log_metadata_input">
-        <property name="metadata-read-db" value="${test.temp.dir}/log_ant_metadata_input_db"/>
-        <delete dir="${metadata-read-db}" failonerror="false" />
         <echo message="ant log metadata input validation" />
-        <echo message="database:${metadata-read-db}" />
         <au:assertFileExists file="${metadata-filterfile}" message="${metadata-filterfile} filter file does not exist"/>
-        <mkdir dir="${test.temp.dir}"/>
 
-        <hlm:metadatarecord database="${metadata-read-db}">
+        <hlm:metadatarecord database="${test.temp.dir}/metadata_db">
             <hlm:antmetadatainput>
                 <fileset dir="${project.dir}/../data/">
                     <include  name="*ant*.log"/>
@@ -510,126 +248,52 @@
             </hlm:antmetadatainput>
         </hlm:metadatarecord>
         <au:assertTrue>
-            <available type="dir" file="${metadata-read-db}" />
+            <available type="dir" file="${test.temp.dir}/metadata_db" />
         </au:assertTrue>
     </target>
 
     <property name="metadata-read-ftl" value="${project.dir}/../../src/templates/readdata.xml.ftl"/>
     <property name="metadata-read-output" value="${test.temp.dir}/readdata.html"/>
-<!-- 
-    <target name="test-readdata" depends="test-text_log_metadata_input" >
-        <property name="metadata-template-dir" value="${project.dir}/../../src/templates/" />
-        <property name="metadata-output-dir" value="${test.temp.dir}" />
-        <property name="metadata-read-ftl" value="${metadata-template-dir}/readdata.xml.ftl"/>
-        <property name="metadata-read-db" value="${metadata-output-dir}/log_text_metadata_input_db"/>
-        <property name="metadata-read-output" value="${metadata-output-dir}/readdata.html"/>
-        <delete file="${metadata-read-output}" failonerror="false" />
-        <au:assertFileExists file="${metadata-read-db}" message="${metadata-read-db} DB file was not created"/>
-        <fmpp sourceFile="${metadata-template-dir}/readdata.xml.ftl"
-                     outputfile="${metadata-output-dir}/readdata.html">
-            <freemarkerLinks expandProperties="yes">
-                macro: ${project.dir}/../../src/templates
-            </freemarkerLinks>
-            <data expandProperties="yes">
-                dbPath: ${metadata-read-db}
-                ant: antProperties()
-            </data>
-        </fmpp>
-        <fmpp sourceFile="${metadata-template-dir}/build_status.xml.ftl"
-                     outputfile="${metadata-output-dir}/build_status.xml">
-            <freemarkerLinks expandProperties="yes">
-                macro: ${project.dir}/../../src/templates
-            </freemarkerLinks>
-            <data expandProperties="yes">
-                dbPath: ${metadata-read-db}
-                logfile: ido_abs_mcl_devlon70_robot_MCL.70.500_fixslashes_raptor.log
-                ant: antProperties()
-            </data>
-        </fmpp>
-        <fmpp sourceFile="${metadata-template-dir}/email_new.html.ftl"
-                     outputfile="${metadata-output-dir}/build_status.html">
-            <freemarkerLinks expandProperties="yes">
-                macro: ${project.dir}/../../src/templates
-            </freemarkerLinks>
-            <data expandProperties="yes">
-                dbPath: ${metadata-read-db}
-                logfile: ido_abs_mcl_devlon70_robot_MCL.70.500_fixslashes_raptor.log
-                ant: antProperties()
-            </data>
-        </fmpp>
-        <au:assertFileExists file="${metadata-read-output}" message="${metadata-read-output} DB file was not created"/>
-    </target>
--->
 
-    <target name="test-generate-summary" depends="test-text_log_metadata_input">
-        <property name="metadata-summary-ftl" value="${project.dir}/../../src/templates/summary.html.ftl"/>
-        <property name="metadata-summary-output" value="${test.temp.dir}/summary.html"/>
-        <property name="metadata-output-dir" value="${test.temp.dir}/" />
-        <delete file="${metadata-summary-output}" failonerror="false" />
-        <property name="metadata-read-db" value="${metadata-output-dir}/log_text_metadata_input_db"/>
-        
-        <fmpp sourceFile="${metadata-summary-ftl}"
-                     outputfile="${metadata-summary-output}">
-            <freemarkerLinks expandProperties="yes">
-                macro: ${project.dir}/../../src/templates/macro
-            </freemarkerLinks>
-            <data expandProperties="yes">
-                dbPath: ${metadata-read-db}
-                loginfo: xml(${project.dir}/../data/ido_abs_mcl_devlon70_robot_MCL.70.500_info.log)
-                ant: antProperties()
-            </data>
-        </fmpp>
-        <!-- check we have created the files -->
-        <au:assertTrue>
-            <available type="dir" file="${metadata-read-db}" />
-        </au:assertTrue>
-        <au:assertFileExists file="${metadata-summary-output}" message="${metadata-summary-output} summary output file was not created"/>
-    </target>
+    <hlm:metadatafilterset id="text.log.metadata.input.filterset">
+        <metadatafilterset filterfile="${project.dir}/../data/common.csv" />
+    </hlm:metadatafilterset>
     
     <target name="test-countseverity">
-        <delete dir="${test.temp.dir}/dp_db" failonerror="false" />
-
-        <hlm:metadatarecord database="${test.temp.dir}/dp_db">
+        <hlm:metadatarecord database="${test.temp.dir}/metadata_db">
             <hlm:textmetadatainput>
-                <fileset dir="${project.dir}/../data/">
+                <fileset dir="${project.dir}/../data/countseverity">
                     <include  name="*_fixslashes*.log"/>
                 </fileset>
-                <metadatafilterset refid="text_log_metadata_input" />
+                <metadatafilterset refid="text.log.metadata.input.filterset" />
             </hlm:textmetadatainput>
         </hlm:metadatarecord>
 
-        <hlm:metadataCountSeverity severity="error" log="_fixslashes_raptor.log" db="${test.temp.dir}/dp_db" property="errors"/>
+        <hlm:metadataCountSeverity severity="error" database="${test.temp.dir}/metadata_db" property="errors">
+                <fileset dir="${project.dir}/../data/countseverity">
+                    <include  name="*_fixslashes*.log"/>
+                </fileset>
+        </hlm:metadataCountSeverity>
         <echo message="${errors}" />
         <au:assertTrue>
             <equals arg1="${errors}" arg2="24"/>
         </au:assertTrue>
         <au:assertTrue>
-            <hlm:metadataHasSeverity severity="error" log="_fixslashes_raptor.log" db="${test.temp.dir}/dp_db" />
+            <hlm:metadataHasSeverity severity="error"  database="${test.temp.dir}/metadata_db">
+                <fileset dir="${project.dir}/../data/countseverity">
+                    <include  name="*_fixslashes*.log"/>
+                </fileset>
+            </hlm:metadataHasSeverity>
         </au:assertTrue>
         <au:assertFalse>
-            <hlm:metadataHasSeverity severity="fatal" log="_fixslashes_raptor.log" db="${test.temp.dir}/dp_db" />
+            <hlm:metadataHasSeverity severity="fatal"  database="${test.temp.dir}/metadata_db">
+                <fileset dir="${project.dir}/../data/">
+                    <include  name="*_fixslashes*.log"/>
+                </fileset>
+            </hlm:metadataHasSeverity>
         </au:assertFalse>
         
     </target>
-
-    <target name="test-metadatacount-no-error-with-missing-files-path-with-backslashes">
-        <hlm:metadatarecord database="${test.temp.dir}/metadatacount_with_missing_files_db">
-            <hlm:sbsmetadatainput>
-                <fileset dir="${project.dir}/../data/">
-                    <include  name="metadatacount_missing_files.log"/>
-                </fileset>
-                <metadatafilterset>
-                    <metadatafilter priority="INFO" regex="^INFO:" description="info" />
-                    <metadatafilter priority="ERROR" regex="^ERROR:" description="error" />
-                    <metadatafilter priority="WARNING" regex=".*warning C4503:.*" description="warning" />
-                </metadatafilterset>
-            </hlm:sbsmetadatainput>
-        </hlm:metadatarecord>
-        <hlm:metadataCountSeverity severity="error" log="data\metadatacount_missing_files.log" db="${test.temp.dir}/metadatacount_with_missing_files_db" property="errors"/>
-        <au:assertTrue message="We must have 5 missing files counted as error.">
-            <equals arg1="${errors}" arg2="5"/>
-        </au:assertTrue>
-    </target>
     
     <target name="test-very-long-warning">
         <delete dir="${test.temp.dir}/very_long_warning_db" failonerror="false" />
@@ -640,161 +304,69 @@
                     <include  name="very_long_warning.log"/>
                 </fileset>
                 <metadatafilterset>
-                    <metadatafilter priority="INFO" regex="^INFO:" description="info" />
-                    <metadatafilter priority="WARNING" regex=".*warning C4503:.*" description="warning" />
+                    <metadatafilter severity="INFO" regex="^INFO:" description="info" />
+                    <metadatafilter severity="WARNING" regex=".*warning C4503:.*" description="warning" />
                 </metadatafilterset>
             </hlm:textmetadatainput>
         </hlm:metadatarecord>
 
-        <hlm:metadataCountSeverity severity="warning" log="very_long_warning.log" db="${test.temp.dir}/very_long_warning_db" property="warnings"/>
+        <hlm:metadataCountSeverity severity="warning" log="${project.dir}/../data/very_long_warning.log" database="${test.temp.dir}/very_long_warning_db" property="warnings"/>
         <echo message="test-very-long-warning: ${warnings}" />
         <au:assertTrue>
             <equals arg1="${warnings}" arg2="1"/>
         </au:assertTrue>
     </target>
 
-    <target name="test-whatlog-parsing">
-        <delete dir="${test.temp.dir}/whatlog_db" failonerror="false" />
-
-        <hlm:metadatarecord database="${test.temp.dir}/whatlog_db">
-            <hlm:sbsmetadatainput whatLogFile="${project.dir}/../data/build_whatlog.whatlog.log">
-                <fileset dir="${project.dir}/../data/">
-                    <include  name="build_whatlog.log"/>
-                </fileset>
-                <metadatafilterset>
-                    <metadatafilter priority="INFO" regex="^INFO:" description="info" />
-                    <metadatafilter priority="ERROR" regex="^ERROR:" description="error" />
-                    <metadatafilter priority="WARNING" regex=".*warning C4503:.*" description="warning" />
-                </metadatafilterset>
-            </hlm:sbsmetadatainput>
-        </hlm:metadatarecord>
-        <fmpp sourceFile="${project.dir}/../data/whatlog_result.ini.ftl"
-                     outputfile="${test.temp.dir}/whatlog_result.ini">
-            <data expandProperties="yes">
-                dbPath: ${test.temp.dir}/whatlog_db
-                ant: antProperties()
-            </data>
-        </fmpp>
-        <property file="${test.temp.dir}/whatlog_result.ini" />
-        <au:assertTrue message="Invalid number of logs">
-            <equals arg1="${number.of.logs}" arg2="1" />
-        </au:assertTrue>
-        <au:assertTrue message="Invalid number of whatlog entries">
-            <equals arg1="${number.of.whatlog.entries}" arg2="5" />
-        </au:assertTrue>
-    </target>
-
     <target name="test-log-with-same-root-name">
-        <delete dir="${test.temp.dir}/log-with-same-root-name_db" failonerror="false"/>
-        <hlm:metadatarecord database="${test.temp.dir}/log-with-same-root-name_db">
+        <hlm:metadatarecord database="${test.temp.dir}/metadata_db">
             <hlm:textmetadatainput>
-                <fileset dir="${project.dir}/../data/">
+                <fileset dir="${project.dir}/../data/regex">
                     <include name="log-with-same-root-name.log*"/>
                 </fileset>
                 <metadatafilterset>
-                    <metadatafilter priority="ERROR" regex="^ERROR:.*" description="error" />
+                    <metadatafilter severity="ERROR" regex="^ERROR:.*" description="error" />
                 </metadatafilterset>
             </hlm:textmetadatainput>
         </hlm:metadatarecord>
-        <hlm:metadataCountSeverity severity="error" log="log-with-same-root-name.log" db="${test.temp.dir}/log-with-same-root-name_db" property="log-with-same-root-name.log.error"/>
+        <hlm:metadataCountSeverity severity="error" log="${project.dir}/../data/regex/log-with-same-root-name.log" database="${test.temp.dir}/metadata_db" property="log-with-same-root-name.log.error"/>
+        <echo>log-with-same-root-name.log.error: ${log-with-same-root-name.log.error}</echo>
         <au:assertTrue message="We should only find 1 error">
             <equals arg1="${log-with-same-root-name.log.error}" arg2="1"/>
         </au:assertTrue>
     </target>
 
     <target name="test-release-database-metadatatask">
-        <hlm:metadatarecord database="${test.temp.dir}/test-release-database-metadatatask_db">
+        <hlm:metadatarecord database="${test.temp.dir}/metadata_db">
             <hlm:textmetadatainput>
                 <fileset dir="${project.dir}/../data/">
                     <include name="test-release-database-metadatatask.log"/>
                 </fileset>
                 <metadatafilterset>
-                    <metadatafilter priority="ERROR" regex="^ERROR:.*" description="error" />
+                    <metadatafilter severity="ERROR" regex="^ERROR:.*" description="error" />
                 </metadatafilterset>
             </hlm:textmetadatainput>
         </hlm:metadatarecord>
-        <delete dir="${test.temp.dir}/log-with-same-root-name_db" failonerror="true" />
     </target>
 
     <target name="test-release-database-fmpp">
-        <hlm:metadatarecord database="${test.temp.dir}/test-release-database-fmpp_db">
+        <echo>test-release-database-fmpp</echo>
+        <hlm:metadatarecord database="${test.temp.dir}/metadata_db">
             <hlm:textmetadatainput>
                 <fileset dir="${project.dir}/../data/">
                     <include name="test-release-database-metadatatask.log"/>
                 </fileset>
                 <metadatafilterset>
-                    <metadatafilter priority="ERROR" regex="^ERROR:.*" description="error" />
+                    <metadatafilter severity="ERROR" regex="^ERROR:.*" description="error" />
                 </metadatafilterset>
             </hlm:textmetadatainput>
         </hlm:metadatarecord>
         <fmpp sourceFile="${project.dir}/../data/test-release-database-fmpp.ini.ftl"
                      outputfile="${test.temp.dir}/test-release-database-fmpp.ini">
             <data expandProperties="yes">
-                dbPath: ${test.temp.dir}/test-release-database-fmpp_db
+                dbPath: ${test.temp.dir}/metadata_db
                 ant: antProperties()
             </data>
         </fmpp>        
-        <delete dir="${test.temp.dir}/test-release-database-fmpp_db" failonerror="true" />
-    </target>
-    
-    
-    <target name="test-metadatacount-no-error-with-missing-files">
-        <hlm:metadatarecord database="${test.temp.dir}/metadatacount_with_missing_files_db">
-            <hlm:sbsmetadatainput>
-                <fileset dir="${project.dir}/../data/">
-                    <include  name="metadatacount_missing_files.log"/>
-                </fileset>
-                <metadatafilterset>
-                    <metadatafilter priority="INFO" regex="^INFO:" description="info" />
-                    <metadatafilter priority="ERROR" regex="^ERROR:" description="error" />
-                    <metadatafilter priority="WARNING" regex=".*warning C4503:.*" description="warning" />
-                </metadatafilterset>
-            </hlm:sbsmetadatainput>
-        </hlm:metadatarecord>
-        <hlm:metadataCountSeverity severity="error" log="metadatacount_missing_files.log" db="${test.temp.dir}/metadatacount_with_missing_files_db" property="errors"/>
-        <au:assertTrue message="We must have 5 missing files counted as error.">
-            <equals arg1="${errors}" arg2="5"/>
-        </au:assertTrue>
     </target>
     
-    <target name="test-metadatacount-error-with-missing-files">
-        <hlm:metadatarecord database="${test.temp.dir}/metadatacount_with_missing_files_db">
-            <hlm:sbsmetadatainput>
-                <fileset dir="${project.dir}/../data/">
-                    <include  name="metadatacount_error_and_missing_files.log"/>
-                </fileset>
-                <metadatafilterset>
-                    <metadatafilter priority="INFO" regex="^INFO:" description="info" />
-                    <metadatafilter priority="ERROR" regex="^ERROR:" description="error" />
-                    <metadatafilter priority="WARNING" regex=".*warning C4503:.*" description="warning" />
-                </metadatafilterset>
-            </hlm:sbsmetadatainput>
-        </hlm:metadatarecord>
-        <hlm:metadataCountSeverity severity="error" log="metadatacount_error_and_missing_files.log" db="${test.temp.dir}/metadatacount_with_missing_files_db" property="errors"/>
-        <au:assertTrue message="We must have 6 missing files counted as error.">
-            <equals arg1="${errors}" arg2="6"/>
-        </au:assertTrue>
-    </target>
-
-    <target name="test-count-error-without-missing-files">
-        <hlm:metadatarecord database="${test.temp.dir}/metadatacount_with_missing_files_db">
-            <hlm:sbsmetadatainput>
-                <fileset dir="${project.dir}/../data/">
-                    <include  name="metadatacount_error_and_missing_files.log"/>
-                </fileset>
-                <metadatafilterset>
-                    <metadatafilter priority="INFO" regex="^INFO:" description="info" />
-                    <metadatafilter priority="ERROR" regex="^ERROR:" description="error" />
-                    <metadatafilter priority="WARNING" regex=".*warning C4503:.*" description="warning" />
-                </metadatafilterset>
-            </hlm:sbsmetadatainput>
-        </hlm:metadatarecord>
-        <hlm:metadataCountSeverity severity="error" log="metadatacount_error_and_missing_files.log"
-            db="${test.temp.dir}/metadatacount_with_missing_files_db" property="errors"
-            countMissing="false"/>
-        <au:assertTrue message="We must have 1 missing files counted as error.">
-            <equals arg1="${errors}" arg2="1"/>
-        </au:assertTrue>
-    </target>
-
 </project>
\ No newline at end of file