| #!/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() |
