Allow the --http flag to run-webkit-tests to override
[WebKit-https.git] / WebKitTools / Scripts / run-webkit-tests
1 #!/usr/bin/perl
2
3 # Copyright (C) 2005, 2006, 2007 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 #
8 # Redistribution and use in source and binary forms, with or without
9 # modification, are permitted provided that the following conditions
10 # are met:
11 #
12 # 1.  Redistributions of source code must retain the above copyright
13 #     notice, this list of conditions and the following disclaimer. 
14 # 2.  Redistributions in binary form must reproduce the above copyright
15 #     notice, this list of conditions and the following disclaimer in the
16 #     documentation and/or other materials provided with the distribution. 
17 # 3.  Neither the name of Apple Computer, Inc. ("Apple") nor the names of
18 #     its contributors may be used to endorse or promote products derived
19 #     from this software without specific prior written permission. 
20 #
21 # THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
22 # EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
23 # WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
24 # DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
25 # DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
26 # (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
27 # LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
28 # ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
29 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
30 # THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
31
32 # Script to run the Web Kit Open Source Project layout tests.
33
34 # Run all the tests passed in on the command line.
35 # If no tests are passed, find all the .html, .shtml, .xml, .xhtml, .pl, .php (and svg) files in the test directory.
36
37 # Run each text.
38 # Compare against the existing file xxx-expected.txt.
39 # If there is a mismatch, generate xxx-actual.txt and xxx-diffs.txt.
40
41 # At the end, report:
42 #   the number of tests that got the expected results
43 #   the number of tests that ran, but did not get the expected results
44 #   the number of tests that failed to run
45 #   the number of tests that were run but had no expected results to compare against
46
47 use strict;
48 use warnings;
49
50 use Cwd;
51 use File::Basename;
52 use File::Copy;
53 use File::Find;
54 use File::Path;
55 use File::Spec;
56 use File::Spec::Functions;
57 use FindBin;
58 use Getopt::Long;
59 use IPC::Open2;
60 use IPC::Open3;
61 use Time::HiRes qw(time);
62
63 use List::Util 'shuffle';
64
65 use lib $FindBin::Bin;
66 use webkitdirs;
67 use POSIX;
68
69 sub openDumpTool();
70 sub closeDumpTool();
71 sub dumpToolDidCrash();
72 sub closeHTTPD();
73 sub countAndPrintLeaks($$$);
74 sub fileNameWithNumber($$);
75 sub numericcmp($$);
76 sub openHTTPDIfNeeded();
77 sub pathcmp($$);
78 sub processIgnoreTests($);
79 sub slowestcmp($$);
80 sub splitpath($);
81 sub stripExtension($);
82 sub isTextOnlyTest($);
83 sub expectedDirectoryForTest($;$;$);
84 sub printFailureMessageForTest($$);
85 sub toURL($);
86 sub toWindowsPath($);
87 sub closeCygpaths();
88 sub validateSkippedArg($$;$);
89 sub htmlForExpectedAndActualResults($);
90 sub deleteExpectedAndActualResults($);
91 sub recordActualResultsAndDiff($$);
92 sub buildPlatformHierarchy();
93
94 # Argument handling
95 my $addPlatformExceptions = 0;
96 my $configuration = configuration();
97 my $guardMalloc = '';
98 my $httpdPort = 8000;
99 my $httpdSSLPort = 8443;
100 my $ignoreTests = '';
101 my $launchSafari = 1;
102 my $platform;
103 my $pixelTests = '';
104 my $quiet = '';
105 my $repaintSweepHorizontally = '';
106 my $repaintTests = '';
107 my $report10Slowest = 0;
108 my $resetResults = 0;
109 my $shouldCheckLeaks = 0;
110 my $showHelp = 0;
111 my $testsPerDumpTool = 1000;
112 my $testHTTP = 1;
113 my $testMedia = 1;
114 my $testResultsDirectory = "/tmp/layout-test-results";
115 my $threaded = 0;
116 my $threshold = 0;
117 my $treatSkipped = "default";
118 my $verbose = 0;
119 my $useValgrind = 0;
120 my $strictTesting = 0;
121 my $generateNewResults = 1;
122 my $stripEditingCallbacks = isCygwin();
123 my $root;
124 my $reverseTests = 0;
125 my $randomizeTests = 0;
126
127 # Default to --no-http for Qt, Gtk and wx for now.
128 $testHTTP = 0 if (isQt() || isGtk() || isWx());
129
130 my $expectedTag = "expected";
131 my $actualTag = "actual";
132 my $diffsTag = "diffs";
133 my $errorTag = "stderr";
134
135 if (isTiger()) {
136     $platform = "mac-tiger";
137 } elsif (isLeopard()) {
138     $platform = "mac-leopard";
139 } elsif (isOSX()) {
140     $platform = "mac";
141 } elsif (isQt()) {
142     $platform = "qt";
143 } elsif (isGtk()) {
144     $platform = "gtk";
145 } elsif (isCygwin()) {
146     $platform = "win";
147 }
148
149 if (!defined($platform)) {
150     print "WARNING: Your platform is not recognized. Any platform-specific results will be generated in platform/undefined.\n";
151     $platform = "undefined";
152 }
153
154 my $programName = basename($0);
155 my $launchSafariDefault = $launchSafari ? "launch" : "do not launch";
156 my $httpDefault = $testHTTP ? "run" : "do not run";
157
158 # FIXME: "--strict" should be renamed to qt-mac-comparison, or something along those lines.
159 my $usage = <<EOF;
160 Usage: $programName [options] [testdir|testpath ...]
161   --add-platform-exceptions       Put new results for non-platform-specific failing tests into the platform-specific results directory
162   -c|--configuration config       Set DumpRenderTree build configuration
163   -g|--guard-malloc               Enable malloc guard
164   --help                          Show this help message
165   -h|--horizontal-sweep           Change repaint to sweep horizontally instead of vertically (implies --repaint-tests)
166   --[no-]http                     Run (or do not run) http tests (default: $httpDefault)
167   -i|--ignore-tests               Comma-separated list of directories or tests to ignore
168   --[no-]launch-safari            Launch (or do not launch) Safari to display test results (default: $launchSafariDefault)
169   -l|--leaks                      Enable leaks checking
170   --[no-]new-test-results         Generate results for new tests
171   -p|--pixel-tests                Enable pixel tests
172   --platform                      Override the detected platform to use for tests and results (default: $platform)
173   --port                          Web server port to use with http tests
174   -q|--quiet                      Less verbose output
175   -r|--repaint-tests              Run repaint tests (implies --pixel-tests)
176   --reset-results                 Reset ALL results (including pixel tests if --pixel-tests is set)
177   -o|--results-directory          Output results directory (default: $testResultsDirectory)
178   --random                        Run the tests in a random order
179   --reverse                       Run the tests in reverse alphabetical order
180   --root                          Path to root tools build
181   -1|--singly                     Isolate each test case run (implies --verbose)
182   --skipped=[default|ignore|only] Specifies how to treat the Skipped file
183                                      default: Tests/directories listed in the Skipped file are not tested
184                                      ignore:  The Skipped file is ignored
185                                      only:    Only those tests/directories listed in the Skipped file will be run
186   --slowest                       Report the 10 slowest tests
187   --strict                        Do a comparison with the output on Mac (Qt only)
188   --[no-]strip-editing-callbacks  Remove editing callbacks from expected results
189   -t|--threaded                   Run a concurrent JavaScript thead with each test
190   --threshold t                   Ignore pixel value deviations less than or equal to t
191   --valgrind                      Run DumpRenderTree inside valgrind (Qt/Linux only)
192   -v|--verbose                    More verbose output (overrides --quiet)
193 EOF
194
195 my $getOptionsResult = GetOptions(
196     'c|configuration=s' => \$configuration,
197     'debug|devel' => sub { $configuration = "Debug" },
198     'guard-malloc|g' => \$guardMalloc,
199     'help' => \$showHelp,
200     'horizontal-sweep|h' => \$repaintSweepHorizontally,
201     'http!' => \$testHTTP,
202     'ignore-tests|i=s' => \$ignoreTests,
203     'launch-safari!' => \$launchSafari,
204     'leaks|l' => \$shouldCheckLeaks,
205     'pixel-tests|p' => \$pixelTests,
206     'platform=s' => \$platform,
207     'port=i' => \$httpdPort,
208     'quiet|q' => \$quiet,
209     'release|deploy' => sub { $configuration = "Release" },
210     'repaint-tests|r' => \$repaintTests,
211     'reset-results' => \$resetResults,
212     'new-test-results!' => \$generateNewResults,
213     'results-directory|o=s' => \$testResultsDirectory,
214     'singly|1' => sub { $testsPerDumpTool = 1; },
215     'nthly=i' => \$testsPerDumpTool,
216     'skipped=s' => \&validateSkippedArg,
217     'slowest' => \$report10Slowest,
218     'threaded|t' => \$threaded,
219     'threshold=i' => \$threshold,
220     'verbose|v' => \$verbose,
221     'valgrind' => \$useValgrind,
222     'strict' => \$strictTesting,
223     'strip-editing-callbacks!' => \$stripEditingCallbacks,
224     'random' => \$randomizeTests,
225     'reverse' => \$reverseTests,
226     'root=s' => \$root,
227     'add-platform-exceptions' => \$addPlatformExceptions,
228 );
229
230 if (!$getOptionsResult || $showHelp) {
231     print STDERR $usage;
232     exit 1;
233 }
234
235 my $ignoreSkipped = $treatSkipped eq "ignore";
236 my $skippedOnly = $treatSkipped eq "only";
237
238 !$skippedOnly || @ARGV == 0 or die "--skipped=only cannot be used when tests are specified on the command line.";
239
240 setConfiguration($configuration);
241
242 my $configurationOption = "--" . lc($configuration);
243
244 $repaintTests = 1 if $repaintSweepHorizontally;
245
246 $pixelTests = 1 if $repaintTests;
247 $pixelTests = 1 if $threshold > 0;
248
249 $verbose = 1 if $testsPerDumpTool == 1;
250
251 if ($shouldCheckLeaks && $testsPerDumpTool > 1000) {
252     print STDERR "\nWARNING: Running more than 1000 tests at a time with MallocStackLogging enabled may cause a crash.\n\n";
253 }
254
255 # Stack logging does not play well with QuickTime on Tiger (rdar://problem/5537157)
256 $testMedia = 0 if $shouldCheckLeaks && isTiger();
257
258 setConfigurationProductDir(Cwd::abs_path($root)) if (defined($root));
259 my $productDir = productDir();
260 $productDir .= "/bin" if (isQt());
261 $productDir .= "/WebKitTools/DumpRenderTree/gtk" if isGtk();
262
263 chdirWebKit();
264
265 if(!defined($root)){
266     # Push the parameters to build-dumprendertree as an array
267     my @args;
268     push(@args, "--" . $configuration);
269     push(@args, "--qt")  if isQt();
270     push(@args, "--gtk")  if isGtk();
271
272     my $buildResult = system "WebKitTools/Scripts/build-dumprendertree", @args;
273     if ($buildResult) {
274         print STDERR "Compiling DumpRenderTree failed!\n";
275         exit exitStatus($buildResult);
276     }
277 }
278
279 my $dumpToolName = "DumpRenderTree";
280 $dumpToolName .= "_debug" if isCygwin() && $configuration ne "Release";
281 my $dumpTool = "$productDir/$dumpToolName";
282 die "can't find executable $dumpToolName (looked in $productDir)\n" unless -x $dumpTool;
283
284 my $imageDiffTool = "$productDir/ImageDiff";
285 die "can't find executable $imageDiffTool (looked in $productDir)\n" if $pixelTests && !-x $imageDiffTool;
286
287 checkFrameworks() unless isCygwin();
288
289 my $layoutTestsName = "LayoutTests";
290 my $testDirectory = File::Spec->rel2abs($layoutTestsName);
291 my $expectedDirectory = $testDirectory;
292 my $platformBaseDirectory = catdir($testDirectory, "platform");
293 my $platformTestDirectory = catdir($platformBaseDirectory, $platform);
294 my @platformHierarchy = buildPlatformHierarchy();
295
296 $expectedDirectory = $ENV{"WebKitExpectedTestResultsDirectory"} if $ENV{"WebKitExpectedTestResultsDirectory"};
297
298 my $testResults = catfile($testResultsDirectory, "results.html");
299
300 print "Running tests from $testDirectory\n";
301
302 my @tests = ();
303 my %testType = ();
304
305 system "ln", "-s", $testDirectory, "/tmp/LayoutTests" unless -x "/tmp/LayoutTests";
306
307 my %ignoredFiles = ();
308 my %ignoredDirectories = map { $_ => 1 } qw(platform);
309 my %ignoredLocalDirectories = map { $_ => 1 } qw(.svn _svn resources);
310 my %supportedFileExtensions = map { $_ => 1 } qw(html shtml xml xhtml pl php);
311 if (checkWebCoreSVGSupport(0)) { 
312     $supportedFileExtensions{'svg'} = 1;
313 } elsif (isCygwin()) {
314     # FIXME: We should fix webkitdirs.pm:hasSVGSupport() to do the correct
315     # check for Windows instead of forcing this here.
316     $supportedFileExtensions{'svg'} = 1;
317 } else {
318     $ignoredLocalDirectories{'svg'} = 1;
319 }
320 if (!$testHTTP) {
321     $ignoredDirectories{'http'} = 1;
322 }
323
324 if (!$testMedia) {
325     $ignoredDirectories{'media'} = 1;
326     $ignoredDirectories{'http/tests/media'} = 1;
327 }
328
329 if ($ignoreTests) {
330     processIgnoreTests($ignoreTests);
331 }
332
333 if (!$ignoreSkipped) {
334     foreach my $level (@platformHierarchy) {
335         if (open SKIPPED, "<", "$level/Skipped") {
336             if ($verbose && !$skippedOnly) {
337                 my ($dir, $name) = splitpath($level);
338                 print "Skipped tests in $name:\n";
339             }
340
341             while (<SKIPPED>) {
342                 my $skipped = $_;
343                 chomp $skipped;
344                 $skipped =~ s/^[ \n\r]+//;
345                 $skipped =~ s/[ \n\r]+$//;
346                 if ($skipped && $skipped !~ /^#/) {
347                     if ($skippedOnly) {
348                         push(@ARGV, $skipped);
349                     } else {
350                         if ($verbose) {
351                             print "    $skipped\n";
352                         }
353                         processIgnoreTests($skipped);
354                     }
355                 }
356             }
357             close SKIPPED;
358         }
359     }
360 }
361
362
363 my $directoryFilter = sub {
364     return () if exists $ignoredLocalDirectories{basename($File::Find::dir)};
365     return () if exists $ignoredDirectories{File::Spec->abs2rel($File::Find::dir, $testDirectory)};
366     return @_;
367 };
368
369 my $fileFilter = sub {
370     my $filename = $_;
371     if ($filename =~ /\.([^.]+)$/) {
372         if (exists $supportedFileExtensions{$1}) {
373             my $path = File::Spec->abs2rel(catfile($File::Find::dir, $filename), $testDirectory);
374             push @tests, $path if !exists $ignoredFiles{$path};
375         }
376     }
377 };
378
379 for my $test (@ARGV) {
380     $test =~ s/^($layoutTestsName|$testDirectory)\///;
381     my $fullPath = catfile($testDirectory, $test);
382     if (file_name_is_absolute($test)) {
383         print "can't run test $test outside $testDirectory\n";
384     } elsif (-f $fullPath) {
385         my ($filename, $pathname, $fileExtension) = fileparse($test, qr{\.[^.]+$});
386         if (!exists $supportedFileExtensions{substr($fileExtension, 1)}) {
387             print "test $test does not have a supported extension\n";
388         } elsif ($testHTTP || $pathname !~ /^http\//) {
389             push @tests, $test;
390         }
391     } elsif (-d $fullPath) {
392         find({ preprocess => $directoryFilter, wanted => $fileFilter }, $fullPath);
393
394         for my $level (@platformHierarchy) {
395             my $platformPath = catfile($level, $test);
396             find({ preprocess => $directoryFilter, wanted => $fileFilter }, $platformPath) if (-d $platformPath);
397         }
398     } else {
399         print "test $test not found\n";
400     }
401 }
402 if (!scalar @ARGV) {
403     find({ preprocess => $directoryFilter, wanted => $fileFilter }, $testDirectory);
404
405     for my $level (@platformHierarchy) {
406         find({ preprocess => $directoryFilter, wanted => $fileFilter }, $level);
407     }
408 }
409
410 die "no tests to run\n" if !@tests;
411
412 @tests = sort pathcmp @tests;
413
414 my %counts;
415 my %tests;
416 my %imagesPresent;
417 my %imageDifferences;
418 my %durations;
419 my $count = 0;
420 my $leaksOutputFileNumber = 1;
421 my $totalLeaks = 0;
422
423 my @toolArgs = ();
424 push @toolArgs, "--dump-all-pixels" if $pixelTests && $resetResults;
425 push @toolArgs, "--pixel-tests" if $pixelTests;
426 push @toolArgs, "--repaint" if $repaintTests;
427 push @toolArgs, "--horizontal-sweep" if $repaintSweepHorizontally;
428 push @toolArgs, "--threaded" if $threaded;
429 push @toolArgs, "-";
430
431 my @diffToolArgs = ();
432 push @diffToolArgs, "--threshold", $threshold;
433
434 $| = 1;
435
436 my $imageDiffToolPID;
437 if ($pixelTests) {
438     local %ENV;
439     $ENV{MallocStackLogging} = 1 if $shouldCheckLeaks;
440     $imageDiffToolPID = open2(\*DIFFIN, \*DIFFOUT, $imageDiffTool, @diffToolArgs) or die "unable to open $imageDiffTool\n";
441 }
442
443 my $dumpToolPID;
444 my $isDumpToolOpen = 0;
445 my $dumpToolCrashed = 0;
446
447 my $atLineStart = 1;
448 my $lastDirectory = "";
449
450 my $isHttpdOpen = 0;
451
452 sub catch_pipe { $dumpToolCrashed = 1; }
453 $SIG{"PIPE"} = "catch_pipe";
454
455 print "Testing ", scalar @tests, " test cases.\n";
456 my $overallStartTime = time;
457
458 my %expectedResultDirectory;
459
460 # Reverse the tests
461 @tests = reverse @tests if $reverseTests;
462
463 # Shuffle the array
464 @tests = shuffle(@tests) if $randomizeTests;
465
466 for my $test (@tests) {
467     next if $test eq 'results.html';
468
469     openDumpTool();
470
471     my $base = stripExtension($test);
472     
473     if ($verbose) {
474         print "running $test -> ";
475         $atLineStart = 0;
476     } elsif (!$quiet) {
477         my $dir = $base;
478         $dir =~ s|/[^/]+$||;
479         if ($dir ne $lastDirectory) {
480             print "\n" unless $atLineStart;
481             print "$dir ";
482             $lastDirectory = $dir;
483         }
484         print ".";
485         $atLineStart = 0;
486     }
487
488     my $result;
489
490     my $startTime = time if $report10Slowest;
491
492     if ($test !~ /^http\//) {
493         my $testPath = "$testDirectory/$test";
494         if (isCygwin()) {
495             $testPath = toWindowsPath($testPath);
496         } else {
497             $testPath = canonpath($testPath);
498         }
499         print OUT "$testPath\n";
500     } else {
501         openHTTPDIfNeeded();
502         if ($test !~ /^http\/tests\/local\// && $test !~ /^http\/tests\/ssl\// && $test !~ /^http\/tests\/media\//) {
503             my $path = canonpath($test);
504             $path =~ s/^http\/tests\///;
505             print OUT "http://127.0.0.1:$httpdPort/$path\n";
506         } elsif ($test =~ /^http\/tests\/ssl\//) {
507             my $path = canonpath($test);
508             $path =~ s/^http\/tests\///;
509             print OUT "https://127.0.0.1:$httpdSSLPort/$path\n";
510         } else {
511             my $testPath = "$testDirectory/$test";
512             if (isCygwin()) {
513                 $testPath = toWindowsPath($testPath);
514             } else {
515                 $testPath = canonpath($testPath);
516             }
517             print OUT "$testPath\n";
518         }
519     }
520
521     my $actual = "";
522     while (<IN>) {
523         last if /#EOF/;
524         $actual .= $_;
525     }
526
527     my $isText = isTextOnlyTest($actual);
528
529     $durations{$test} = time - $startTime if $report10Slowest;
530
531     my $expected;
532     my $expectedDir = expectedDirectoryForTest($base, $isText, 0);
533     $expectedResultDirectory{$base} = $expectedDir;
534
535     if (!$resetResults && open EXPECTED, "<", "$expectedDir/$base-$expectedTag.txt") {
536         $expected = "";
537         while (<EXPECTED>) {
538             next if $stripEditingCallbacks && $_ =~ /^EDITING DELEGATE:/;
539             $expected .= $_;
540         }
541         close EXPECTED;
542     }
543     my $expectedMac;
544     if (!isOSX() && $strictTesting && !$isText) {
545       if (!$resetResults && open EXPECTED, "<", "$testDirectory/platform/mac/$base-$expectedTag.txt") {
546         $expectedMac = "";
547         while (<EXPECTED>) {
548           $expectedMac .= $_;
549         }
550         close EXPECTED;
551       }
552     }
553
554     if ($shouldCheckLeaks && $testsPerDumpTool == 1) {
555         print "        $test -> ";
556     }
557
558     my $actualPNG = "";
559     my $diffPNG = "";
560     my $diffPercentage = "";
561     my $diffResult = "passed";
562     
563     if ($pixelTests) {
564         my $expectedPixelDir = expectedDirectoryForTest($base, $isText, 1);
565
566         my $actualHash = "";
567         my $expectedHash = "";
568         my $actualPNGSize = 0;
569
570         while (<IN>) {
571             last if /#EOF/;
572             if (/ActualHash: ([a-f0-9]{32})/) {
573                 $actualHash = $1;
574             } elsif (/BaselineHash: ([a-f0-9]{32})/) {
575                 $expectedHash = $1;
576             } elsif (/Content-length: (\d+)\s*/) {
577                 $actualPNGSize = $1;
578                 read(IN, $actualPNG, $actualPNGSize);
579             }
580         }
581
582         if ($expectedHash ne $actualHash && -f "$expectedPixelDir/$base-$expectedTag.png") {
583             my $expectedPNGSize = -s "$expectedPixelDir/$base-$expectedTag.png";
584             my $expectedPNG = "";
585             open EXPECTEDPNG, "$expectedPixelDir/$base-$expectedTag.png";
586             read(EXPECTEDPNG, $expectedPNG, $expectedPNGSize);
587
588             print DIFFOUT "Content-length: $actualPNGSize\n";
589             print DIFFOUT $actualPNG;
590
591             print DIFFOUT "Content-length: $expectedPNGSize\n";
592             print DIFFOUT $expectedPNG;
593
594             while (<DIFFIN>) {
595                 last if /^error/ || /^diff:/;
596                 if (/Content-length: (\d+)\s*/) {
597                     read(DIFFIN, $diffPNG, $1);
598                 }
599             }
600
601             if (/^diff: (.+)% (passed|failed)/) {
602                 $diffPercentage = $1;
603                 $imageDifferences{$base} = $diffPercentage;
604                 $diffResult = $2;
605             }
606         }
607
608         if ($actualPNGSize && ($resetResults || !-f "$expectedPixelDir/$base-$expectedTag.png")) {
609             mkpath catfile($expectedPixelDir, dirname($base)) if $testDirectory ne $expectedPixelDir;
610             open EXPECTED, ">", "$expectedPixelDir/$base-expected.png" or die "could not create $expectedPixelDir/$base-expected.png\n";
611             print EXPECTED $actualPNG;
612             close EXPECTED;
613         }
614
615         # update the expected hash if the image diff said that there was no difference
616         if ($actualHash ne "" && ($resetResults || !-f "$expectedPixelDir/$base-$expectedTag.checksum")) {
617             open EXPECTED, ">", "$expectedPixelDir/$base-$expectedTag.checksum" or die "could not create $expectedPixelDir/$base-$expectedTag.checksum\n";
618             print EXPECTED $actualHash;
619             close EXPECTED;
620         }
621     }
622
623     if (!isOSX() && $strictTesting && !$isText) {
624       if (defined $expectedMac) {
625         my $simplified_actual;
626         $simplified_actual = $actual;
627         $simplified_actual =~ s/at \(-?[0-9]+,-?[0-9]+\) *//g;
628         $simplified_actual =~ s/size -?[0-9]+x-?[0-9]+ *//g;
629         $simplified_actual =~ s/text run width -?[0-9]+: //g;
630         $simplified_actual =~ s/text run width -?[0-9]+ [a-zA-Z ]+: //g;
631         $simplified_actual =~ s/RenderButton {BUTTON} .*/RenderButton {BUTTON}/g;
632         $simplified_actual =~ s/RenderImage {INPUT} .*/RenderImage {INPUT}/g;
633         $simplified_actual =~ s/RenderBlock {INPUT} .*/RenderBlock {INPUT}/g;
634         $simplified_actual =~ s/RenderTextControl {INPUT} .*/RenderTextControl {INPUT}/g;
635         $simplified_actual =~ s/\([0-9]+px/px/g;
636         $simplified_actual =~ s/ *" *\n +" */ /g;
637         $simplified_actual =~ s/" +$/"/g;
638
639         $simplified_actual =~ s/- /-/g;
640         $simplified_actual =~ s/\n( *)"\s+/\n$1"/g;
641         $simplified_actual =~ s/\s+"\n/"\n/g;
642         
643         $expectedMac =~ s/at \(-?[0-9]+,-?[0-9]+\) *//g;
644         $expectedMac =~ s/size -?[0-9]+x-?[0-9]+ *//g;
645         $expectedMac =~ s/text run width -?[0-9]+: //g;
646         $expectedMac =~ s/text run width -?[0-9]+ [a-zA-Z ]+: //g;
647         $expectedMac =~ s/RenderButton {BUTTON} .*/RenderButton {BUTTON}/g;
648         $expectedMac =~ s/RenderImage {INPUT} .*/RenderImage {INPUT}/g;
649         $expectedMac =~ s/RenderBlock {INPUT} .*/RenderBlock {INPUT}/g;
650         $expectedMac =~ s/RenderTextControl {INPUT} .*/RenderTextControl {INPUT}/g;
651         $expectedMac =~ s/\([0-9]+px/px/g;
652         $expectedMac =~ s/ *" *\n +" */ /g;
653         $expectedMac =~ s/" +$/"/g;
654
655         $expectedMac =~ s/- /-/g;
656         $expectedMac =~ s/\n( *)"\s+/\n$1"/g;
657         $expectedMac =~ s/\s+"\n/"\n/g;
658         
659         if ($simplified_actual ne $expectedMac) {
660           open ACTUAL, ">", "/tmp/actual.txt" or die;
661           print ACTUAL $simplified_actual;
662           close ACTUAL;
663           open ACTUAL, ">", "/tmp/expected.txt" or die;
664           print ACTUAL $expectedMac;
665           close ACTUAL;
666           system "diff -u \"/tmp/expected.txt\" \"/tmp/actual.txt\" > \"/tmp/simplified.diff\"";
667
668           $diffResult = "failed";
669           if($verbose) {
670             print "\n";
671             system "cat /tmp/simplified.diff";
672             print "failed!!!!!";
673           }
674         }
675       }
676     }
677
678     if (dumpToolDidCrash()) {
679         $result = "crash";
680
681         printFailureMessageForTest($test, "crashed");
682
683         my $dir = "$testResultsDirectory/$base";
684         $dir =~ s|/([^/]+)$|| or die "Failed to find test name from base\n";
685         mkpath $dir;
686
687         deleteExpectedAndActualResults($base);
688
689         open CRASH, ">", "$testResultsDirectory/$base-$errorTag.txt" or die;
690         print CRASH <ERROR>;
691         close CRASH;
692
693         recordActualResultsAndDiff($base, $actual);
694
695         closeDumpTool();
696     } elsif (!defined $expected) {
697         if ($verbose) {
698             print "new " . ($resetResults ? "result" : "test") ."\n";
699             $atLineStart = 1;
700         }
701         $result = "new";
702
703         if ($generateNewResults || $resetResults) {
704             mkpath catfile($expectedDir, dirname($base)) if $testDirectory ne $expectedDir;
705             open EXPECTED, ">", "$expectedDir/$base-$expectedTag.txt" or die "could not create $expectedDir/$base-$expectedTag.txt\n";
706             print EXPECTED $actual;
707             close EXPECTED;
708         }
709         deleteExpectedAndActualResults($base);
710         unless ($resetResults) {
711             # Always print the file name for new tests, as they will probably need some manual inspection.
712             # in verbose mode we already printed the test case, so no need to do it again.
713             unless ($verbose) {
714                 print "\n" unless $atLineStart;
715                 print "$test -> ";
716             }
717             my $resultsDir = catdir($expectedDir, dirname($base));
718             print "new (results generated in $resultsDir)\n";
719             $atLineStart = 1;
720         }
721     } elsif ($actual eq $expected && $diffResult eq "passed") {
722         if ($verbose) {
723             print "succeeded\n";
724             $atLineStart = 1;
725         }
726         $result = "match";
727         deleteExpectedAndActualResults($base);
728     } else {
729         $result = "mismatch";
730
731         my $message = $actual eq $expected ? "pixel test failed" : "failed";
732
733         if ($actual ne $expected && $addPlatformExceptions) {
734             my $testBase = catfile($testDirectory, $base);
735             my $expectedBase = catfile($expectedDir, $base);
736             my $testIsMaximallyPlatformSpecific = $testBase =~ m|^\Q$platformTestDirectory\E/|;
737             my $expectedResultIsMaximallyPlatformSpecific = $expectedBase =~ m|^\Q$platformTestDirectory\E/|;
738             if (!$testIsMaximallyPlatformSpecific && !$expectedResultIsMaximallyPlatformSpecific) {
739                 mkpath catfile($platformTestDirectory, dirname($base));
740                 my $expectedFile = catfile($platformTestDirectory, "$base-$expectedTag.txt");
741                 open EXPECTED, ">", $expectedFile or die "could not create $expectedFile\n";
742                 print EXPECTED $actual;
743                 close EXPECTED;
744                 $message .= " (results generated in $platformTestDirectory)";
745             }
746         }
747
748         printFailureMessageForTest($test, $message);
749
750         my $dir = "$testResultsDirectory/$base";
751         $dir =~ s|/([^/]+)$|| or die "Failed to find test name from base\n";
752         my $testName = $1;
753         mkpath $dir;
754
755         deleteExpectedAndActualResults($base);
756         recordActualResultsAndDiff($base, $actual);
757
758         if ($pixelTests && $diffPNG && $diffPNG ne "") {
759             $imagesPresent{$base} = 1;
760
761             open ACTUAL, ">", "$testResultsDirectory/$base-$actualTag.png" or die;
762             print ACTUAL $actualPNG;
763             close ACTUAL;
764
765             open DIFF, ">", "$testResultsDirectory/$base-$diffsTag.png" or die;
766             print DIFF $diffPNG;
767             close DIFF;
768             
769             copy("$expectedDir/$base-$expectedTag.png", "$testResultsDirectory/$base-$expectedTag.png");
770
771             open DIFFHTML, ">$testResultsDirectory/$base-$diffsTag.html" or die;
772             print DIFFHTML "<html>\n";
773             print DIFFHTML "<head>\n";
774             print DIFFHTML "<title>$base Image Compare</title>\n";
775             print DIFFHTML "<script language=\"Javascript\" type=\"text/javascript\">\n";
776             print DIFFHTML "var currentImage = 0;\n";
777             print DIFFHTML "var imageNames = new Array(\"Actual\", \"Expected\");\n";
778             print DIFFHTML "var imagePaths = new Array(\"$testName-$actualTag.png\", \"$testName-$expectedTag.png\");\n";
779             if (-f "$testDirectory/$base-w3c.png") {
780                 copy("$testDirectory/$base-w3c.png", "$testResultsDirectory/$base-w3c.png");
781                 print DIFFHTML "imageNames.push(\"W3C\");\n";
782                 print DIFFHTML "imagePaths.push(\"$testName-w3c.png\");\n";
783             }
784             print DIFFHTML "function animateImage() {\n";
785             print DIFFHTML "    var image = document.getElementById(\"animatedImage\");\n";
786             print DIFFHTML "    var imageText = document.getElementById(\"imageText\");\n";
787             print DIFFHTML "    image.src = imagePaths[currentImage];\n";
788             print DIFFHTML "    imageText.innerHTML = imageNames[currentImage] + \" Image\";\n";
789             print DIFFHTML "    currentImage = (currentImage + 1) % imageNames.length;\n";
790             print DIFFHTML "    setTimeout('animateImage()',2000);\n";
791             print DIFFHTML "}\n";
792             print DIFFHTML "</script>\n";
793             print DIFFHTML "</head>\n";
794             print DIFFHTML "<body onLoad=\"animateImage();\">\n";
795             print DIFFHTML "<table>\n";
796             if ($diffPercentage) {
797                 print DIFFHTML "<tr>\n";
798                 print DIFFHTML "<td>Difference between images: <a href=\"$testName-$diffsTag.png\">$diffPercentage%</a></td>\n";
799                 print DIFFHTML "</tr>\n";
800             }
801             print DIFFHTML "<tr>\n";
802             print DIFFHTML "<td><a href=\"" . toURL("$testDirectory/$test") . "\">test file</a></td>\n";
803             print DIFFHTML "</tr>\n";
804             print DIFFHTML "<tr>\n";
805             print DIFFHTML "<td id=\"imageText\" style=\"text-weight: bold;\">Actual Image</td>\n";
806             print DIFFHTML "</tr>\n";
807             print DIFFHTML "<tr>\n";
808             print DIFFHTML "<td><img src=\"$testName-$actualTag.png\" id=\"animatedImage\"></td>\n";
809             print DIFFHTML "</tr>\n";
810             print DIFFHTML "</table>\n";
811             print DIFFHTML "</body>\n";
812             print DIFFHTML "</html>\n";
813         }
814     }
815
816     if (($count + 1) % $testsPerDumpTool == 0 || $count == $#tests) {
817         if ($shouldCheckLeaks) {
818             my $fileName;
819             if ($testsPerDumpTool == 1) {
820                 $fileName = "$testResultsDirectory/$base-leaks.txt";
821             } else {
822                 $fileName = "$testResultsDirectory/" . fileNameWithNumber($dumpToolName, $leaksOutputFileNumber) . "-leaks.txt";
823             }
824             my $leakCount = countAndPrintLeaks($dumpToolName, $dumpToolPID, $fileName);
825             $totalLeaks += $leakCount;
826             $leaksOutputFileNumber++ if ($leakCount);
827         }
828
829         closeDumpTool();
830     }
831
832     $count++;
833     $counts{$result}++;
834     push @{$tests{$result}}, $test;
835     $testType{$test} = $isText;
836 }
837 printf "\n%0.2fs total testing time\n", (time - $overallStartTime) . "";
838
839 !$isDumpToolOpen || die "Failed to close $dumpToolName.\n";
840
841 closeHTTPD();
842
843 # Because multiple instances of this script are running concurrently we cannot 
844 # safely delete this symlink.
845 # system "rm /tmp/LayoutTests";
846
847 # FIXME: Do we really want to check the image-comparison tool for leaks every time?
848 if ($shouldCheckLeaks && $pixelTests) {
849     $totalLeaks += countAndPrintLeaks("ImageDiff", $imageDiffToolPID, "$testResultsDirectory/ImageDiff-leaks.txt");
850 }
851
852 if ($totalLeaks) {
853     print "\nWARNING: $totalLeaks total leaks found!\n";
854     print "See above for individual leaks results.\n" if ($leaksOutputFileNumber > 2);
855 }
856
857 close IN;
858 close OUT;
859 close ERROR;
860
861 if ($report10Slowest) {
862     print "\n\nThe 10 slowest tests:\n\n";
863     my $count = 0;
864     for my $test (sort slowestcmp keys %durations) {
865         printf "%0.2f secs: %s\n", $durations{$test}, $test;
866         last if ++$count == 10;
867     }
868 }
869
870 print "\n";
871
872 if ($skippedOnly && $counts{"match"}) {
873     print "The following tests are in the Skipped file (" . File::Spec->abs2rel("$platformTestDirectory/Skipped", $testDirectory) . "), but succeeded:\n";
874     foreach my $test (@{$tests{"match"}}) {
875         print "  $test\n";
876     }
877 }
878
879 if ($resetResults || ($counts{match} && $counts{match} == $count)) {
880     print "all $count test cases succeeded\n";
881     unlink $testResults;
882     exit;
883 }
884
885
886 my %text = (
887     match => "succeeded",
888     mismatch => "had incorrect layout",
889     new => "were new",
890     crash => "crashed",
891 );
892
893 for my $type ("match", "mismatch", "new", "crash") {
894     my $c = $counts{$type};
895     if ($c) {
896         my $t = $text{$type};
897         my $message;
898         if ($c == 1) {
899             $t =~ s/were/was/;
900             $message = sprintf "1 test case (%d%%) %s\n", 1 * 100 / $count, $t;
901         } else {
902             $message = sprintf "%d test cases (%d%%) %s\n", $c, $c * 100 / $count, $t;
903         }
904         $message =~ s-\(0%\)-(<1%)-;
905         print $message;
906     }
907 }
908
909 mkpath $testResultsDirectory;
910
911 open HTML, ">", $testResults or die;
912 print HTML "<html>\n";
913 print HTML "<head>\n";
914 print HTML "<title>Layout Test Results</title>\n";
915 print HTML "</head>\n";
916 print HTML "<body>\n";
917
918 if ($counts{mismatch}) {
919     print HTML "<p>Tests where results did not match expected results:</p>\n";
920     print HTML "<table>\n";
921     for my $test (@{$tests{mismatch}}) {
922         my $base = stripExtension($test);
923         print HTML "<tr>\n";            
924         print HTML "<td><a href=\"" . toURL("$testDirectory/$test") . "\">$test</a></td>\n";
925         print HTML htmlForExpectedAndActualResults($base);
926         if ($pixelTests) {
927             if ($imagesPresent{$base}) {
928                 print HTML "<td><a href=\"$base-$expectedTag.png\">expected image</a></td>\n";
929                 print HTML "<td><a href=\"$base-$diffsTag.html\">image diffs</a>\n";
930                 print HTML "<a href=\"$base-$diffsTag.png\">$imageDifferences{$base}%</a></td>\n";
931             } else {
932                 print HTML "<td></td><td></td>\n";
933             }            
934         }
935         print HTML "</tr>\n";
936     }
937     print HTML "</table>\n";
938 }
939
940 if ($counts{crash}) {
941     print HTML "<p>Tests that caused the DumpRenderTree tool to crash:</p>\n";
942     print HTML "<table>\n";
943     for my $test (@{$tests{crash}}) {
944         my $base = stripExtension($test);
945         my $expectedDir = $expectedResultDirectory{$base};
946         print HTML "<tr>\n";
947         print HTML "<td><a href=\"" . toURL("$testDirectory/$test") . "\">$base</a></td>\n";
948         print HTML htmlForExpectedAndActualResults($base);
949         print HTML "<td><a href=\"$base-$errorTag.txt\">stderr</a></td>\n";
950         print HTML "</tr>\n";
951     }
952     print HTML "</table>\n";
953 }
954
955 if ($counts{new}) {
956     print HTML "<p>Tests that had no expected results (probably new):</p>\n";
957     print HTML "<table>\n";
958     for my $test (@{$tests{new}}) {
959         my $base = stripExtension($test);
960         my $expectedDir = $expectedResultDirectory{$base};
961         print HTML "<tr>\n";
962         print HTML "<td><a href=\"" . toURL("$testDirectory/$test") . "\">$base</a></td>\n";
963         print HTML "<td><a href=\"" . toURL("$expectedDir/$base-$expectedTag.txt") . "\">results</a></td>\n";
964         if ($pixelTests && -f "$expectedDir/$base-$expectedTag.png") {
965             print HTML "<td><a href=\"" . toURL("$expectedDir/$base-$expectedTag.png") . "\">image</a></td>\n";
966         }
967         print HTML "</tr>\n";
968     }
969     print HTML "</table>\n";
970 }
971
972 print HTML "</body>\n";
973 print HTML "</html>\n";
974 close HTML;
975
976 if (isQt()) {
977   system "konqueror", $testResults if $launchSafari;
978 } elsif (isGtk()) {
979   system "WebKitTools/Scripts/run-launcher", "--gtk", $configurationOption, $testResults if $launchSafari;
980 } elsif (isCygwin()) {
981   system "cygstart", $testResults if $launchSafari;
982 } else {
983   system "WebKitTools/Scripts/run-safari", $configurationOption, "-NSOpen", $testResults if $launchSafari;
984 }
985
986 closeCygpaths() if isCygwin();
987
988 exit 1;
989
990 sub countAndPrintLeaks($$$)
991 {
992     my ($dumpToolName, $dumpToolPID, $leaksFilePath) = @_;
993
994     print "\n" unless $atLineStart;
995     $atLineStart = 1;
996
997     # We are excluding the following reported leaks so they don't get in our way when looking for WebKit leaks:
998     # This allows us ignore known leaks and only be alerted when new leaks occur. Some leaks are in the old
999     # versions of the system frameworks that are being used by the leaks bots. Even though a leak has been
1000     # fixed, it will be listed here until the bot has been updated with the newer frameworks.
1001
1002     my @typesToExclude = (
1003     );
1004
1005     my @callStacksToExclude = (
1006         "Flash_EnforceLocalSecurity" # leaks in Flash plug-in code, rdar://problem/4449747
1007     );
1008
1009     if (isTiger()) {
1010         # Leak list for the version of Tiger used on the build bot.
1011         push @callStacksToExclude, (
1012             "CFRunLoopRunSpecific \\| malloc_zone_malloc", "CFRunLoopRunSpecific \\| CFAllocatorAllocate ", # leak in CFRunLoopRunSpecific, rdar://problem/4670839
1013             "CGImageSourceGetPropertiesAtIndex", # leak in ImageIO, rdar://problem/4628809
1014             "FOGetCoveredUnicodeChars", # leak in ATS, rdar://problem/3943604
1015             "GetLineDirectionPreference", "InitUnicodeUtilities", # leaks tool falsely reporting leak in CFNotificationCenterAddObserver, rdar://problem/4964790
1016             "ICCFPrefWrapper::GetPrefDictionary", # leaks in Internet Config. code, rdar://problem/4449794
1017             "NSHTTPURLProtocol setResponseHeader:", # leak in multipart/mixed-replace handling in Foundation, no Radar, but fixed in Leopard
1018             "NSURLCache cachedResponseForRequest", # leak in CFURL cache, rdar://problem/4768430
1019             "PCFragPrepareClosureFromFile", # leak in Code Fragment Manager, rdar://problem/3426998
1020             "WebCore::Selection::toRange", # bug in 'leaks', rdar://problem/4967949
1021             "WebCore::SubresourceLoader::create", # bug in 'leaks', rdar://problem/4985806
1022             "_CFPreferencesDomainDeepCopyDictionary", # leak in CFPreferences, rdar://problem/4220786
1023             "_objc_msgForward", # leak in NSSpellChecker, rdar://problem/4965278
1024             "gldGetString", # leak in OpenGL, rdar://problem/5013699
1025             "_setDefaultUserInfoFromURL", # leak in NSHTTPAuthenticator, rdar://problem/5546453 
1026             "SSLHandshake", # leak in SSL, rdar://problem/5546440 
1027             "SecCertificateCreateFromData", # leak in SSL code, rdar://problem/4464397
1028         );
1029         push @typesToExclude, (
1030             "THRD", # bug in 'leaks', rdar://problem/3387783
1031             "DRHT", # ditto (endian little hate i)
1032         );
1033     }
1034
1035     if (isLeopard()) {
1036         # Leak list for the version of Leopard used on the build bot.
1037         push @callStacksToExclude, (
1038             "CFHTTPMessageAppendBytes", # leak in CFNetwork, rdar://problem/5435912
1039             "sendDidReceiveDataCallback", # leak in CFNetwork, rdar://problem/5441619
1040             "_CFHTTPReadStreamReadMark", # leak in CFNetwork, rdar://problem/5441468
1041             "httpProtocolStart", # leak in CFNetwork, rdar://problem/5468837
1042             "_CFURLConnectionSendCallbacks", # leak in CFNetwork, rdar://problem/5441600
1043             "DispatchQTMsg", # leak in Quicktime, PPC only, <rdar://problem/5667132>
1044             "QTMovieContentView createVisualContext", # leak in Quicktime, PPC only, <rdar://problem/5667132>
1045         );
1046     }
1047
1048     my $leaksTool = sourceDir() . "/WebKitTools/Scripts/run-leaks";
1049     my $excludeString = "--exclude-callstack '" . (join "' --exclude-callstack '", @callStacksToExclude) . "'";
1050     $excludeString .= " --exclude-type '" . (join "' --exclude-type '", @typesToExclude) . "'" if @typesToExclude;
1051
1052     print " ? checking for leaks in $dumpToolName\n";
1053     my $leaksOutput = `$leaksTool $excludeString $dumpToolPID`;
1054     my ($count, $bytes) = $leaksOutput =~ /Process $dumpToolPID: (\d+) leaks? for (\d+) total/;
1055     my ($excluded) = $leaksOutput =~ /(\d+) leaks? excluded/;
1056
1057     my $adjustedCount = $count;
1058     $adjustedCount -= $excluded if $excluded;
1059
1060     if (!$adjustedCount) {
1061         print " - no leaks found\n";
1062         unlink $leaksFilePath;
1063         return 0;
1064     } else {
1065         my $dir = $leaksFilePath;
1066         $dir =~ s|/[^/]+$|| or die;
1067         mkpath $dir;
1068
1069         if ($excluded) {
1070             print " + $adjustedCount leaks ($bytes bytes including $excluded excluded leaks) were found, details in $leaksFilePath\n";
1071         } else {
1072             print " + $count leaks ($bytes bytes) were found, details in $leaksFilePath\n";
1073         }
1074
1075         open LEAKS, ">", $leaksFilePath or die;
1076         print LEAKS $leaksOutput;
1077         close LEAKS;
1078     }
1079
1080     return $adjustedCount;
1081 }
1082
1083 # Break up a path into the directory (with slash) and base name.
1084 sub splitpath($)
1085 {
1086     my ($path) = @_;
1087
1088     my $pathSeparator = "/";
1089     my $dirname = dirname($path) . $pathSeparator;
1090     $dirname = "" if $dirname eq "." . $pathSeparator;
1091
1092     return ($dirname, basename($path));
1093 }
1094
1095 # Sort first by directory, then by file, so all paths in one directory are grouped
1096 # rather than being interspersed with items from subdirectories.
1097 # Use numericcmp to sort directory and filenames to make order logical.
1098 sub pathcmp($$)
1099 {
1100     my ($patha, $pathb) = @_;
1101
1102     my ($dira, $namea) = splitpath($patha);
1103     my ($dirb, $nameb) = splitpath($pathb);
1104
1105     return numericcmp($dira, $dirb) if $dira ne $dirb;
1106     return numericcmp($namea, $nameb);
1107 }
1108
1109 # Sort numeric parts of strings as numbers, other parts as strings.
1110 # Makes 1.33 come after 1.3, which is cool.
1111 sub numericcmp($$)
1112 {
1113     my ($aa, $bb) = @_;
1114
1115     my @a = split /(\d+)/, $aa;
1116     my @b = split /(\d+)/, $bb;
1117
1118     # Compare one chunk at a time.
1119     # Each chunk is either all numeric digits, or all not numeric digits.
1120     while (@a && @b) {
1121         my $a = shift @a;
1122         my $b = shift @b;
1123         
1124         # Use numeric comparison if chunks are non-equal numbers.
1125         return $a <=> $b if $a =~ /^\d/ && $b =~ /^\d/ && $a != $b;
1126
1127         # Use string comparison if chunks are any other kind of non-equal string.
1128         return $a cmp $b if $a ne $b;
1129     }
1130     
1131     # One of the two is now empty; compare lengths for result in this case.
1132     return @a <=> @b;
1133 }
1134
1135 # Sort slowest tests first.
1136 sub slowestcmp($$)
1137 {
1138     my ($testa, $testb) = @_;
1139
1140     my $dura = $durations{$testa};
1141     my $durb = $durations{$testb};
1142     return $durb <=> $dura if $dura != $durb;
1143     return pathcmp($testa, $testb);
1144 }
1145
1146 sub openDumpTool()
1147 {
1148     return if $isDumpToolOpen;
1149
1150     # Save some requires variables for the linux environment...
1151     my $homeDir = $ENV{'HOME'};
1152     my $libraryPath = $ENV{'LD_LIBRARY_PATH'};
1153     my $dyldLibraryPath = $ENV{'DYLD_LIBRARY_PATH'};
1154     my $dbusAddress = $ENV{'DBUS_SESSION_BUS_ADDRESS'};
1155     my $display = $ENV{'DISPLAY'};
1156     my $testfonts = $ENV{'WEBKIT_TESTFONTS'};
1157
1158     my $homeDrive = $ENV{'HOMEDRIVE'};
1159     my $homePath = $ENV{'HOMEPATH'};
1160         
1161     local %ENV;
1162     if (isQt() || isGtk()) {
1163         if (defined $display) {
1164             $ENV{DISPLAY} = $display;
1165         } else {
1166             $ENV{DISPLAY} = ":1";
1167         }
1168         $ENV{'WEBKIT_TESTFONTS'} = $testfonts if defined($testfonts);
1169         $ENV{HOME} = $homeDir;
1170         if (defined $libraryPath) {
1171             $ENV{LD_LIBRARY_PATH} = $libraryPath;
1172         }
1173         if (defined $dyldLibraryPath) {
1174             $ENV{DYLD_LIBRARY_PATH} = $dyldLibraryPath;
1175         }
1176         if (defined $dbusAddress) {
1177             $ENV{DBUS_SESSION_BUS_ADDRESS} = $dbusAddress;
1178         }
1179     }
1180     $ENV{DYLD_FRAMEWORK_PATH} = $productDir;
1181     $ENV{XML_CATALOG_FILES} = ""; # work around missing /etc/catalog <rdar://problem/4292995>
1182     $ENV{MallocStackLogging} = 1 if $shouldCheckLeaks;
1183     $ENV{DYLD_INSERT_LIBRARIES} = "/usr/lib/libgmalloc.dylib" if $guardMalloc;
1184     
1185     if (isCygwin()) {
1186         $ENV{HOMEDRIVE} = $homeDrive;
1187         $ENV{HOMEPATH} = $homePath;
1188         if ($testfonts) {
1189             $ENV{WEBKIT_TESTFONTS} = $testfonts;
1190         }
1191         setPathForRunningWebKitApp(\%ENV) if isCygwin();
1192     }
1193         
1194     my @args = ();
1195     if ($useValgrind) {
1196       push @args, $dumpTool;
1197     }
1198     push @args, @toolArgs;
1199     if ($useValgrind) {
1200       $dumpTool = "valgrind";
1201     }
1202     $dumpToolPID = open3(\*OUT, \*IN, \*ERROR, $dumpTool, @args) or die "Failed to start tool: $dumpTool\n";
1203     $isDumpToolOpen = 1;
1204     $dumpToolCrashed = 0;
1205 }
1206
1207 sub closeDumpTool()
1208 {
1209     return if !$isDumpToolOpen;
1210
1211     close IN;
1212     close OUT;
1213     close ERROR;
1214     waitpid $dumpToolPID, 0;
1215     $isDumpToolOpen = 0;
1216 }
1217
1218 sub dumpToolDidCrash()
1219 {
1220     return 1 if $dumpToolCrashed;
1221     return 0 unless $isDumpToolOpen;
1222
1223     my $pid = waitpid(-1, WNOHANG);
1224     return $pid == $dumpToolPID;
1225 }
1226
1227 sub openHTTPDIfNeeded()
1228 {
1229     return if $isHttpdOpen;
1230
1231     mkdir "/tmp/WebKit";
1232     
1233     if (-f "/tmp/WebKit/httpd.pid") {
1234         my $oldPid = `cat /tmp/WebKit/httpd.pid`;
1235         chomp $oldPid;
1236         if (0 != kill 0, $oldPid) {
1237             print "\nhttpd is already running: pid $oldPid, killing...\n";
1238             kill 15, $oldPid;
1239             
1240             my $retryCount = 20;
1241             while ((0 != kill 0, $oldPid) && $retryCount) {
1242                 sleep 1;
1243                 --$retryCount;
1244             }
1245             
1246             die "Timed out waiting for httpd to quit" unless $retryCount;
1247         }
1248     }
1249     
1250     my $httpdPath = "/usr/sbin/httpd";
1251     my $httpdConfig;
1252     if (isCygwin()) {
1253         my $windowsConfDirectory = "$testDirectory/http/conf/";
1254         unless (-x "/usr/lib/apache/libphp4.dll") {
1255             copy("$windowsConfDirectory/libphp4.dll", "/usr/lib/apache/libphp4.dll");
1256             chmod(0755, "/usr/lib/apache/libphp4.dll");
1257         }
1258         $httpdConfig = "$windowsConfDirectory/cygwin-httpd.conf";
1259     } elsif (isDebianBased()) {
1260         $httpdPath = "/usr/sbin/apache2";
1261         $httpdConfig = "$testDirectory/http/conf/apache2-debian-httpd.conf";
1262     } else {
1263         $httpdConfig = "$testDirectory/http/conf/httpd.conf";
1264         $httpdConfig = "$testDirectory/http/conf/apache2-httpd.conf" if `$httpdPath -v` =~ m|Apache/2|;
1265     }
1266     my $documentRoot = "$testDirectory/http/tests";
1267     my $typesConfig = "$testDirectory/http/conf/mime.types";
1268     my $listen = "127.0.0.1:$httpdPort";
1269     my $absTestResultsDirectory = File::Spec->rel2abs(glob $testResultsDirectory);
1270     my $sslCertificate = "$testDirectory/http/conf/webkit-httpd.pem";
1271
1272     mkpath $absTestResultsDirectory;
1273
1274     my @args = (
1275         "-f", "$httpdConfig",
1276         "-C", "DocumentRoot \"$documentRoot\"",
1277         "-C", "Listen $listen",
1278         "-c", "TypesConfig \"$typesConfig\"",
1279         "-c", "CustomLog \"$absTestResultsDirectory/access_log.txt\" common",
1280         "-c", "ErrorLog \"$absTestResultsDirectory/error_log.txt\"",
1281         # Apache wouldn't run CGIs with permissions==700 otherwise
1282         "-c", "User \"#$<\""
1283     );
1284
1285     # FIXME: Enable this on Windows once <rdar://problem/5345985> is fixed
1286     push(@args, "-c", "SSLCertificateFile \"$sslCertificate\"") unless isCygwin();
1287
1288     open2(\*HTTPDIN, \*HTTPDOUT, $httpdPath, @args);
1289
1290     my $retryCount = 20;
1291     while (system("/usr/bin/curl -q --silent --stderr - --output /dev/null $listen") && $retryCount) {
1292         sleep 1;
1293         --$retryCount;
1294     }
1295     
1296     die "Timed out waiting for httpd to start" unless $retryCount;
1297     
1298     $isHttpdOpen = 1;
1299 }
1300
1301 sub closeHTTPD()
1302 {
1303     return if !$isHttpdOpen;
1304
1305     close HTTPDIN;
1306     close HTTPDOUT;
1307
1308     kill 15, `cat /tmp/WebKit/httpd.pid` if -f "/tmp/WebKit/httpd.pid";
1309
1310     $isHttpdOpen = 0;
1311 }
1312
1313 sub fileNameWithNumber($$)
1314 {
1315     my ($base, $number) = @_;
1316     return "$base$number" if ($number > 1);
1317     return $base;
1318 }
1319
1320 sub processIgnoreTests($) {
1321     my @ignoreList = split(/\s*,\s*/, shift);
1322     my $addIgnoredDirectories = sub {
1323         return () if exists $ignoredLocalDirectories{basename($File::Find::dir)};
1324         $ignoredDirectories{File::Spec->abs2rel($File::Find::dir, $testDirectory)} = 1;
1325         return @_;
1326     };
1327     foreach my $item (@ignoreList) {
1328         my $path = catfile($testDirectory, $item); 
1329         if (-d $path) {
1330             $ignoredDirectories{$item} = 1;
1331             find({ preprocess => $addIgnoredDirectories, wanted => sub {} }, $path);
1332         }
1333         elsif (-f $path) {
1334             $ignoredFiles{$item} = 1;
1335         }
1336         else {
1337             print "ignoring '$item' on ignore-tests list\n";
1338         }
1339     }
1340 }
1341
1342 sub stripExtension($)
1343 {
1344     my ($test) = @_;
1345
1346     $test =~ s/\.[a-zA-Z]+$//;
1347     return $test;
1348 }
1349
1350 sub isTextOnlyTest($)
1351 {
1352     my ($actual) = @_;
1353     my $isText;
1354     if ($actual =~ /^layer at/ms) {
1355         $isText = 0;
1356     } else {
1357         $isText = 1;
1358     }
1359     return $isText;
1360 }
1361
1362 sub expectedDirectoryForTest($;$;$)
1363 {
1364     my ($base, $isText, $isPixelTest) = @_;
1365
1366     my @directories = @platformHierarchy;
1367     push @directories, map { catdir($platformBaseDirectory, $_) } qw(mac-leopard mac) if isCygwin();
1368     push @directories, $expectedDirectory;
1369
1370     # If we already have expected results, just return their location.
1371     if ($isPixelTest) {
1372         foreach my $directory (@directories) {
1373             return $directory if (-f "$directory/$base-$expectedTag.png");
1374         }
1375     } else {
1376         foreach my $directory (@directories) {
1377             return $directory if (-f "$directory/$base-$expectedTag.txt");
1378         }
1379     }
1380
1381     # For platform-specific tests, the results should go right next to the test itself.
1382     # Note: The return value of this subroutine will be concatenated with $base
1383     # to determine the location of the new results, so returning $expectedDirectory
1384     # will put the results right next to the test.
1385     # FIXME: We want to allow platform/mac tests with platform/mac-leopard results,
1386     # so this needs to be enhanced.
1387     return $expectedDirectory if $base =~ /^platform/;
1388
1389     # For cross-platform tests, text-only results should go in the cross-platform directory,
1390     # while render tree dumps should go in the least-specific platform directory.
1391     return $isText ? $expectedDirectory : $platformHierarchy[$#platformHierarchy];
1392 }
1393
1394 sub printFailureMessageForTest($$)
1395 {
1396     my ($test, $description) = @_;
1397
1398     unless ($verbose) {
1399         print "\n" unless $atLineStart;
1400         print "$test -> ";
1401     }
1402     print "$description\n";
1403     $atLineStart = 1;
1404 }
1405
1406 my %cygpaths = ();
1407
1408 sub openCygpathIfNeeded($)
1409 {
1410     my ($options) = @_;
1411
1412     return unless isCygwin();
1413     return $cygpaths{$options} if $cygpaths{$options} && $cygpaths{$options}->{"open"};
1414
1415     local (*CYGPATHIN, *CYGPATHOUT);
1416     my $pid = open2(\*CYGPATHIN, \*CYGPATHOUT, "cygpath -f - $options");
1417     my $cygpath =  {
1418         "pid" => $pid,
1419         "in" => *CYGPATHIN,
1420         "out" => *CYGPATHOUT,
1421         "open" => 1
1422     };
1423
1424     $cygpaths{$options} = $cygpath;
1425
1426     return $cygpath;
1427 }
1428
1429 sub closeCygpaths()
1430 {
1431     return unless isCygwin();
1432
1433     foreach my $cygpath (values(%cygpaths)) {
1434         close $cygpath->{"in"};
1435         close $cygpath->{"out"};
1436         waitpid($cygpath->{"pid"}, 0);
1437         $cygpath->{"open"} = 0;
1438
1439     }
1440 }
1441
1442 sub convertPathUsingCygpath($$)
1443 {
1444     my ($path, $options) = @_;
1445
1446     my $cygpath = openCygpathIfNeeded($options);
1447     local *inFH = $cygpath->{"in"};
1448     local *outFH = $cygpath->{"out"};
1449     print outFH $path . "\n";
1450     chomp(my $convertedPath = <inFH>);
1451     return $convertedPath;
1452 }
1453
1454 sub toWindowsPath($)
1455 {
1456     my ($path) = @_;
1457     return unless isCygwin();
1458
1459     return convertPathUsingCygpath($path, "-w");
1460 }
1461
1462 sub toURL($)
1463 {
1464     my ($path) = @_;
1465     return $path unless isCygwin();
1466     
1467     return "file:///" . convertPathUsingCygpath($path, "-m");
1468 }
1469
1470 sub validateSkippedArg($$;$)
1471 {
1472     my ($option, $value, $value2) = @_;
1473     my %validSkippedValues = map { $_ => 1 } qw(default ignore only);
1474     $value = lc($value);
1475     die "Invalid argument '" . $value . "' for option $option" unless $validSkippedValues{$value};
1476     $treatSkipped = $value;
1477 }
1478
1479 sub htmlForExpectedAndActualResults($)
1480 {
1481     my ($base) = @_;
1482
1483     return "<td></td><td></td><td></td>\n" unless -s "$testResultsDirectory/$base-$diffsTag.txt";
1484
1485     return "<td><a href=\"$base-$expectedTag.txt\">expected</a></td>\n"
1486          . "<td><a href=\"$base-$actualTag.txt\">actual</a></td>\n"
1487          . "<td><a href=\"$base-$diffsTag.txt\">diffs</a></td>\n";
1488 }
1489
1490 sub deleteExpectedAndActualResults($)
1491 {
1492     my ($base) = @_;
1493
1494     unlink "$testResultsDirectory/$base-$actualTag.txt";
1495     unlink "$testResultsDirectory/$base-$diffsTag.txt";
1496     unlink "$testResultsDirectory/$base-$errorTag.txt";
1497 }
1498
1499 sub recordActualResultsAndDiff($$)
1500 {
1501     my ($base, $actual) = @_;
1502
1503     return unless length($actual);
1504
1505     open ACTUAL, ">", "$testResultsDirectory/$base-$actualTag.txt" or die "Couldn't open actual results file for $base";
1506     print ACTUAL $actual;
1507     close ACTUAL;
1508
1509     my $expectedDir = $expectedResultDirectory{$base};
1510     copy("$expectedDir/$base-$expectedTag.txt", "$testResultsDirectory/$base-$expectedTag.txt");
1511
1512     system "diff -u \"$testResultsDirectory/$base-$expectedTag.txt\" \"$testResultsDirectory/$base-$actualTag.txt\" > \"$testResultsDirectory/$base-$diffsTag.txt\"";
1513 }
1514
1515 sub buildPlatformHierarchy()
1516 {
1517     mkpath($platformTestDirectory) if ($platform eq "undefined" && !-d "$platformTestDirectory");
1518
1519     my @platforms = split('-', $platform);
1520     my @hierarchy;
1521     for (my $i=0; $i < @platforms; $i++) {
1522         my $scoped = catdir($platformBaseDirectory, join('-', @platforms[0..($#platforms - $i)]));
1523         push(@hierarchy, $scoped) if (-d $scoped);
1524     }
1525
1526     return @hierarchy;
1527 }