Update the mozilla tests to new version (as of 2010-06-29).

mozilla-tests/known-failures.pl

 #!/usr/bin/perl
 # -*- Mode: Perl; tab-width: 4; indent-tabs-mode: nil; -*-
 
 # ***** BEGIN LICENSE BLOCK *****
 # Version: MPL 1.1/GPL 2.0/LGPL 2.1
 #
 # The contents of this file are subject to the Mozilla Public License Version
 # 1.1 (the "License"); you may not use this file except in compliance with
 # the License. You may obtain a copy of the License at
 # http://www.mozilla.org/MPL/
@@ skipping 26 matching lines @@
 #
 # ***** END LICENSE BLOCK *****
 
 use strict;
 use Getopt::Mixed "nextOption";
 
 # predeclarations
 sub debug;
 sub usage;
 sub parse_options;
+sub escape_string;
 sub escape_pattern;
 sub unescape_pattern;
 
 # option arguments
 
-my $option_desc = "b=s branch>b T=s buildtype>T R=s repo>R t=s testtype>t o=s os>o K=s kernel>K A=s arch>A M=s memory>M S=s speed>S z=s timezone>z l=s rawlogfile>l f=s failurelogfile>f r=s patterns>r O=s outputprefix>O D debug>D";
+my $option_desc = "b=s branch>b T=s buildtype>T R=s repo>R t=s testtype>t o=s os>o K=s kernel>K A=s arch>A M=s memory>M z=s timezone>z J=s jsoptions>J l=s rawlogfile>l f=s failurelogfile>f r=s patterns>r O=s outputprefix>O D debug>D";
 
 my $testid;
 my $branch;
 my $repo;
 my $buildtype;
 my $testtype;
 my $rawlogfile;
 my $failurelogfile;
 my $os;
 my $patterns;
 my $timezone;
+my $jsoptions;
 my $outputprefix;
 my $arch;
 my $kernel;
 my $memory;
-my $cpuspeed;
 my $debug = $ENV{DEBUG};
 
 # pattern variables
 
 my $knownfailurebranchpattern;
 my $failurebranchpattern;
 my $knownfailureospattern;
 my $failureospattern;
 my $knownfailurerepopattern;
 my $failurerepopattern;
 my $knownfailurebuildtypepattern;
 my $failurebuildtypepattern;
 my $knownfailuretesttypepattern;
 my $failuretesttypepattern;
 my $knownfailuretimezonepattern;
 my $failuretimezonepattern;
+my $knownfailurejsoptionspattern;
+my $failurejsoptionspattern;
 my $knownfailurearchpattern;
 my $failurearchpattern;
 my $knownfailurekernelpattern;
 my $failurekernelpattern;
 my $knownfailurememorypattern;
 my $failurememorypattern;
-my $knownfailurecpuspeedpattern;
-my $failurecpuspeedpattern;
 
 my @patterns;
 my $pattern;
 my @failures;
 my @fixes;
 my @excludedtests;
 my $excludedtest;
 my $excludedfile;
 my %includedtests = {};
 my $includedfile;
@@ skipping 43 matching lines @@
         next if ($_ =~ /^\#/);
 
         s/\s+$//;
 
         $includedtests{$_} = 1;
     }
     close INCLUDED;
 }
 
 debug "loading patterns $patterns";
