2011-01-20 Dirk Pranke <dpranke@chromium.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 test_expectations
33
34 import cPickle
35
36
37 # FIXME: This is backwards.  Each TestFailure subclass should know what
38 # test_expectation type it corresponds too.  Then this method just
39 # collects them all from the failure list and returns the worst one.
40 def determine_result_type(failure_list):
41     """Takes a set of test_failures and returns which result type best fits
42     the list of failures. "Best fits" means we use the worst type of failure.
43
44     Returns:
45       one of the test_expectations result types - PASS, TEXT, CRASH, etc."""
46
47     if not failure_list or len(failure_list) == 0:
48         return test_expectations.PASS
49
50     failure_types = [type(f) for f in failure_list]
51     if FailureCrash in failure_types:
52         return test_expectations.CRASH
53     elif FailureTimeout in failure_types:
54         return test_expectations.TIMEOUT
55     elif (FailureMissingResult in failure_types or
56           FailureMissingImage in failure_types or
57           FailureMissingImageHash in failure_types):
58         return test_expectations.MISSING
59     else:
60         is_text_failure = FailureTextMismatch in failure_types
61         is_image_failure = (FailureImageHashIncorrect in failure_types or
62                             FailureImageHashMismatch in failure_types)
63         if is_text_failure and is_image_failure:
64             return test_expectations.IMAGE_PLUS_TEXT
65         elif is_text_failure:
66             return test_expectations.TEXT
67         elif is_image_failure:
68             return test_expectations.IMAGE
69         else:
70             raise ValueError("unclassifiable set of failures: "
71                              + str(failure_types))
72
73
74 class TestFailure(object):
75     """Abstract base class that defines the failure interface."""
76
77     @staticmethod
78     def loads(s):
79         """Creates a TestFailure object from the specified string."""
80         return cPickle.loads(s)
81
82     @staticmethod
83     def message():
84         """Returns a string describing the failure in more detail."""
85         raise NotImplementedError
86
87     def __eq__(self, other):
88         return self.__class__.__name__ == other.__class__.__name__
89
90     def __ne__(self, other):
91         return self.__class__.__name__ != other.__class__.__name__
92
93     def __hash__(self):
94         return hash(self.__class__.__name__)
95
96     def dumps(self):
97         """Returns the string/JSON representation of a TestFailure."""
98         return cPickle.dumps(self)
99
100     def result_html_output(self, filename):
101         """Returns an HTML string to be included on the results.html page."""
102         raise NotImplementedError
103
104     def should_kill_dump_render_tree(self):
105         """Returns True if we should kill DumpRenderTree before the next
106         test."""
107         return False
108
109     def relative_output_filename(self, filename, modifier):
110         """Returns a relative filename inside the output dir that contains
111         modifier.
112
113         For example, if filename is fast\dom\foo.html and modifier is
114         "-expected.txt", the return value is fast\dom\foo-expected.txt
115
116         Args:
117           filename: relative filename to test file
118           modifier: a string to replace the extension of filename with
119
120         Return:
121           The relative windows path to the output filename
122         """
123         # FIXME: technically this breaks if files don't use ".ext" to indicate
124         # the extension, but passing in a Filesystem object here is a huge
125         # hassle.
126         return filename[:filename.rfind('.')] + modifier
127
128
129 class FailureWithType(TestFailure):
130     """Base class that produces standard HTML output based on the test type.
131
132     Subclasses may commonly choose to override the ResultHtmlOutput, but still
133     use the standard OutputLinks.
134     """
135
136     # Filename suffixes used by ResultHtmlOutput.
137     OUT_FILENAMES = ()
138
139     def output_links(self, filename, out_names):
140         """Returns a string holding all applicable output file links.
141
142         Args:
143           filename: the test filename, used to construct the result file names
144           out_names: list of filename suffixes for the files. If three or more
145               suffixes are in the list, they should be [actual, expected, diff,
146               wdiff]. Two suffixes should be [actual, expected], and a
147               single item is the [actual] filename suffix.
148               If out_names is empty, returns the empty string.
149         """
150         # FIXME: Seems like a bad idea to separate the display name data
151         # from the path data by hard-coding the display name here
152         # and passing in the path information via out_names.
153         #
154         # FIXME: Also, we don't know for sure that these files exist,
155         # and we shouldn't be creating links to files that don't exist
156         # (for example, if we don't actually have wdiff output).
157         links = ['']
158         uris = [self.relative_output_filename(filename, fn) for
159                 fn in out_names]
160         if len(uris) > 1:
161             links.append("<a href='%s'>expected</a>" % uris[1])
162         if len(uris) > 0:
163             links.append("<a href='%s'>actual</a>" % uris[0])
164         if len(uris) > 2:
165             links.append("<a href='%s'>diff</a>" % uris[2])
166         if len(uris) > 3:
167             links.append("<a href='%s'>wdiff</a>" % uris[3])
168         if len(uris) > 4:
169             links.append("<a href='%s'>pretty diff</a>" % uris[4])
170         return ' '.join(links)
171
172     def result_html_output(self, filename):
173         return self.message() + self.output_links(filename, self.OUT_FILENAMES)
174
175
176 class FailureTimeout(TestFailure):
177     """Test timed out.  We also want to restart DumpRenderTree if this
178     happens."""
179
180     @staticmethod
181     def message():
182         return "Test timed out"
183
184     def result_html_output(self, filename):
185         return "<strong>%s</strong>" % self.message()
186
187     def should_kill_dump_render_tree(self):
188         return True
189
190
191 class FailureCrash(TestFailure):
192     """DumpRenderTree crashed."""
193
194     @staticmethod
195     def message():
196         return "DumpRenderTree crashed"
197
198     def result_html_output(self, filename):
199         # FIXME: create a link to the minidump file
200         stack = self.relative_output_filename(filename, "-stack.txt")
201         return "<strong>%s</strong> <a href=%s>stack</a>" % (self.message(),
202                                                              stack)
203
204     def should_kill_dump_render_tree(self):
205         return True
206
207
208 class FailureMissingResult(FailureWithType):
209     """Expected result was missing."""
210     OUT_FILENAMES = ("-actual.txt",)
211
212     @staticmethod
213     def message():
214         return "No expected results found"
215
216     def result_html_output(self, filename):
217         return ("<strong>%s</strong>" % self.message() +
218                 self.output_links(filename, self.OUT_FILENAMES))
219
220
221 class FailureTextMismatch(FailureWithType):
222     """Text diff output failed."""
223     # Filename suffixes used by ResultHtmlOutput.
224     # FIXME: Why don't we use the constants from TestTypeBase here?
225     OUT_FILENAMES = ("-actual.txt", "-expected.txt", "-diff.txt",
226                      "-wdiff.html", "-pretty-diff.html")
227
228     @staticmethod
229     def message():
230         return "Text diff mismatch"
231
232
233 class FailureMissingImageHash(FailureWithType):
234     """Actual result hash was missing."""
235     # Chrome doesn't know to display a .checksum file as text, so don't bother
236     # putting in a link to the actual result.
237
238     @staticmethod
239     def message():
240         return "No expected image hash found"
241
242     def result_html_output(self, filename):
243         return "<strong>%s</strong>" % self.message()
244
245
246 class FailureMissingImage(FailureWithType):
247     """Actual result image was missing."""
248     OUT_FILENAMES = ("-actual.png",)
249
250     @staticmethod
251     def message():
252         return "No expected image found"
253
254     def result_html_output(self, filename):
255         return ("<strong>%s</strong>" % self.message() +
256                 self.output_links(filename, self.OUT_FILENAMES))
257
258
259 class FailureImageHashMismatch(FailureWithType):
260     """Image hashes didn't match."""
261     OUT_FILENAMES = ("-actual.png", "-expected.png", "-diff.png")
262
263     @staticmethod
264     def message():
265         # We call this a simple image mismatch to avoid confusion, since
266         # we link to the PNGs rather than the checksums.
267         return "Image mismatch"
268
269
270 class FailureImageHashIncorrect(FailureWithType):
271     """Actual result hash is incorrect."""
272     # Chrome doesn't know to display a .checksum file as text, so don't bother
273     # putting in a link to the actual result.
274
275     @staticmethod
276     def message():
277         return "Images match, expected image hash incorrect. "
278
279     def result_html_output(self, filename):
280         return "<strong>%s</strong>" % self.message()
281
282 # Convenient collection of all failure classes for anything that might
283 # need to enumerate over them all.
284 ALL_FAILURE_CLASSES = (FailureTimeout, FailureCrash, FailureMissingResult,
285                        FailureTextMismatch, FailureMissingImageHash,
286                        FailureMissingImage, FailureImageHashMismatch,
287                        FailureImageHashIncorrect)