2011-01-08 Eric Seidel <eric@webkit.org>
[WebKit.git] / Tools / Scripts / webkitpy / layout_tests / layout_package / test_failures.py
1 #!/usr/bin/env python
2 # Copyright (C) 2010 Google Inc. All rights reserved.
3 #
4 # Redistribution and use in source and binary forms, with or without
5 # modification, are permitted provided that the following conditions are
6 # met:
7 #
8 #     * Redistributions of source code must retain the above copyright
9 # notice, this list of conditions and the following disclaimer.
10 #     * Redistributions in binary form must reproduce the above
11 # copyright notice, this list of conditions and the following disclaimer
12 # in the documentation and/or other materials provided with the
13 # distribution.
14 #     * Neither the name of Google Inc. nor the names of its
15 # contributors may be used to endorse or promote products derived from
16 # this software without specific prior written permission.
17 #
18 # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
19 # "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
20 # LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
21 # A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
22 # OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
23 # SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
24 # LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
25 # DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
26 # THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
27 # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
28 # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
29
30 """Classes for failures that occur during tests."""
31
32 import os
33 import test_expectations
34
35 import cPickle
36
37
38 # FIXME: This is backwards.  Each TestFailure subclass should know what
39 # test_expectation type it corresponds too.  Then this method just
40 # collects them all from the failure list and returns the worst one.
41 def determine_result_type(failure_list):
42     """Takes a set of test_failures and returns which result type best fits
43     the list of failures. "Best fits" means we use the worst type of failure.
44
45     Returns:
46       one of the test_expectations result types - PASS, TEXT, CRASH, etc."""
47
48     if not failure_list or len(failure_list) == 0:
49         return test_expectations.PASS
50
51     failure_types = [type(f) for f in failure_list]
52     if FailureCrash in failure_types:
53         return test_expectations.CRASH
54     elif FailureTimeout in failure_types:
55         return test_expectations.TIMEOUT
56     elif (FailureMissingResult in failure_types or
57           FailureMissingImage in failure_types or
58           FailureMissingImageHash in failure_types):
59         return test_expectations.MISSING
60     else:
61         is_text_failure = FailureTextMismatch in failure_types
62         is_image_failure = (FailureImageHashIncorrect in failure_types or
63                             FailureImageHashMismatch in failure_types)
64         if is_text_failure and is_image_failure:
65             return test_expectations.IMAGE_PLUS_TEXT
66         elif is_text_failure:
67             return test_expectations.TEXT
68         elif is_image_failure:
69             return test_expectations.IMAGE
70         else:
71             raise ValueError("unclassifiable set of failures: "
72                              + str(failure_types))
73
74
75 class TestFailure(object):
76     """Abstract base class that defines the failure interface."""
77
78     @staticmethod
79     def loads(s):
80         """Creates a TestFailure object from the specified string."""
81         return cPickle.loads(s)
82
83     @staticmethod
84     def message():
85         """Returns a string describing the failure in more detail."""
86         raise NotImplementedError
87
88     def __eq__(self, other):
89         return self.__class__.__name__ == other.__class__.__name__
90
91     def __ne__(self, other):
92         return self.__class__.__name__ != other.__class__.__name__
93
94     def __hash__(self):
95         return hash(self.__class__.__name__)
96
97     def dumps(self):
98         """Returns the string/JSON representation of a TestFailure."""
99         return cPickle.dumps(self)
100
101     def result_html_output(self, filename):
102         """Returns an HTML string to be included on the results.html page."""
103         raise NotImplementedError
104
105     def should_kill_dump_render_tree(self):
106         """Returns True if we should kill DumpRenderTree before the next
107         test."""
108         return False
109
110     def relative_output_filename(self, filename, modifier):
111         """Returns a relative filename inside the output dir that contains
112         modifier.
113
114         For example, if filename is fast\dom\foo.html and modifier is
115         "-expected.txt", the return value is fast\dom\foo-expected.txt
116
117         Args:
118           filename: relative filename to test file
119           modifier: a string to replace the extension of filename with
120
121         Return:
122           The relative windows path to the output filename
123         """
124         return os.path.splitext(filename)[0] + modifier
125
126
127 class FailureWithType(TestFailure):
128     """Base class that produces standard HTML output based on the test type.
129
130     Subclasses may commonly choose to override the ResultHtmlOutput, but still
131     use the standard OutputLinks.
132     """
133
134     # Filename suffixes used by ResultHtmlOutput.
135     OUT_FILENAMES = ()
136
137     def output_links(self, filename, out_names):
138         """Returns a string holding all applicable output file links.
139
140         Args:
141           filename: the test filename, used to construct the result file names
142           out_names: list of filename suffixes for the files. If three or more
143               suffixes are in the list, they should be [actual, expected, diff,
144               wdiff]. Two suffixes should be [actual, expected], and a
145               single item is the [actual] filename suffix.
146               If out_names is empty, returns the empty string.
147         """
148         # FIXME: Seems like a bad idea to separate the display name data
149         # from the path data by hard-coding the display name here
150         # and passing in the path information via out_names.
151         #
152         # FIXME: Also, we don't know for sure that these files exist,
153         # and we shouldn't be creating links to files that don't exist
154         # (for example, if we don't actually have wdiff output).
155         links = ['']
156         uris = [self.relative_output_filename(filename, fn) for
157                 fn in out_names]
158         if len(uris) > 1:
159             links.append("<a href='%s'>expected</a>" % uris[1])
160         if len(uris) > 0:
161             links.append("<a href='%s'>actual</a>" % uris[0])
162         if len(uris) > 2:
163             links.append("<a href='%s'>diff</a>" % uris[2])
164         if len(uris) > 3:
165             links.append("<a href='%s'>wdiff</a>" % uris[3])
166         if len(uris) > 4:
167             links.append("<a href='%s'>pretty diff</a>" % uris[4])
168         return ' '.join(links)
169
170     def result_html_output(self, filename):
171         return self.message() + self.output_links(filename, self.OUT_FILENAMES)
172
173
174 class FailureTimeout(TestFailure):
175     """Test timed out.  We also want to restart DumpRenderTree if this
176     happens."""
177
178     @staticmethod
179     def message():
180         return "Test timed out"
181
182     def result_html_output(self, filename):
183         return "<strong>%s</strong>" % self.message()
184
185     def should_kill_dump_render_tree(self):
186         return True
187
188
189 class FailureCrash(TestFailure):
190     """DumpRenderTree crashed."""
191
192     @staticmethod
193     def message():
194         return "DumpRenderTree crashed"
195
196     def result_html_output(self, filename):
197         # FIXME: create a link to the minidump file
198         stack = self.relative_output_filename(filename, "-stack.txt")
199         return "<strong>%s</strong> <a href=%s>stack</a>" % (self.message(),
200                                                              stack)
201
202     def should_kill_dump_render_tree(self):
203         return True
204
205
206 class FailureMissingResult(FailureWithType):
207     """Expected result was missing."""
208     OUT_FILENAMES = ("-actual.txt",)
209
210     @staticmethod
211     def message():
212         return "No expected results found"
213
214     def result_html_output(self, filename):
215         return ("<strong>%s</strong>" % self.message() +
216                 self.output_links(filename, self.OUT_FILENAMES))
217
218
219 class FailureTextMismatch(FailureWithType):
220     """Text diff output failed."""
221     # Filename suffixes used by ResultHtmlOutput.
222     # FIXME: Why don't we use the constants from TestTypeBase here?
223     OUT_FILENAMES = ("-actual.txt", "-expected.txt", "-diff.txt",
224                      "-wdiff.html", "-pretty-diff.html")
225
226     @staticmethod
227     def message():
228         return "Text diff mismatch"
229
230
231 class FailureMissingImageHash(FailureWithType):
232     """Actual result hash was missing."""
233     # Chrome doesn't know to display a .checksum file as text, so don't bother
234     # putting in a link to the actual result.
235
236     @staticmethod
237     def message():
238         return "No expected image hash found"
239
240     def result_html_output(self, filename):
241         return "<strong>%s</strong>" % self.message()
242
243
244 class FailureMissingImage(FailureWithType):
245     """Actual result image was missing."""
246     OUT_FILENAMES = ("-actual.png",)
247
248     @staticmethod
249     def message():
250         return "No expected image found"
251
252     def result_html_output(self, filename):
253         return ("<strong>%s</strong>" % self.message() +
254                 self.output_links(filename, self.OUT_FILENAMES))
255
256
257 class FailureImageHashMismatch(FailureWithType):
258     """Image hashes didn't match."""
259     OUT_FILENAMES = ("-actual.png", "-expected.png", "-diff.png")
260
261     @staticmethod
262     def message():
263         # We call this a simple image mismatch to avoid confusion, since
264         # we link to the PNGs rather than the checksums.
265         return "Image mismatch"
266
267
268 class FailureImageHashIncorrect(FailureWithType):
269     """Actual result hash is incorrect."""
270     # Chrome doesn't know to display a .checksum file as text, so don't bother
271     # putting in a link to the actual result.
272
273     @staticmethod
274     def message():
275         return "Images match, expected image hash incorrect. "
276
277     def result_html_output(self, filename):
278         return "<strong>%s</strong>" % self.message()
279
280 # Convenient collection of all failure classes for anything that might
281 # need to enumerate over them all.
282 ALL_FAILURE_CLASSES = (FailureTimeout, FailureCrash, FailureMissingResult,
283                        FailureTextMismatch, FailureMissingImageHash,
284                        FailureMissingImage, FailureImageHashMismatch,
285                        FailureImageHashIncorrect)