-debug "pattern filter: ^TEST_ID=[^,]*, TEST_BRANCH=$knownfailurebranchpattern, TEST_REPO=$knownfailurerepopattern, TEST_BUILDTYPE=$knownfailurebuildtypepattern, TEST_TYPE=$knownfailuretesttypepattern, TEST_OS=$knownfailureospattern, TEST_KERNEL=$knownfailurekernelpattern, TEST_PROCESSORTYPE=$knownfailurearchpattern, TEST_MEMORY=$knownfailurememorypattern, TEST_CPUSPEED=$knownfailurecpuspeedpattern, TEST_TIMEZONE=$knownfailuretimezonepattern,";
+debug "pattern filter: ^TEST_ID=[^,]*, TEST_BRANCH=$knownfailurebranchpattern, TEST_REPO=$knownfailurerepopattern, TEST_BUILDTYPE=$knownfailurebuildtypepattern, TEST_TYPE=$knownfailuretesttypepattern, TEST_OS=$knownfailureospattern, TEST_KERNEL=$knownfailurekernelpattern, TEST_PROCESSORTYPE=$knownfailurearchpattern, TEST_MEMORY=$knownfailurememorypattern, TEST_TIMEZONE=$knownfailuretimezonepattern, TEST_OPTIONS=$knownfailurejsoptionspattern,";
 
 open PATTERNS, "<$patterns" or die "Unable to open known failure patterns file $patterns: $!\n";
 while (<PATTERNS>) {
     chomp;
 
     s/\s+$//;
 
     ($testid) = $_ =~ /^TEST_ID=([^,]*),/;
 
     if (!$includedtests{$testid})
     {
         debug "test $testid was not included during this run";
     }
-    elsif ($_ =~ /^TEST_ID=[^,]*, TEST_BRANCH=$knownfailurebranchpattern, TEST_REPO=$knownfailurerepopattern, TEST_BUILDTYPE=$knownfailurebuildtypepattern, TEST_TYPE=$knownfailuretesttypepattern, TEST_OS=$knownfailureospattern, TEST_KERNEL=$knownfailurekernelpattern, TEST_PROCESSORTYPE=$knownfailurearchpattern, TEST_MEMORY=$knownfailurememorypattern, TEST_CPUSPEED=$knownfailurecpuspeedpattern, TEST_TIMEZONE=$knownfailuretimezonepattern,/) {
+    elsif ($_ =~ /^TEST_ID=[^,]*, TEST_BRANCH=$knownfailurebranchpattern, TEST_REPO=$knownfailurerepopattern, TEST_BUILDTYPE=$knownfailurebuildtypepattern, TEST_TYPE=$knownfailuretesttypepattern, TEST_OS=$knownfailureospattern, TEST_KERNEL=$knownfailurekernelpattern, TEST_PROCESSORTYPE=$knownfailurearchpattern, TEST_MEMORY=$knownfailurememorypattern, TEST_TIMEZONE=$knownfailuretimezonepattern, TEST_OPTIONS=$knownfailurejsoptionspattern,/) {
         debug "adding pattern  : $_";
         push @patterns, (escape_pattern($_));   
     }
     else {
         debug "skipping pattern: $_";
     }
 
 }
 close PATTERNS;
 
  # create a working copy of the current failures which match the users selection
 
-debug "failure filter: ^TEST_ID=[^,]*, TEST_BRANCH=$failurebranchpattern, TEST_REPO=$failurerepopattern, TEST_BUILDTYPE=$failurebuildtypepattern, TEST_TYPE=$failuretesttypepattern, TEST_OS=$failureospattern, TEST_KERNEL=$failurekernelpattern, TEST_PROCESSORTYPE=$failurearchpattern, TEST_MEMORY=$failurememorypattern, TEST_CPUSPEED=$failurecpuspeedpattern, TEST_TIMEZONE=$failuretimezonepattern, TEST_RESULT=FAIL[^,]*,/";
+debug "failure filter: ^TEST_ID=[^,]*, TEST_BRANCH=$failurebranchpattern, TEST_REPO=$failurerepopattern, TEST_BUILDTYPE=$failurebuildtypepattern, TEST_TYPE=$failuretesttypepattern, TEST_OS=$failureospattern, TEST_KERNEL=$failurekernelpattern, TEST_PROCESSORTYPE=$failurearchpattern, TEST_MEMORY=$failurememorypattern, TEST_TIMEZONE=$failuretimezonepattern, TEST_OPTIONS=$failurejsoptionspattern, TEST_RESULT=FAIL[^,]*,/";
 
 if (defined($rawlogfile)) {
 
     $failurelogfile = "$outputprefix-results-failures.log";
     my $alllog      = "$outputprefix-results-all.log";
 
     debug "writing failures $failurelogfile";
 
     open INPUTLOG, "$jsdir/post-process-logs.pl $rawlogfile |" or die "Unable to open $rawlogfile $!\n";
     open ALLLOG, ">$alllog" or die "Unable to open $alllog $!\n";
     open FAILURELOG, ">$failurelogfile" or die "Unable to open $failurelogfile $!\n";
 
     while (<INPUTLOG>) {
         chomp;
 
         print ALLLOG "$_\n";
 
-        if ($_ =~ /^TEST_ID=[^,]*, TEST_BRANCH=$failurebranchpattern, TEST_REPO=$failurerepopattern, TEST_BUILDTYPE=$failurebuildtypepattern, TEST_TYPE=$failuretesttypepattern, TEST_OS=$failureospattern, TEST_KERNEL=$failurekernelpattern, TEST_PROCESSORTYPE=$failurearchpattern, TEST_MEMORY=$failurememorypattern, TEST_CPUSPEED=$failurecpuspeedpattern, TEST_TIMEZONE=$failuretimezonepattern, TEST_RESULT=FAIL[^,]*,/) {
+        if ($_ =~ /^TEST_ID=[^,]*, TEST_BRANCH=$failurebranchpattern, TEST_REPO=$failurerepopattern, TEST_BUILDTYPE=$failurebuildtypepattern, TEST_TYPE=$failuretesttypepattern, TEST_OS=$failureospattern, TEST_KERNEL=$failurekernelpattern, TEST_PROCESSORTYPE=$failurearchpattern, TEST_MEMORY=$failurememorypattern, TEST_TIMEZONE=$failuretimezonepattern, TEST_OPTIONS=$failurejsoptionspattern, TEST_RESULT=FAIL[^,]*,/) {
             debug "failure: $_";
             push @failures, ($_);
             print FAILURELOG "$_\n";
         }
     }
     close INPUTLOG;
     my $inputrc = $?;
     close ALLLOG;
     close FAILURELOG;
 
@@ skipping 15 matching lines @@
     }
     else
     {
         $failurelogfilemode = "<$failurelogfile";
     }
 
     open FAILURES, "$failurelogfilemode" or die "Unable to open current failure log $failurelogfile: $!\n";
     while (<FAILURES>) {
         chomp;
 
-        if ($_ =~ /^TEST_ID=[^,]*, TEST_BRANCH=$failurebranchpattern, TEST_REPO=$failurerepopattern, TEST_BUILDTYPE=$failurebuildtypepattern, TEST_TYPE=$failuretesttypepattern, TEST_OS=$failureospattern, TEST_KERNEL=$failurekernelpattern, TEST_PROCESSORTYPE=$failurearchpattern, TEST_MEMORY=$failurememorypattern, TEST_CPUSPEED=$failurecpuspeedpattern, TEST_TIMEZONE=$failuretimezonepattern, TEST_RESULT=FAIL[^,]*,/) {
+        if ($_ =~ /^TEST_ID=[^,]*, TEST_BRANCH=$failurebranchpattern, TEST_REPO=$failurerepopattern, TEST_BUILDTYPE=$failurebuildtypepattern, TEST_TYPE=$failuretesttypepattern, TEST_OS=$failureospattern, TEST_KERNEL=$failurekernelpattern, TEST_PROCESSORTYPE=$failurearchpattern, TEST_MEMORY=$failurememorypattern, TEST_TIMEZONE=$failuretimezonepattern, TEST_OPTIONS=$failurejsoptionspattern, TEST_RESULT=FAIL[^,]*,/) {
             debug "failure: $_";
             push @failures, ($_);
         }
     }
     close FAILURES;
 }
 
 debug "finding fixed bugs";
 
 unlink "$outputprefix-results-possible-fixes.log";
@@ skipping 48 matching lines @@
 }
 close OUTPUT;
 
 print STDOUT "log: $outputprefix-results-possible-fixes.log\n";
 
 debug "finding regressions";
 
 my $pass = 0;
 my $changed = ($#patterns != -1);
 
+debug "changed=$changed, \$#patterns=$#patterns, \$#failures=$#failures";
+
 while ($changed) {
 
     $pass = $pass + 1;
 
     $changed = 0;
 
     debug "pass $pass";
 
     foreach $pattern (@patterns) {
 
@@ skipping 13 matching lines @@
 
         if ($#matches > -1) {
             $changed = 1;
         }
 
         debug "*****************************************";
     }
 
 }
 
+debug "\$#excludedtests=$#excludedtests, \$#failures=$#failures";
+
 foreach $excludedtest ( @excludedtests ) {
 
     if ($debug) {
         @results = grep m@$excludedtest@, @failures;
         if ($#results > -1) {
             print "excluding: " . (join ', ', @results) . "\n";
         }
     }
 
     @results = grep !m@$excludedtest@, @failures;
 
+    debug "\$#results=$#results, \$excludedtest=$excludedtest, \$#failures=$#failures";
+
     @failures = @results;
 }
 
+debug "possible regressions: \$#failures=$#failures";
+
 open OUTPUT, ">$outputprefix-results-possible-regressions.log" or die "Unable to open $outputprefix-results-possible-regressions.log: $!";
 
 my $failure;
 foreach $failure (@failures) {
     print OUTPUT "$failure\n";
     if ($debug) {
         debug "regression: $failure";
     }
 }
 close OUTPUT;
@@ skipping 16 matching lines @@
 
 usage: $msg
 
 known-failures.pl [-b|--branch] branch 
                   [-T|--buildtype] buildtype 
                   [-t|--testtype] testtype 
                   [-o|--os] os
                   [-K|--kernel] kernel
                   [-A|--arch] arch
                   [-M|--memory] memory
-                  [-S|--speed] speed
                   [-z|--timezone] timezone 
+                  [-J|--jsoptions] jsoptions
                   [-r|--patterns] patterns 
                   ([-f|--failurelogfile] failurelogfile|[-l|--logfile] rawlogfile])
                   [-O|--outputprefix] outputprefix
                   [-D]
 
     variable            description
     ===============     ============================================================
     -b branch           branch 1.8.0, 1.8.1, 1.9.0, all
     -R repository       CVS for 1.8.0, 1.8.1, 1.9.0 branches, 
-                        mercurial repository name for 1.9.1 branches
+                        mercurial repository name for 1.9.1 and later branches
                         (\`basename http://hg.mozilla.org/repository\`)
     -T buildtype        build type opt, debug, all
     -t testtype         test type browser, shell, all
     -o os               operating system nt, darwin, linux, all
     -K kernel           kernel, all or a specific pattern
     -A arch             architecture, all or a specific pattern
     -M memory           memory in Gigabytes, all or a specific pattern
-    -S speed            speed, all or specific pattern
     -z timezone         -0400, -0700, etc. default to user\'s zone
+    -J jsoptions        JavaScript options
     -l rawlogfile       raw logfile
     -f failurelogfile   failure logfile
     -r patterns         known failure patterns
     -O outputprefix     output files will be generated with this prefix
     -D                  turn on debugging output
 EOF
 
     exit(2);
 }
 
@@ skipping 22 matching lines @@
         }
         elsif ($option eq "K") {
             $kernel = $value;
         }
         elsif ($option eq "A") {
             $arch = $value;
         }
         elsif ($option eq "M") {
             $memory = $value;
         }
-        elsif ($option eq "S") {
-            $cpuspeed = $value;
-            if ($cpuspeed < 4)
-            {
-                $cpuspeed = 'slow';
-            }
-            elsif ($cpuspeed < 9)
-            {
-                $cpuspeed = 'medium';
-            }
-            else
-            {
-                $cpuspeed = 'fast';
-            }
-        }
         elsif ($option eq "z") {
             $timezone = $value;
         }
+        elsif ($option eq "J") {
+            my (@s, $j);
+
+            if (! $value) {
+                $jsoptions = 'none';
+            }
+            else {
+                $value =~ s/(-\w) (\w)/$1$2/g; 
+                @s = sort split / /, $value; 
+                $j = join(" ", @s); 
+                $j =~ s/(-\w)(\w)/$1 $2/g; 
+                $jsoptions = $j;
+            }
+        }
         elsif ($option eq "r") {
             $patterns = $value;
         }
         elsif ($option eq "l") {
             $rawlogfile = $value;
         }
         elsif ($option eq "f") {
             $failurelogfile = $value;
         }
         elsif ($option eq "O") {
             $outputprefix = $value;
         }
         elsif ($option eq "D") {
             $debug = 1;
         }
 
     }
 
     if ($debug) {
-        print "branch=$branch, buildtype=$buildtype, testtype=$testtype, os=$os, kernel=$kernel, arch=$arch, memory=$memory, cpuspeed=$cpuspeed, timezone=$timezone, patterns=$patterns, rawlogfile=$rawlogfile failurelogfile=$failurelogfile, outputprefix=$outputprefix\n";
+        print "branch=$branch, buildtype=$buildtype, testtype=$testtype, os=$os, kernel=$kernel, arch=$arch, memory=$memory, timezone=$timezone, jsoptions=$jsoptions, patterns=$patterns, rawlogfile=$rawlogfile failurelogfile=$failurelogfile, outputprefix=$outputprefix\n";
     }
     Getopt::Mixed::cleanup();
 
     if ( !defined($branch) ) {
         usage "missing branch";
     }
 
     if (!defined($buildtype)) {
         usage "missing buildtype";
     }
 
     if (!defined($testtype)) {
         usage "missing testtype";
     }
 
     if (!defined($os)) { 
         usage "missing os";
     }
 
     if (!defined($memory)) {
         $memory = 'all';
     }
 
-    if (!defined($cpuspeed)) {
-        $cpuspeed = 'all';
-    }
-
     if (!defined($timezone)) {
         usage "missing timezone";
     }
 
+    if (!defined($jsoptions)) {
+        $jsoptions = 'none';
+    }
+
     if (!defined($patterns)) {
         usage "missing patterns";
     }
 
     if (!defined($rawlogfile) && !defined($failurelogfile)) {
         usage "missing logfile";
     }
 
     if (!defined($outputprefix)) {
         usage "missing outputprefix";
     }
 
-    if ($branch eq "1.8.0") {
-        $knownfailurebranchpattern = "(1\\.8\\.0|\\.\\*)";
-        $failurebranchpattern      = "1\\.8\\.0";
-    }
-    elsif ($branch eq "1.8.1") {
-        $knownfailurebranchpattern = "(1\\.8\\.1|\\.\\*)";
-        $failurebranchpattern      = "1\\.8\\.1";
-    }
-    elsif ($branch eq "1.9.0") {
-        $knownfailurebranchpattern = "(1\\.9\\.0|\\.\\*)";
-        $failurebranchpattern      = "1\\.9\\.0";
-    }
-    elsif ($branch eq "1.9.1") {
-        $knownfailurebranchpattern = "(1\\.9\\.1|\\.\\*)";
-        $failurebranchpattern      = "1\\.9\\.1";
-    }
-    elsif ($branch eq "all") {
+    if ($branch eq "all") {
         $knownfailurebranchpattern = "[^,]*";
         $failurebranchpattern      = "[^,]*";
     }
+    else {
+        $knownfailurebranchpattern = "($branch|.*)";
+        $knownfailurebranchpattern =~ s/\./\\./g;
+
+        $failurebranchpattern = "$branch";
+        $failurebranchpattern =~ s/\./\\./g;
+    }
 
     if ($repo eq "all" || $repo eq ".*") {
         $knownfailurerepopattern = "[^,]*";
         $failurerepopattern      = "[^,]*";
     }
     else {
         $knownfailurerepopattern = "($repo|\\.\\*)";
         $failurerepopattern      = "$repo";
     }
 
@@ skipping 60 matching lines @@
 
     if ($memory ne  "all") {
         $knownfailurememorypattern = "(" . $memory . "|\\.\\*)";
         $failurememorypattern      = "$memory";
     }
     else {
         $knownfailurememorypattern = "[^,]*";
         $failurememorypattern      = "[^,]*";
     }
 
-    if ($cpuspeed ne  "all") {
-        $knownfailurecpuspeedpattern = "(" . $cpuspeed . "|\\.\\*)";
-        $failurecpuspeedpattern      = "$cpuspeed";
-    }
-    else {
-        $knownfailurecpuspeedpattern = "[^,]*";
-        $failurecpuspeedpattern      = "[^,]*";
-    }
-
     if ($timezone eq "all") {
         $knownfailuretimezonepattern = "[^,]*";
         $failuretimezonepattern      = "[^,]*";
     }
     else {
-        $knownfailuretimezonepattern = "(" . $timezone . "|\\.\\*)";
-        $failuretimezonepattern      = "$timezone";
+        $knownfailuretimezonepattern = "(" . escape_string($timezone) . "|\\.\\*)";
+        $failuretimezonepattern      = escape_string("$timezone");
     }
 
+    if ($jsoptions eq "all") {
+        $knownfailurejsoptionspattern = "[^,]*";
+        $failurejsoptionspattern      = "[^,]*";
+    }
+    else {
+        $knownfailurejsoptionspattern = "(" . escape_string($jsoptions) . "|\\.\\*)";
+        $failurejsoptionspattern      = escape_string("$jsoptions");
+    }
+
+}
+
+sub escape_string {
+    my $s = shift;
+
+    # replace unescaped regular expression characters in the 
+    # string so they are not interpreted as regexp chars
+    # when matching descriptions. leave the escaped regexp chars
+    # `regexp` alone so they can be unescaped later and used in 
+    # pattern matching.
+
+    # see perldoc perlre
+
+    $s =~ s/\\/\\\\/g;
+
+    # escape non word chars that aren't surrounded by ``
+    $s =~ s/(?<!`)([$regchars])(?!`)/\\$1/g;
+    $s =~ s/(?<!`)([$regchars])(?=`)/\\$1/g;
+    $s =~ s/(?<=`)([$regchars])(?!`)/\\$1/g;
+
+    # unquote the regchars
+    $s =~ s/\`([^\`])\`/$1/g;
+
+    debug "escape_string  : $s";
+
+    return "$s";
 
 }
 
 sub escape_pattern {
 
     my $line = shift;
 
     chomp;
 
     my ($leading, $trailing) = $line =~ /(.*TEST_DESCRIPTION=)(.*)/;
 
     #    debug "escape_pattern: before: $leading$trailing";
 
-    # replace unescaped regular expression characters in the 
-    # description so they are not interpreted as regexp chars
-    # when matching descriptions. leave the escaped regexp chars
-    # `regexp alone so they can be unescaped later and used in 
-    # pattern matching.
-
-    # see perldoc perlre
-
-    $trailing =~ s/\\/\\\\/g;
-
-    # escape non word chars that aren't surrounded by ``
-    $trailing =~ s/(?<!`)([$regchars])(?!`)/\\$1/g;
-    $trailing =~ s/(?<!`)([$regchars])(?=`)/\\$1/g;
-    $trailing =~ s/(?<=`)([$regchars])(?!`)/\\$1/g;
-    #    $trailing =~ s/(?<!`)(\W)(?!`)/\\$1/g;
-
-    # unquote the regchars
-    $trailing =~ s/\`([^\`])\`/$1/g;
+    $trailing = escape_string($trailing);
 
     debug "escape_pattern  : $leading$trailing";
 
     return "$leading$trailing";
 
 }
 
 sub unescape_pattern {
     my $line = shift;
 
@@ skipping 11 matching lines @@
 
     debug "unescape_pattern: after: $leading$trailing";
 
     return "$leading$trailing";
 }
 
 ####
 
 
 1;