| # Copyright (C) 2011 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: |
| # |
| # * Redistributions of source code must retain the above copyright |
| # notice, this list of conditions and the following disclaimer. |
| # * 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. |
| # * Neither the name of Google Inc. nor the names of its |
| # contributors may be used to endorse or promote products derived from |
| # this software without specific prior written permission. |
| # |
| # THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND 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 THE COPYRIGHT |
| # OWNER OR 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 logging |
| |
| from webkitpy.common.wavediff import WaveDiff |
| |
| |
| _log = logging.getLogger(__name__) |
| |
| |
| def write_test_result(filesystem, port, results_directory, test_name, driver_output, |
| expected_driver_output, failures): |
| """Write the test result to the result output directory.""" |
| root_output_dir = results_directory |
| writer = TestResultWriter(filesystem, port, root_output_dir, test_name) |
| |
| if driver_output.error: |
| writer.write_stderr(driver_output.error) |
| |
| for failure in failures: |
| failure.write_failure(writer, driver_output, expected_driver_output, port) |
| |
| |
| class TestResultWriter(object): |
| """A class which handles all writing operations to the result directory.""" |
| |
| # Filename pieces when writing failures to the test results directory. |
| FILENAME_SUFFIX_ACTUAL = "-actual" |
| FILENAME_SUFFIX_EXPECTED = "-expected" |
| FILENAME_SUFFIX_DIFF = "-diff" |
| FILENAME_SUFFIX_STDERR = "-stderr" |
| FILENAME_SUFFIX_CRASH_LOG = "-crash-log" |
| FILENAME_SUFFIX_SAMPLE = "-sample" |
| FILENAME_SUFFIX_PRETTY_PATCH = "-pretty-diff.html" |
| FILENAME_SUFFIX_IMAGE_DIFF = "-diff.png" |
| FILENAME_SUFFIX_IMAGE_DIFFS_HTML = "-diffs.html" |
| |
| @staticmethod |
| def expected_filename(test_name, filesystem, port_name=None, suffix='txt'): |
| if not port_name: |
| return filesystem.splitext(test_name)[0] + TestResultWriter.FILENAME_SUFFIX_EXPECTED + '.' + suffix |
| return filesystem.join("platform", port_name, filesystem.splitext(test_name)[0] + TestResultWriter.FILENAME_SUFFIX_EXPECTED + '.' + suffix) |
| |
| @staticmethod |
| def actual_filename(test_name, filesystem, suffix='txt'): |
| return filesystem.splitext(test_name)[0] + TestResultWriter.FILENAME_SUFFIX_ACTUAL + '.' + suffix |
| |
| def __init__(self, filesystem, port, root_output_dir, test_name): |
| self._filesystem = filesystem |
| self._port = port |
| self._root_output_dir = root_output_dir |
| self._test_name = test_name |
| |
| def _make_output_directory(self): |
| """Creates the output directory (if needed) for a given test filename.""" |
| fs = self._filesystem |
| output_filename = fs.join(self._root_output_dir, self._test_name) |
| fs.maybe_make_directory(fs.dirname(output_filename)) |
| |
| def output_filename(self, modifier): |
| """Returns a filename inside the output dir that contains modifier. |
| |
| For example, if test name is "fast/dom/foo.html" and modifier is "-expected.txt", |
| the return value is "/<path-to-root-output-dir>/fast/dom/foo-expected.txt". |
| |
| Args: |
| modifier: a string to replace the extension of filename with |
| |
| Return: |
| The absolute path to the output filename |
| """ |
| fs = self._filesystem |
| output_filename = fs.join(self._root_output_dir, self._test_name) |
| |
| # Temporary fix, also in LayoutTests/fast/harness/results.html, line 275. |
| # FIXME: Refactor to avoid confusing reference to both test and process names. |
| if len(fs.splitext(output_filename)[1]) - 1 > 5: |
| return output_filename + modifier |
| return fs.splitext(output_filename)[0] + modifier |
| |
| def _write_binary_file(self, path, contents): |
| if contents is not None: |
| self._make_output_directory() |
| self._filesystem.write_binary_file(path, contents) |
| |
| def _write_text_file(self, path, contents): |
| if contents is not None: |
| self._make_output_directory() |
| self._filesystem.write_text_file(path, contents) |
| |
| def _output_testname(self, modifier): |
| fs = self._filesystem |
| return fs.splitext(fs.basename(self._test_name))[0] + modifier |
| |
| def write_output_files(self, file_type, output, expected): |
| """Writes the test output, the expected output in the results directory. |
| |
| The full output filename of the actual, for example, will be |
| <filename>-actual<file_type> |
| For instance, |
| my_test-actual.txt |
| |
| Args: |
| file_type: A string describing the test output file type, e.g. ".txt" |
| output: A string containing the test output |
| expected: A string containing the expected test output |
| """ |
| actual_filename = self.output_filename(self.FILENAME_SUFFIX_ACTUAL + file_type) |
| expected_filename = self.output_filename(self.FILENAME_SUFFIX_EXPECTED + file_type) |
| |
| self._write_binary_file(actual_filename, output) |
| self._write_binary_file(expected_filename, expected) |
| |
| def write_stderr(self, error): |
| filename = self.output_filename(self.FILENAME_SUFFIX_STDERR + ".txt") |
| self._write_binary_file(filename, error) |
| |
| def write_crash_log(self, crash_log): |
| filename = self.output_filename(self.FILENAME_SUFFIX_CRASH_LOG + ".txt") |
| self._write_text_file(filename, crash_log) |
| |
| def copy_sample_file(self, sample_file): |
| filename = self.output_filename(self.FILENAME_SUFFIX_SAMPLE + ".txt") |
| self._filesystem.copyfile(sample_file, filename) |
| |
| def write_text_files(self, actual_text, expected_text): |
| self.write_output_files(".txt", actual_text, expected_text) |
| |
| def create_text_diff_and_write_result(self, actual_text, expected_text): |
| # FIXME: This function is actually doing the diffs as well as writing results. |
| # It might be better to extract code which does 'diff' and make it a separate function. |
| if not actual_text or not expected_text: |
| return |
| |
| file_type = '.txt' |
| actual_filename = self.output_filename(self.FILENAME_SUFFIX_ACTUAL + file_type) |
| expected_filename = self.output_filename(self.FILENAME_SUFFIX_EXPECTED + file_type) |
| # We treat diff output as binary. Diff output may contain multiple files |
| # in conflicting encodings. |
| diff = self._port.diff_text(expected_text, actual_text, expected_filename, actual_filename) |
| diff_filename = self.output_filename(self.FILENAME_SUFFIX_DIFF + file_type) |
| self._write_binary_file(diff_filename, diff) |
| |
| # Use WebKit's PrettyPatch.rb to get an HTML diff. |
| if self._port.pretty_patch.pretty_patch_available(): |
| pretty_patch = self._port.pretty_patch.pretty_patch_text(diff_filename) |
| pretty_patch_filename = self.output_filename(self.FILENAME_SUFFIX_PRETTY_PATCH) |
| self._write_binary_file(pretty_patch_filename, pretty_patch) |
| |
| def write_audio_files(self, actual_audio, expected_audio): |
| self.write_output_files('.wav', actual_audio, expected_audio) |
| |
| def create_audio_diff_and_write_result(self, actual_audio, expected_audio): |
| diff_filename = self.output_filename(self.FILENAME_SUFFIX_DIFF + '.txt') |
| self._write_text_file(diff_filename, WaveDiff(expected_audio, actual_audio).diffText()) |
| |
| def write_image_files(self, actual_image, expected_image): |
| self.write_output_files('.png', actual_image, expected_image) |
| |
| def write_image_diff_files(self, image_diff, diff_percent_text=None, fuzzy_data_text=None): |
| diff_filename = self.output_filename(self.FILENAME_SUFFIX_IMAGE_DIFF) |
| self._write_binary_file(diff_filename, image_diff) |
| |
| base_dir = self._port.path_from_webkit_base('LayoutTests', 'fast', 'harness') |
| |
| image_diff_template = self._filesystem.join(base_dir, 'image-diff-template.html') |
| image_diff_file = "" |
| if self._filesystem.exists(image_diff_template): |
| image_diff_file = self._filesystem.read_text_file(image_diff_template) |
| |
| html = image_diff_file.replace('__TITLE__', self._test_name) |
| html = html.replace('__PREFIX__', self._output_testname('')) |
| |
| if not diff_percent_text: |
| html = html.replace('__HIDE_DIFF_CLASS__', 'hidden') |
| else: |
| html = html.replace('__HIDE_DIFF_CLASS__', '') |
| html = html.replace('__PIXEL_DIFF__', diff_percent_text) |
| |
| if not fuzzy_data_text: |
| html = html.replace('__HIDE_FUZZY_CLASS__', 'hidden') |
| else: |
| html = html.replace('__HIDE_FUZZY_CLASS__', '') |
| html = html.replace('__FUZZY_DATA__', fuzzy_data_text) |
| |
| diffs_html_filename = self.output_filename(self.FILENAME_SUFFIX_IMAGE_DIFFS_HTML) |
| self._filesystem.write_text_file(diffs_html_filename, html) |
| |
| def write_reftest(self, src_filepath): |
| fs = self._filesystem |
| dst_dir = fs.dirname(fs.join(self._root_output_dir, self._test_name)) |
| dst_filepath = fs.join(dst_dir, fs.basename(src_filepath)) |
| self._make_output_directory() |
| fs.copyfile(src_filepath, dst_filepath) |
