1 #!/usr/bin/perl

     2 

     3 # Copyright (C) 2005, 2006, 2007, 2008, 2009, 2010 Apple Inc. All rights reserved.

     4 # Copyright (C) 2006 Alexey Proskuryakov (ap@nypop.com)

     5 # Copyright (C) 2007 Matt Lilek (pewtermoose@gmail.com)

     6 # Copyright (C) 2007 Eric Seidel <eric@webkit.org>

     7 # Copyright (C) 2009 Google Inc. All rights reserved.

     8 # Copyright (C) 2009 Andras Becsi (becsi.andras@stud.u-szeged.hu), University of Szeged

     9 #

    10 # Redistribution and use in source and binary forms, with or without

    11 # modification, are permitted provided that the following conditions

    12 # are met:

    13 #

    14 # 1.  Redistributions of source code must retain the above copyright

    15 #     notice, this list of conditions and the following disclaimer. 

    16 # 2.  Redistributions in binary form must reproduce the above copyright

    17 #     notice, this list of conditions and the following disclaimer in the

    18 #     documentation and/or other materials provided with the distribution. 

    19 # 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of

    20 #     its contributors may be used to endorse or promote products derived

    21 #     from this software without specific prior written permission. 

    22 #

    23 # THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY

    24 # EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED

    25 # WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE

    26 # DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY

    27 # DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES

    28 # (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;

    29 # LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND

    30 # ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

    31 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

    32 # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

    33 

    34 # Script to run the WebKit Open Source Project layout tests.

    35 

    36 # Run all the tests passed in on the command line.

    37 # If no tests are passed, find all the .html, .shtml, .xml, .xhtml, .xhtmlmp, .pl, .php (and svg) files in the test directory.

    38 

    39 # Run each text.

    40 # Compare against the existing file xxx-expected.txt.

    41 # If there is a mismatch, generate xxx-actual.txt and xxx-diffs.txt.

    42 

    43 # At the end, report:

    44 #   the number of tests that got the expected results

    45 #   the number of tests that ran, but did not get the expected results

    46 #   the number of tests that failed to run

    47 #   the number of tests that were run but had no expected results to compare against

    48 

    49 use strict;

    50 use warnings;

    51 

    52 use Cwd;

    53 use Data::Dumper;

    54 use Fcntl qw(F_GETFL F_SETFL O_NONBLOCK);

    55 use File::Basename;

    56 use File::Copy;

    57 use File::Find;

    58 use File::Path;

    59 use File::Spec;

    60 use File::Spec::Functions;

    61 use File::Temp;

    62 use FindBin;

    63 use Getopt::Long;

    64 use IPC::Open2;

    65 use IPC::Open3;

    66 use Time::HiRes qw(time usleep);

    67 

    68 use List::Util 'shuffle';

    69 

    70 use lib $FindBin::Bin;

    71 use webkitperl::features;

    72 use webkitperl::httpd;

    73 use webkitdirs;

    74 use VCSUtils;

    75 use POSIX;

    76 

    77 sub buildPlatformResultHierarchy();

    78 sub buildPlatformTestHierarchy(@);

    79 sub checkPythonVersion();

    80 sub closeCygpaths();

    81 sub closeDumpTool();

    82 sub closeWebSocketServer();

    83 sub configureAndOpenHTTPDIfNeeded();

    84 sub countAndPrintLeaks($$$);

    85 sub countFinishedTest($$$$);

    86 sub deleteExpectedAndActualResults($);

    87 sub dumpToolDidCrash();

    88 sub epiloguesAndPrologues($$);

    89 sub expectedDirectoryForTest($;$;$);

    90 sub fileNameWithNumber($$);

    91 sub htmlForResultsSection(\@$&);

    92 sub isTextOnlyTest($);

    93 sub launchWithEnv(\@\%);

    94 sub resolveAndMakeTestResultsDirectory();

    95 sub numericcmp($$);

    96 sub openDiffTool();

    97 sub openDumpTool();

    98 sub parseLeaksandPrintUniqueLeaks();

    99 sub openWebSocketServerIfNeeded();

   100 sub pathcmp($$);

   101 sub printFailureMessageForTest($$);

   102 sub processIgnoreTests($$);

   103 sub readFromDumpToolWithTimer(**);

   104 sub readSkippedFiles($);

   105 sub recordActualResultsAndDiff($$);

   106 sub sampleDumpTool();

   107 sub setFileHandleNonBlocking(*$);

   108 sub slowestcmp($$);

   109 sub splitpath($);

   110 sub stopRunningTestsEarlyIfNeeded();

   111 sub stripExtension($);

   112 sub stripMetrics($$);

   113 sub testCrashedOrTimedOut($$$$$);

   114 sub toURL($);

   115 sub toWindowsPath($);

   116 sub validateSkippedArg($$;$);

   117 sub writeToFile($$);

   118 

   119 # Argument handling

   120 my $addPlatformExceptions = 0;

   121 my $complexText = 0;

   122 my $exitAfterNFailures = 0;

   123 my $exitAfterNCrashesOrTimeouts = 0;

   124 my $generateNewResults = isAppleMacWebKit() ? 1 : 0;

   125 my $guardMalloc = '';

   126 # FIXME: Dynamic HTTP-port configuration in this file is wrong.  The various

   127 # apache config files in LayoutTests/http/config govern the port numbers.

   128 # Dynamic configuration as-written will also cause random failures in

   129 # an IPv6 environment.  See https://bugs.webkit.org/show_bug.cgi?id=37104.

   130 my $httpdPort = 8000;

   131 my $httpdSSLPort = 8443;

   132 my $ignoreMetrics = 0;

   133 my $webSocketPort = 8880;

   134 # wss is disabled until all platforms support pyOpenSSL.

   135 # my $webSocketSecurePort = 9323;

   136 my $ignoreTests = '';

   137 my $iterations = 1;

   138 my $launchSafari = 1;

   139 my $mergeDepth;

   140 my $pixelTests = '';

   141 my $platform;

   142 my $quiet = '';

   143 my $randomizeTests = 0;

   144 my $repeatEach = 1;

   145 my $report10Slowest = 0;

   146 my $resetResults = 0;

   147 my $reverseTests = 0;

   148 my $root;

   149 my $runSample = 1;

   150 my $shouldCheckLeaks = 0;

   151 my $showHelp = 0;

   152 my $stripEditingCallbacks = isCygwin();

   153 my $testHTTP = 1;

   154 my $testWebSocket = 1;

   155 my $testMedia = 1;

   156 my $tmpDir = "/tmp";

   157 my $testResultsDirectory = File::Spec->catfile($tmpDir, "layout-test-results");

   158 my $testsPerDumpTool = 1000;

   159 my $threaded = 0;

   160 my $html5treebuilder = 0;

   161 # DumpRenderTree has an internal timeout of 30 seconds, so this must be > 30.

   162 my $timeoutSeconds = 35;

   163 my $tolerance = 0;

   164 my $treatSkipped = "default";

   165 my $useRemoteLinksToTests = 0;

   166 my $useValgrind = 0;

   167 my $verbose = 0;

   168 my $shouldWaitForHTTPD = 0;

   169 my $useWebKitTestRunner = 0;

   170 

   171 my @leaksFilenames;

   172 

   173 if (isWindows() || isMsys()) {

   174     print "This script has to be run under Cygwin to function correctly.\n";

   175     exit 1;

   176 }

   177 

   178 # Default to --no-http for wx for now.

   179 $testHTTP = 0 if (isWx());

   180 

   181 my $expectedTag = "expected";

   182 my $actualTag = "actual";

   183 my $prettyDiffTag = "pretty-diff";

   184 my $diffsTag = "diffs";

   185 my $errorTag = "stderr";

   186 

   187 my $realPlatform;

   188 

   189 my @macPlatforms = ("mac-tiger", "mac-leopard", "mac-snowleopard", "mac");

   190 my @winPlatforms = ("win-xp", "win-vista", "win-7", "win");

   191 

   192 if (isAppleMacWebKit()) {

   193     if (isTiger()) {

   194         $platform = "mac-tiger";

   195         $tolerance = 1.0;

   196     } elsif (isLeopard()) {

   197         $platform = "mac-leopard";

   198         $tolerance = 0.1;

   199     } elsif (isSnowLeopard()) {

   200         $platform = "mac-snowleopard";

   201         $tolerance = 0.1;

   202     } else {

   203         $platform = "mac";

   204     }

   205 } elsif (isQt()) {

   206     if (isDarwin()) {

   207         $platform = "qt-mac";

   208     } elsif (isLinux()) {

   209         $platform = "qt-linux";

   210     } elsif (isWindows() || isCygwin()) {

   211         $platform = "qt-win";

   212     } else {

   213         $platform = "qt";

   214     }

   215 } elsif (isGtk()) {

   216     $platform = "gtk";

   217     if (!$ENV{"WEBKIT_TESTFONTS"}) {

   218         print "The WEBKIT_TESTFONTS environment variable is not defined.\n";

   219         print "You must set it before running the tests.\n";

   220         print "Use git to grab the actual fonts from http://gitorious.org/qtwebkit/testfonts\n";

   221         exit 1;

   222     }

   223 } elsif (isWx()) {

   224     $platform = "wx";

   225 } elsif (isCygwin()) {

   226     if (isWindowsXP()) {

   227         $platform = "win-xp";

   228     } elsif (isWindowsVista()) {

   229         $platform = "win-vista";

   230     } elsif (isWindows7()) {

   231         $platform = "win-7";

   232     } else {

   233         $platform = "win";

   234     }

   235 }

   236 

   237 if (!defined($platform)) {

   238     print "WARNING: Your platform is not recognized. Any platform-specific results will be generated in platform/undefined.\n";

   239     $platform = "undefined";

   240 }

   241 

   242 if (!checkPythonVersion()) {

   243     print "WARNING: Your platform does not have Python 2.5+, which is required to run websocket server, so disabling websocket/tests.\n";

   244     $testWebSocket = 0;

   245 }

   246 

   247 my $programName = basename($0);

   248 my $launchSafariDefault = $launchSafari ? "launch" : "do not launch";

   249 my $httpDefault = $testHTTP ? "run" : "do not run";

   250 my $sampleDefault = $runSample ? "run" : "do not run";

   251 

   252 my $usage = <<EOF;

   253 Usage: $programName [options] [testdir|testpath ...]

   254   --add-platform-exceptions       Put new results for non-platform-specific failing tests into the platform-specific results directory

   255   --complex-text                  Use the complex text code path for all text (Mac OS X and Windows only)

   256   -c|--configuration config       Set DumpRenderTree build configuration

   257   -g|--guard-malloc               Enable malloc guard

   258   --exit-after-n-failures N       Exit after the first N failures (includes crashes) instead of running all tests

   259   --exit-after-n-crashes-or-timeouts N

   260                                   Exit after the first N crashes instead of running all tests

   261   -h|--help                       Show this help message

   262   --[no-]http                     Run (or do not run) http tests (default: $httpDefault)

   263   --[no-]wait-for-httpd           Wait for httpd if some other test session is using it already (same as WEBKIT_WAIT_FOR_HTTPD=1). (default: $shouldWaitForHTTPD) 

   264   -i|--ignore-tests               Comma-separated list of directories or tests to ignore

   265   --iterations n                  Number of times to run the set of tests (e.g. ABCABCABC)

   266   --[no-]launch-safari            Launch (or do not launch) Safari to display test results (default: $launchSafariDefault)

   267   -l|--leaks                      Enable leaks checking

   268   --[no-]new-test-results         Generate results for new tests

   269   --nthly n                       Restart DumpRenderTree every n tests (default: $testsPerDumpTool)

   270   -p|--pixel-tests                Enable pixel tests

   271   --tolerance t                   Ignore image differences less than this percentage (default: $tolerance)

   272   --platform                      Override the detected platform to use for tests and results (default: $platform)

   273   --port                          Web server port to use with http tests

   274   -q|--quiet                      Less verbose output

   275   --reset-results                 Reset ALL results (including pixel tests if --pixel-tests is set)

   276   -o|--results-directory          Output results directory (default: $testResultsDirectory)

   277   --random                        Run the tests in a random order

   278   --repeat-each n                 Number of times to run each test (e.g. AAABBBCCC)

   279   --reverse                       Run the tests in reverse alphabetical order

   280   --root                          Path to root tools build

   281   --[no-]sample-on-timeout        Run sample on timeout (default: $sampleDefault) (Mac OS X only)

   282   -1|--singly                     Isolate each test case run (implies --nthly 1 --verbose)

   283   --skipped=[default|ignore|only] Specifies how to treat the Skipped file

   284                                      default: Tests/directories listed in the Skipped file are not tested

   285                                      ignore:  The Skipped file is ignored

   286                                      only:    Only those tests/directories listed in the Skipped file will be run

   287   --slowest                       Report the 10 slowest tests

   288   --ignore-metrics                Ignore metrics in tests

   289   --[no-]strip-editing-callbacks  Remove editing callbacks from expected results

   290   -t|--threaded                   Run a concurrent JavaScript thead with each test

   291   --html5-treebuilder             Run the tests using the HTML5 tree builder

   292   --timeout t                     Sets the number of seconds before a test times out (default: $timeoutSeconds)

   293   --valgrind                      Run DumpRenderTree inside valgrind (Qt/Linux only)

   294   -v|--verbose                    More verbose output (overrides --quiet)

   295   -m|--merge-leak-depth arg       Merges leak callStacks and prints the number of unique leaks beneath a callstack depth of arg.  Defaults to 5.

   296   --use-remote-links-to-tests     Link to test files within the SVN repository in the results.

   297   --webkit-test-runner            Use WebKitTestRunner rather than DumpRenderTree.

   298 EOF

   299 

   300 setConfiguration();

   301 

   302 my $getOptionsResult = GetOptions(

   303     'add-platform-exceptions' => \$addPlatformExceptions,

   304     'complex-text' => \$complexText,

   305     'exit-after-n-failures=i' => \$exitAfterNFailures,

   306     'exit-after-n-crashes-or-timeouts=i' => \$exitAfterNCrashesOrTimeouts,

   307     'guard-malloc|g' => \$guardMalloc,

   308     'help|h' => \$showHelp,

   309     'http!' => \$testHTTP,

   310     'wait-for-httpd!' => \$shouldWaitForHTTPD,

   311     'ignore-metrics!' => \$ignoreMetrics,

   312     'ignore-tests|i=s' => \$ignoreTests,

   313     'iterations=i' => \$iterations,

   314     'launch-safari!' => \$launchSafari,

   315     'leaks|l' => \$shouldCheckLeaks,

   316     'merge-leak-depth|m:5' => \$mergeDepth,

   317     'new-test-results!' => \$generateNewResults,

   318     'nthly=i' => \$testsPerDumpTool,

   319     'pixel-tests|p' => \$pixelTests,

   320     'platform=s' => \$platform,

   321     'port=i' => \$httpdPort,

   322     'quiet|q' => \$quiet,

   323     'random' => \$randomizeTests,

   324     'repeat-each=i' => \$repeatEach,

   325     'reset-results' => \$resetResults,

   326     'results-directory|o=s' => \$testResultsDirectory,

   327     'reverse' => \$reverseTests,

   328     'root=s' => \$root,

   329     'sample-on-timeout!' => \$runSample,

   330     'singly|1' => sub { $testsPerDumpTool = 1; },

   331     'skipped=s' => \&validateSkippedArg,

   332     'slowest' => \$report10Slowest,

   333     'strip-editing-callbacks!' => \$stripEditingCallbacks,

   334     'threaded|t' => \$threaded,

   335     'html5-treebuilder' => \$html5treebuilder,

   336     'timeout=i' => \$timeoutSeconds,

   337     'tolerance=f' => \$tolerance,

   338     'use-remote-links-to-tests' => \$useRemoteLinksToTests,

   339     'valgrind' => \$useValgrind,

   340     'verbose|v' => \$verbose,

   341     'webkit-test-runner' => \$useWebKitTestRunner,

   342 );

   343 

   344 if (!$getOptionsResult || $showHelp) {

   345     print STDERR $usage;

   346     exit 1;

   347 }

   348 

   349 if ($useWebKitTestRunner) {

   350     if (isAppleMacWebKit()) {

   351         $realPlatform = $platform;

   352         $platform = "mac-wk2";

   353     }

   354 }

   355 

   356 

   357 my $ignoreSkipped = $treatSkipped eq "ignore";

   358 my $skippedOnly = $treatSkipped eq "only";

   359 

   360 my $configuration = configuration();

   361 

   362 # We need an environment variable to be able to enable the feature per-slave

   363 $shouldWaitForHTTPD = $ENV{"WEBKIT_WAIT_FOR_HTTPD"} unless ($shouldWaitForHTTPD);

   364 $verbose = 1 if $testsPerDumpTool == 1;

   365 

   366 if ($shouldCheckLeaks && $testsPerDumpTool > 1000) {

   367     print STDERR "\nWARNING: Running more than 1000 tests at a time with MallocStackLogging enabled may cause a crash.\n\n";

   368 }

   369 

   370 # Stack logging does not play well with QuickTime on Tiger (rdar://problem/5537157)

   371 $testMedia = 0 if $shouldCheckLeaks && isTiger();

   372 

   373 # Generating remote links causes a lot of unnecessary spew on GTK build bot

   374 $useRemoteLinksToTests = 0 if isGtk();

   375 

   376 setConfigurationProductDir(Cwd::abs_path($root)) if (defined($root));

   377 my $productDir = productDir();

   378 $productDir .= "/bin" if isQt();

   379 $productDir .= "/Programs" if isGtk();

   380 

   381 chdirWebKit();

   382 

   383 my $dumpToolName = $useWebKitTestRunner ? "WebKitTestRunner" : "DumpRenderTree";

   384 

   385 if (!defined($root)) {

   386     my $dumpToolBuildScript =  "build-" . lc($dumpToolName);

   387     print STDERR "Running $dumpToolBuildScript\n";

   388 

   389     local *DEVNULL;

   390     my ($childIn, $childOut, $childErr);

   391     if ($quiet) {

   392         open(DEVNULL, ">", File::Spec->devnull()) or die "Failed to open /dev/null";

   393         $childOut = ">&DEVNULL";

   394         $childErr = ">&DEVNULL";

   395     } else {

   396         # When not quiet, let the child use our stdout/stderr.

   397         $childOut = ">&STDOUT";

   398         $childErr = ">&STDERR";

   399     }

   400 

   401     my @args = argumentsForConfiguration();

   402     my $buildProcess = open3($childIn, $childOut, $childErr, "WebKitTools/Scripts/$dumpToolBuildScript", @args) or die "Failed to run build-dumprendertree";

   403     close($childIn);

   404     waitpid $buildProcess, 0;

   405     my $buildResult = $?;

   406     close($childOut);

   407     close($childErr);

   408 

   409     close DEVNULL if ($quiet);

   410 

   411     if ($buildResult) {

   412         print STDERR "Compiling $dumpToolName failed!\n";

   413         exit exitStatus($buildResult);

   414     }

   415 }

   416 

   417 $dumpToolName .= "_debug" if isCygwin() && configurationForVisualStudio() !~ /^Release|Debug_Internal$/;

   418 my $dumpTool = "$productDir/$dumpToolName";

   419 die "can't find executable $dumpToolName (looked in $productDir)\n" unless -x $dumpTool;

   420 

   421 my $imageDiffTool = "$productDir/ImageDiff";

   422 $imageDiffTool .= "_debug" if isCygwin() && configurationForVisualStudio() !~ /^Release|Debug_Internal$/;

   423 die "can't find executable $imageDiffTool (looked in $productDir)\n" if $pixelTests && !-x $imageDiffTool;

   424 

   425 checkFrameworks() unless isCygwin();

   426 

   427 if (isAppleMacWebKit()) {

   428     push @INC, $productDir;

   429     require DumpRenderTreeSupport;

   430 }

   431 

   432 my $layoutTestsName = "LayoutTests";

   433 my $testDirectory = File::Spec->rel2abs($layoutTestsName);

   434 my $expectedDirectory = $testDirectory;

   435 my $platformBaseDirectory = catdir($testDirectory, "platform");

   436 my $platformTestDirectory = catdir($platformBaseDirectory, $platform);

   437 my @platformResultHierarchy = buildPlatformResultHierarchy();

   438 my @platformTestHierarchy = buildPlatformTestHierarchy(@platformResultHierarchy);

   439 

   440 $expectedDirectory = $ENV{"WebKitExpectedTestResultsDirectory"} if $ENV{"WebKitExpectedTestResultsDirectory"};

   441 

   442 $testResultsDirectory = File::Spec->rel2abs($testResultsDirectory);

   443 my $testResults = File::Spec->catfile($testResultsDirectory, "results.html");

   444 

   445 if (isAppleMacWebKit()) {

   446     print STDERR "Compiling Java tests\n";

   447     my $javaTestsDirectory = catdir($testDirectory, "java");

   448 

   449     if (system("/usr/bin/make", "-C", "$javaTestsDirectory")) {

   450         exit 1;

   451     }

   452 }

   453 

   454 

   455 print "Running tests from $testDirectory\n";

   456 if ($pixelTests) {

   457     print "Enabling pixel tests with a tolerance of $tolerance%\n";

   458     if (isDarwin()) {

   459         print "WARNING: Temporarily changing the main display color profile:\n";

   460         print "\tThe colors on your screen will change for the duration of the testing.\n";

   461         print "\tThis allows the pixel tests to have consistent color values across all machines.\n";

   462         

   463         if (isPerianInstalled()) {

   464             print "WARNING: Perian's QuickTime component is installed and this may affect pixel test results!\n";

   465             print "\tYou should avoid generating new pixel results in this environment.\n";

   466             print "\tSee https://bugs.webkit.org/show_bug.cgi?id=22615 for details.\n";

   467         }

   468     }

   469 }

   470 

   471 system "ln", "-s", $testDirectory, "/tmp/LayoutTests" unless -x "/tmp/LayoutTests";

   472 

   473 my %ignoredFiles = ( "results.html" => 1 );

   474 my %ignoredDirectories = map { $_ => 1 } qw(platform);

   475 my %ignoredLocalDirectories = map { $_ => 1 } qw(.svn _svn resources script-tests);

   476 my %supportedFileExtensions = map { $_ => 1 } qw(html shtml xml xhtml xhtmlmp pl php);

   477 

   478 if (!checkWebCoreFeatureSupport("MathML", 0)) {

   479     $ignoredDirectories{'mathml'} = 1;

   480 }

   481 

   482 # FIXME: We should fix webkitperl/features.pm:hasFeature() to do the correct feature detection for Cygwin.

   483 if (checkWebCoreFeatureSupport("SVG", 0)) {

   484     $supportedFileExtensions{'svg'} = 1;

   485 } elsif (isCygwin()) {

   486     $supportedFileExtensions{'svg'} = 1;

   487 } else {

   488     $ignoredLocalDirectories{'svg'} = 1;

   489 }

   490 

   491 if (!$testHTTP) {

   492     $ignoredDirectories{'http'} = 1;

   493     $ignoredDirectories{'websocket'} = 1;

   494 }

   495 if (!$testWebSocket) {

   496     $ignoredDirectories{'websocket'} = 1;

   497 }

   498 

   499 if (!$testMedia) {

   500     $ignoredDirectories{'media'} = 1;

   501     $ignoredDirectories{'http/tests/media'} = 1;

   502 }

   503 

   504 my $supportedFeaturesResult = "";

   505 

   506 if (isCygwin()) {

   507     # Collect supported features list

   508     setPathForRunningWebKitApp(\%ENV);

   509     my $supportedFeaturesCommand = $dumpTool . " --print-supported-features 2>&1";

   510     $supportedFeaturesResult = `$supportedFeaturesCommand 2>&1`;

   511 }

   512 

   513 my $hasAcceleratedCompositing = 0;

   514 my $has3DRendering = 0;

   515 

   516 if (isCygwin()) {

   517     $hasAcceleratedCompositing = $supportedFeaturesResult =~ /AcceleratedCompositing/;

   518     $has3DRendering = $supportedFeaturesResult =~ /3DRendering/;

   519 } else {

   520     $hasAcceleratedCompositing = checkWebCoreFeatureSupport("Accelerated Compositing", 0);

   521     $has3DRendering = checkWebCoreFeatureSupport("3D Rendering", 0);

   522 }

   523 

   524 if (!$hasAcceleratedCompositing) {

   525     $ignoredDirectories{'compositing'} = 1;

   526 }

   527 

   528 if (!$has3DRendering) {

   529     $ignoredDirectories{'animations/3d'} = 1;

   530     $ignoredDirectories{'transforms/3d'} = 1;

   531 }

   532 

   533 if (!checkWebCoreFeatureSupport("3D Canvas", 0)) {

   534     $ignoredDirectories{'fast/canvas/webgl'} = 1;

   535     $ignoredDirectories{'compositing/webgl'} = 1;

   536 }

   537 

   538 if (checkWebCoreFeatureSupport("WML", 0)) {

   539     $supportedFileExtensions{'wml'} = 1;

   540 } else {

   541     $ignoredDirectories{'http/tests/wml'} = 1;

   542     $ignoredDirectories{'fast/wml'} = 1;

   543     $ignoredDirectories{'wml'} = 1;

   544 }

   545 

   546 if (!checkWebCoreFeatureSupport("WCSS", 0)) {

   547     $ignoredDirectories{'fast/wcss'} = 1;

   548 }

   549 

   550 if (!checkWebCoreFeatureSupport("XHTMLMP", 0)) {

   551     $ignoredDirectories{'fast/xhtmlmp'} = 1;

   552 }

   553 

   554 processIgnoreTests($ignoreTests, "ignore-tests") if $ignoreTests;

   555 if (!$ignoreSkipped) {

   556     if (!$skippedOnly || @ARGV == 0) {

   557         readSkippedFiles("");

   558     } else {

   559         # Since readSkippedFiles() appends to @ARGV, we must use a foreach

   560         # loop so that we only iterate over the original argument list.

   561         foreach my $argnum (0 .. $#ARGV) {

   562             readSkippedFiles(shift @ARGV);

   563         }

   564     }

   565 }

   566 

   567 my @tests = findTestsToRun();

   568 

   569 die "no tests to run\n" if !@tests;

   570 

   571 my %counts;

   572 my %tests;

   573 my %imagesPresent;

   574 my %imageDifferences;

   575 my %durations;

   576 my $count = 0;

   577 my $leaksOutputFileNumber = 1;

   578 my $totalLeaks = 0;

   579 

   580 my @toolArgs = ();

   581 push @toolArgs, "--pixel-tests" if $pixelTests;

   582 push @toolArgs, "--threaded" if $threaded;

   583 push @toolArgs, "--html5-treebuilder" if $html5treebuilder;

   584 push @toolArgs, "--complex-text" if $complexText;

   585 push @toolArgs, "-";

   586 

   587 my @diffToolArgs = ();

   588 push @diffToolArgs, "--tolerance", $tolerance;

   589 

   590 $| = 1;

   591 

   592 my $dumpToolPID;

   593 my $isDumpToolOpen = 0;

   594 my $dumpToolCrashed = 0;

   595 my $imageDiffToolPID;

   596 my $isDiffToolOpen = 0;

   597 

   598 my $atLineStart = 1;

   599 my $lastDirectory = "";

   600 

   601 my $isHttpdOpen = 0;

   602 my $isWebSocketServerOpen = 0;

   603 my $webSocketServerPidFile = 0;

   604 my $failedToStartWebSocketServer = 0;

   605 # wss is disabled until all platforms support pyOpenSSL.

   606 # my $webSocketSecureServerPID = 0;

   607 

   608 sub catch_pipe { $dumpToolCrashed = 1; }

   609 $SIG{"PIPE"} = "catch_pipe";

   610 

   611 print "Testing ", scalar @tests, " test cases";

   612 print " $iterations times" if ($iterations > 1);

   613 print ", repeating each test $repeatEach times" if ($repeatEach > 1);

   614 print ".\n";

   615 

   616 my $overallStartTime = time;

   617 

   618 my %expectedResultPaths;

   619 

   620 my @originalTests = @tests;

   621 # Add individual test repetitions

   622 if ($repeatEach > 1) {

   623     @tests = ();

   624     foreach my $test (@originalTests) {

   625         for (my $i = 0; $i < $repeatEach; $i++) {

   626             push(@tests, $test);

   627         }

   628     }

   629 }

   630 # Add test set repetitions

   631 for (my $i = 1; $i < $iterations; $i++) {

   632     push(@tests, @originalTests);

   633 }

   634 

   635 for my $test (@tests) {

   636     my $newDumpTool = not $isDumpToolOpen;

   637     openDumpTool();

   638 

   639     my $base = stripExtension($test);

   640     my $expectedExtension = ".txt";

   641     

   642     my $dir = $base;

   643     $dir =~ s|/[^/]+$||;

   644 

   645     if ($newDumpTool || $dir ne $lastDirectory) {

   646         foreach my $logue (epiloguesAndPrologues($newDumpTool ? "" : $lastDirectory, $dir)) {

   647             if (isCygwin()) {

   648                 $logue = toWindowsPath($logue);

   649             } else {

   650                 $logue = canonpath($logue);

   651             }

   652             if ($verbose) {

   653                 print "running epilogue or prologue $logue\n";

   654             }

   655             print OUT "$logue\n";

   656             # Throw away output from DumpRenderTree.

   657             # Once for the test output and once for pixel results (empty)

   658             while (<IN>) {

   659                 last if /#EOF/;

   660             }

   661             while (<IN>) {

   662                 last if /#EOF/;

   663             }

   664         }

   665     }

   666 

   667     if ($verbose) {

   668         print "running $test -> ";

   669         $atLineStart = 0;

   670     } elsif (!$quiet) {

   671         if ($dir ne $lastDirectory) {

   672             print "\n" unless $atLineStart;

   673             print "$dir ";

   674         }

   675         print ".";

   676         $atLineStart = 0;

   677     }

   678 

   679     $lastDirectory = $dir;

   680 

   681     my $result;

   682 

   683     my $startTime = time if $report10Slowest;

   684 

   685     # Try to read expected hash file for pixel tests

   686     my $suffixExpectedHash = "";

   687     if ($pixelTests && !$resetResults) {

   688         my $expectedPixelDir = expectedDirectoryForTest($base, 0, "png");

   689         if (open EXPECTEDHASH, "$expectedPixelDir/$base-$expectedTag.checksum") {

   690             my $expectedHash = <EXPECTEDHASH>;

   691             chomp($expectedHash);

   692             close EXPECTEDHASH;

   693             

   694             # Format expected hash into a suffix string that is appended to the path / URL passed to DRT

   695             $suffixExpectedHash = "'$expectedHash";

   696         }

   697     }

   698 

   699     if ($test =~ /^http\//) {

   700         configureAndOpenHTTPDIfNeeded();

   701         if ($test !~ /^http\/tests\/local\// && $test !~ /^http\/tests\/ssl\// && $test !~ /^http\/tests\/wml\// && $test !~ /^http\/tests\/media\//) {

   702             my $path = canonpath($test);

   703             $path =~ s/^http\/tests\///;

   704             print OUT "http://127.0.0.1:$httpdPort/$path$suffixExpectedHash\n";

   705         } elsif ($test =~ /^http\/tests\/ssl\//) {

   706             my $path = canonpath($test);

   707             $path =~ s/^http\/tests\///;

   708             print OUT "https://127.0.0.1:$httpdSSLPort/$path$suffixExpectedHash\n";

   709         } else {

   710             my $testPath = "$testDirectory/$test";

   711             if (isCygwin()) {

   712                 $testPath = toWindowsPath($testPath);

   713             } else {

   714                 $testPath = canonpath($testPath);

   715             }

   716             print OUT "$testPath$suffixExpectedHash\n";

   717         }

   718     } elsif ($test =~ /^websocket\//) {

   719         if ($test =~ /^websocket\/tests\/local\//) {

   720             my $testPath = "$testDirectory/$test";

   721             if (isCygwin()) {

   722                 $testPath = toWindowsPath($testPath);

   723             } else {

   724                 $testPath = canonpath($testPath);

   725             }

   726             print OUT "$testPath\n";

   727         } else {

   728             if (openWebSocketServerIfNeeded()) {

   729                 my $path = canonpath($test);

   730                 if ($test =~ /^websocket\/tests\/ssl\//) {

   731                     # wss is disabled until all platforms support pyOpenSSL.

   732                     print STDERR "Error: wss is disabled until all platforms support pyOpenSSL.";

   733                     # print OUT "https://127.0.0.1:$webSocketSecurePort/$path\n";

   734                 } else {

   735                     print OUT "http://127.0.0.1:$webSocketPort/$path\n";

   736                 }

   737             } else {

   738                 # We failed to launch the WebSocket server.  Display a useful error message rather than attempting

   739                 # to run tests that expect the server to be available.

   740                 my $errorMessagePath = "$testDirectory/websocket/resources/server-failed-to-start.html";

   741                 $errorMessagePath = isCygwin() ? toWindowsPath($errorMessagePath) : canonpath($errorMessagePath);

   742                 print OUT "$errorMessagePath\n";

   743             }

   744         }

   745     } else {

   746         my $testPath = "$testDirectory/$test";

   747         if (isCygwin()) {

   748             $testPath = toWindowsPath($testPath);

   749         } else {

   750             $testPath = canonpath($testPath);

   751         }

   752         print OUT "$testPath$suffixExpectedHash\n" if defined $testPath;

   753     }

   754 

   755     # DumpRenderTree is expected to dump two "blocks" to stdout for each test.

   756     # Each block is terminated by a #EOF on a line by itself.

   757     # The first block is the output of the test (in text, RenderTree or other formats).

   758     # The second block is for optional pixel data in PNG format, and may be empty if

   759     # pixel tests are not being run, or the test does not dump pixels (e.g. text tests).

   760     my $readResults = readFromDumpToolWithTimer(IN, ERROR);

   761 

   762     my $actual = $readResults->{output};

   763     my $error = $readResults->{error};

   764 

   765     $expectedExtension = $readResults->{extension};

   766     my $expectedFileName = "$base-$expectedTag.$expectedExtension";

   767 

   768     my $isText = isTextOnlyTest($actual);

   769 

   770     my $expectedDir = expectedDirectoryForTest($base, $isText, $expectedExtension);

   771     $expectedResultPaths{$base} = "$expectedDir/$expectedFileName";

   772 

   773     unless ($readResults->{status} eq "success") {

   774         my $crashed = $readResults->{status} eq "crashed";

   775         testCrashedOrTimedOut($test, $base, $crashed, $actual, $error);

   776         countFinishedTest($test, $base, $crashed ? "crash" : "timedout", 0);

   777         last if stopRunningTestsEarlyIfNeeded();

   778         next;

   779     }

   780 

   781     $durations{$test} = time - $startTime if $report10Slowest;

   782 

   783     my $expected;

   784 

   785     if (!$resetResults && open EXPECTED, "<", "$expectedDir/$expectedFileName") {

   786         $expected = "";

   787         while (<EXPECTED>) {

   788             next if $stripEditingCallbacks && $_ =~ /^EDITING DELEGATE:/;

   789             $expected .= $_;

   790         }

   791         close EXPECTED;

   792     }

   793 

   794     if ($ignoreMetrics && !$isText && defined $expected) {

   795         ($actual, $expected) = stripMetrics($actual, $expected);

   796     }

   797 

   798     if ($shouldCheckLeaks && $testsPerDumpTool == 1) {

   799         print "        $test -> ";

   800     }

   801 

   802     my $actualPNG = "";

   803     my $diffPNG = "";

   804     my $diffPercentage = 0;

   805     my $diffResult = "passed";

   806 

   807     my $actualHash = "";

   808     my $expectedHash = "";

   809     my $actualPNGSize = 0;

   810 

   811     while (<IN>) {

   812         last if /#EOF/;

   813         if (/ActualHash: ([a-f0-9]{32})/) {

   814             $actualHash = $1;

   815         } elsif (/ExpectedHash: ([a-f0-9]{32})/) {

   816             $expectedHash = $1;

   817         } elsif (/Content-Length: (\d+)\s*/) {

   818             $actualPNGSize = $1;

   819             read(IN, $actualPNG, $actualPNGSize);

   820         }

   821     }

   822 

   823     if ($verbose && $pixelTests && !$resetResults && $actualPNGSize) {

   824         if ($actualHash eq "" && $expectedHash eq "") {

   825             printFailureMessageForTest($test, "WARNING: actual & expected pixel hashes are missing!");

   826         } elsif ($actualHash eq "") {

   827             printFailureMessageForTest($test, "WARNING: actual pixel hash is missing!");

   828         } elsif ($expectedHash eq "") {

   829             printFailureMessageForTest($test, "WARNING: expected pixel hash is missing!");

   830         }

   831     }

   832 

   833     if ($actualPNGSize > 0) {

   834         my $expectedPixelDir = expectedDirectoryForTest($base, 0, "png");

   835 

   836         if (!$resetResults && ($expectedHash ne $actualHash || ($actualHash eq "" && $expectedHash eq ""))) {

   837             if (-f "$expectedPixelDir/$base-$expectedTag.png") {

   838                 my $expectedPNGSize = -s "$expectedPixelDir/$base-$expectedTag.png";

   839                 my $expectedPNG = "";

   840                 open EXPECTEDPNG, "$expectedPixelDir/$base-$expectedTag.png";

   841                 read(EXPECTEDPNG, $expectedPNG, $expectedPNGSize);

   842 

   843                 openDiffTool();

   844                 print DIFFOUT "Content-Length: $actualPNGSize\n";

   845                 print DIFFOUT $actualPNG;

   846 

   847                 print DIFFOUT "Content-Length: $expectedPNGSize\n";

   848                 print DIFFOUT $expectedPNG;

   849 

   850                 while (<DIFFIN>) {

   851                     last if /^error/ || /^diff:/;

   852                     if (/Content-Length: (\d+)\s*/) {

   853                         read(DIFFIN, $diffPNG, $1);

   854                     }

   855                 }

   856 

   857                 if (/^diff: (.+)% (passed|failed)/) {

   858                     $diffPercentage = $1 + 0;

   859                     $imageDifferences{$base} = $diffPercentage;

   860                     $diffResult = $2;

   861                 }

   862                 

   863                 if (!$diffPercentage) {

   864                     printFailureMessageForTest($test, "pixel hash failed (but pixel test still passes)");

   865                 }

   866             } elsif ($verbose) {

   867                 printFailureMessageForTest($test, "WARNING: expected image is missing!");

   868             }

   869         }

   870 

   871         if ($resetResults || !-f "$expectedPixelDir/$base-$expectedTag.png") {

   872             mkpath catfile($expectedPixelDir, dirname($base)) if $testDirectory ne $expectedPixelDir;

   873             writeToFile("$expectedPixelDir/$base-$expectedTag.png", $actualPNG);

   874         }

   875 

   876         if ($actualHash ne "" && ($resetResults || !-f "$expectedPixelDir/$base-$expectedTag.checksum")) {

   877             writeToFile("$expectedPixelDir/$base-$expectedTag.checksum", $actualHash);

   878         }

   879     }

   880 

   881     if (dumpToolDidCrash()) {

   882         $result = "crash";

   883         testCrashedOrTimedOut($test, $base, 1, $actual, $error);

   884     } elsif (!defined $expected) {

   885         if ($verbose) {

   886             print "new " . ($resetResults ? "result" : "test") ."\n";

   887             $atLineStart = 1;

   888         }

   889         $result = "new";

   890 

   891         if ($generateNewResults || $resetResults) {

   892             mkpath catfile($expectedDir, dirname($base)) if $testDirectory ne $expectedDir;

   893             writeToFile("$expectedDir/$expectedFileName", $actual);

   894         }

   895         deleteExpectedAndActualResults($base);

   896         recordActualResultsAndDiff($base, $actual);

   897         if (!$resetResults) {

   898             # Always print the file name for new tests, as they will probably need some manual inspection.

   899             # in verbose mode we already printed the test case, so no need to do it again.

   900             unless ($verbose) {

   901                 print "\n" unless $atLineStart;

   902                 print "$test -> ";

   903             }

   904             my $resultsDir = catdir($expectedDir, dirname($base));

   905             if ($generateNewResults) {

   906                 print "new (results generated in $resultsDir)\n";

   907             } else {

   908                 print "new\n";

   909             }

   910             $atLineStart = 1;

   911         }

   912     } elsif ($actual eq $expected && $diffResult eq "passed") {

   913         if ($verbose) {

   914             print "succeeded\n";

   915             $atLineStart = 1;

   916         }

   917         $result = "match";

   918         deleteExpectedAndActualResults($base);

   919     } else {

   920         $result = "mismatch";

   921 

   922         my $pixelTestFailed = $pixelTests && $diffPNG && $diffPNG ne "";

   923         my $testFailed = $actual ne $expected;

   924 

   925         my $message = !$testFailed ? "pixel test failed" : "failed";

   926 

   927         if (($testFailed || $pixelTestFailed) && $addPlatformExceptions) {

   928             my $testBase = catfile($testDirectory, $base);

   929             my $expectedBase = catfile($expectedDir, $base);

   930             my $testIsMaximallyPlatformSpecific = $testBase =~ m|^\Q$platformTestDirectory\E/|;

   931             my $expectedResultIsMaximallyPlatformSpecific = $expectedBase =~ m|^\Q$platformTestDirectory\E/|;

   932             if (!$testIsMaximallyPlatformSpecific && !$expectedResultIsMaximallyPlatformSpecific) {

   933                 mkpath catfile($platformTestDirectory, dirname($base));

   934                 if ($testFailed) {

   935                     my $expectedFile = catfile($platformTestDirectory, "$expectedFileName");

   936                     writeToFile("$expectedFile", $actual);

   937                 }

   938                 if ($pixelTestFailed) {

   939                     my $expectedFile = catfile($platformTestDirectory, "$base-$expectedTag.checksum");

   940                     writeToFile("$expectedFile", $actualHash);

   941 

   942                     $expectedFile = catfile($platformTestDirectory, "$base-$expectedTag.png");

   943                     writeToFile("$expectedFile", $actualPNG);

   944                 }

   945                 $message .= " (results generated in $platformTestDirectory)";

   946             }

   947         }

   948 

   949         printFailureMessageForTest($test, $message);

   950 

   951         my $dir = "$testResultsDirectory/$base";

   952         $dir =~ s|/([^/]+)$|| or die "Failed to find test name from base\n";

   953         my $testName = $1;

   954         mkpath $dir;

   955 

   956         deleteExpectedAndActualResults($base);

   957         recordActualResultsAndDiff($base, $actual);

   958 

   959         if ($pixelTestFailed) {

   960             $imagesPresent{$base} = 1;

   961 

   962             writeToFile("$testResultsDirectory/$base-$actualTag.png", $actualPNG);

   963             writeToFile("$testResultsDirectory/$base-$diffsTag.png", $diffPNG);

   964 

   965             my $expectedPixelDir = expectedDirectoryForTest($base, 0, "png");

   966             copy("$expectedPixelDir/$base-$expectedTag.png", "$testResultsDirectory/$base-$expectedTag.png");

   967 

   968             open DIFFHTML, ">$testResultsDirectory/$base-$diffsTag.html" or die;

   969             print DIFFHTML "<html>\n";

   970             print DIFFHTML "<head>\n";

   971             print DIFFHTML "<title>$base Image Compare</title>\n";

   972             print DIFFHTML "<script language=\"Javascript\" type=\"text/javascript\">\n";

   973             print DIFFHTML "var currentImage = 0;\n";

   974             print DIFFHTML "var imageNames = new Array(\"Actual\", \"Expected\");\n";

   975             print DIFFHTML "var imagePaths = new Array(\"$testName-$actualTag.png\", \"$testName-$expectedTag.png\");\n";

   976             if (-f "$testDirectory/$base-w3c.png") {

   977                 copy("$testDirectory/$base-w3c.png", "$testResultsDirectory/$base-w3c.png");

   978                 print DIFFHTML "imageNames.push(\"W3C\");\n";

   979                 print DIFFHTML "imagePaths.push(\"$testName-w3c.png\");\n";

   980             }

   981             print DIFFHTML "function animateImage() {\n";

   982             print DIFFHTML "    var image = document.getElementById(\"animatedImage\");\n";

   983             print DIFFHTML "    var imageText = document.getElementById(\"imageText\");\n";

   984             print DIFFHTML "    image.src = imagePaths[currentImage];\n";

   985             print DIFFHTML "    imageText.innerHTML = imageNames[currentImage] + \" Image\";\n";

   986             print DIFFHTML "    currentImage = (currentImage + 1) % imageNames.length;\n";

   987             print DIFFHTML "    setTimeout('animateImage()',2000);\n";

   988             print DIFFHTML "}\n";

   989             print DIFFHTML "</script>\n";

   990             print DIFFHTML "</head>\n";

   991             print DIFFHTML "<body onLoad=\"animateImage();\">\n";

   992             print DIFFHTML "<table>\n";

   993             if ($diffPercentage) {

   994                 print DIFFHTML "<tr>\n";

   995                 print DIFFHTML "<td>Difference between images: <a href=\"$testName-$diffsTag.png\">$diffPercentage%</a></td>\n";

   996                 print DIFFHTML "</tr>\n";

   997             }

   998             print DIFFHTML "<tr>\n";

   999             print DIFFHTML "<td><a href=\"" . toURL("$testDirectory/$test") . "\">test file</a></td>\n";

  1000             print DIFFHTML "</tr>\n";

  1001             print DIFFHTML "<tr>\n";

  1002             print DIFFHTML "<td id=\"imageText\" style=\"text-weight: bold;\">Actual Image</td>\n";

  1003             print DIFFHTML "</tr>\n";

  1004             print DIFFHTML "<tr>\n";

  1005             print DIFFHTML "<td><img src=\"$testName-$actualTag.png\" id=\"animatedImage\"></td>\n";

  1006             print DIFFHTML "</tr>\n";

  1007             print DIFFHTML "</table>\n";

  1008             print DIFFHTML "</body>\n";

  1009             print DIFFHTML "</html>\n";

  1010         }

  1011     }

  1012 

  1013     if ($error) {

  1014         my $dir = "$testResultsDirectory/$base";

  1015         $dir =~ s|/([^/]+)$|| or die "Failed to find test name from base\n";

  1016         mkpath $dir;

  1017         

  1018         writeToFile("$testResultsDirectory/$base-$errorTag.txt", $error);

  1019         

  1020         $counts{error}++;

  1021         push @{$tests{error}}, $test;

  1022     }

  1023 

  1024     countFinishedTest($test, $base, $result, $isText);

  1025     last if stopRunningTestsEarlyIfNeeded();

  1026 }

  1027 

  1028 my $totalTestingTime = time - $overallStartTime;

  1029 my $waitTime = getWaitTime();

  1030 if ($waitTime > 0.1) {

  1031     my $normalizedTestingTime = $totalTestingTime - $waitTime;

  1032     printf "\n%0.2fs HTTPD waiting time\n", $waitTime . "";

  1033     printf "%0.2fs normalized testing time", $normalizedTestingTime . "";

  1034 }

  1035 printf "\n%0.2fs total testing time\n", $totalTestingTime . "";

  1036 

  1037 !$isDumpToolOpen || die "Failed to close $dumpToolName.\n";

  1038 

  1039 $isHttpdOpen = !closeHTTPD();

  1040 closeWebSocketServer();

  1041 

  1042 # Because multiple instances of this script are running concurrently we cannot 

  1043 # safely delete this symlink.

  1044 # system "rm /tmp/LayoutTests";

  1045 

  1046 # FIXME: Do we really want to check the image-comparison tool for leaks every time?

  1047 if ($isDiffToolOpen && $shouldCheckLeaks) {

  1048     $totalLeaks += countAndPrintLeaks("ImageDiff", $imageDiffToolPID, "$testResultsDirectory/ImageDiff-leaks.txt");

  1049 }

  1050 

  1051 if ($totalLeaks) {

  1052     if ($mergeDepth) {

  1053         parseLeaksandPrintUniqueLeaks();

  1054     } else { 

  1055         print "\nWARNING: $totalLeaks total leaks found!\n";

  1056         print "See above for individual leaks results.\n" if ($leaksOutputFileNumber > 2);

  1057     }

  1058 }

  1059 

  1060 close IN;

  1061 close OUT;

  1062 close ERROR;

  1063 

  1064 if ($report10Slowest) {

  1065     print "\n\nThe 10 slowest tests:\n\n";

  1066     my $count = 0;

  1067     for my $test (sort slowestcmp keys %durations) {

  1068         printf "%0.2f secs: %s\n", $durations{$test}, $test;

  1069         last if ++$count == 10;

  1070     }

  1071 }

  1072 

  1073 print "\n";

  1074 

  1075 if ($skippedOnly && $counts{"match"}) {

  1076     print "The following tests are in the Skipped file (" . File::Spec->abs2rel("$platformTestDirectory/Skipped", $testDirectory) . "), but succeeded:\n";

  1077     foreach my $test (@{$tests{"match"}}) {

  1078         print "  $test\n";

  1079     }

  1080 }

  1081 

  1082 if ($resetResults || ($counts{match} && $counts{match} == $count)) {

  1083     print "all $count test cases succeeded\n";

  1084     unlink $testResults;

  1085     exit;

  1086 }

  1087 

  1088 printResults();

  1089 

  1090 mkpath $testResultsDirectory;

  1091 

  1092 open HTML, ">", $testResults or die "Failed to open $testResults. $!";

  1093 print HTML "<html>\n";

  1094 print HTML "<head>\n";

  1095 print HTML "<title>Layout Test Results</title>\n";

  1096 print HTML "</head>\n";

  1097 print HTML "<body>\n";

  1098 

  1099 if ($ignoreMetrics) {

  1100     print HTML "<h4>Tested with metrics ignored.</h4>";

  1101 }

  1102 

  1103 print HTML htmlForResultsSection(@{$tests{mismatch}}, "Tests where results did not match expected results", \&linksForMismatchTest);

  1104 print HTML htmlForResultsSection(@{$tests{timedout}}, "Tests that timed out", \&linksForErrorTest);

  1105 print HTML htmlForResultsSection(@{$tests{crash}}, "Tests that caused the DumpRenderTree tool to crash", \&linksForErrorTest);

  1106 print HTML htmlForResultsSection(@{$tests{error}}, "Tests that had stderr output", \&linksForErrorTest);

  1107 print HTML htmlForResultsSection(@{$tests{new}}, "Tests that had no expected results (probably new)", \&linksForNewTest);

  1108 

  1109 print HTML "</body>\n";

  1110 print HTML "</html>\n";

  1111 close HTML;

  1112 

  1113 my @configurationArgs = argumentsForConfiguration();

  1114 

  1115 if (isGtk()) {

  1116   system "WebKitTools/Scripts/run-launcher", @configurationArgs, "file://".$testResults if $launchSafari;

  1117 } elsif (isQt()) {

  1118   unshift @configurationArgs, qw(-graphicssystem raster -style windows);

  1119   if (isCygwin()) {

  1120     $testResults = "/" . toWindowsPath($testResults);

  1121     $testResults =~ s/\\/\//g;

  1122   }

  1123   system "WebKitTools/Scripts/run-launcher", @configurationArgs, "file://".$testResults if $launchSafari;

  1124 } elsif (isCygwin()) {

  1125   system "cygstart", $testResults if $launchSafari;

  1126 } else {

  1127   system "WebKitTools/Scripts/run-safari", @configurationArgs, "-NSOpen", $testResults if $launchSafari;

  1128 }

  1129 

  1130 closeCygpaths() if isCygwin();

  1131 

  1132 exit 1;

  1133 

  1134 sub countAndPrintLeaks($$$)

  1135 {