Unreviewed build fix for WebInspector with Qt build.
[WebKit-https.git] / WebKitTools / Scripts / run-webkit-tests
1 #!/usr/bin/perl
2
3 # Copyright (C) 2005, 2006, 2007, 2008, 2009 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, .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 FindBin;
62 use Getopt::Long;
63 use IPC::Open2;
64 use IPC::Open3;
65 use Time::HiRes qw(time usleep);
66
67 use List::Util 'shuffle';
68
69 use lib $FindBin::Bin;
70 use webkitdirs;
71 use VCSUtils;
72 use POSIX;
73
74 sub buildPlatformResultHierarchy();
75 sub buildPlatformTestHierarchy(@);
76 sub closeCygpaths();
77 sub closeDumpTool();
78 sub closeHTTPD();
79 sub countAndPrintLeaks($$$);
80 sub countFinishedTest($$$$);
81 sub deleteExpectedAndActualResults($);
82 sub dumpToolDidCrash();
83 sub epiloguesAndPrologues($$);
84 sub expectedDirectoryForTest($;$;$);
85 sub fileNameWithNumber($$);
86 sub htmlForResultsSection(\@$&);
87 sub isTextOnlyTest($);
88 sub launchWithCurrentEnv(@);
89 sub numericcmp($$);
90 sub openDiffTool();
91 sub openDumpTool();
92 sub openHTTPDIfNeeded();
93 sub parseLeaksandPrintUniqueLeaks();
94 sub pathcmp($$);
95 sub printFailureMessageForTest($$);
96 sub processIgnoreTests($$);
97 sub readFromDumpToolWithTimer(**);
98 sub recordActualResultsAndDiff($$);
99 sub sampleDumpTool();
100 sub setFileHandleNonBlocking(*$);
101 sub slowestcmp($$);
102 sub splitpath($);
103 sub stripExtension($);
104 sub stripMetrics($$);
105 sub testCrashedOrTimedOut($$$$$);
106 sub toURL($);
107 sub toWindowsPath($);
108 sub validateSkippedArg($$;$);
109 sub writeToFile($$);
110
111 # Argument handling
112 my $addPlatformExceptions = 0;
113 my $complexText = 0;
114 my $exitAfterNFailures = 0;
115 my $generateNewResults = isAppleMacWebKit() ? 1 : 0;
116 my $guardMalloc = '';
117 my $httpdPort = 8000;
118 my $httpdSSLPort = 8443;
119 my $ignoreMetrics = 0;
120 my $ignoreTests = '';
121 my $iterations = 1;
122 my $launchSafari = 1;
123 my $mergeDepth;
124 my $pixelTests = '';
125 my $platform;
126 my $quiet = '';
127 my $randomizeTests = 0;
128 my $repeatEach = 1;
129 my $report10Slowest = 0;
130 my $resetResults = 0;
131 my $reverseTests = 0;
132 my $root;
133 my $runSample = 1;
134 my $shouldCheckLeaks = 0;
135 my $showHelp = 0;
136 my $stripEditingCallbacks = isCygwin();
137 my $testHTTP = 1;
138 my $testMedia = 1;
139 my $testResultsDirectory = "/tmp/layout-test-results";
140 my $testsPerDumpTool = 1000;
141 my $threaded = 0;
142 # DumpRenderTree has an internal timeout of 15 seconds, so this must be > 15.
143 my $timeoutSeconds = 20;
144 my $tolerance = 0;
145 my $treatSkipped = "default";
146 my $useRemoteLinksToTests = 0;
147 my $useValgrind = 0;
148 my $verbose = 0;
149
150 my @leaksFilenames;
151
152 # Default to --no-http for wx for now.
153 $testHTTP = 0 if (isWx());
154
155 my $expectedTag = "expected";
156 my $actualTag = "actual";
157 my $prettyDiffTag = "pretty-diff";
158 my $diffsTag = "diffs";
159 my $errorTag = "stderr";
160
161 my @macPlatforms = ("mac-tiger", "mac-leopard", "mac-snowleopard", "mac");
162
163 if (isAppleMacWebKit()) {
164     if (isTiger()) {
165         $platform = "mac-tiger";
166         $tolerance = 1.0;
167     } elsif (isLeopard()) {
168         $platform = "mac-leopard";
169         $tolerance = 0.1;
170     } elsif (isSnowLeopard()) {
171         $platform = "mac-snowleopard";
172         $tolerance = 0.1;
173     } else {
174         $platform = "mac";
175     }
176 } elsif (isQt()) {
177     if (isDarwin()) {
178         $platform = "qt-mac";
179     } elsif (isLinux()) {
180         $platform = "qt-linux";
181     } elsif (isWindows() || isCygwin()) {
182         $platform = "qt-win";
183     } else {
184         $platform = "qt";
185     }
186 } elsif (isGtk()) {
187     $platform = "gtk";
188 } elsif (isWx()) {
189     $platform = "wx";
190 } elsif (isCygwin()) {
191     $platform = "win";
192 }
193
194 if (!defined($platform)) {
195     print "WARNING: Your platform is not recognized. Any platform-specific results will be generated in platform/undefined.\n";
196     $platform = "undefined";
197 }
198
199 my $programName = basename($0);
200 my $launchSafariDefault = $launchSafari ? "launch" : "do not launch";
201 my $httpDefault = $testHTTP ? "run" : "do not run";
202 my $sampleDefault = $runSample ? "run" : "do not run";
203
204 my $usage = <<EOF;
205 Usage: $programName [options] [testdir|testpath ...]
206   --add-platform-exceptions       Put new results for non-platform-specific failing tests into the platform-specific results directory
207   --complex-text                  Use the complex text code path for all text (Mac OS X and Windows only)
208   -c|--configuration config       Set DumpRenderTree build configuration
209   -g|--guard-malloc               Enable malloc guard
210   --exit-after-n-failures N       Exit after the first N failures instead of running all tests
211   -h|--help                       Show this help message
212   --[no-]http                     Run (or do not run) http tests (default: $httpDefault)
213   -i|--ignore-tests               Comma-separated list of directories or tests to ignore
214   --iterations n                  Number of times to run the set of tests (e.g. ABCABCABC)
215   --[no-]launch-safari            Launch (or do not launch) Safari to display test results (default: $launchSafariDefault)
216   -l|--leaks                      Enable leaks checking
217   --[no-]new-test-results         Generate results for new tests
218   --nthly n                       Restart DumpRenderTree every n tests (default: $testsPerDumpTool)
219   -p|--pixel-tests                Enable pixel tests
220   --tolerance t                   Ignore image differences less than this percentage (default: $tolerance)
221   --platform                      Override the detected platform to use for tests and results (default: $platform)
222   --port                          Web server port to use with http tests
223   -q|--quiet                      Less verbose output
224   --reset-results                 Reset ALL results (including pixel tests if --pixel-tests is set)
225   -o|--results-directory          Output results directory (default: $testResultsDirectory)
226   --random                        Run the tests in a random order
227   --repeat-each n                 Number of times to run each test (e.g. AAABBBCCC)
228   --reverse                       Run the tests in reverse alphabetical order
229   --root                          Path to root tools build
230   --[no-]sample-on-timeout        Run sample on timeout (default: $sampleDefault) (Mac OS X only)
231   -1|--singly                     Isolate each test case run (implies --nthly 1 --verbose)
232   --skipped=[default|ignore|only] Specifies how to treat the Skipped file
233                                      default: Tests/directories listed in the Skipped file are not tested
234                                      ignore:  The Skipped file is ignored
235                                      only:    Only those tests/directories listed in the Skipped file will be run
236   --slowest                       Report the 10 slowest tests
237   --ignore-metrics                Ignore metrics in tests
238   --[no-]strip-editing-callbacks  Remove editing callbacks from expected results
239   -t|--threaded                   Run a concurrent JavaScript thead with each test
240   --timeout t                     Sets the number of seconds before a test times out (default: $timeoutSeconds)
241   --valgrind                      Run DumpRenderTree inside valgrind (Qt/Linux only)
242   -v|--verbose                    More verbose output (overrides --quiet)
243   -m|--merge-leak-depth arg       Merges leak callStacks and prints the number of unique leaks beneath a callstack depth of arg.  Defaults to 5.
244   --use-remote-links-to-tests     Link to test files within the SVN repository in the results.
245 EOF
246
247 setConfiguration();
248
249 my $getOptionsResult = GetOptions(
250     'add-platform-exceptions' => \$addPlatformExceptions,
251     'complex-text' => \$complexText,
252     'exit-after-n-failures=i' => \$exitAfterNFailures,
253     'guard-malloc|g' => \$guardMalloc,
254     'help|h' => \$showHelp,
255     'http!' => \$testHTTP,
256     'ignore-metrics!' => \$ignoreMetrics,
257     'ignore-tests|i=s' => \$ignoreTests,
258     'iterations=i' => \$iterations,
259     'launch-safari!' => \$launchSafari,
260     'leaks|l' => \$shouldCheckLeaks,
261     'merge-leak-depth|m:5' => \$mergeDepth,
262     'new-test-results!' => \$generateNewResults,
263     'nthly=i' => \$testsPerDumpTool,
264     'pixel-tests|p' => \$pixelTests,
265     'platform=s' => \$platform,
266     'port=i' => \$httpdPort,
267     'quiet|q' => \$quiet,
268     'random' => \$randomizeTests,
269     'repeat-each=i' => \$repeatEach,
270     'reset-results' => \$resetResults,
271     'results-directory|o=s' => \$testResultsDirectory,
272     'reverse' => \$reverseTests,
273     'root=s' => \$root,
274     'sample-on-timeout!' => \$runSample,
275     'singly|1' => sub { $testsPerDumpTool = 1; },
276     'skipped=s' => \&validateSkippedArg,
277     'slowest' => \$report10Slowest,
278     'strip-editing-callbacks!' => \$stripEditingCallbacks,
279     'threaded|t' => \$threaded,
280     'timeout=i' => \$timeoutSeconds,
281     'tolerance=f' => \$tolerance,
282     'use-remote-links-to-tests' => \$useRemoteLinksToTests,
283     'valgrind' => \$useValgrind,
284     'verbose|v' => \$verbose,
285 );
286
287 if (!$getOptionsResult || $showHelp) {
288     print STDERR $usage;
289     exit 1;
290 }
291
292 my $ignoreSkipped = $treatSkipped eq "ignore";
293 my $skippedOnly = $treatSkipped eq "only";
294
295 !$skippedOnly || @ARGV == 0 or die "--skipped=only cannot be used when tests are specified on the command line.";
296
297 my $configuration = configuration();
298
299 $verbose = 1 if $testsPerDumpTool == 1;
300
301 if ($shouldCheckLeaks && $testsPerDumpTool > 1000) {
302     print STDERR "\nWARNING: Running more than 1000 tests at a time with MallocStackLogging enabled may cause a crash.\n\n";
303 }
304
305 # Stack logging does not play well with QuickTime on Tiger (rdar://problem/5537157)
306 $testMedia = 0 if $shouldCheckLeaks && isTiger();
307
308 # Generating remote links causes a lot of unnecessary spew on GTK build bot
309 $useRemoteLinksToTests = 0 if isGtk();
310
311 setConfigurationProductDir(Cwd::abs_path($root)) if (defined($root));
312 my $productDir = productDir();
313 $productDir .= "/bin" if isQt();
314 $productDir .= "/Programs" if isGtk();
315
316 chdirWebKit();
317
318 if (!defined($root)) {
319     print STDERR "Running build-dumprendertree\n";
320
321     local *DEVNULL;
322     my ($childIn, $childOut, $childErr);
323     if ($quiet) {
324         open(DEVNULL, ">", File::Spec->devnull()) or die "Failed to open /dev/null";
325         $childOut = ">&DEVNULL";
326         $childErr = ">&DEVNULL";
327     } else {
328         # When not quiet, let the child use our stdout/stderr.
329         $childOut = ">&STDOUT";
330         $childErr = ">&STDERR";
331     }
332
333     my @args = argumentsForConfiguration();
334     my $buildProcess = open3($childIn, $childOut, $childErr, "WebKitTools/Scripts/build-dumprendertree", @args) or die "Failed to run build-dumprendertree";
335     close($childIn);
336     waitpid $buildProcess, 0;
337     my $buildResult = $?;
338     close($childOut);
339     close($childErr);
340
341     close DEVNULL if ($quiet);
342
343     if ($buildResult) {
344         print STDERR "Compiling DumpRenderTree failed!\n";
345         exit exitStatus($buildResult);
346     }
347 }
348
349 my $dumpToolName = "DumpRenderTree";
350 $dumpToolName .= "_debug" if isCygwin() && $configuration ne "Release";
351 my $dumpTool = "$productDir/$dumpToolName";
352 die "can't find executable $dumpToolName (looked in $productDir)\n" unless -x $dumpTool;
353
354 my $imageDiffTool = "$productDir/ImageDiff";
355 $imageDiffTool .= "_debug" if isCygwin() && $configuration ne "Release";
356 die "can't find executable $imageDiffTool (looked in $productDir)\n" if $pixelTests && !-x $imageDiffTool;
357
358 checkFrameworks() unless isCygwin();
359
360 if (isAppleMacWebKit()) {
361     push @INC, $productDir;
362     require DumpRenderTreeSupport;
363 }
364
365 my $layoutTestsName = "LayoutTests";
366 my $testDirectory = File::Spec->rel2abs($layoutTestsName);
367 my $expectedDirectory = $testDirectory;
368 my $platformBaseDirectory = catdir($testDirectory, "platform");
369 my $platformTestDirectory = catdir($platformBaseDirectory, $platform);
370 my @platformResultHierarchy = buildPlatformResultHierarchy();
371 my @platformTestHierarchy = buildPlatformTestHierarchy(@platformResultHierarchy);
372
373 $expectedDirectory = $ENV{"WebKitExpectedTestResultsDirectory"} if $ENV{"WebKitExpectedTestResultsDirectory"};
374
375 my $testResults = catfile($testResultsDirectory, "results.html");
376
377 print "Running tests from $testDirectory\n";
378 if ($pixelTests) {
379     print "Enabling pixel tests with a tolerance of $tolerance%\n";
380     if (isDarwin()) {
381         print "WARNING: Temporarily changing the main display color profile:\n";
382         print "\tThe colors on your screen will change for the duration of the testing.\n";
383         print "\tThis allows the pixel tests to have consistent color values across all machines.\n";
384         
385         if (isPerianInstalled()) {
386             print "WARNING: Perian's QuickTime component is installed and this may affect pixel test results!\n";
387             print "\tYou should avoid generating new pixel results in this environment.\n";
388             print "\tSee https://bugs.webkit.org/show_bug.cgi?id=22615 for details.\n";
389         }
390     }
391 }
392
393 system "ln", "-s", $testDirectory, "/tmp/LayoutTests" unless -x "/tmp/LayoutTests";
394
395 my %ignoredFiles = ( "results.html" => 1 );
396 my %ignoredDirectories = map { $_ => 1 } qw(platform);
397 my %ignoredLocalDirectories = map { $_ => 1 } qw(.svn _svn resources script-tests);
398 my %supportedFileExtensions = map { $_ => 1 } qw(html shtml xml xhtml pl php);
399
400 if (!checkWebCoreMathMLSupport(0)) { 
401     $ignoredDirectories{'mathml'} = 1;
402 }
403
404 # FIXME: We should fix webkitdirs.pm:hasSVG/WMLSupport() to do the correct feature detection for Cygwin.
405 if (checkWebCoreSVGSupport(0)) { 
406     $supportedFileExtensions{'svg'} = 1;
407 } elsif (isCygwin()) {
408     $supportedFileExtensions{'svg'} = 1;
409 } else {
410     $ignoredLocalDirectories{'svg'} = 1;
411 }
412
413 if (!$testHTTP) {
414     $ignoredDirectories{'http'} = 1;
415 }
416
417 if (!$testMedia) {
418     $ignoredDirectories{'media'} = 1;
419     $ignoredDirectories{'http/tests/media'} = 1;
420 }
421
422 if (!checkWebCoreAcceleratedCompositingSupport(0)) {
423     $ignoredDirectories{'compositing'} = 1;
424 }
425
426 if (!checkWebCore3DRenderingSupport(0)) {
427     $ignoredDirectories{'animations/3d'} = 1;
428     $ignoredDirectories{'transforms/3d'} = 1;
429 }
430
431 if (!checkWebCore3DCanvasSupport(0)) {
432     $ignoredDirectories{'fast/canvas/webgl'} = 1;
433 }
434
435 if (checkWebCoreWMLSupport(0)) { 
436     $supportedFileExtensions{'wml'} = 1;
437 } else {
438     $ignoredDirectories{'http/tests/wml'} = 1;
439     $ignoredDirectories{'fast/wml'} = 1;
440     $ignoredDirectories{'wml'} = 1;
441 }
442
443 if (!checkWebCoreXHTMLMPSupport(0)) {
444     $ignoredDirectories{'fast/xhtmlmp'} = 1;
445 }
446
447 if (!checkWebCoreWCSSSupport(0)) {
448     $ignoredDirectories{'fast/wcss'} = 1;
449 }
450
451 processIgnoreTests($ignoreTests, "ignore-tests") if $ignoreTests;
452 readSkippedFiles() unless $ignoreSkipped;
453
454 my @tests = findTestsToRun();
455
456 die "no tests to run\n" if !@tests;
457
458 my %counts;
459 my %tests;
460 my %imagesPresent;
461 my %imageDifferences;
462 my %durations;
463 my $count = 0;
464 my $leaksOutputFileNumber = 1;
465 my $totalLeaks = 0;
466
467 my @toolArgs = ();
468 push @toolArgs, "--pixel-tests" if $pixelTests;
469 push @toolArgs, "--threaded" if $threaded;
470 push @toolArgs, "--complex-text" if $complexText;
471 push @toolArgs, "-";
472
473 my @diffToolArgs = ();
474 push @diffToolArgs, "--tolerance", $tolerance;
475
476 $| = 1;
477
478 my $dumpToolPID;
479 my $isDumpToolOpen = 0;
480 my $dumpToolCrashed = 0;
481 my $imageDiffToolPID;
482 my $isDiffToolOpen = 0;
483
484 my $atLineStart = 1;
485 my $lastDirectory = "";
486
487 my $isHttpdOpen = 0;
488
489 sub catch_pipe { $dumpToolCrashed = 1; }
490 $SIG{"PIPE"} = "catch_pipe";
491
492 print "Testing ", scalar @tests, " test cases";
493 print " $iterations times" if ($iterations > 1);
494 print ", repeating each test $repeatEach times" if ($repeatEach > 1);
495 print ".\n";
496
497 my $overallStartTime = time;
498
499 my %expectedResultPaths;
500
501 my @originalTests = @tests;
502 # Add individual test repetitions
503 if ($repeatEach > 1) {
504     @tests = ();
505     foreach my $test (@originalTests) {
506         for (my $i = 0; $i < $repeatEach; $i++) {
507             push(@tests, $test);
508         }
509     }
510 }
511 # Add test set repetitions
512 for (my $i = 1; $i < $iterations; $i++) {
513     push(@tests, @originalTests);
514 }
515
516 for my $test (@tests) {
517     my $newDumpTool = not $isDumpToolOpen;
518     openDumpTool();
519
520     my $base = stripExtension($test);
521     my $expectedExtension = ".txt";
522     
523     my $dir = $base;
524     $dir =~ s|/[^/]+$||;
525
526     if ($newDumpTool || $dir ne $lastDirectory) {
527         foreach my $logue (epiloguesAndPrologues($newDumpTool ? "" : $lastDirectory, $dir)) {
528             if (isCygwin()) {
529                 $logue = toWindowsPath($logue);
530             } else {
531                 $logue = canonpath($logue);
532             }
533             if ($verbose) {
534                 print "running epilogue or prologue $logue\n";
535             }
536             print OUT "$logue\n";
537             # Throw away output from DumpRenderTree.
538             # Once for the test output and once for pixel results (empty)
539             while (<IN>) {
540                 last if /#EOF/;
541             }
542             while (<IN>) {
543                 last if /#EOF/;
544             }
545         }
546     }
547
548     if ($verbose) {
549         print "running $test -> ";
550         $atLineStart = 0;
551     } elsif (!$quiet) {
552         if ($dir ne $lastDirectory) {
553             print "\n" unless $atLineStart;
554             print "$dir ";
555         }
556         print ".";
557         $atLineStart = 0;
558     }
559
560     $lastDirectory = $dir;
561
562     my $result;
563
564     my $startTime = time if $report10Slowest;
565
566     # Try to read expected hash file for pixel tests
567     my $suffixExpectedHash = "";
568     if ($pixelTests && !$resetResults) {
569         my $expectedPixelDir = expectedDirectoryForTest($base, 0, "png");
570         if (open EXPECTEDHASH, "$expectedPixelDir/$base-$expectedTag.checksum") {
571             my $expectedHash = <EXPECTEDHASH>;
572             chomp($expectedHash);
573             close EXPECTEDHASH;
574             
575             # Format expected hash into a suffix string that is appended to the path / URL passed to DRT
576             $suffixExpectedHash = "'$expectedHash";
577         }
578     }
579
580     if ($test !~ /^http\//) {
581         my $testPath = "$testDirectory/$test";
582         if (isCygwin()) {
583             $testPath = toWindowsPath($testPath);
584         } else {
585             $testPath = canonpath($testPath);
586         }
587         print OUT "$testPath$suffixExpectedHash\n";
588     } else {
589         openHTTPDIfNeeded();
590         if ($test !~ /^http\/tests\/local\// && $test !~ /^http\/tests\/ssl\// && $test !~ /^http\/tests\/wml\// && $test !~ /^http\/tests\/media\//) {
591             my $path = canonpath($test);
592             $path =~ s/^http\/tests\///;
593             print OUT "http://127.0.0.1:$httpdPort/$path$suffixExpectedHash\n";
594         } elsif ($test =~ /^http\/tests\/ssl\//) {
595             my $path = canonpath($test);
596             $path =~ s/^http\/tests\///;
597             print OUT "https://127.0.0.1:$httpdSSLPort/$path$suffixExpectedHash\n";
598         } else {
599             my $testPath = "$testDirectory/$test";
600             if (isCygwin()) {
601                 $testPath = toWindowsPath($testPath);
602             } else {
603                 $testPath = canonpath($testPath);
604             }
605             print OUT "$testPath$suffixExpectedHash\n";
606         }
607     }
608
609     # DumpRenderTree is expected to dump two "blocks" to stdout for each test.
610     # Each block is terminated by a #EOF on a line by itself.
611     # The first block is the output of the test (in text, RenderTree or other formats).
612     # The second block is for optional pixel data in PNG format, and may be empty if
613     # pixel tests are not being run, or the test does not dump pixels (e.g. text tests).
614     my $readResults = readFromDumpToolWithTimer(IN, ERROR);
615
616     my $actual = $readResults->{output};
617     my $error = $readResults->{error};
618
619     $expectedExtension = $readResults->{extension};
620     my $expectedFileName = "$base-$expectedTag.$expectedExtension";
621
622     my $isText = isTextOnlyTest($actual);
623
624     my $expectedDir = expectedDirectoryForTest($base, $isText, $expectedExtension);
625     $expectedResultPaths{$base} = "$expectedDir/$expectedFileName";
626
627     unless ($readResults->{status} eq "success") {
628         my $crashed = $readResults->{status} eq "crashed";
629         testCrashedOrTimedOut($test, $base, $crashed, $actual, $error);
630         countFinishedTest($test, $base, $crashed ? "crash" : "timedout", 0);
631         next;
632     }
633
634     $durations{$test} = time - $startTime if $report10Slowest;
635
636     my $expected;
637
638     if (!$resetResults && open EXPECTED, "<", "$expectedDir/$expectedFileName") {
639         $expected = "";
640         while (<EXPECTED>) {
641             next if $stripEditingCallbacks && $_ =~ /^EDITING DELEGATE:/;
642             $expected .= $_;
643         }
644         close EXPECTED;
645     }
646
647     if ($ignoreMetrics && !$isText && defined $expected) {
648         ($actual, $expected) = stripMetrics($actual, $expected);
649     }
650
651     if ($shouldCheckLeaks && $testsPerDumpTool == 1) {
652         print "        $test -> ";
653     }
654
655     my $actualPNG = "";
656     my $diffPNG = "";
657     my $diffPercentage = "";
658     my $diffResult = "passed";
659
660     my $actualHash = "";
661     my $expectedHash = "";
662     my $actualPNGSize = 0;
663
664     while (<IN>) {
665         last if /#EOF/;
666         if (/ActualHash: ([a-f0-9]{32})/) {
667             $actualHash = $1;
668         } elsif (/ExpectedHash: ([a-f0-9]{32})/) {
669             $expectedHash = $1;
670         } elsif (/Content-Length: (\d+)\s*/) {
671             $actualPNGSize = $1;
672             read(IN, $actualPNG, $actualPNGSize);
673         }
674     }
675
676     if ($verbose && $pixelTests && !$resetResults && $actualPNGSize) {
677         if ($actualHash eq "" && $expectedHash eq "") {
678             printFailureMessageForTest($test, "WARNING: actual & expected pixel hashes are missing!");
679         } elsif ($actualHash eq "") {
680             printFailureMessageForTest($test, "WARNING: actual pixel hash is missing!");
681         } elsif ($expectedHash eq "") {
682             printFailureMessageForTest($test, "WARNING: expected pixel hash is missing!");
683         }
684     }
685
686     if ($actualPNGSize > 0) {
687         my $expectedPixelDir = expectedDirectoryForTest($base, 0, "png");
688
689         if (!$resetResults && ($expectedHash ne $actualHash || ($actualHash eq "" && $expectedHash eq ""))) {
690             if (-f "$expectedPixelDir/$base-$expectedTag.png") {
691                 my $expectedPNGSize = -s "$expectedPixelDir/$base-$expectedTag.png";
692                 my $expectedPNG = "";
693                 open EXPECTEDPNG, "$expectedPixelDir/$base-$expectedTag.png";
694                 read(EXPECTEDPNG, $expectedPNG, $expectedPNGSize);
695
696                 openDiffTool();
697                 print DIFFOUT "Content-Length: $actualPNGSize\n";
698                 print DIFFOUT $actualPNG;
699
700                 print DIFFOUT "Content-Length: $expectedPNGSize\n";
701                 print DIFFOUT $expectedPNG;
702
703                 while (<DIFFIN>) {
704                     last if /^error/ || /^diff:/;
705                     if (/Content-Length: (\d+)\s*/) {
706                         read(DIFFIN, $diffPNG, $1);
707                     }
708                 }
709
710                 if (/^diff: (.+)% (passed|failed)/) {
711                     $diffPercentage = $1;
712                     $imageDifferences{$base} = $diffPercentage;
713                     $diffResult = $2;
714                 }
715                 
716                 if ($diffPercentage == 0) {
717                     printFailureMessageForTest($test, "pixel hash failed (but pixel test still passes)");
718                 }
719             } elsif ($verbose) {
720                 printFailureMessageForTest($test, "WARNING: expected image is missing!");
721             }
722         }
723
724         if ($resetResults || !-f "$expectedPixelDir/$base-$expectedTag.png") {
725             mkpath catfile($expectedPixelDir, dirname($base)) if $testDirectory ne $expectedPixelDir;
726             writeToFile("$expectedPixelDir/$base-$expectedTag.png", $actualPNG);
727         }
728
729         if ($actualHash ne "" && ($resetResults || !-f "$expectedPixelDir/$base-$expectedTag.checksum")) {
730             writeToFile("$expectedPixelDir/$base-$expectedTag.checksum", $actualHash);
731         }
732     }
733
734     if (dumpToolDidCrash()) {
735         $result = "crash";
736         testCrashedOrTimedOut($test, $base, 1, $actual, $error);
737     } elsif (!defined $expected) {
738         if ($verbose) {
739             print "new " . ($resetResults ? "result" : "test") ."\n";
740             $atLineStart = 1;
741         }
742         $result = "new";
743
744         if ($generateNewResults || $resetResults) {
745             mkpath catfile($expectedDir, dirname($base)) if $testDirectory ne $expectedDir;
746             writeToFile("$expectedDir/$expectedFileName", $actual);
747         }
748         deleteExpectedAndActualResults($base);
749         recordActualResultsAndDiff($base, $actual);
750         if (!$resetResults) {
751             # Always print the file name for new tests, as they will probably need some manual inspection.
752             # in verbose mode we already printed the test case, so no need to do it again.
753             unless ($verbose) {
754                 print "\n" unless $atLineStart;
755                 print "$test -> ";
756             }
757             my $resultsDir = catdir($expectedDir, dirname($base));
758             if ($generateNewResults) {
759                 print "new (results generated in $resultsDir)\n";
760             } else {
761                 print "new\n";
762             }
763             $atLineStart = 1;
764         }
765     } elsif ($actual eq $expected && $diffResult eq "passed") {
766         if ($verbose) {
767             print "succeeded\n";
768             $atLineStart = 1;
769         }
770         $result = "match";
771         deleteExpectedAndActualResults($base);
772     } else {
773         $result = "mismatch";
774
775         my $pixelTestFailed = $pixelTests && $diffPNG && $diffPNG ne "";
776         my $testFailed = $actual ne $expected;
777
778         my $message = !$testFailed ? "pixel test failed" : "failed";
779
780         if (($testFailed || $pixelTestFailed) && $addPlatformExceptions) {
781             my $testBase = catfile($testDirectory, $base);
782             my $expectedBase = catfile($expectedDir, $base);
783             my $testIsMaximallyPlatformSpecific = $testBase =~ m|^\Q$platformTestDirectory\E/|;
784             my $expectedResultIsMaximallyPlatformSpecific = $expectedBase =~ m|^\Q$platformTestDirectory\E/|;
785             if (!$testIsMaximallyPlatformSpecific && !$expectedResultIsMaximallyPlatformSpecific) {
786                 mkpath catfile($platformTestDirectory, dirname($base));
787                 if ($testFailed) {
788                     my $expectedFile = catfile($platformTestDirectory, "$expectedFileName");
789                     writeToFile("$expectedFile", $actual);
790                 }
791                 if ($pixelTestFailed) {
792                     my $expectedFile = catfile($platformTestDirectory, "$base-$expectedTag.checksum");
793                     writeToFile("$expectedFile", $actualHash);
794
795                     $expectedFile = catfile($platformTestDirectory, "$base-$expectedTag.png");
796                     writeToFile("$expectedFile", $actualPNG);
797                 }
798                 $message .= " (results generated in $platformTestDirectory)";
799             }
800         }
801
802         printFailureMessageForTest($test, $message);
803
804         my $dir = "$testResultsDirectory/$base";
805         $dir =~ s|/([^/]+)$|| or die "Failed to find test name from base\n";
806         my $testName = $1;
807         mkpath $dir;
808
809         deleteExpectedAndActualResults($base);
810         recordActualResultsAndDiff($base, $actual);
811
812         if ($pixelTestFailed) {
813             $imagesPresent{$base} = 1;
814
815             writeToFile("$testResultsDirectory/$base-$actualTag.png", $actualPNG);
816             writeToFile("$testResultsDirectory/$base-$diffsTag.png", $diffPNG);
817
818             my $expectedPixelDir = expectedDirectoryForTest($base, 0, "png");
819             copy("$expectedPixelDir/$base-$expectedTag.png", "$testResultsDirectory/$base-$expectedTag.png");
820
821             open DIFFHTML, ">$testResultsDirectory/$base-$diffsTag.html" or die;
822             print DIFFHTML "<html>\n";
823             print DIFFHTML "<head>\n";
824             print DIFFHTML "<title>$base Image Compare</title>\n";
825             print DIFFHTML "<script language=\"Javascript\" type=\"text/javascript\">\n";
826             print DIFFHTML "var currentImage = 0;\n";
827             print DIFFHTML "var imageNames = new Array(\"Actual\", \"Expected\");\n";
828             print DIFFHTML "var imagePaths = new Array(\"$testName-$actualTag.png\", \"$testName-$expectedTag.png\");\n";
829             if (-f "$testDirectory/$base-w3c.png") {
830                 copy("$testDirectory/$base-w3c.png", "$testResultsDirectory/$base-w3c.png");
831                 print DIFFHTML "imageNames.push(\"W3C\");\n";
832                 print DIFFHTML "imagePaths.push(\"$testName-w3c.png\");\n";
833             }
834             print DIFFHTML "function animateImage() {\n";
835             print DIFFHTML "    var image = document.getElementById(\"animatedImage\");\n";
836             print DIFFHTML "    var imageText = document.getElementById(\"imageText\");\n";
837             print DIFFHTML "    image.src = imagePaths[currentImage];\n";
838             print DIFFHTML "    imageText.innerHTML = imageNames[currentImage] + \" Image\";\n";
839             print DIFFHTML "    currentImage = (currentImage + 1) % imageNames.length;\n";
840             print DIFFHTML "    setTimeout('animateImage()',2000);\n";
841             print DIFFHTML "}\n";
842             print DIFFHTML "</script>\n";
843             print DIFFHTML "</head>\n";
844             print DIFFHTML "<body onLoad=\"animateImage();\">\n";
845             print DIFFHTML "<table>\n";
846             if ($diffPercentage) {
847                 print DIFFHTML "<tr>\n";
848                 print DIFFHTML "<td>Difference between images: <a href=\"$testName-$diffsTag.png\">$diffPercentage%</a></td>\n";
849                 print DIFFHTML "</tr>\n";
850             }
851             print DIFFHTML "<tr>\n";
852             print DIFFHTML "<td><a href=\"" . toURL("$testDirectory/$test") . "\">test file</a></td>\n";
853             print DIFFHTML "</tr>\n";
854             print DIFFHTML "<tr>\n";
855             print DIFFHTML "<td id=\"imageText\" style=\"text-weight: bold;\">Actual Image</td>\n";
856             print DIFFHTML "</tr>\n";
857             print DIFFHTML "<tr>\n";
858             print DIFFHTML "<td><img src=\"$testName-$actualTag.png\" id=\"animatedImage\"></td>\n";
859             print DIFFHTML "</tr>\n";
860             print DIFFHTML "</table>\n";
861             print DIFFHTML "</body>\n";
862             print DIFFHTML "</html>\n";
863         }
864     }
865
866     if ($error) {
867         my $dir = "$testResultsDirectory/$base";
868         $dir =~ s|/([^/]+)$|| or die "Failed to find test name from base\n";
869         mkpath $dir;
870         
871         writeToFile("$testResultsDirectory/$base-$errorTag.txt", $error);
872         
873         $counts{error}++;
874         push @{$tests{error}}, $test;
875     }
876
877     countFinishedTest($test, $base, $result, $isText);
878
879     # --reset-results does not check pass vs. fail, so exitAfterNFailures makes no sense with --reset-results.
880     if ($exitAfterNFailures && !$resetResults) {
881         my $passCount = $counts{match} || 0; # $counts{match} will be undefined if we've not yet passed a test (e.g. the first test fails).
882         my $failureCount = $count - $passCount; # "Failure" here includes new tests, timeouts, crashes, etc.
883         if ($failureCount >= $exitAfterNFailures) {
884             print "\nExiting early after $failureCount failures. $count tests run.";
885             closeDumpTool();
886             last;
887         }
888     }
889 }
890 printf "\n%0.2fs total testing time\n", (time - $overallStartTime) . "";
891
892 !$isDumpToolOpen || die "Failed to close $dumpToolName.\n";
893
894 closeHTTPD();
895
896 # Because multiple instances of this script are running concurrently we cannot 
897 # safely delete this symlink.
898 # system "rm /tmp/LayoutTests";
899
900 # FIXME: Do we really want to check the image-comparison tool for leaks every time?
901 if ($isDiffToolOpen && $shouldCheckLeaks) {
902     $totalLeaks += countAndPrintLeaks("ImageDiff", $imageDiffToolPID, "$testResultsDirectory/ImageDiff-leaks.txt");
903 }
904
905 if ($totalLeaks) {
906     if ($mergeDepth) {
907         parseLeaksandPrintUniqueLeaks();
908     } else { 
909         print "\nWARNING: $totalLeaks total leaks found!\n";
910         print "See above for individual leaks results.\n" if ($leaksOutputFileNumber > 2);
911     }
912 }
913
914 close IN;
915 close OUT;
916 close ERROR;
917
918 if ($report10Slowest) {
919     print "\n\nThe 10 slowest tests:\n\n";
920     my $count = 0;
921     for my $test (sort slowestcmp keys %durations) {
922         printf "%0.2f secs: %s\n", $durations{$test}, $test;
923         last if ++$count == 10;
924     }
925 }
926
927 print "\n";
928
929 if ($skippedOnly && $counts{"match"}) {
930     print "The following tests are in the Skipped file (" . File::Spec->abs2rel("$platformTestDirectory/Skipped", $testDirectory) . "), but succeeded:\n";
931     foreach my $test (@{$tests{"match"}}) {
932         print "  $test\n";
933     }
934 }
935
936 if ($resetResults || ($counts{match} && $counts{match} == $count)) {
937     print "all $count test cases succeeded\n";
938     unlink $testResults;
939     exit;
940 }
941
942 printResults();
943
944 mkpath $testResultsDirectory;
945
946 open HTML, ">", $testResults or die "Failed to open $testResults. $!";
947 print HTML "<html>\n";
948 print HTML "<head>\n";
949 print HTML "<title>Layout Test Results</title>\n";
950 print HTML "</head>\n";
951 print HTML "<body>\n";
952
953 if ($ignoreMetrics) {
954     print HTML "<h4>Tested with metrics ignored.</h4>";
955 }
956
957 print HTML htmlForResultsSection(@{$tests{mismatch}}, "Tests where results did not match expected results", \&linksForMismatchTest);
958 print HTML htmlForResultsSection(@{$tests{timedout}}, "Tests that timed out", \&linksForErrorTest);
959 print HTML htmlForResultsSection(@{$tests{crash}}, "Tests that caused the DumpRenderTree tool to crash", \&linksForErrorTest);
960 print HTML htmlForResultsSection(@{$tests{error}}, "Tests that had stderr output", \&linksForErrorTest);
961 print HTML htmlForResultsSection(@{$tests{new}}, "Tests that had no expected results (probably new)", \&linksForNewTest);
962
963 print HTML "</body>\n";
964 print HTML "</html>\n";
965 close HTML;
966
967 my @configurationArgs = argumentsForConfiguration();
968
969 if (isQt() || isGtk()) {
970   system "WebKitTools/Scripts/run-launcher", @configurationArgs, "file://".$testResults if $launchSafari;
971 } elsif (isCygwin()) {
972   system "cygstart", $testResults if $launchSafari;
973 } else {
974   system "WebKitTools/Scripts/run-safari", @configurationArgs, "-NSOpen", $testResults if $launchSafari;
975 }
976
977 closeCygpaths() if isCygwin();
978
979 exit 1;
980
981 sub countAndPrintLeaks($$$)
982 {
983     my ($dumpToolName, $dumpToolPID, $leaksFilePath) = @_;
984
985     print "\n" unless $atLineStart;
986     $atLineStart = 1;
987
988     # We are excluding the following reported leaks so they don't get in our way when looking for WebKit leaks:
989     # This allows us ignore known leaks and only be alerted when new leaks occur. Some leaks are in the old
990     # versions of the system frameworks that are being used by the leaks bots. Even though a leak has been
991     # fixed, it will be listed here until the bot has been updated with the newer frameworks.
992
993     my @typesToExclude = (
994     );
995
996     my @callStacksToExclude = (
997         "Flash_EnforceLocalSecurity" # leaks in Flash plug-in code, rdar://problem/4449747
998     );
999
1000     if (isTiger()) {
1001         # Leak list for the version of Tiger used on the build bot.
1002         push @callStacksToExclude, (
1003             "CFRunLoopRunSpecific \\| malloc_zone_malloc", "CFRunLoopRunSpecific \\| CFAllocatorAllocate ", # leak in CFRunLoopRunSpecific, rdar://problem/4670839
1004             "CGImageSourceGetPropertiesAtIndex", # leak in ImageIO, rdar://problem/4628809
1005             "FOGetCoveredUnicodeChars", # leak in ATS, rdar://problem/3943604
1006             "GetLineDirectionPreference", "InitUnicodeUtilities", # leaks tool falsely reporting leak in CFNotificationCenterAddObserver, rdar://problem/4964790
1007             "ICCFPrefWrapper::GetPrefDictionary", # leaks in Internet Config. code, rdar://problem/4449794
1008             "NSHTTPURLProtocol setResponseHeader:", # leak in multipart/mixed-replace handling in Foundation, no Radar, but fixed in Leopard
1009             "NSURLCache cachedResponseForRequest", # leak in CFURL cache, rdar://problem/4768430
1010             "PCFragPrepareClosureFromFile", # leak in Code Fragment Manager, rdar://problem/3426998
1011             "WebCore::Selection::toRange", # bug in 'leaks', rdar://problem/4967949
1012             "WebCore::SubresourceLoader::create", # bug in 'leaks', rdar://problem/4985806
1013             "_CFPreferencesDomainDeepCopyDictionary", # leak in CFPreferences, rdar://problem/4220786
1014             "_objc_msgForward", # leak in NSSpellChecker, rdar://problem/4965278
1015             "gldGetString", # leak in OpenGL, rdar://problem/5013699
1016             "_setDefaultUserInfoFromURL", # leak in NSHTTPAuthenticator, rdar://problem/5546453 
1017             "SSLHandshake", # leak in SSL, rdar://problem/5546440 
1018             "SecCertificateCreateFromData", # leak in SSL code, rdar://problem/4464397
1019         );
1020         push @typesToExclude, (
1021             "THRD", # bug in 'leaks', rdar://problem/3387783
1022             "DRHT", # ditto (endian little hate i)
1023         );
1024     }
1025
1026     if (isLeopard()) {
1027         # Leak list for the version of Leopard used on the build bot.
1028         push @callStacksToExclude, (
1029             "CFHTTPMessageAppendBytes", # leak in CFNetwork, rdar://problem/5435912
1030             "sendDidReceiveDataCallback", # leak in CFNetwork, rdar://problem/5441619
1031             "_CFHTTPReadStreamReadMark", # leak in CFNetwork, rdar://problem/5441468
1032             "httpProtocolStart", # leak in CFNetwork, rdar://problem/5468837
1033             "_CFURLConnectionSendCallbacks", # leak in CFNetwork, rdar://problem/5441600
1034             "DispatchQTMsg", # leak in QuickTime, PPC only, rdar://problem/5667132
1035             "QTMovieContentView createVisualContext", # leak in QuickTime, PPC only, rdar://problem/5667132
1036             "_CopyArchitecturesForJVMVersion", # leak in Java, rdar://problem/5910823
1037         );
1038     }
1039
1040     if (isSnowLeopard()) {
1041         push @callStacksToExclude, (
1042             "readMakerNoteProps", # <rdar://problem/7156432> leak in ImageIO
1043             "QTKitMovieControllerView completeUISetup", # <rdar://problem/7155156> leak in QTKit
1044         );
1045     }
1046
1047     my $leaksTool = sourceDir() . "/WebKitTools/Scripts/run-leaks";
1048     my $excludeString = "--exclude-callstack '" . (join "' --exclude-callstack '", @callStacksToExclude) . "'";
1049     $excludeString .= " --exclude-type '" . (join "' --exclude-type '", @typesToExclude) . "'" if @typesToExclude;
1050
1051     print " ? checking for leaks in $dumpToolName\n";
1052     my $leaksOutput = `$leaksTool $excludeString $dumpToolPID`;
1053     my ($count, $bytes) = $leaksOutput =~ /Process $dumpToolPID: (\d+) leaks? for (\d+) total/;
1054     my ($excluded) = $leaksOutput =~ /(\d+) leaks? excluded/;
1055
1056     my $adjustedCount = $count;
1057     $adjustedCount -= $excluded if $excluded;
1058
1059     if (!$adjustedCount) {
1060         print " - no leaks found\n";
1061         unlink $leaksFilePath;
1062         return 0;
1063     } else {
1064         my $dir = $leaksFilePath;
1065         $dir =~ s|/[^/]+$|| or die;
1066         mkpath $dir;
1067
1068         if ($excluded) {
1069             print " + $adjustedCount leaks ($bytes bytes including $excluded excluded leaks) were found, details in $leaksFilePath\n";
1070         } else {
1071             print " + $count leaks ($bytes bytes) were found, details in $leaksFilePath\n";
1072         }
1073
1074         writeToFile($leaksFilePath, $leaksOutput);
1075         
1076         push @leaksFilenames, $leaksFilePath;
1077     }
1078
1079     return $adjustedCount;
1080 }
1081
1082 sub writeToFile($$)
1083 {
1084     my ($filePath, $contents) = @_;
1085     open NEWFILE, ">", "$filePath" or die "Could not create $filePath. $!\n";
1086     print NEWFILE $contents;
1087     close NEWFILE;
1088 }
1089
1090 # Break up a path into the directory (with slash) and base name.
1091 sub splitpath($)
1092 {
1093     my ($path) = @_;
1094
1095     my $pathSeparator = "/";
1096     my $dirname = dirname($path) . $pathSeparator;
1097     $dirname = "" if $dirname eq "." . $pathSeparator;
1098
1099     return ($dirname, basename($path));
1100 }
1101
1102 # Sort first by directory, then by file, so all paths in one directory are grouped
1103 # rather than being interspersed with items from subdirectories.
1104 # Use numericcmp to sort directory and filenames to make order logical.
1105 sub pathcmp($$)
1106 {
1107     my ($patha, $pathb) = @_;
1108
1109     my ($dira, $namea) = splitpath($patha);
1110     my ($dirb, $nameb) = splitpath($pathb);
1111
1112     return numericcmp($dira, $dirb) if $dira ne $dirb;
1113     return numericcmp($namea, $nameb);
1114 }
1115
1116 # Sort numeric parts of strings as numbers, other parts as strings.
1117 # Makes 1.33 come after 1.3, which is cool.
1118 sub numericcmp($$)
1119 {
1120     my ($aa, $bb) = @_;
1121
1122     my @a = split /(\d+)/, $aa;
1123     my @b = split /(\d+)/, $bb;
1124
1125     # Compare one chunk at a time.
1126     # Each chunk is either all numeric digits, or all not numeric digits.
1127     while (@a && @b) {
1128         my $a = shift @a;
1129         my $b = shift @b;
1130         
1131         # Use numeric comparison if chunks are non-equal numbers.
1132         return $a <=> $b if $a =~ /^\d/ && $b =~ /^\d/ && $a != $b;
1133
1134         # Use string comparison if chunks are any other kind of non-equal string.
1135         return $a cmp $b if $a ne $b;
1136     }
1137     
1138     # One of the two is now empty; compare lengths for result in this case.
1139     return @a <=> @b;
1140 }
1141
1142 # Sort slowest tests first.
1143 sub slowestcmp($$)
1144 {
1145     my ($testa, $testb) = @_;
1146
1147     my $dura = $durations{$testa};
1148     my $durb = $durations{$testb};
1149     return $durb <=> $dura if $dura != $durb;
1150     return pathcmp($testa, $testb);
1151 }
1152
1153 sub launchWithCurrentEnv(@)
1154 {
1155     my (@args) = @_;
1156
1157     # Dump the current environment as perl code and then put it in quotes so it is one parameter.
1158     my $environmentDumper = Data::Dumper->new([\%ENV], [qw(*ENV)]);
1159     $environmentDumper->Indent(0);
1160     $environmentDumper->Purity(1);
1161     my $allEnvVars = $environmentDumper->Dump();
1162     unshift @args, "\"$allEnvVars\"";
1163
1164     my $execScript = File::Spec->catfile(sourceDir(), qw(WebKitTools Scripts execAppWithEnv));
1165     unshift @args, $execScript;
1166     return @args;
1167 }
1168
1169 sub openDiffTool()
1170 {
1171     return if $isDiffToolOpen;
1172     return if !$pixelTests;
1173
1174     local %ENV;
1175     $ENV{MallocStackLogging} = 1 if $shouldCheckLeaks;
1176     $imageDiffToolPID = open2(\*DIFFIN, \*DIFFOUT, $imageDiffTool, launchWithCurrentEnv(@diffToolArgs)) or die "unable to open $imageDiffTool\n";
1177     $ENV{MallocStackLogging} = 0 if $shouldCheckLeaks;
1178     $isDiffToolOpen = 1;
1179 }
1180
1181 sub openDumpTool()
1182 {
1183     return if $isDumpToolOpen;
1184
1185     # Save environment variables required for the linux environment.
1186     my $homeDir = $ENV{'HOME'};
1187     my $libraryPath = $ENV{'LD_LIBRARY_PATH'};
1188     my $dyldLibraryPath = $ENV{'DYLD_LIBRARY_PATH'};
1189     my $dbusAddress = $ENV{'DBUS_SESSION_BUS_ADDRESS'};
1190     my $display = $ENV{'DISPLAY'};
1191     my $xauthority = $ENV{'XAUTHORITY'};
1192     my $testfonts = $ENV{'WEBKIT_TESTFONTS'};
1193
1194     my $homeDrive = $ENV{'HOMEDRIVE'};
1195     my $homePath = $ENV{'HOMEPATH'};
1196         
1197     local %ENV;
1198     if (isQt() || isGtk()) {
1199         if (defined $display) {
1200             $ENV{DISPLAY} = $display;
1201         } else {
1202             $ENV{DISPLAY} = ":1";
1203         }
1204         if (defined $xauthority) {
1205             $ENV{XAUTHORITY} = $xauthority;
1206         }
1207         $ENV{'WEBKIT_TESTFONTS'} = $testfonts if defined($testfonts);
1208         $ENV{HOME} = $homeDir;
1209         if (defined $libraryPath) {
1210             $ENV{LD_LIBRARY_PATH} = $libraryPath;
1211         }
1212         if (defined $dyldLibraryPath) {
1213             $ENV{DYLD_LIBRARY_PATH} = $dyldLibraryPath;
1214         }
1215         if (defined $dbusAddress) {
1216             $ENV{DBUS_SESSION_BUS_ADDRESS} = $dbusAddress;
1217         }
1218     }
1219     if (isQt()) {
1220         $ENV{QTWEBKIT_PLUGIN_PATH} = productDir() . "/lib/plugins";
1221     }
1222     $ENV{DYLD_FRAMEWORK_PATH} = $productDir;
1223     $ENV{XML_CATALOG_FILES} = ""; # work around missing /etc/catalog <rdar://problem/4292995>
1224     $ENV{DYLD_INSERT_LIBRARIES} = "/usr/lib/libgmalloc.dylib" if $guardMalloc;
1225     
1226     if (isCygwin()) {
1227         $ENV{HOMEDRIVE} = $homeDrive;
1228         $ENV{HOMEPATH} = $homePath;
1229         if ($testfonts) {
1230             $ENV{WEBKIT_TESTFONTS} = $testfonts;
1231         }
1232         setPathForRunningWebKitApp(\%ENV) if isCygwin();
1233     }
1234
1235     my @args = ($dumpTool, @toolArgs);
1236     if (isAppleMacWebKit() and !isTiger()) { 
1237         unshift @args, "arch", "-" . architecture();             
1238     }
1239
1240     if ($useValgrind) {
1241         unshift @args, "valgrind";
1242     } 
1243     
1244     $ENV{MallocStackLogging} = 1 if $shouldCheckLeaks;
1245     $dumpToolPID = open3(\*OUT, \*IN, \*ERROR, launchWithCurrentEnv(@args)) or die "Failed to start tool: $dumpTool\n";
1246     $ENV{MallocStackLogging} = 0 if $shouldCheckLeaks;
1247     $isDumpToolOpen = 1;
1248     $dumpToolCrashed = 0;
1249 }
1250
1251 sub closeDumpTool()
1252 {
1253     return if !$isDumpToolOpen;
1254
1255     close IN;
1256     close OUT;
1257     waitpid $dumpToolPID, 0;
1258     
1259     # check for WebCore counter leaks.
1260     if ($shouldCheckLeaks) {
1261         while (<ERROR>) {
1262             print;
1263         }
1264     }
1265     close ERROR;
1266     $isDumpToolOpen = 0;
1267 }
1268
1269 sub dumpToolDidCrash()
1270 {
1271     return 1 if $dumpToolCrashed;
1272     return 0 unless $isDumpToolOpen;
1273
1274     my $pid = waitpid(-1, WNOHANG);
1275     return 1 if ($pid == $dumpToolPID);
1276
1277     # On Mac OS X, crashing may be significantly delayed by crash reporter.
1278     return 0 unless isAppleMacWebKit();
1279
1280     return DumpRenderTreeSupport::processIsCrashing($dumpToolPID);
1281 }
1282
1283 sub openHTTPDIfNeeded()
1284 {
1285     return if $isHttpdOpen;
1286
1287     mkdir "/tmp/WebKit";
1288     
1289     if (-f "/tmp/WebKit/httpd.pid") {
1290         my $oldPid = `cat /tmp/WebKit/httpd.pid`;
1291         chomp $oldPid;
1292         if (0 != kill 0, $oldPid) {
1293             print "\nhttpd is already running: pid $oldPid, killing...\n";
1294             kill 15, $oldPid;
1295             
1296             my $retryCount = 20;
1297             while ((0 != kill 0, $oldPid) && $retryCount) {
1298                 sleep 1;
1299                 --$retryCount;
1300             }
1301             
1302             die "Timed out waiting for httpd to quit" unless $retryCount;
1303         }
1304     }
1305     
1306     my $httpdPath = "/usr/sbin/httpd";
1307     my $httpdConfig;
1308     if (isCygwin()) {
1309         my $windowsConfDirectory = "$testDirectory/http/conf/";
1310         unless (-x "/usr/lib/apache/libphp4.dll") {
1311             copy("$windowsConfDirectory/libphp4.dll", "/usr/lib/apache/libphp4.dll");
1312             chmod(0755, "/usr/lib/apache/libphp4.dll");
1313         }
1314         $httpdConfig = "$windowsConfDirectory/cygwin-httpd.conf";
1315     } elsif (isDebianBased()) {
1316         $httpdPath = "/usr/sbin/apache2";
1317         $httpdConfig = "$testDirectory/http/conf/apache2-debian-httpd.conf";
1318     } elsif (isFedoraBased()) {
1319         $httpdPath = "/usr/sbin/httpd";
1320         $httpdConfig = "$testDirectory/http/conf/fedora-httpd.conf";
1321     } else {
1322         $httpdConfig = "$testDirectory/http/conf/httpd.conf";
1323         $httpdConfig = "$testDirectory/http/conf/apache2-httpd.conf" if `$httpdPath -v` =~ m|Apache/2|;
1324     }
1325     my $documentRoot = "$testDirectory/http/tests";
1326     my $jsTestResourcesDirectory = $testDirectory . "/fast/js/resources";
1327     my $typesConfig = "$testDirectory/http/conf/mime.types";
1328     my $listen = "127.0.0.1:$httpdPort";
1329     my $absTestResultsDirectory = File::Spec->rel2abs(glob $testResultsDirectory);
1330     my $sslCertificate = "$testDirectory/http/conf/webkit-httpd.pem";
1331
1332     mkpath $absTestResultsDirectory;
1333
1334     my @args = (
1335         "-f", "$httpdConfig",
1336         "-C", "DocumentRoot \"$documentRoot\"",
1337         # Setup a link to where the js test templates are stored, use -c so that mod_alias will already be laoded.
1338         "-c", "Alias /js-test-resources \"$jsTestResourcesDirectory\"",
1339         "-C", "Listen $listen",
1340         "-c", "TypesConfig \"$typesConfig\"",
1341         "-c", "CustomLog \"$absTestResultsDirectory/access_log.txt\" common",
1342         "-c", "ErrorLog \"$absTestResultsDirectory/error_log.txt\"",
1343         # Apache wouldn't run CGIs with permissions==700 otherwise
1344         "-c", "User \"#$<\""
1345     );
1346
1347     # FIXME: Enable this on Windows once <rdar://problem/5345985> is fixed
1348     # The version of Apache we use with Cygwin does not support SSL
1349     push(@args, "-c", "SSLCertificateFile \"$sslCertificate\"") unless isCygwin();
1350
1351     open2(\*HTTPDIN, \*HTTPDOUT, $httpdPath, @args);
1352
1353     my $retryCount = 20;
1354     while (system("/usr/bin/curl -q --silent --stderr - --output " . File::Spec->devnull() . " $listen") && $retryCount) {
1355         sleep 1;
1356         --$retryCount;
1357     }
1358     
1359     die "Timed out waiting for httpd to start" unless $retryCount;
1360     
1361     $isHttpdOpen = 1;
1362 }
1363
1364 sub closeHTTPD()
1365 {
1366     return if !$isHttpdOpen;
1367
1368     close HTTPDIN;
1369     close HTTPDOUT;
1370
1371     kill 15, `cat /tmp/WebKit/httpd.pid` if -f "/tmp/WebKit/httpd.pid";
1372
1373     $isHttpdOpen = 0;
1374 }
1375
1376 sub fileNameWithNumber($$)
1377 {
1378     my ($base, $number) = @_;
1379     return "$base$number" if ($number > 1);
1380     return $base;
1381 }
1382
1383 sub processIgnoreTests($$)
1384 {
1385     my @ignoreList = split(/\s*,\s*/, shift);
1386     my $listName = shift;
1387
1388     my $disabledSuffix = "-disabled";
1389
1390     my $addIgnoredDirectories = sub {
1391         return () if exists $ignoredLocalDirectories{basename($File::Find::dir)};
1392         $ignoredDirectories{File::Spec->abs2rel($File::Find::dir, $testDirectory)} = 1;
1393         return @_;
1394     };
1395     foreach my $item (@ignoreList) {
1396         my $path = catfile($testDirectory, $item); 
1397         if (-d $path) {
1398             $ignoredDirectories{$item} = 1;
1399             find({ preprocess => $addIgnoredDirectories, wanted => sub {} }, $path);
1400         }
1401         elsif (-f $path) {
1402             $ignoredFiles{$item} = 1;
1403         } elsif (-f $path . $disabledSuffix) {
1404             # The test is disabled, so do nothing.
1405         } else {
1406             print "$listName list contained '$item', but no file of that name could be found\n";
1407         }
1408     }
1409 }
1410
1411 sub stripExtension($)
1412 {
1413     my ($test) = @_;
1414
1415     $test =~ s/\.[a-zA-Z]+$//;
1416     return $test;
1417 }
1418
1419 sub isTextOnlyTest($)
1420 {
1421     my ($actual) = @_;
1422     my $isText;
1423     if ($actual =~ /^layer at/ms) {
1424         $isText = 0;
1425     } else {
1426         $isText = 1;
1427     }
1428     return $isText;
1429 }
1430
1431 sub expectedDirectoryForTest($;$;$)
1432 {
1433     my ($base, $isText, $expectedExtension) = @_;
1434
1435     my @directories = @platformResultHierarchy;
1436     push @directories, map { catdir($platformBaseDirectory, $_) } qw(mac-snowleopard mac) if isCygwin();
1437     push @directories, $expectedDirectory;
1438
1439     # If we already have expected results, just return their location.
1440     foreach my $directory (@directories) {
1441         return $directory if (-f "$directory/$base-$expectedTag.$expectedExtension");
1442     }
1443
1444     # For cross-platform tests, text-only results should go in the cross-platform directory,
1445     # while render tree dumps should go in the least-specific platform directory.
1446     return $isText ? $expectedDirectory : $platformResultHierarchy[$#platformResultHierarchy];
1447 }
1448
1449 sub countFinishedTest($$$$)
1450 {
1451     my ($test, $base, $result, $isText) = @_;
1452
1453     if (($count + 1) % $testsPerDumpTool == 0 || $count == $#tests) {
1454         if ($shouldCheckLeaks) {
1455             my $fileName;
1456             if ($testsPerDumpTool == 1) {
1457                 $fileName = "$testResultsDirectory/$base-leaks.txt";
1458             } else {
1459                 $fileName = "$testResultsDirectory/" . fileNameWithNumber($dumpToolName, $leaksOutputFileNumber) . "-leaks.txt";
1460             }
1461             my $leakCount = countAndPrintLeaks($dumpToolName, $dumpToolPID, $fileName);
1462             $totalLeaks += $leakCount;
1463             $leaksOutputFileNumber++ if ($leakCount);
1464         }
1465
1466         closeDumpTool();
1467     }
1468     
1469     $count++;
1470     $counts{$result}++;
1471     push @{$tests{$result}}, $test;
1472 }
1473
1474 sub testCrashedOrTimedOut($$$$$)
1475 {
1476     my ($test, $base, $didCrash, $actual, $error) = @_;
1477
1478     printFailureMessageForTest($test, $didCrash ? "crashed" : "timed out");
1479
1480     sampleDumpTool() unless $didCrash;
1481
1482     my $dir = "$testResultsDirectory/$base";
1483     $dir =~ s|/([^/]+)$|| or die "Failed to find test name from base\n";
1484     mkpath $dir;
1485
1486     deleteExpectedAndActualResults($base);
1487
1488     if (defined($error) && length($error)) {
1489         writeToFile("$testResultsDirectory/$base-$errorTag.txt", $error);
1490     }
1491
1492     recordActualResultsAndDiff($base, $actual);
1493
1494     kill 9, $dumpToolPID unless $didCrash;
1495
1496     closeDumpTool();
1497 }
1498
1499 sub printFailureMessageForTest($$)
1500 {
1501     my ($test, $description) = @_;
1502
1503     unless ($verbose) {
1504         print "\n" unless $atLineStart;
1505         print "$test -> ";
1506     }
1507     print "$description\n";
1508     $atLineStart = 1;
1509 }
1510
1511 my %cygpaths = ();
1512
1513 sub openCygpathIfNeeded($)
1514 {
1515     my ($options) = @_;
1516
1517     return unless isCygwin();
1518     return $cygpaths{$options} if $cygpaths{$options} && $cygpaths{$options}->{"open"};
1519
1520     local (*CYGPATHIN, *CYGPATHOUT);
1521     my $pid = open2(\*CYGPATHIN, \*CYGPATHOUT, "cygpath -f - $options");
1522     my $cygpath =  {
1523         "pid" => $pid,
1524         "in" => *CYGPATHIN,
1525         "out" => *CYGPATHOUT,
1526         "open" => 1
1527     };
1528
1529     $cygpaths{$options} = $cygpath;
1530
1531     return $cygpath;
1532 }
1533
1534 sub closeCygpaths()
1535 {
1536     return unless isCygwin();
1537
1538     foreach my $cygpath (values(%cygpaths)) {
1539         close $cygpath->{"in"};
1540         close $cygpath->{"out"};
1541         waitpid($cygpath->{"pid"}, 0);
1542         $cygpath->{"open"} = 0;
1543
1544     }
1545 }
1546
1547 sub convertPathUsingCygpath($$)
1548 {
1549     my ($path, $options) = @_;
1550
1551     my $cygpath = openCygpathIfNeeded($options);
1552     local *inFH = $cygpath->{"in"};
1553     local *outFH = $cygpath->{"out"};
1554     print outFH $path . "\n";
1555     chomp(my $convertedPath = <inFH>);
1556     return $convertedPath;
1557 }
1558
1559 sub toWindowsPath($)
1560 {
1561     my ($path) = @_;
1562     return unless isCygwin();
1563
1564     return convertPathUsingCygpath($path, "-w");
1565 }
1566
1567 sub toURL($)
1568 {
1569     my ($path) = @_;
1570
1571     if ($useRemoteLinksToTests) {
1572         my $relativePath = File::Spec->abs2rel($path, $testDirectory);
1573
1574         # If the file is below the test directory then convert it into a link to the file in SVN
1575         if ($relativePath !~ /^\.\.\//) {
1576             my $revision = svnRevisionForDirectory($testDirectory);
1577             my $svnPath = pathRelativeToSVNRepositoryRootForPath($path);
1578             return "http://trac.webkit.org/export/$revision/$svnPath";
1579         }
1580     }
1581
1582     return $path unless isCygwin();
1583
1584     return "file:///" . convertPathUsingCygpath($path, "-m");
1585 }
1586
1587 sub validateSkippedArg($$;$)
1588 {
1589     my ($option, $value, $value2) = @_;
1590     my %validSkippedValues = map { $_ => 1 } qw(default ignore only);
1591     $value = lc($value);
1592     die "Invalid argument '" . $value . "' for option $option" unless $validSkippedValues{$value};
1593     $treatSkipped = $value;
1594 }
1595
1596 sub htmlForResultsSection(\@$&)
1597 {
1598     my ($tests, $description, $linkGetter) = @_;
1599
1600     my @html = ();
1601     return join("\n", @html) unless @{$tests};
1602
1603     push @html, "<p>$description:</p>";
1604     push @html, "<table>";
1605     foreach my $test (@{$tests}) {
1606         push @html, "<tr>";
1607         push @html, "<td><a href=\"" . toURL("$testDirectory/$test") . "\">$test</a></td>";
1608         foreach my $link (@{&{$linkGetter}($test)}) {
1609             push @html, "<td><a href=\"$link->{href}\">$link->{text}</a></td>";
1610         }
1611         push @html, "</tr>";
1612     }
1613     push @html, "</table>";
1614
1615     return join("\n", @html);
1616 }
1617
1618 sub linksForExpectedAndActualResults($)
1619 {
1620     my ($base) = @_;
1621
1622     my @links = ();
1623
1624     return \@links unless -s "$testResultsDirectory/$base-$diffsTag.txt";
1625     
1626     my $expectedResultPath = $expectedResultPaths{$base};
1627     my ($expectedResultFileName, $expectedResultsDirectory, $expectedResultExtension) = fileparse($expectedResultPath, qr{\.[^.]+$});
1628
1629     push @links, { href => "$base-$expectedTag$expectedResultExtension", text => "expected" };
1630     push @links, { href => "$base-$actualTag$expectedResultExtension", text => "actual" };
1631     push @links, { href => "$base-$diffsTag.txt", text => "diff" };
1632     push @links, { href => "$base-$prettyDiffTag.html", text => "pretty diff" };
1633
1634     return \@links;
1635 }
1636
1637 sub linksForMismatchTest
1638 {
1639     my ($test) = @_;
1640
1641     my @links = ();
1642
1643     my $base = stripExtension($test);
1644
1645     push @links, @{linksForExpectedAndActualResults($base)};
1646     return \@links unless $pixelTests && $imagesPresent{$base};
1647
1648     push @links, { href => "$base-$expectedTag.png", text => "expected image" };
1649     push @links, { href => "$base-$diffsTag.html", text => "image diffs" };
1650     push @links, { href => "$base-$diffsTag.png", text => "$imageDifferences{$base}%" };
1651
1652     return \@links;
1653 }
1654
1655 sub linksForErrorTest
1656 {
1657     my ($test) = @_;
1658
1659     my @links = ();
1660
1661     my $base = stripExtension($test);
1662
1663     push @links, @{linksForExpectedAndActualResults($base)};
1664     push @links, { href => "$base-$errorTag.txt", text => "stderr" };
1665
1666     return \@links;
1667 }
1668
1669 sub linksForNewTest
1670 {
1671     my ($test) = @_;
1672
1673     my @links = ();
1674
1675     my $base = stripExtension($test);
1676
1677     my $expectedResultPath = $expectedResultPaths{$base};
1678     my ($expectedResultFileName, $expectedResultsDirectory, $expectedResultExtension) = fileparse($expectedResultPath, qr{\.[^.]+$});
1679
1680     push @links, { href => "$base-$actualTag$expectedResultExtension", text => "result" };
1681     if ($pixelTests && $imagesPresent{$base}) {
1682         push @links, { href => "$base-$expectedTag.png", text => "image" };
1683     }
1684
1685     return \@links;
1686 }
1687
1688 sub deleteExpectedAndActualResults($)
1689 {
1690     my ($base) = @_;
1691
1692     unlink "$testResultsDirectory/$base-$actualTag.txt";
1693     unlink "$testResultsDirectory/$base-$diffsTag.txt";
1694     unlink "$testResultsDirectory/$base-$errorTag.txt";
1695 }
1696
1697 sub recordActualResultsAndDiff($$)
1698 {
1699     my ($base, $actualResults) = @_;
1700
1701     return unless defined($actualResults) && length($actualResults);
1702
1703     my $expectedResultPath = $expectedResultPaths{$base};
1704     my ($expectedResultFileNameMinusExtension, $expectedResultDirectoryPath, $expectedResultExtension) = fileparse($expectedResultPath, qr{\.[^.]+$});
1705     my $actualResultsPath = "$testResultsDirectory/$base-$actualTag$expectedResultExtension";
1706     my $copiedExpectedResultsPath = "$testResultsDirectory/$base-$expectedTag$expectedResultExtension";
1707
1708     mkpath(dirname($actualResultsPath));
1709     writeToFile("$actualResultsPath", $actualResults);
1710
1711     if (-f $expectedResultPath) {
1712         copy("$expectedResultPath", "$copiedExpectedResultsPath");
1713     } else {
1714         open EMPTY, ">$copiedExpectedResultsPath";
1715         close EMPTY;
1716     }
1717
1718     my $diffOuputBasePath = "$testResultsDirectory/$base";
1719     my $diffOutputPath = "$diffOuputBasePath-$diffsTag.txt";
1720     system "diff -u \"$copiedExpectedResultsPath\" \"$actualResultsPath\" > \"$diffOutputPath\"";
1721
1722     my $prettyDiffOutputPath = "$diffOuputBasePath-$prettyDiffTag.html";
1723     my $prettyPatchPath = "BugsSite/PrettyPatch/";
1724     my $prettifyPath = "$prettyPatchPath/prettify.rb";
1725     system "ruby -I \"$prettyPatchPath\" \"$prettifyPath\" \"$diffOutputPath\" > \"$prettyDiffOutputPath\"";
1726 }
1727
1728 sub buildPlatformResultHierarchy()
1729 {
1730     mkpath($platformTestDirectory) if ($platform eq "undefined" && !-d "$platformTestDirectory");
1731
1732     my @platforms;
1733     if ($platform =~ /^mac-/) {
1734         my $i;
1735         for ($i = 0; $i < @macPlatforms; $i++) {
1736             last if $macPlatforms[$i] eq $platform;
1737         }
1738         for (; $i < @macPlatforms; $i++) {
1739             push @platforms, $macPlatforms[$i];
1740         }
1741     } elsif ($platform =~ /^qt-/) {
1742         push @platforms, $platform;
1743         push @platforms, "qt";
1744     } else {
1745         @platforms = $platform;
1746     }
1747
1748     my @hierarchy;
1749     for (my $i = 0; $i < @platforms; $i++) {
1750         my $scoped = catdir($platformBaseDirectory, $platforms[$i]);
1751         push(@hierarchy, $scoped) if (-d $scoped);
1752     }
1753
1754     return @hierarchy;
1755 }
1756
1757 sub buildPlatformTestHierarchy(@)
1758 {
1759     my (@platformHierarchy) = @_;
1760     return @platformHierarchy if (@platformHierarchy < 2);
1761
1762     return ($platformHierarchy[0], $platformHierarchy[$#platformHierarchy]);
1763 }
1764
1765 sub epiloguesAndPrologues($$)
1766 {
1767     my ($lastDirectory, $directory) = @_;
1768     my @lastComponents = split('/', $lastDirectory);
1769     my @components = split('/', $directory);
1770
1771     while (@lastComponents) {
1772         if (!defined($components[0]) || $lastComponents[0] ne $components[0]) {
1773             last;
1774         }
1775         shift @components;
1776         shift @lastComponents;
1777     }
1778
1779     my @result;
1780     my $leaving = $lastDirectory;
1781     foreach (@lastComponents) {
1782         my $epilogue = $leaving . "/resources/run-webkit-tests-epilogue.html";
1783         foreach (@platformResultHierarchy) {
1784             push @result, catdir($_, $epilogue) if (stat(catdir($_, $epilogue)));
1785         }
1786         push @result, catdir($testDirectory, $epilogue) if (stat(catdir($testDirectory, $epilogue)));
1787         $leaving =~ s|(^\|/)[^/]+$||;
1788     }
1789
1790     my $entering = $leaving;
1791     foreach (@components) {
1792         $entering .= '/' . $_;
1793         my $prologue = $entering . "/resources/run-webkit-tests-prologue.html";
1794         push @result, catdir($testDirectory, $prologue) if (stat(catdir($testDirectory, $prologue)));
1795         foreach (reverse @platformResultHierarchy) {
1796             push @result, catdir($_, $prologue) if (stat(catdir($_, $prologue)));
1797         }
1798     }
1799     return @result;
1800 }
1801     
1802 sub parseLeaksandPrintUniqueLeaks()
1803 {
1804     return unless @leaksFilenames;
1805      
1806     my $mergedFilenames = join " ", @leaksFilenames;
1807     my $parseMallocHistoryTool = sourceDir() . "/WebKitTools/Scripts/parse-malloc-history";
1808     
1809     open MERGED_LEAKS, "cat $mergedFilenames | $parseMallocHistoryTool --merge-depth $mergeDepth  - |" ;
1810     my @leakLines = <MERGED_LEAKS>;
1811     close MERGED_LEAKS;
1812     
1813     my $uniqueLeakCount = 0;
1814     my $totalBytes;
1815     foreach my $line (@leakLines) {
1816         ++$uniqueLeakCount if ($line =~ /^(\d*)\scalls/);
1817         $totalBytes = $1 if $line =~ /^total\:\s(.*)\s\(/;
1818     }
1819     
1820     print "\nWARNING: $totalLeaks total leaks found for a total of $totalBytes!\n";
1821     print "WARNING: $uniqueLeakCount unique leaks found!\n";
1822     print "See above for individual leaks results.\n" if ($leaksOutputFileNumber > 2);
1823     
1824 }
1825
1826 sub extensionForMimeType($)
1827 {
1828     my ($mimeType) = @_;
1829
1830     if ($mimeType eq "application/x-webarchive") {
1831         return "webarchive";
1832     } elsif ($mimeType eq "application/pdf") {
1833         return "pdf";
1834     }
1835     return "txt";
1836 }
1837
1838 # Read up to the first #EOF (the content block of the test), or until detecting crashes or timeouts.
1839 sub readFromDumpToolWithTimer(**)
1840 {
1841     my ($fhIn, $fhError) = @_;
1842
1843     setFileHandleNonBlocking($fhIn, 1);
1844     setFileHandleNonBlocking($fhError, 1);
1845
1846     my $maximumSecondsWithoutOutput = $timeoutSeconds;
1847     $maximumSecondsWithoutOutput *= 10 if $guardMalloc;
1848     my $microsecondsToWaitBeforeReadingAgain = 1000;
1849
1850     my $timeOfLastSuccessfulRead = time;
1851
1852     my @output = ();
1853     my @error = ();
1854     my $status = "success";
1855     my $mimeType = "text/plain";
1856     # We don't have a very good way to know when the "headers" stop
1857     # and the content starts, so we use this as a hack:
1858     my $haveSeenContentType = 0;
1859     my $haveSeenEofIn = 0;
1860     my $haveSeenEofError = 0;
1861
1862     while (1) {
1863         if (time - $timeOfLastSuccessfulRead > $maximumSecondsWithoutOutput) {
1864             $status = dumpToolDidCrash() ? "crashed" : "timedOut";
1865             last;
1866         }
1867
1868         # Once we've seen the EOF, we must not read anymore.
1869         my $lineIn = readline($fhIn) unless $haveSeenEofIn;
1870         my $lineError = readline($fhError) unless $haveSeenEofError;
1871         if (!defined($lineIn) && !defined($lineError)) {
1872             last if ($haveSeenEofIn && $haveSeenEofError);
1873
1874             if ($! != EAGAIN) {
1875                 $status = "crashed";
1876                 last;
1877             }
1878
1879             # No data ready
1880             usleep($microsecondsToWaitBeforeReadingAgain);
1881             next;
1882         }
1883
1884         $timeOfLastSuccessfulRead = time;
1885
1886         if (defined($lineIn)) {
1887             if (!$haveSeenContentType && $lineIn =~ /^Content-Type: (\S+)$/) {
1888                 $mimeType = $1;
1889                 $haveSeenContentType = 1;
1890             } elsif ($lineIn =~ /#EOF/) {
1891                 $haveSeenEofIn = 1;
1892             } else {
1893                 push @output, $lineIn;
1894             }
1895         }
1896         if (defined($lineError)) {
1897             if ($lineError =~ /#EOF/) {
1898                 $haveSeenEofError = 1;
1899             } else {
1900                 push @error, $lineError;
1901             }
1902         }
1903     }
1904
1905     setFileHandleNonBlocking($fhIn, 0);
1906     setFileHandleNonBlocking($fhError, 0);
1907     return {
1908         output => join("", @output),
1909         error => join("", @error),
1910         status => $status,
1911         mimeType => $mimeType,
1912         extension => extensionForMimeType($mimeType)
1913     };
1914 }
1915
1916 sub setFileHandleNonBlocking(*$)
1917 {
1918     my ($fh, $nonBlocking) = @_;
1919
1920     my $flags = fcntl($fh, F_GETFL, 0) or die "Couldn't get filehandle flags";
1921
1922     if ($nonBlocking) {
1923         $flags |= O_NONBLOCK;
1924     } else {
1925         $flags &= ~O_NONBLOCK;
1926     }
1927
1928     fcntl($fh, F_SETFL, $flags) or die "Couldn't set filehandle flags";
1929
1930     return 1;
1931 }
1932
1933 sub sampleDumpTool()
1934 {
1935     return unless isAppleMacWebKit();
1936     return unless $runSample;
1937
1938     my $outputDirectory = "$ENV{HOME}/Library/Logs/DumpRenderTree";
1939     -d $outputDirectory or mkdir $outputDirectory;
1940
1941     my $outputFile = "$outputDirectory/HangReport.txt";
1942     system "/usr/bin/sample", $dumpToolPID, qw(10 10 -file), $outputFile;
1943 }
1944
1945 sub stripMetrics($$)
1946 {
1947     my ($actual, $expected) = @_;
1948
1949     foreach my $result ($actual, $expected) {
1950         $result =~ s/at \(-?[0-9]+,-?[0-9]+\) *//g;
1951         $result =~ s/size -?[0-9]+x-?[0-9]+ *//g;
1952         $result =~ s/text run width -?[0-9]+: //g;
1953         $result =~ s/text run width -?[0-9]+ [a-zA-Z ]+: //g;
1954         $result =~ s/RenderButton {BUTTON} .*/RenderButton {BUTTON}/g;
1955         $result =~ s/RenderImage {INPUT} .*/RenderImage {INPUT}/g;
1956         $result =~ s/RenderBlock {INPUT} .*/RenderBlock {INPUT}/g;
1957         $result =~ s/RenderTextControl {INPUT} .*/RenderTextControl {INPUT}/g;
1958         $result =~ s/\([0-9]+px/px/g;
1959         $result =~ s/ *" *\n +" */ /g;
1960         $result =~ s/" +$/"/g;
1961
1962         $result =~ s/- /-/g;
1963         $result =~ s/\n( *)"\s+/\n$1"/g;
1964         $result =~ s/\s+"\n/"\n/g;
1965         $result =~ s/scrollWidth [0-9]+/scrollWidth/g;
1966         $result =~ s/scrollHeight [0-9]+/scrollHeight/g;
1967     }
1968
1969     return ($actual, $expected);
1970 }
1971
1972 sub fileShouldBeIgnored
1973 {
1974     my ($filePath) = @_;
1975     foreach my $ignoredDir (keys %ignoredDirectories) {
1976         if ($filePath =~ m/^$ignoredDir/) {
1977             return 1;
1978         }
1979     }
1980     return 0;
1981 }
1982
1983 sub readSkippedFiles
1984 {
1985     foreach my $level (@platformTestHierarchy) {
1986         if (open SKIPPED, "<", "$level/Skipped") {
1987             if ($verbose) {
1988                 my ($dir, $name) = splitpath($level);
1989                 print "Skipped tests in $name:\n";
1990             }
1991
1992             while (<SKIPPED>) {
1993                 my $skipped = $_;
1994                 chomp $skipped;
1995                 $skipped =~ s/^[ \n\r]+//;
1996                 $skipped =~ s/[ \n\r]+$//;
1997                 if ($skipped && $skipped !~ /^#/) {
1998                     if ($skippedOnly) {
1999                         if (!&fileShouldBeIgnored($skipped)) {
2000                             push(@ARGV, $skipped);
2001                         } elsif ($verbose) {
2002                             print "    $skipped\n";
2003                         }
2004                     } else {
2005                         if ($verbose) {
2006                             print "    $skipped\n";
2007                         }
2008                         processIgnoreTests($skipped, "Skipped");
2009                     }
2010                 }
2011             }
2012             close SKIPPED;
2013         }
2014     }
2015 }
2016
2017 my @testsToRun;
2018
2019 sub directoryFilter
2020 {
2021     return () if exists $ignoredLocalDirectories{basename($File::Find::dir)};
2022     return () if exists $ignoredDirectories{File::Spec->abs2rel($File::Find::dir, $testDirectory)};
2023     return @_;
2024 }
2025
2026 sub fileFilter
2027 {
2028     my $filename = $_;
2029     if ($filename =~ /\.([^.]+)$/) {
2030         if (exists $supportedFileExtensions{$1}) {
2031             my $path = File::Spec->abs2rel(catfile($File::Find::dir, $filename), $testDirectory);
2032             push @testsToRun, $path if !exists $ignoredFiles{$path};
2033         }
2034     }
2035 }
2036
2037 sub findTestsToRun
2038 {
2039     @testsToRun = ();
2040
2041     for my $test (@ARGV) {
2042         $test =~ s/^($layoutTestsName|$testDirectory)\///;
2043         my $fullPath = catfile($testDirectory, $test);
2044         if (file_name_is_absolute($test)) {
2045             print "can't run test $test outside $testDirectory\n";
2046         } elsif (-f $fullPath) {
2047             my ($filename, $pathname, $fileExtension) = fileparse($test, qr{\.[^.]+$});
2048             if (!exists $supportedFileExtensions{substr($fileExtension, 1)}) {
2049                 print "test $test does not have a supported extension\n";
2050             } elsif ($testHTTP || $pathname !~ /^http\//) {
2051                 push @testsToRun, $test;
2052             }
2053         } elsif (-d $fullPath) {
2054             find({ preprocess => \&directoryFilter, wanted => \&fileFilter }, $fullPath);
2055             for my $level (@platformTestHierarchy) {
2056                 my $platformPath = catfile($level, $test);
2057                 find({ preprocess => \&directoryFilter, wanted => \&fileFilter }, $platformPath) if (-d $platformPath);
2058             }
2059         } else {
2060             print "test $test not found\n";
2061         }
2062     }
2063
2064     if (!scalar @ARGV) {
2065         find({ preprocess => \&directoryFilter, wanted => \&fileFilter }, $testDirectory);
2066         for my $level (@platformTestHierarchy) {
2067             find({ preprocess => \&directoryFilter, wanted => \&fileFilter }, $level);
2068         }
2069     }
2070
2071     @testsToRun = sort pathcmp @testsToRun;
2072
2073     # Reverse the tests
2074     @testsToRun = reverse @testsToRun if $reverseTests;
2075
2076     # Shuffle the array
2077     @testsToRun = shuffle(@testsToRun) if $randomizeTests;
2078
2079     return @testsToRun;
2080 }
2081
2082 sub printResults
2083 {
2084     my %text = (
2085         match => "succeeded",
2086         mismatch => "had incorrect layout",
2087         new => "were new",
2088         timedout => "timed out",
2089         crash => "crashed",
2090         error => "had stderr output"
2091     );
2092
2093     for my $type ("match", "mismatch", "new", "timedout", "crash", "error") {
2094         my $typeCount = $counts{$type};
2095         next unless $typeCount;
2096         my $typeText = $text{$type};
2097         my $message;
2098         if ($typeCount == 1) {
2099             $typeText =~ s/were/was/;
2100             $message = sprintf "1 test case (%d%%) %s\n", 1 * 100 / $count, $typeText;
2101         } else {
2102             $message = sprintf "%d test cases (%d%%) %s\n", $typeCount, $typeCount * 100 / $count, $typeText;
2103         }
2104         $message =~ s-\(0%\)-(<1%)-;
2105         print $message;
2106     }
2107 }