1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
|
#!/usr/bin/env python
# Copyright (C) 2010 Google Inc. All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions
# are met:
#
# 1. Redistributions of source code must retain the above copyright
# notice, this list of conditions and the following disclaimer.
# 2. Redistributions in binary form must reproduce the above copyright
# notice, this list of conditions and the following disclaimer in the
# documentation and/or other materials provided with the distribution.
#
# THIS SOFTWARE IS PROVIDED BY APPLE AND ITS CONTRIBUTORS "AS IS" AND ANY
# EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
# WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
# DISCLAIMED. IN NO EVENT SHALL APPLE OR ITS CONTRIBUTORS BE LIABLE FOR ANY
# DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
# (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
# LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
# ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
# THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
import os
import re
class NaiveImageDiffer(object):
def same_image(self, img1, img2):
return img1 == img2
class TestOutput(object):
"""Represents the output that a single layout test generates when it is run
on a particular platform.
Note that this is the raw output that is produced when the layout test is
run, not the results of the subsequent comparison between that output and
the expected output."""
def __init__(self, platform, output_type, files):
self._output_type = output_type
self._files = files
file = files[0] # Pick some file to do test name calculation.
self._name = self._extract_test_name(file.name())
self._is_actual = '-actual.' in file.name()
self._platform = platform or self._extract_platform(file.name())
def _extract_platform(self, filename):
"""Calculates the platform from the name of the file if it isn't known already"""
path = filename.split(os.path.sep)
if 'platform' in path:
return path[path.index('platform') + 1]
return None
def _extract_test_name(self, filename):
path = filename.split(os.path.sep)
if 'LayoutTests' in path:
path = path[1 + path.index('LayoutTests'):]
if 'layout-test-results' in path:
path = path[1 + path.index('layout-test-results'):]
if 'platform' in path:
path = path[2 + path.index('platform'):]
filename = path[-1]
filename = re.sub('-expected\..*$', '', filename)
filename = re.sub('-actual\..*$', '', filename)
path[-1] = filename
return os.path.sep.join(path)
def save_to(self, path):
"""Have the files in this TestOutput write themselves to the disk at the specified location."""
for file in self._files:
file.save_to(path)
def is_actual(self):
"""Is this output the actual output of a test? (As opposed to expected output.)"""
return self._is_actual
def name(self):
"""The name of this test (doesn't include extension)"""
return self._name
def __eq__(self, other):
return (other != None and
self.name() == other.name() and
self.type() == other.type() and
self.platform() == other.platform() and
self.is_actual() == other.is_actual() and
self.same_content(other))
def __hash__(self):
return hash(str(self.name()) + str(self.type()) + str(self.platform()))
def is_new_baseline_for(self, other):
return (self.name() == other.name() and
self.type() == other.type() and
self.platform() == other.platform() and
self.is_actual() and
(not other.is_actual()))
def __str__(self):
actual_str = '[A] ' if self.is_actual() else ''
return "TestOutput[%s/%s] %s%s" % (self._platform, self._output_type, actual_str, self.name())
def type(self):
return self._output_type
def platform(self):
return self._platform
def _path_to_platform(self):
"""Returns the path that tests for this platform are stored in."""
if self._platform is None:
return ""
else:
return os.path.join("self._platform", self._platform)
def _save_expected_result(self, file, path):
path = os.path.join(path, self._path_to_platform())
extension = os.path.splitext(file.name())[1]
filename = self.name() + '-expected' + extension
file.save_to(path, filename)
def save_expected_results(self, path_to_layout_tests):
"""Save the files of this TestOutput to the appropriate directory
inside the LayoutTests directory. Typically this means that these files
will be saved in "LayoutTests/platform/<platform>/, or simply
LayoutTests if the platform is None."""
for file in self._files:
self._save_expected_result(file, path_to_layout_tests)
def delete(self):
"""Deletes the files that comprise this TestOutput from disk. This
fails if the files are virtual files (eg: the files may reside inside a
remote zip file)."""
for file in self._files:
file.delete()
class TextTestOutput(TestOutput):
"""Represents a text output of a single test on a single platform"""
def __init__(self, platform, text_file):
self._text_file = text_file
TestOutput.__init__(self, platform, 'text', [text_file])
def same_content(self, other):
return self._text_file.contents() == other._text_file.contents()
def retarget(self, platform):
return TextTestOutput(platform, self._text_file)
class ImageTestOutput(TestOutput):
image_differ = NaiveImageDiffer()
"""Represents an image output of a single test on a single platform"""
def __init__(self, platform, image_file, checksum_file):
self._checksum_file = checksum_file
self._image_file = image_file
files = filter(bool, [self._checksum_file, self._image_file])
TestOutput.__init__(self, platform, 'image', files)
def has_checksum(self):
return self._checksum_file is not None
def same_content(self, other):
# FIXME This should not assume that checksums are up to date.
if self.has_checksum() and other.has_checksum():
return self._checksum_file.contents() == other._checksum_file.contents()
else:
self_contents = self._image_file.contents()
other_contents = other._image_file.contents()
return ImageTestOutput.image_differ.same_image(self_contents, other_contents)
def retarget(self, platform):
return ImageTestOutput(platform, self._image_file, self._checksum_file)
def checksum(self):
return self._checksum_file.contents()
|
