buildframework/helium/sf/java/metadata/tests/antunit/test_regex.ant.xml
changeset 628 7c4a911dc066
parent 588 c7c26511138f
equal deleted inserted replaced
588:c7c26511138f 628:7c4a911dc066
    35     <hlm:metadatafilterset id="all-regex-filterfile">
    35     <hlm:metadatafilterset id="all-regex-filterfile">
    36         <metadatafilterset filterfile="${metadata-filterfile}" />
    36         <metadatafilterset filterfile="${metadata-filterfile}" />
    37     </hlm:metadatafilterset>
    37     </hlm:metadatafilterset>
    38 
    38 
    39     <target name="setUp">
    39     <target name="setUp">
       
    40         <echo>---=====================================---</echo>
    40         <mkdir dir="${test.temp.dir}" />
    41         <mkdir dir="${test.temp.dir}" />
    41     </target>
    42         <delete dir="${test.temp.dir}" />
    42     
    43         <mkdir dir="${test.temp.dir}" />
    43     <!-- Test categorization for sbs scanlog
    44     </target>
    44     -->
    45     
    45     <target name="test-categorization">
    46     <target name="tearDown">
    46         <delete dir="${test.temp.dir}/categorization_db" failonerror="false" />
    47         <delete dir="${test.temp.dir}" />
    47         <echo message="categorization validation" />
    48         <echo>---=====================================---</echo>
    48         <hlm:metadatarecord database="${test.temp.dir}/categorization_db">
    49     </target>
    49             <hlm:sbsmetadatainput cleanLogFile="${project.dir}/../data/categorization_clean.log">
    50 
    50                 <fileset dir="${project.dir}/../data/">
       
    51                     <include  name="categorization.log"/>
       
    52                 </fileset>
       
    53                 <metadatafilterset refid="all-regex-filterfile" />
       
    54             </hlm:sbsmetadatainput>
       
    55         </hlm:metadatarecord>
       
    56         <fmpp sourceFile="${project.dir}/../data/parsing_result.ini.ftl"
       
    57                      outputfile="${test.temp.dir}/categorization_db_result.ini">
       
    58             <data expandProperties="yes">
       
    59                 dbPath: ${test.temp.dir}/categorization_db
       
    60                 ant: antProperties()
       
    61             </data>
       
    62         </fmpp>
       
    63         <property file="${test.temp.dir}/categorization_db_result.ini" />
       
    64         <au:assertTrue message="Invalid number of logs">
       
    65             <equals arg1="${number.of.logs}" arg2="1" />
       
    66         </au:assertTrue>
       
    67         <au:assertTrue message="Invalid number of logs">
       
    68             <equals arg1="${number.of.execution.times}" arg2="1" />
       
    69         </au:assertTrue>
       
    70         <au:assertTrue message="Invalid number of logs">
       
    71             <equals arg1="${execution.time.0}" arg2="226" />
       
    72         </au:assertTrue>
       
    73         <hlm:metadataCountSeverity severity="error" log="categorization.log" db="${test.temp.dir}/categorization_db" property="cleanlog_errors"/>
       
    74         <echo>cleanlog_errors: ${cleanlog_errors}</echo>
       
    75         <au:assertTrue>
       
    76             <equals arg1="${cleanlog_errors}" arg2="2"/>
       
    77         </au:assertTrue>
       
    78     </target>
       
    79     <!-- Test parser error
       
    80     -->
       
    81     <!-- Test parser error
    51     <!-- Test parser error
    82     -->
    52     -->
    83     <target name="parser-error">
    53     <target name="parser-error">
    84         <property name="metadata-read-db" value="${test.temp.dir}/log_all_filterfile_db"/>
    54         <echo message="all regular expression validation" />
    85         <delete dir="${metadata-read-db}" failonerror="false"/>
       
    86         <echo message="all regular expression validation" />
       
    87         <echo message="database:${metadata-read-db}" />
       
    88         <!-- do some checks that files are present and raise asserts if not present-->
    55         <!-- do some checks that files are present and raise asserts if not present-->
    89         <au:assertFileExists file="${metadata-filterfile}" message="${metadata-filterfile} filter file does not exist"/>
    56         <au:assertFileExists file="${metadata-filterfile}" message="${metadata-filterfile} filter file does not exist"/>
    90         <mkdir dir="${test.temp.dir}"/>
       
    91         
    57         
    92         <hlm:metadatarecord database="${metadata-read-db}">
    58         <hlm:metadatarecord database="${test.temp.dir}/metadata_db">
    93             <hlm:sbsmetadatainput>
    59             <hlm:sbsmetadatainput>
    94                 <fileset dir="${project.dir}/../data/">
    60                 <fileset dir="${project.dir}/../data/">
    95                     <include  name="all_regex_type.log"/>
    61                     <include  name="all_regex_type.log"/>
    96                 </fileset>
    62                 </fileset>
    97                 <metadatafilterset refid="all-regex-filterfile" />
    63                 <metadatafilterset refid="all-regex-filterfile" />
    98             </hlm:sbsmetadatainput>
    64             </hlm:sbsmetadatainput>
    99         </hlm:metadatarecord>
    65         </hlm:metadatarecord>
   100         <!-- check we have created the DB file-->
    66         <!-- check we have created the DB file-->
   101         <au:assertTrue>
    67         <au:assertTrue>
   102             <available type="dir" file="${metadata-read-db}" />
    68             <available type="dir" file="${test.temp.dir}/metadata_db" />
   103         </au:assertTrue>
    69         </au:assertTrue>
   104     </target>
    70     </target>
   105 
    71 
   106     <target name="parser-error1">
    72     <target name="parser-error1">
   107         <property name="metadata-read-db" value="${test.temp.dir}/log_all_filterfile_db"/>
    73         <echo message="all regular expression validation" />
   108         <delete dir="${metadata-read-db}" failonerror="false"/>
       
   109         <echo message="all regular expression validation" />
       
   110         <echo message="database:${metadata-read-db}" />
       
   111         <!-- do some checks that files are present and raise asserts if not present-->
    74         <!-- do some checks that files are present and raise asserts if not present-->
   112         <au:assertFileExists file="${metadata-filterfile}" message="${metadata-filterfile} filter file does not exist"/>
    75         <au:assertFileExists file="${metadata-filterfile}" message="${metadata-filterfile} filter file does not exist"/>
   113         <mkdir dir="${test.temp.dir}"/>
       
   114         
    76         
   115         <hlm:metadatarecord database="${metadata-read-db}">
    77         <hlm:metadatarecord database="${test.temp.dir}/metadata_db">
   116             <hlm:sbsmetadatainput>
    78             <hlm:sbsmetadatainput>
   117                 <fileset dir="${project.dir}/../data/">
    79                 <fileset dir="${project.dir}/../data/">
   118                     <include  name="all_regex1_type.log"/>
    80                     <include  name="all_regex1_type.log"/>
   119                 </fileset>
    81                 </fileset>
   120                 <metadatafilterset refid="all-regex-filterfile" />
    82                 <metadatafilterset refid="all-regex-filterfile" />
   121             </hlm:sbsmetadatainput>
    83             </hlm:sbsmetadatainput>
   122         </hlm:metadatarecord>
    84         </hlm:metadatarecord>
   123         <!-- check we have created the DB file-->
    85         <!-- check we have created the DB file-->
   124         <au:assertTrue>
    86         <au:assertTrue>
   125             <available type="dir" file="${metadata-read-db}" />
    87             <available type="dir" file="${test.temp.dir}/metadata_db" />
   126         </au:assertTrue>
    88         </au:assertTrue>
   127     </target>
    89     </target>
   128 
    90 
   129     <target name="test-parser-error-ant-call">
    91     <target name="test-parser-error-ant-call">
       
    92         <echo>test-parser-error-ant-call</echo>
   130         <parallel>
    93         <parallel>
   131             <antcall target="parser-error" />
    94             <antcall target="parser-error" />
   132             <antcall target="parser-error1" />
    95             <antcall target="parser-error1" />
   133         </parallel>
    96         </parallel>
   134     </target>
    97     </target>
   144                 <metadatafilterset refid="all-regex-filterfile" />
   107                 <metadatafilterset refid="all-regex-filterfile" />
   145             </hlm:sbsmetadatainput>
   108             </hlm:sbsmetadatainput>
   146         </hlm:metadatarecord>
   109         </hlm:metadatarecord>
   147     </target>
   110     </target>
   148 
   111 
   149     <!-- Test categorization without cleanLogFile
   112 
   150     -->
       
   151     <target name="test-categorization-nocleanlog">
       
   152         <delete dir="${test.temp.dir}/categorization_no_clean_db" failonerror="false" />
       
   153         <echo message="categorization validation" />
       
   154         <hlm:metadatarecord database="${test.temp.dir}/categorization_no_clean_db">
       
   155             <hlm:sbsmetadatainput>
       
   156                 <fileset dir="${project.dir}/../data/">
       
   157                     <include  name="categorization.log"/>
       
   158                 </fileset>
       
   159                 <metadatafilterset refid="all-regex-filterfile" />
       
   160             </hlm:sbsmetadatainput>
       
   161         </hlm:metadatarecord>
       
   162         <hlm:metadataCountSeverity severity="error" log="categorization.log" db="${test.temp.dir}/categorization_no_clean_db" property="nocleanlog_errors"/>
       
   163         <echo>test-categorization-nocleanlog: ${nocleanlog_errors}</echo>
       
   164         <au:assertTrue>
       
   165             <equals arg1="${nocleanlog_errors}" arg2="2"/>
       
   166         </au:assertTrue>
       
   167     </target>
       
   168     <target name="test-categorization-component-check">
       
   169         <delete dir="${test.temp.dir}/log-entry-category_component_check_db" failonerror="false" />
       
   170         <echo message="component error check for categorization" />
       
   171         <hlm:metadatarecord database="${test.temp.dir}/log-entry-category_component_check_db">
       
   172             <hlm:sbsmetadatainput>
       
   173                 <fileset dir="${project.dir}/../data/">
       
   174                     <include  name="categorization_compile.log"/>
       
   175                 </fileset>
       
   176                 <metadatafilterset refid="all-regex-filterfile" />
       
   177             </hlm:sbsmetadatainput>
       
   178         </hlm:metadatarecord>
       
   179         <fmpp sourceFile="${project.dir}/../../src/templates/faults.txt.ftl"
       
   180                      outputfile="${test.temp.dir}/faults.txt">
       
   181             <freemarkerLinks expandProperties="yes">
       
   182                 macro: ${project.dir}/../../src/templates
       
   183             </freemarkerLinks>
       
   184             
       
   185             <data expandProperties="yes">
       
   186                 dbPath: ${test.temp.dir}/log-entry-category_component_check_db
       
   187                 ant: antProperties()
       
   188             </data>
       
   189         </fmpp>
       
   190         <loadfile property="componentlogEntry"
       
   191               srcFile="${test.temp.dir}/faults.txt"/>
       
   192         <au:assertMatches string="${componentlogEntry}" pattern="sf/app/organizer/group:error:2" 
       
   193                      casesensitive="false"/>
       
   194     </target>
       
   195     
       
   196     <target name="test-categorization-nocleanlog-failed-empty-recipe">
       
   197         <delete dir="${test.temp.dir}/log-entry-failed-empty-recipe_db" failonerror="false" />
       
   198         <echo message="categorization validation" />
       
   199         <hlm:metadatarecord database="${test.temp.dir}/log-entry-failed-empty-recipe_db">
       
   200             <hlm:sbsmetadatainput>
       
   201                 <fileset dir="${project.dir}/../data/">
       
   202                     <include  name="categorization_failed_empty_recipe.log"/>
       
   203                 </fileset>
       
   204                 <metadatafilterset refid="all-regex-filterfile" />
       
   205             </hlm:sbsmetadatainput>
       
   206         </hlm:metadatarecord>
       
   207         <hlm:metadataCountSeverity severity="error" log="categorization_failed_empty_recipe.log" db="${test.temp.dir}/log-entry-failed-empty-recipe_db" property="empty_nocleanlog_errors"/>
       
   208         <au:assertTrue>
       
   209             <equals arg1="${empty_nocleanlog_errors}" arg2="2"/>
       
   210         </au:assertTrue>
       
   211     </target>
       
   212 
       
   213     <target name="test-categorization-nocleanlog-failed-error-in-recipe">
       
   214         <delete dir="${test.temp.dir}/log-entry-failed-error-in-recipe_db" failonerror="false" />
       
   215         <echo message="categorization validation" />
       
   216         <hlm:metadatarecord database="${test.temp.dir}/log-entry-failed-error-in-recipe_db">
       
   217             <hlm:sbsmetadatainput>
       
   218                 <fileset dir="${project.dir}/../data/">
       
   219                     <include  name="categorization_failed_error_in_recipe.log"/>
       
   220                 </fileset>
       
   221                 <metadatafilterset refid="all-regex-filterfile" />
       
   222             </hlm:sbsmetadatainput>
       
   223         </hlm:metadatarecord>
       
   224         <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"/>
       
   225         <au:assertTrue>
       
   226             <equals arg1="${empty_nocleanlog_errors1}" arg2="2"/>
       
   227         </au:assertTrue>
       
   228     </target>
       
   229 
       
   230 <!-- 
       
   231     <target name="test-log-entry-for-no-errors">
       
   232         <delete dir="${test.temp.dir}/log-entry-for-no-error_db" failonerror="false" />
       
   233         <echo message="categorization validation" />
       
   234         <hlm:metadatarecord database="${test.temp.dir}/log-entry-for-no-error_db">
       
   235             <hlm:sbsmetadatainput>
       
   236                 <fileset dir="${project.dir}/../data/">
       
   237                     <include  name="noerror.log"/>
       
   238                 </fileset>
       
   239                 <metadatafilterset refid="all-regex-filterfile" />
       
   240             </hlm:sbsmetadatainput>
       
   241         </hlm:metadatarecord>
       
   242         <fmpp sourceFile="${project.dir}/../../src/templates/general_category.txt.ftl"
       
   243                      outputfile="${test.temp.dir}/general_category.txt">
       
   244             <freemarkerLinks expandProperties="yes">
       
   245                 macro: ${project.dir}/../../src/templates/macro
       
   246             </freemarkerLinks>
       
   247             <data expandProperties="yes">
       
   248                 dbPath: ${test.temp.dir}/log-entry-for-no-error_db
       
   249                 ant: antProperties()
       
   250             </data>
       
   251         </fmpp>
       
   252         <au:assertFileExists file="${test.temp.dir}/general_category.txt" message="Error in test cases"/>
       
   253         <loadfile property="logEntry"
       
   254               srcFile="${test.temp.dir}/general_category.txt"/>
       
   255         <au:assertMatches string="${logEntry}" pattern="component : general : logfile : " 
       
   256                      casesensitive="false"/>
       
   257     </target>
       
   258     -->
       
   259     <!-- Check for all the regular expression defined in the filter file,
   113     <!-- Check for all the regular expression defined in the filter file,
   260     The log file contains text for matching regular expression.
   114     The log file contains text for matching regular expression.
   261     -->
   115     -->
   262     <target name="test-all-regex-filterfile">
   116     <target name="test-all-regex-filterfile">
   263         <property name="metadata-read-db" value="${test.temp.dir}/log_all_filterfile_db"/>
   117         <echo message="all regular expression validation" />
   264         <delete dir="${metadata-read-db}" failonerror="false"/>
       
   265         <echo message="all regular expression validation" />
       
   266         <echo message="database:${metadata-read-db}" />
       
   267         <!-- do some checks that files are present and raise asserts if not present-->
   118         <!-- do some checks that files are present and raise asserts if not present-->
   268         <au:assertFileExists file="${metadata-filterfile}" message="${metadata-filterfile} filter file does not exist"/>
   119         <au:assertFileExists file="${metadata-filterfile}" message="${metadata-filterfile} filter file does not exist"/>
   269         <mkdir dir="${test.temp.dir}"/>
       
   270         
   120         
   271         <hlm:metadatarecord database="${metadata-read-db}">
   121         <hlm:metadatarecord database="${test.temp.dir}/metadata_db">
   272             <hlm:sbsmetadatainput>
   122             <hlm:sbsmetadatainput>
   273                 <fileset dir="${project.dir}/../data/">
   123                 <fileset dir="${project.dir}/../data/">
   274                     <include  name="*regex*.log"/>
   124                     <include  name="*regex*.log"/>
   275                 </fileset>
   125                 </fileset>
   276                 <metadatafilterset refid="all-regex-filterfile" />
   126                 <metadatafilterset refid="all-regex-filterfile" />
   277             </hlm:sbsmetadatainput>
   127             </hlm:sbsmetadatainput>
   278         </hlm:metadatarecord>
   128         </hlm:metadatarecord>
   279         <!-- check we have created the DB file-->
   129         <!-- check we have created the DB file-->
   280         <au:assertTrue>
   130         <au:assertTrue>
   281             <available type="dir" file="${metadata-read-db}" />
   131             <available type="dir" file="${test.temp.dir}/metadata_db" />
   282         </au:assertTrue>
   132         </au:assertTrue>
   283     </target>
   133     </target>
   284 
   134 
   285     <!-- To verify some lengthy text for recipe tag from 
       
   286     sbs metadata input.
       
   287     -->
       
   288     <target name="test-recipe-lengthy-text">
       
   289         <property name="metadata-read-db" value="${test.temp.dir}/log_lengthy_text_db"/>
       
   290         <au:assertFileExists file="${metadata-filterfile}" message="${metadata-filterfile} filter file does not exist"/>
       
   291         <delete dir="${metadata-read-db}" failonerror="false"/>
       
   292         <echo message="all regular expression validation" />
       
   293         <echo message="database:${metadata-read-db}" />
       
   294         <hlm:metadatarecord database="${metadata-read-db}">
       
   295             <hlm:sbsmetadatainput>
       
   296                 <fileset dir="${project.dir}/../data/">
       
   297                     <include  name="receipe*.log"/>
       
   298                 </fileset>
       
   299                 <metadatafilterset refid="all-regex-filterfile" />
       
   300             </hlm:sbsmetadatainput>
       
   301         </hlm:metadatarecord>
       
   302         <au:assertTrue>
       
   303             <available type="dir" file="${metadata-read-db}" />
       
   304         </au:assertTrue>
       
   305     </target>
       
   306 
   135 
   307     <!--modify the errors so regex=".*warning U4010" description="mingw error" is no longer 
   136     <!--modify the errors so regex=".*warning U4010" description="mingw error" is no longer 
   308     an error but a warning-->
   137     an error but a warning-->
   309     <hlm:metadatafilterset id="all-regex-combined">
   138     <hlm:metadatafilterset id="all-regex-combined">
   310         <metadatafilter priority="WARNING" regex=".*warning U4010" description="mingw error" />
   139         <metadatafilter severity="WARNING" regex=".*warning U4010" description="mingw error" />
   311         <metadatafilterset filterfile="${metadata-filterfile}" />
   140         <metadatafilterset filterfile="${metadata-filterfile}" />
   312     </hlm:metadatafilterset>
   141     </hlm:metadatafilterset>
   313 
   142 
   314     <property name="metadata-all-db" value="${test.temp.dir}/log_all_combined_db"/>
   143     <property name="metadata-all-db" value="${test.temp.dir}/log_all_combined_db"/>
   315 
   144 
   316     <target name="test-all-regex-combined">
   145     <target name="test-all-regex-combined">
   317         <property name="metadata-read-db" value="${test.temp.dir}/log_all_combined_db"/>
   146         <echo message="all regular expression validation" />
   318         <delete dir="${metadata-read-db}" failonerror="false" />
   147         <au:assertFileExists file="${metadata-filterfile}" message="${metadata-filterfile} filter file does not exist"/>
   319         <echo message="all regular expression validation" />
   148 
   320         <echo message="database:${metadata-read-db}" />
   149         <hlm:metadatarecord database="${test.temp.dir}/metadata_db">
   321         <au:assertFileExists file="${metadata-filterfile}" message="${metadata-filterfile} filter file does not exist"/>
       
   322         <mkdir dir="${test.temp.dir}"/>
       
   323 
       
   324         <hlm:metadatarecord database="${metadata-read-db}">
       
   325             <hlm:sbsmetadatainput>
   150             <hlm:sbsmetadatainput>
   326                 <fileset dir="${project.dir}/../data/">
   151                 <fileset dir="${project.dir}/../data/">
   327                     <include  name="*regex*.log"/>
   152                     <include  name="*regex*.log"/>
   328                 </fileset>
   153                 </fileset>
   329                 <metadatafilterset refid="all-regex-combined" />
   154                 <metadatafilterset refid="all-regex-combined" />
   330             </hlm:sbsmetadatainput>
   155             </hlm:sbsmetadatainput>
   331         </hlm:metadatarecord>
   156         </hlm:metadatarecord>
   332         <au:assertTrue>
   157         <au:assertTrue>
   333             <available type="dir" file="${metadata-read-db}" />
   158             <available type="dir" file="${test.temp.dir}/metadata_db" />
   334         </au:assertTrue>
   159         </au:assertTrue>
   335     </target>
   160     </target>
   336 
   161 
   337 
   162 
   338     <property name="metadata-error-db" value="${test.temp.dir}/log_error_combined_db"/>
   163     <!--
   339     <!--create an invalid priority type, so contains message invalid 
   164         create an invalid priority type, so contains message invalid 
   340     priority and set to error as priority -->
   165         priority and set to error as priority, validation is done by ant, 
   341     <hlm:metadatafilterset id="all-regex-combined-error">
   166         and parsing of the xml build script will fail.
   342         <metadatafilter priority="INCORRECT" regex=".*warning U4010" description="test error handling so incorrect priority" />
       
   343         <metadatafilterset filterfile="${metadata-filterfile}" />
       
   344     </hlm:metadatafilterset>
       
   345     <!--create an invalid priority type, which contains warning invalid priority 
       
   346     and continues with other data. 
       
   347     -->
   167     -->
   348     <target name="test-all-regex-combined-error">
   168     <target name="test-incorrect-severity-error">
   349         <property name="metadata-read-db" value="${test.temp.dir}/log_error_combined_db"/>
   169         <echo message="test-regex-validation-error" />
   350         <delete dir="${metadata-read-db}" failonerror="false" />
   170 
   351         <echo message="all regular expression validation" />
   171         <au:expectfailure message="INCORRECT is not a legal value for this attribute">
   352         <echo message="database:${metadata-read-db}" />
   172             <hlm:metadatarecord database="${test.temp.dir}/metadata_db" >
   353         <au:assertFileExists file="${metadata-filterfile}" message="${metadata-filterfile} filter file does not exist"/>
   173                 <hlm:textmetadatainput>
   354         <mkdir dir="${test.temp.dir}"/>
   174                     <fileset dir="${project.dir}/../data/regex" includes="empty.log"/>
   355 
   175                      <hlm:metadatafilterset id="all-regex-combined-error">
   356         <hlm:metadatarecord database="${metadata-read-db}" >
   176                         <metadatafilter severity="INCORRECT" regex=".*warning U4010" description="test error handling so incorrect priority" />
   357             <hlm:sbsmetadatainput>
   177                     </hlm:metadatafilterset>
   358                 <fileset dir="${project.dir}/../data/">
   178                 </hlm:textmetadatainput>
   359                     <include  name="*regex*.log"/>
   179             </hlm:metadatarecord>
   360                 </fileset>
   180         </au:expectfailure>
   361                 <metadatafilterset refid="all-regex-combined-error" />
       
   362             </hlm:sbsmetadatainput>
       
   363         </hlm:metadatarecord>
       
   364         <!-- no need to check the DB file not present as it won't be-->
   181         <!-- no need to check the DB file not present as it won't be-->
   365     </target>
   182     </target>
   366     <!--try to add a different different filter type but not add the parameter so has an error-->
   183     
   367     <hlm:metadatafilterset id="all-regex-combined-no-priority">
   184     
   368         <metadatafilter regex=".*warning U4010" description="test error handling so incorrect priority" />
   185     
   369         <metadatafilterset filterfile="${metadata-filterfile}" />
       
   370     </hlm:metadatafilterset>
       
   371     <!--try to add a different different filter type but not add the parameter so has an error-->
   186     <!--try to add a different different filter type but not add the parameter so has an error-->
   372     <target name="test-all-regex-combined-no-priority">
   187     <target name="test-all-regex-combined-no-priority">
   373         <property name="metadata-read-db" value="${test.temp.dir}/log_error_combined_db"/>
   188         <au:expectfailure message="Invalid filter have been found. Please check your configuration.">
   374         <delete dir="${metadata-read-db}" failonerror="false" />
   189             <hlm:metadatarecord database="${test.temp.dir}/metadata_db">
   375         <echo message="all regular expression validation" />
   190                 <hlm:textmetadatainput>
   376         <echo message="database:${metadata-read-db}" />
   191                     <fileset dir="${project.dir}/../data/regex" includes="empty.log" />
   377         <au:assertFileExists file="${metadata-filterfile}" message="${metadata-filterfile} filter file does not exist"/>
   192                     <metadatafilterset refid="all-regex-combined-no-priority" />
   378         <mkdir dir="${test.temp.dir}"/>
   193                     <!--try to add a different different filter type but not add the parameter so has an error -->
   379 
   194                     <hlm:metadatafilterset>
   380         <hlm:metadatarecord database="${metadata-read-db}">
   195                         <metadatafilter severity="error" regex="^ERROR:.*" />
   381             <hlm:sbsmetadatainput>
   196                         <metadatafilter regex=".*warning U4010" description="test error handling so incorrect priority" />
   382                 <fileset dir="${project.dir}/../data/">
   197                         <metadatafilter severity="warning" regex="^WARNING*" />
   383                     <include  name="*regex*.log"/>
   198                     </hlm:metadatafilterset>
   384                 </fileset>
   199                 </hlm:textmetadatainput>
   385                 <metadatafilterset refid="all-regex-combined-no-priority" />
   200             </hlm:metadatarecord>
   386             </hlm:sbsmetadatainput>
   201         </au:expectfailure>
   387         </hlm:metadatarecord>
   202     </target>
   388         <!-- no need to check the DB file not present as it won't be-->
   203     
   389     </target>
       
   390     
       
   391 
       
   392     <!--try to add a different different filter type but not add the parameter so has an error-->
       
   393     <hlm:metadatafilterset id="all-regex-combined-no-regex">
       
   394         <metadatafilter priority="INCORRECT" description="test error handling so incorrect priority" />
       
   395         <metadatafilter priority="WARNING" description="test error handling so incorrect priority" />
       
   396         <metadatafilterset filterfile="${metadata-filterfile}" />
       
   397     </hlm:metadatafilterset>
       
   398 
   204 
   399     <!--try to add a different different filter type but not add the parameter so has an error-->
   205     <!--try to add a different different filter type but not add the parameter so has an error-->
   400     <target name="test-all-regex-combined-no-regex">
   206     <target name="test-all-regex-combined-no-regex">
   401         <property name="metadata-read-db" value="${test.temp.dir}/log_error_combined_db"/>
   207         <echo message="all regular expression validation" />
   402         <delete dir="${metadata-read-db}" failonerror="false" />
   208         <au:assertFileExists file="${metadata-filterfile}" message="${metadata-filterfile} filter file does not exist"/>
   403         <echo message="all regular expression validation" />
   209 
   404         <echo message="database:${metadata-read-db}" />
   210         <au:expectfailure message="INCORRECT is not a legal value for this attribute">
   405         <au:assertFileExists file="${metadata-filterfile}" message="${metadata-filterfile} filter file does not exist"/>
   211             <hlm:metadatarecord database="${test.temp.dir}/metadata_db">
   406         <mkdir dir="${test.temp.dir}"/>
   212                 <hlm:sbsmetadatainput>
   407 
   213                     <fileset dir="${project.dir}/../data/">
   408         <hlm:metadatarecord database="${metadata-read-db}">
   214                         <include  name="*regex*.log"/>
   409             <hlm:sbsmetadatainput>
   215                     </fileset>
   410                 <fileset dir="${project.dir}/../data/">
   216                     <hlm:metadatafilterset>
   411                     <include  name="*regex*.log"/>
   217                         <metadatafilter severity="INCORRECT" description="test error handling so incorrect priority" />
   412                 </fileset>
   218                         <metadatafilter severity="WARNING" description="test error handling so incorrect priority" />
   413                 <metadatafilterset refid="all-regex-combined-no-regex" />
   219                         <metadatafilterset filterfile="${metadata-filterfile}" />
   414             </hlm:sbsmetadatainput>
   220                     </hlm:metadatafilterset>
   415         </hlm:metadatarecord>
   221                 </hlm:sbsmetadatainput>
       
   222             </hlm:metadatarecord>
       
   223         </au:expectfailure>
   416         <!-- no need to check the DB file not present as it won't be-->
   224         <!-- no need to check the DB file not present as it won't be-->
   417     </target>
   225     </target>
       
   226     
       
   227     
   418     <hlm:metadatafilterset id="text_log_metadata_input">
   228     <hlm:metadatafilterset id="text_log_metadata_input">
   419         <metadatafilterset filterfile="${project.dir}/../data/common.csv" />
   229         <metadatafilterset filterfile="${project.dir}/../data/common.csv" />
   420     </hlm:metadatafilterset>
   230     </hlm:metadatafilterset>
   421 
   231 
   422     <target name="test-text_log_metadata_input">
       
   423         <property name="metadata-read-db" value="${test.temp.dir}/log_text_metadata_input_db"/>
       
   424         <delete dir="${metadata-read-db}" failonerror="false" />
       
   425         <echo message="text log metadata input validation" />
       
   426         <echo message="database:${metadata-read-db}" />
       
   427         <au:assertFileExists file="${metadata-filterfile}" message="${metadata-filterfile} filter file does not exist"/>
       
   428         <mkdir dir="${test.temp.dir}"/>
       
   429 
       
   430         <hlm:metadatarecord database="${metadata-read-db}">
       
   431             <hlm:textmetadatainput>
       
   432                 <fileset dir="${project.dir}/../data/">
       
   433                     <include  name="*_fixslashes*.log"/>
       
   434                 </fileset>
       
   435                 <metadatafilterset refid="text_log_metadata_input" />
       
   436             </hlm:textmetadatainput>
       
   437         </hlm:metadatarecord>
       
   438         <au:assertTrue>
       
   439             <available type="dir" file="${metadata-read-db}" />
       
   440         </au:assertTrue>
       
   441     </target>
       
   442 
       
   443     <hlm:metadatafilterset id="abld_log_metadata_input">
       
   444         <metadatafilter priority="WARNING" regex=".*warning U4010" description="mingw error" />
       
   445         <metadatafilterset filterfile="${project.dir}/../data/common.csv" />
       
   446     </hlm:metadatafilterset>
       
   447 
       
   448 
       
   449     <target name="test-abld_log_metadata_input">
       
   450         <property name="metadata-read-db" value="${test.temp.dir}/log_abld_metadata_input_db"/>
       
   451         <delete dir="${test.temp.dir}/log_abld_metadata_input_db" failonerror="false" />
       
   452         <echo message="abld log metadata input validation" />
       
   453         <echo message="database:${metadata-read-db}" />
       
   454         <au:assertFileExists file="${metadata-filterfile}" message="${metadata-filterfile} filter file does not exist"/>
       
   455         <mkdir dir="${test.temp.dir}"/>
       
   456 
       
   457         <hlm:metadatarecord database="${metadata-read-db}">
       
   458             <hlm:abldmetadatainput>
       
   459                 <fileset dir="${project.dir}/../data/">
       
   460                     <include  name="*sample_abld.log"/>
       
   461                 </fileset>
       
   462                 <metadatafilterset refid="abld_log_metadata_input" />
       
   463             </hlm:abldmetadatainput>
       
   464         </hlm:metadatarecord>
       
   465         <au:assertTrue>
       
   466             <available type="dir" file="${metadata-read-db}" />
       
   467         </au:assertTrue>
       
   468     </target>
       
   469 
       
   470 
       
   471     <target name="test-policy_metadata_input">
       
   472         <property name="metadata-read-db" value="${test.temp.dir}/log_policy_metadata_input_db"/>
       
   473         <delete dir="${metadata-read-db}" failonerror="false" />
       
   474         <echo message="policy metadata input validation" />
       
   475         <echo message="database:${metadata-read-db}" />
       
   476         <au:assertFileExists file="${metadata-filterfile}" message="${metadata-filterfile} filter file does not exist"/>
       
   477         <mkdir dir="${test.temp.dir}"/>
       
   478 
       
   479         <hlm:metadatarecord database="${metadata-read-db}">
       
   480             <hlm:policymetadatainput>
       
   481                 <fileset dir="${project.dir}/../data/">
       
   482                     <include  name="*policy*.log"/>
       
   483                 </fileset>
       
   484             </hlm:policymetadatainput>
       
   485         </hlm:metadatarecord>
       
   486         <au:assertTrue>
       
   487             <available type="dir" file="${metadata-read-db}" />
       
   488         </au:assertTrue>
       
   489     </target>
       
   490 
   232 
   491     <hlm:metadatafilterset id="ant_log_metadata_input">
   233     <hlm:metadatafilterset id="ant_log_metadata_input">
   492         <metadatafilterset filterfile="${project.dir}/../data/common.csv" />
   234         <metadatafilterset filterfile="${project.dir}/../data/common.csv" />
   493     </hlm:metadatafilterset>
   235     </hlm:metadatafilterset>
   494 
   236 
   495 
   237 
   496     <target name="test-ant_log_metadata_input">
   238     <target name="test-ant_log_metadata_input">
   497         <property name="metadata-read-db" value="${test.temp.dir}/log_ant_metadata_input_db"/>
       
   498         <delete dir="${metadata-read-db}" failonerror="false" />
       
   499         <echo message="ant log metadata input validation" />
   239         <echo message="ant log metadata input validation" />
   500         <echo message="database:${metadata-read-db}" />
   240         <au:assertFileExists file="${metadata-filterfile}" message="${metadata-filterfile} filter file does not exist"/>
   501         <au:assertFileExists file="${metadata-filterfile}" message="${metadata-filterfile} filter file does not exist"/>
   241 
   502         <mkdir dir="${test.temp.dir}"/>
   242         <hlm:metadatarecord database="${test.temp.dir}/metadata_db">
   503 
       
   504         <hlm:metadatarecord database="${metadata-read-db}">
       
   505             <hlm:antmetadatainput>
   243             <hlm:antmetadatainput>
   506                 <fileset dir="${project.dir}/../data/">
   244                 <fileset dir="${project.dir}/../data/">
   507                     <include  name="*ant*.log"/>
   245                     <include  name="*ant*.log"/>
   508                 </fileset>
   246                 </fileset>
   509                 <metadatafilterset refid="ant_log_metadata_input" />
   247                 <metadatafilterset refid="ant_log_metadata_input" />
   510             </hlm:antmetadatainput>
   248             </hlm:antmetadatainput>
   511         </hlm:metadatarecord>
   249         </hlm:metadatarecord>
   512         <au:assertTrue>
   250         <au:assertTrue>
   513             <available type="dir" file="${metadata-read-db}" />
   251             <available type="dir" file="${test.temp.dir}/metadata_db" />
   514         </au:assertTrue>
   252         </au:assertTrue>
   515     </target>
   253     </target>
   516 
   254 
   517     <property name="metadata-read-ftl" value="${project.dir}/../../src/templates/readdata.xml.ftl"/>
   255     <property name="metadata-read-ftl" value="${project.dir}/../../src/templates/readdata.xml.ftl"/>
   518     <property name="metadata-read-output" value="${test.temp.dir}/readdata.html"/>
   256     <property name="metadata-read-output" value="${test.temp.dir}/readdata.html"/>
   519 <!-- 
   257 
   520     <target name="test-readdata" depends="test-text_log_metadata_input" >
   258     <hlm:metadatafilterset id="text.log.metadata.input.filterset">
   521         <property name="metadata-template-dir" value="${project.dir}/../../src/templates/" />
   259         <metadatafilterset filterfile="${project.dir}/../data/common.csv" />
   522         <property name="metadata-output-dir" value="${test.temp.dir}" />
   260     </hlm:metadatafilterset>
   523         <property name="metadata-read-ftl" value="${metadata-template-dir}/readdata.xml.ftl"/>
       
   524         <property name="metadata-read-db" value="${metadata-output-dir}/log_text_metadata_input_db"/>
       
   525         <property name="metadata-read-output" value="${metadata-output-dir}/readdata.html"/>
       
   526         <delete file="${metadata-read-output}" failonerror="false" />
       
   527         <au:assertFileExists file="${metadata-read-db}" message="${metadata-read-db} DB file was not created"/>
       
   528         <fmpp sourceFile="${metadata-template-dir}/readdata.xml.ftl"
       
   529                      outputfile="${metadata-output-dir}/readdata.html">
       
   530             <freemarkerLinks expandProperties="yes">
       
   531                 macro: ${project.dir}/../../src/templates
       
   532             </freemarkerLinks>
       
   533             <data expandProperties="yes">
       
   534                 dbPath: ${metadata-read-db}
       
   535                 ant: antProperties()
       
   536             </data>
       
   537         </fmpp>
       
   538         <fmpp sourceFile="${metadata-template-dir}/build_status.xml.ftl"
       
   539                      outputfile="${metadata-output-dir}/build_status.xml">
       
   540             <freemarkerLinks expandProperties="yes">
       
   541                 macro: ${project.dir}/../../src/templates
       
   542             </freemarkerLinks>
       
   543             <data expandProperties="yes">
       
   544                 dbPath: ${metadata-read-db}
       
   545                 logfile: ido_abs_mcl_devlon70_robot_MCL.70.500_fixslashes_raptor.log
       
   546                 ant: antProperties()
       
   547             </data>
       
   548         </fmpp>
       
   549         <fmpp sourceFile="${metadata-template-dir}/email_new.html.ftl"
       
   550                      outputfile="${metadata-output-dir}/build_status.html">
       
   551             <freemarkerLinks expandProperties="yes">
       
   552                 macro: ${project.dir}/../../src/templates
       
   553             </freemarkerLinks>
       
   554             <data expandProperties="yes">
       
   555                 dbPath: ${metadata-read-db}
       
   556                 logfile: ido_abs_mcl_devlon70_robot_MCL.70.500_fixslashes_raptor.log
       
   557                 ant: antProperties()
       
   558             </data>
       
   559         </fmpp>
       
   560         <au:assertFileExists file="${metadata-read-output}" message="${metadata-read-output} DB file was not created"/>
       
   561     </target>
       
   562 -->
       
   563 
       
   564     <target name="test-generate-summary" depends="test-text_log_metadata_input">
       
   565         <property name="metadata-summary-ftl" value="${project.dir}/../../src/templates/summary.html.ftl"/>
       
   566         <property name="metadata-summary-output" value="${test.temp.dir}/summary.html"/>
       
   567         <property name="metadata-output-dir" value="${test.temp.dir}/" />
       
   568         <delete file="${metadata-summary-output}" failonerror="false" />
       
   569         <property name="metadata-read-db" value="${metadata-output-dir}/log_text_metadata_input_db"/>
       
   570         
       
   571         <fmpp sourceFile="${metadata-summary-ftl}"
       
   572                      outputfile="${metadata-summary-output}">
       
   573             <freemarkerLinks expandProperties="yes">
       
   574                 macro: ${project.dir}/../../src/templates/macro
       
   575             </freemarkerLinks>
       
   576             <data expandProperties="yes">
       
   577                 dbPath: ${metadata-read-db}
       
   578                 loginfo: xml(${project.dir}/../data/ido_abs_mcl_devlon70_robot_MCL.70.500_info.log)
       
   579                 ant: antProperties()
       
   580             </data>
       
   581         </fmpp>
       
   582         <!-- check we have created the files -->
       
   583         <au:assertTrue>
       
   584             <available type="dir" file="${metadata-read-db}" />
       
   585         </au:assertTrue>
       
   586         <au:assertFileExists file="${metadata-summary-output}" message="${metadata-summary-output} summary output file was not created"/>
       
   587     </target>
       
   588     
   261     
   589     <target name="test-countseverity">
   262     <target name="test-countseverity">
   590         <delete dir="${test.temp.dir}/dp_db" failonerror="false" />
   263         <hlm:metadatarecord database="${test.temp.dir}/metadata_db">
   591 
   264             <hlm:textmetadatainput>
   592         <hlm:metadatarecord database="${test.temp.dir}/dp_db">
   265                 <fileset dir="${project.dir}/../data/countseverity">
   593             <hlm:textmetadatainput>
       
   594                 <fileset dir="${project.dir}/../data/">
       
   595                     <include  name="*_fixslashes*.log"/>
   266                     <include  name="*_fixslashes*.log"/>
   596                 </fileset>
   267                 </fileset>
   597                 <metadatafilterset refid="text_log_metadata_input" />
   268                 <metadatafilterset refid="text.log.metadata.input.filterset" />
   598             </hlm:textmetadatainput>
   269             </hlm:textmetadatainput>
   599         </hlm:metadatarecord>
   270         </hlm:metadatarecord>
   600 
   271 
   601         <hlm:metadataCountSeverity severity="error" log="_fixslashes_raptor.log" db="${test.temp.dir}/dp_db" property="errors"/>
   272         <hlm:metadataCountSeverity severity="error" database="${test.temp.dir}/metadata_db" property="errors">
       
   273                 <fileset dir="${project.dir}/../data/countseverity">
       
   274                     <include  name="*_fixslashes*.log"/>
       
   275                 </fileset>
       
   276         </hlm:metadataCountSeverity>
   602         <echo message="${errors}" />
   277         <echo message="${errors}" />
   603         <au:assertTrue>
   278         <au:assertTrue>
   604             <equals arg1="${errors}" arg2="24"/>
   279             <equals arg1="${errors}" arg2="24"/>
   605         </au:assertTrue>
   280         </au:assertTrue>
   606         <au:assertTrue>
   281         <au:assertTrue>
   607             <hlm:metadataHasSeverity severity="error" log="_fixslashes_raptor.log" db="${test.temp.dir}/dp_db" />
   282             <hlm:metadataHasSeverity severity="error"  database="${test.temp.dir}/metadata_db">
       
   283                 <fileset dir="${project.dir}/../data/countseverity">
       
   284                     <include  name="*_fixslashes*.log"/>
       
   285                 </fileset>
       
   286             </hlm:metadataHasSeverity>
   608         </au:assertTrue>
   287         </au:assertTrue>
   609         <au:assertFalse>
   288         <au:assertFalse>
   610             <hlm:metadataHasSeverity severity="fatal" log="_fixslashes_raptor.log" db="${test.temp.dir}/dp_db" />
   289             <hlm:metadataHasSeverity severity="fatal"  database="${test.temp.dir}/metadata_db">
       
   290                 <fileset dir="${project.dir}/../data/">
       
   291                     <include  name="*_fixslashes*.log"/>
       
   292                 </fileset>
       
   293             </hlm:metadataHasSeverity>
   611         </au:assertFalse>
   294         </au:assertFalse>
   612         
   295         
   613     </target>
   296     </target>
   614 
       
   615     <target name="test-metadatacount-no-error-with-missing-files-path-with-backslashes">
       
   616         <hlm:metadatarecord database="${test.temp.dir}/metadatacount_with_missing_files_db">
       
   617             <hlm:sbsmetadatainput>
       
   618                 <fileset dir="${project.dir}/../data/">
       
   619                     <include  name="metadatacount_missing_files.log"/>
       
   620                 </fileset>
       
   621                 <metadatafilterset>
       
   622                     <metadatafilter priority="INFO" regex="^INFO:" description="info" />
       
   623                     <metadatafilter priority="ERROR" regex="^ERROR:" description="error" />
       
   624                     <metadatafilter priority="WARNING" regex=".*warning C4503:.*" description="warning" />
       
   625                 </metadatafilterset>
       
   626             </hlm:sbsmetadatainput>
       
   627         </hlm:metadatarecord>
       
   628         <hlm:metadataCountSeverity severity="error" log="data\metadatacount_missing_files.log" db="${test.temp.dir}/metadatacount_with_missing_files_db" property="errors"/>
       
   629         <au:assertTrue message="We must have 5 missing files counted as error.">
       
   630             <equals arg1="${errors}" arg2="5"/>
       
   631         </au:assertTrue>
       
   632     </target>
       
   633     
   297     
   634     <target name="test-very-long-warning">
   298     <target name="test-very-long-warning">
   635         <delete dir="${test.temp.dir}/very_long_warning_db" failonerror="false" />
   299         <delete dir="${test.temp.dir}/very_long_warning_db" failonerror="false" />
   636 
   300 
   637         <hlm:metadatarecord database="${test.temp.dir}/very_long_warning_db">
   301         <hlm:metadatarecord database="${test.temp.dir}/very_long_warning_db">
   638             <hlm:textmetadatainput>
   302             <hlm:textmetadatainput>
   639                 <fileset dir="${project.dir}/../data/">
   303                 <fileset dir="${project.dir}/../data/">
   640                     <include  name="very_long_warning.log"/>
   304                     <include  name="very_long_warning.log"/>
   641                 </fileset>
   305                 </fileset>
   642                 <metadatafilterset>
   306                 <metadatafilterset>
   643                     <metadatafilter priority="INFO" regex="^INFO:" description="info" />
   307                     <metadatafilter severity="INFO" regex="^INFO:" description="info" />
   644                     <metadatafilter priority="WARNING" regex=".*warning C4503:.*" description="warning" />
   308                     <metadatafilter severity="WARNING" regex=".*warning C4503:.*" description="warning" />
   645                 </metadatafilterset>
   309                 </metadatafilterset>
   646             </hlm:textmetadatainput>
   310             </hlm:textmetadatainput>
   647         </hlm:metadatarecord>
   311         </hlm:metadatarecord>
   648 
   312 
   649         <hlm:metadataCountSeverity severity="warning" log="very_long_warning.log" db="${test.temp.dir}/very_long_warning_db" property="warnings"/>
   313         <hlm:metadataCountSeverity severity="warning" log="${project.dir}/../data/very_long_warning.log" database="${test.temp.dir}/very_long_warning_db" property="warnings"/>
   650         <echo message="test-very-long-warning: ${warnings}" />
   314         <echo message="test-very-long-warning: ${warnings}" />
   651         <au:assertTrue>
   315         <au:assertTrue>
   652             <equals arg1="${warnings}" arg2="1"/>
   316             <equals arg1="${warnings}" arg2="1"/>
   653         </au:assertTrue>
   317         </au:assertTrue>
   654     </target>
   318     </target>
   655 
   319 
   656     <target name="test-whatlog-parsing">
   320     <target name="test-log-with-same-root-name">
   657         <delete dir="${test.temp.dir}/whatlog_db" failonerror="false" />
   321         <hlm:metadatarecord database="${test.temp.dir}/metadata_db">
   658 
   322             <hlm:textmetadatainput>
   659         <hlm:metadatarecord database="${test.temp.dir}/whatlog_db">
   323                 <fileset dir="${project.dir}/../data/regex">
   660             <hlm:sbsmetadatainput whatLogFile="${project.dir}/../data/build_whatlog.whatlog.log">
   324                     <include name="log-with-same-root-name.log*"/>
   661                 <fileset dir="${project.dir}/../data/">
       
   662                     <include  name="build_whatlog.log"/>
       
   663                 </fileset>
   325                 </fileset>
   664                 <metadatafilterset>
   326                 <metadatafilterset>
   665                     <metadatafilter priority="INFO" regex="^INFO:" description="info" />
   327                     <metadatafilter severity="ERROR" regex="^ERROR:.*" description="error" />
   666                     <metadatafilter priority="ERROR" regex="^ERROR:" description="error" />
       
   667                     <metadatafilter priority="WARNING" regex=".*warning C4503:.*" description="warning" />
       
   668                 </metadatafilterset>
   328                 </metadatafilterset>
   669             </hlm:sbsmetadatainput>
   329             </hlm:textmetadatainput>
   670         </hlm:metadatarecord>
   330         </hlm:metadatarecord>
   671         <fmpp sourceFile="${project.dir}/../data/whatlog_result.ini.ftl"
   331         <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"/>
   672                      outputfile="${test.temp.dir}/whatlog_result.ini">
   332         <echo>log-with-same-root-name.log.error: ${log-with-same-root-name.log.error}</echo>
   673             <data expandProperties="yes">
       
   674                 dbPath: ${test.temp.dir}/whatlog_db
       
   675                 ant: antProperties()
       
   676             </data>
       
   677         </fmpp>
       
   678         <property file="${test.temp.dir}/whatlog_result.ini" />
       
   679         <au:assertTrue message="Invalid number of logs">
       
   680             <equals arg1="${number.of.logs}" arg2="1" />
       
   681         </au:assertTrue>
       
   682         <au:assertTrue message="Invalid number of whatlog entries">
       
   683             <equals arg1="${number.of.whatlog.entries}" arg2="5" />
       
   684         </au:assertTrue>
       
   685     </target>
       
   686 
       
   687     <target name="test-log-with-same-root-name">
       
   688         <delete dir="${test.temp.dir}/log-with-same-root-name_db" failonerror="false"/>
       
   689         <hlm:metadatarecord database="${test.temp.dir}/log-with-same-root-name_db">
       
   690             <hlm:textmetadatainput>
       
   691                 <fileset dir="${project.dir}/../data/">
       
   692                     <include name="log-with-same-root-name.log*"/>
       
   693                 </fileset>
       
   694                 <metadatafilterset>
       
   695                     <metadatafilter priority="ERROR" regex="^ERROR:.*" description="error" />
       
   696                 </metadatafilterset>
       
   697             </hlm:textmetadatainput>
       
   698         </hlm:metadatarecord>
       
   699         <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"/>
       
   700         <au:assertTrue message="We should only find 1 error">
   333         <au:assertTrue message="We should only find 1 error">
   701             <equals arg1="${log-with-same-root-name.log.error}" arg2="1"/>
   334             <equals arg1="${log-with-same-root-name.log.error}" arg2="1"/>
   702         </au:assertTrue>
   335         </au:assertTrue>
   703     </target>
   336     </target>
   704 
   337 
   705     <target name="test-release-database-metadatatask">
   338     <target name="test-release-database-metadatatask">
   706         <hlm:metadatarecord database="${test.temp.dir}/test-release-database-metadatatask_db">
   339         <hlm:metadatarecord database="${test.temp.dir}/metadata_db">
   707             <hlm:textmetadatainput>
   340             <hlm:textmetadatainput>
   708                 <fileset dir="${project.dir}/../data/">
   341                 <fileset dir="${project.dir}/../data/">
   709                     <include name="test-release-database-metadatatask.log"/>
   342                     <include name="test-release-database-metadatatask.log"/>
   710                 </fileset>
   343                 </fileset>
   711                 <metadatafilterset>
   344                 <metadatafilterset>
   712                     <metadatafilter priority="ERROR" regex="^ERROR:.*" description="error" />
   345                     <metadatafilter severity="ERROR" regex="^ERROR:.*" description="error" />
   713                 </metadatafilterset>
   346                 </metadatafilterset>
   714             </hlm:textmetadatainput>
   347             </hlm:textmetadatainput>
   715         </hlm:metadatarecord>
   348         </hlm:metadatarecord>
   716         <delete dir="${test.temp.dir}/log-with-same-root-name_db" failonerror="true" />
       
   717     </target>
   349     </target>
   718 
   350 
   719     <target name="test-release-database-fmpp">
   351     <target name="test-release-database-fmpp">
   720         <hlm:metadatarecord database="${test.temp.dir}/test-release-database-fmpp_db">
   352         <echo>test-release-database-fmpp</echo>
       
   353         <hlm:metadatarecord database="${test.temp.dir}/metadata_db">
   721             <hlm:textmetadatainput>
   354             <hlm:textmetadatainput>
   722                 <fileset dir="${project.dir}/../data/">
   355                 <fileset dir="${project.dir}/../data/">
   723                     <include name="test-release-database-metadatatask.log"/>
   356                     <include name="test-release-database-metadatatask.log"/>
   724                 </fileset>
   357                 </fileset>
   725                 <metadatafilterset>
   358                 <metadatafilterset>
   726                     <metadatafilter priority="ERROR" regex="^ERROR:.*" description="error" />
   359                     <metadatafilter severity="ERROR" regex="^ERROR:.*" description="error" />
   727                 </metadatafilterset>
   360                 </metadatafilterset>
   728             </hlm:textmetadatainput>
   361             </hlm:textmetadatainput>
   729         </hlm:metadatarecord>
   362         </hlm:metadatarecord>
   730         <fmpp sourceFile="${project.dir}/../data/test-release-database-fmpp.ini.ftl"
   363         <fmpp sourceFile="${project.dir}/../data/test-release-database-fmpp.ini.ftl"
   731                      outputfile="${test.temp.dir}/test-release-database-fmpp.ini">
   364                      outputfile="${test.temp.dir}/test-release-database-fmpp.ini">
   732             <data expandProperties="yes">
   365             <data expandProperties="yes">
   733                 dbPath: ${test.temp.dir}/test-release-database-fmpp_db
   366                 dbPath: ${test.temp.dir}/metadata_db
   734                 ant: antProperties()
   367                 ant: antProperties()
   735             </data>
   368             </data>
   736         </fmpp>        
   369         </fmpp>        
   737         <delete dir="${test.temp.dir}/test-release-database-fmpp_db" failonerror="true" />
   370     </target>
   738     </target>
   371     
   739     
       
   740     
       
   741     <target name="test-metadatacount-no-error-with-missing-files">
       
   742         <hlm:metadatarecord database="${test.temp.dir}/metadatacount_with_missing_files_db">
       
   743             <hlm:sbsmetadatainput>
       
   744                 <fileset dir="${project.dir}/../data/">
       
   745                     <include  name="metadatacount_missing_files.log"/>
       
   746                 </fileset>
       
   747                 <metadatafilterset>
       
   748                     <metadatafilter priority="INFO" regex="^INFO:" description="info" />
       
   749                     <metadatafilter priority="ERROR" regex="^ERROR:" description="error" />
       
   750                     <metadatafilter priority="WARNING" regex=".*warning C4503:.*" description="warning" />
       
   751                 </metadatafilterset>
       
   752             </hlm:sbsmetadatainput>
       
   753         </hlm:metadatarecord>
       
   754         <hlm:metadataCountSeverity severity="error" log="metadatacount_missing_files.log" db="${test.temp.dir}/metadatacount_with_missing_files_db" property="errors"/>
       
   755         <au:assertTrue message="We must have 5 missing files counted as error.">
       
   756             <equals arg1="${errors}" arg2="5"/>
       
   757         </au:assertTrue>
       
   758     </target>
       
   759     
       
   760     <target name="test-metadatacount-error-with-missing-files">
       
   761         <hlm:metadatarecord database="${test.temp.dir}/metadatacount_with_missing_files_db">
       
   762             <hlm:sbsmetadatainput>
       
   763                 <fileset dir="${project.dir}/../data/">
       
   764                     <include  name="metadatacount_error_and_missing_files.log"/>
       
   765                 </fileset>
       
   766                 <metadatafilterset>
       
   767                     <metadatafilter priority="INFO" regex="^INFO:" description="info" />
       
   768                     <metadatafilter priority="ERROR" regex="^ERROR:" description="error" />
       
   769                     <metadatafilter priority="WARNING" regex=".*warning C4503:.*" description="warning" />
       
   770                 </metadatafilterset>
       
   771             </hlm:sbsmetadatainput>
       
   772         </hlm:metadatarecord>
       
   773         <hlm:metadataCountSeverity severity="error" log="metadatacount_error_and_missing_files.log" db="${test.temp.dir}/metadatacount_with_missing_files_db" property="errors"/>
       
   774         <au:assertTrue message="We must have 6 missing files counted as error.">
       
   775             <equals arg1="${errors}" arg2="6"/>
       
   776         </au:assertTrue>
       
   777     </target>
       
   778 
       
   779     <target name="test-count-error-without-missing-files">
       
   780         <hlm:metadatarecord database="${test.temp.dir}/metadatacount_with_missing_files_db">
       
   781             <hlm:sbsmetadatainput>
       
   782                 <fileset dir="${project.dir}/../data/">
       
   783                     <include  name="metadatacount_error_and_missing_files.log"/>
       
   784                 </fileset>
       
   785                 <metadatafilterset>
       
   786                     <metadatafilter priority="INFO" regex="^INFO:" description="info" />
       
   787                     <metadatafilter priority="ERROR" regex="^ERROR:" description="error" />
       
   788                     <metadatafilter priority="WARNING" regex=".*warning C4503:.*" description="warning" />
       
   789                 </metadatafilterset>
       
   790             </hlm:sbsmetadatainput>
       
   791         </hlm:metadatarecord>
       
   792         <hlm:metadataCountSeverity severity="error" log="metadatacount_error_and_missing_files.log"
       
   793             db="${test.temp.dir}/metadatacount_with_missing_files_db" property="errors"
       
   794             countMissing="false"/>
       
   795         <au:assertTrue message="We must have 1 missing files counted as error.">
       
   796             <equals arg1="${errors}" arg2="1"/>
       
   797         </au:assertTrue>
       
   798     </target>
       
   799 
       
   800 </project>
   372 </project>