7260d7292b
BUG=skia:2902 R=mtklein@google.com, rmistry@google.com Author: stephana@google.com Review URL: https://codereview.chromium.org/546753003
755 lines
29 KiB
Python
Executable File
755 lines
29 KiB
Python
Executable File
#!/usr/bin/python
|
|
|
|
"""
|
|
Copyright 2014 Google Inc.
|
|
|
|
Use of this source code is governed by a BSD-style license that can be
|
|
found in the LICENSE file.
|
|
|
|
Test the render_pictures binary.
|
|
"""
|
|
|
|
# System-level imports
|
|
import copy
|
|
import json
|
|
import os
|
|
import shutil
|
|
import tempfile
|
|
|
|
# Must fix up PYTHONPATH before importing from within Skia
|
|
import fix_pythonpath # pylint: disable=W0611
|
|
|
|
# Imports from within Skia
|
|
import base_unittest
|
|
import find_run_binary
|
|
|
|
# Maximum length of text diffs to show when tests fail
|
|
MAX_DIFF_LENGTH = 30000
|
|
|
|
EXPECTED_HEADER_CONTENTS = {
|
|
"type" : "ChecksummedImages",
|
|
"revision" : 1,
|
|
}
|
|
|
|
# Manually verified: 640x400 red rectangle with black border
|
|
# Standard expectations will be set up in such a way that this image fails
|
|
# the comparison.
|
|
RED_WHOLEIMAGE = {
|
|
"checksumAlgorithm" : "bitmap-64bitMD5",
|
|
"checksumValue" : 2853310525600416231,
|
|
"comparisonResult" : "failed",
|
|
"filepath" : "red_skp.png",
|
|
}
|
|
|
|
# Manually verified: 640x400 green rectangle with black border
|
|
# Standard expectations will be set up in such a way that this image passes
|
|
# the comparison.
|
|
GREEN_WHOLEIMAGE = {
|
|
"checksumAlgorithm" : "bitmap-64bitMD5",
|
|
"checksumValue" : 11143979097452425335,
|
|
"comparisonResult" : "succeeded",
|
|
"filepath" : "green_skp.png",
|
|
}
|
|
|
|
# Manually verified these 6 images, all 256x256 tiles,
|
|
# consistent with a tiled version of the 640x400 red rect
|
|
# with black borders.
|
|
# Standard expectations will be set up in such a way that these images fail
|
|
# the comparison.
|
|
RED_TILES = [{
|
|
"checksumAlgorithm" : "bitmap-64bitMD5",
|
|
"checksumValue" : 5815827069051002745,
|
|
"comparisonResult" : "failed",
|
|
"filepath" : "red_skp-tile0.png",
|
|
},{
|
|
"checksumAlgorithm" : "bitmap-64bitMD5",
|
|
"checksumValue" : 9323613075234140270,
|
|
"comparisonResult" : "failed",
|
|
"filepath" : "red_skp-tile1.png",
|
|
}, {
|
|
"checksumAlgorithm" : "bitmap-64bitMD5",
|
|
"checksumValue" : 15939355025996362179,
|
|
"comparisonResult" : "failed",
|
|
"filepath" : "red_skp-tile2.png",
|
|
}, {
|
|
"checksumAlgorithm" : "bitmap-64bitMD5",
|
|
"checksumValue" : 649771916797529222,
|
|
"comparisonResult" : "failed",
|
|
"filepath" : "red_skp-tile3.png",
|
|
}, {
|
|
"checksumAlgorithm" : "bitmap-64bitMD5",
|
|
"checksumValue" : 8132820002266077288,
|
|
"comparisonResult" : "failed",
|
|
"filepath" : "red_skp-tile4.png",
|
|
}, {
|
|
"checksumAlgorithm" : "bitmap-64bitMD5",
|
|
"checksumValue" : 2406160701181324581,
|
|
"comparisonResult" : "failed",
|
|
"filepath" : "red_skp-tile5.png",
|
|
}]
|
|
|
|
# Manually verified these 6 images, all 256x256 tiles,
|
|
# consistent with a tiled version of the 640x400 green rect
|
|
# with black borders.
|
|
# Standard expectations will be set up in such a way that these images pass
|
|
# the comparison.
|
|
GREEN_TILES = [{
|
|
"checksumAlgorithm" : "bitmap-64bitMD5",
|
|
"checksumValue" : 12587324416545178013,
|
|
"comparisonResult" : "succeeded",
|
|
"filepath" : "green_skp-tile0.png",
|
|
}, {
|
|
"checksumAlgorithm" : "bitmap-64bitMD5",
|
|
"checksumValue" : 7624374914829746293,
|
|
"comparisonResult" : "succeeded",
|
|
"filepath" : "green_skp-tile1.png",
|
|
}, {
|
|
"checksumAlgorithm" : "bitmap-64bitMD5",
|
|
"checksumValue" : 11866144860997809880,
|
|
"comparisonResult" : "succeeded",
|
|
"filepath" : "green_skp-tile2.png",
|
|
}, {
|
|
"checksumAlgorithm" : "bitmap-64bitMD5",
|
|
"checksumValue" : 3893392565127823822,
|
|
"comparisonResult" : "succeeded",
|
|
"filepath" : "green_skp-tile3.png",
|
|
}, {
|
|
"checksumAlgorithm" : "bitmap-64bitMD5",
|
|
"checksumValue" : 2083084978343901738,
|
|
"comparisonResult" : "succeeded",
|
|
"filepath" : "green_skp-tile4.png",
|
|
}, {
|
|
"checksumAlgorithm" : "bitmap-64bitMD5",
|
|
"checksumValue" : 89620927366502076,
|
|
"comparisonResult" : "succeeded",
|
|
"filepath" : "green_skp-tile5.png",
|
|
}]
|
|
|
|
|
|
def modified_dict(input_dict, modification_dict):
|
|
"""Returns a dict, with some modifications applied to it.
|
|
|
|
Args:
|
|
input_dict: a dictionary (which will be copied, not modified in place)
|
|
modification_dict: a set of key/value pairs to overwrite in the dict
|
|
"""
|
|
output_dict = input_dict.copy()
|
|
output_dict.update(modification_dict)
|
|
return output_dict
|
|
|
|
|
|
def modified_list_of_dicts(input_list, modification_dict):
|
|
"""Returns a list of dicts, with some modifications applied to each dict.
|
|
|
|
Args:
|
|
input_list: a list of dictionaries; these dicts will be copied, not
|
|
modified in place
|
|
modification_dict: a set of key/value pairs to overwrite in each dict
|
|
within input_list
|
|
"""
|
|
output_list = []
|
|
for input_dict in input_list:
|
|
output_dict = modified_dict(input_dict, modification_dict)
|
|
output_list.append(output_dict)
|
|
return output_list
|
|
|
|
|
|
class RenderPicturesTest(base_unittest.TestCase):
|
|
|
|
def setUp(self):
|
|
self.maxDiff = MAX_DIFF_LENGTH
|
|
self._expectations_dir = tempfile.mkdtemp()
|
|
self._input_skp_dir = tempfile.mkdtemp()
|
|
# All output of render_pictures binary will go into this directory.
|
|
self._output_dir = tempfile.mkdtemp()
|
|
|
|
def tearDown(self):
|
|
shutil.rmtree(self._expectations_dir)
|
|
shutil.rmtree(self._input_skp_dir)
|
|
shutil.rmtree(self._output_dir)
|
|
|
|
def test_tiled_whole_image(self):
|
|
"""Run render_pictures with tiles and --writeWholeImage flag.
|
|
|
|
TODO(epoger): This test generates undesired results! The JSON summary
|
|
includes both whole-image and tiled-images (as it should), but only
|
|
whole-images are written out to disk. See http://skbug.com/2463
|
|
Once I fix that, I should add a similar test that exercises mismatchPath.
|
|
|
|
TODO(epoger): I noticed that when this is run without --writePath being
|
|
specified, this test writes red_skp.png and green_skp.png to the current
|
|
directory. We should fix that... if --writePath is not specified, this
|
|
probably shouldn't write out red_skp.png and green_skp.png at all!
|
|
See http://skbug.com/2464
|
|
"""
|
|
output_json_path = os.path.join(self._output_dir, 'actuals.json')
|
|
write_path_dir = self.create_empty_dir(
|
|
path=os.path.join(self._output_dir, 'writePath'))
|
|
self._generate_skps()
|
|
expectations_path = self._create_expectations()
|
|
self._run_render_pictures([
|
|
'-r', self._input_skp_dir,
|
|
'--bbh', 'grid', '256', '256',
|
|
'--mode', 'tile', '256', '256',
|
|
'--readJsonSummaryPath', expectations_path,
|
|
'--writeJsonSummaryPath', output_json_path,
|
|
'--writePath', write_path_dir,
|
|
'--writeWholeImage'])
|
|
expected_summary_dict = {
|
|
"header" : EXPECTED_HEADER_CONTENTS,
|
|
"image-base-gs-url" : None,
|
|
"descriptions" : None,
|
|
"actual-results" : {
|
|
"red.skp": {
|
|
"tiled-images": RED_TILES,
|
|
"whole-image": RED_WHOLEIMAGE,
|
|
},
|
|
"green.skp": {
|
|
"tiled-images": GREEN_TILES,
|
|
"whole-image": GREEN_WHOLEIMAGE,
|
|
}
|
|
}
|
|
}
|
|
self._assert_json_contents(output_json_path, expected_summary_dict)
|
|
self._assert_directory_contents(
|
|
write_path_dir, ['red_skp.png', 'green_skp.png'])
|
|
|
|
def test_ignore_some_failures(self):
|
|
"""test_tiled_whole_image, but ignoring some failed tests.
|
|
"""
|
|
output_json_path = os.path.join(self._output_dir, 'actuals.json')
|
|
write_path_dir = self.create_empty_dir(
|
|
path=os.path.join(self._output_dir, 'writePath'))
|
|
self._generate_skps()
|
|
expectations_path = self._create_expectations(ignore_some_failures=True)
|
|
self._run_render_pictures([
|
|
'-r', self._input_skp_dir,
|
|
'--bbh', 'grid', '256', '256',
|
|
'--mode', 'tile', '256', '256',
|
|
'--readJsonSummaryPath', expectations_path,
|
|
'--writeJsonSummaryPath', output_json_path,
|
|
'--writePath', write_path_dir,
|
|
'--writeWholeImage'])
|
|
modified_red_tiles = copy.deepcopy(RED_TILES)
|
|
modified_red_tiles[5]['comparisonResult'] = 'failure-ignored'
|
|
expected_summary_dict = {
|
|
"header" : EXPECTED_HEADER_CONTENTS,
|
|
"image-base-gs-url" : None,
|
|
"descriptions" : None,
|
|
"actual-results" : {
|
|
"red.skp": {
|
|
"tiled-images": modified_red_tiles,
|
|
"whole-image": modified_dict(
|
|
RED_WHOLEIMAGE, {"comparisonResult" : "failure-ignored"}),
|
|
},
|
|
"green.skp": {
|
|
"tiled-images": GREEN_TILES,
|
|
"whole-image": GREEN_WHOLEIMAGE,
|
|
}
|
|
}
|
|
}
|
|
self._assert_json_contents(output_json_path, expected_summary_dict)
|
|
self._assert_directory_contents(
|
|
write_path_dir, ['red_skp.png', 'green_skp.png'])
|
|
|
|
def test_missing_tile_and_whole_image(self):
|
|
"""test_tiled_whole_image, but missing expectations for some images.
|
|
"""
|
|
output_json_path = os.path.join(self._output_dir, 'actuals.json')
|
|
write_path_dir = self.create_empty_dir(
|
|
path=os.path.join(self._output_dir, 'writePath'))
|
|
self._generate_skps()
|
|
expectations_path = self._create_expectations(missing_some_images=True)
|
|
self._run_render_pictures([
|
|
'-r', self._input_skp_dir,
|
|
'--bbh', 'grid', '256', '256',
|
|
'--mode', 'tile', '256', '256',
|
|
'--readJsonSummaryPath', expectations_path,
|
|
'--writeJsonSummaryPath', output_json_path,
|
|
'--writePath', write_path_dir,
|
|
'--writeWholeImage'])
|
|
modified_red_tiles = copy.deepcopy(RED_TILES)
|
|
modified_red_tiles[5]['comparisonResult'] = 'no-comparison'
|
|
expected_summary_dict = {
|
|
"header" : EXPECTED_HEADER_CONTENTS,
|
|
"image-base-gs-url" : None,
|
|
"descriptions" : None,
|
|
"actual-results" : {
|
|
"red.skp": {
|
|
"tiled-images": modified_red_tiles,
|
|
"whole-image": modified_dict(
|
|
RED_WHOLEIMAGE, {"comparisonResult" : "no-comparison"}),
|
|
},
|
|
"green.skp": {
|
|
"tiled-images": GREEN_TILES,
|
|
"whole-image": GREEN_WHOLEIMAGE,
|
|
}
|
|
}
|
|
}
|
|
self._assert_json_contents(output_json_path, expected_summary_dict)
|
|
|
|
def _test_untiled(self, expectations_path=None, expected_summary_dict=None,
|
|
additional_args=None):
|
|
"""Base for multiple tests without tiles.
|
|
|
|
Args:
|
|
expectations_path: path we should pass using --readJsonSummaryPath, or
|
|
None if we should create the default expectations file
|
|
expected_summary_dict: dict we should compare against the output actual
|
|
results summary, or None if we should use a default comparison dict
|
|
additional_args: array of command-line args to add when we run
|
|
render_pictures
|
|
"""
|
|
output_json_path = os.path.join(self._output_dir, 'actuals.json')
|
|
write_path_dir = self.create_empty_dir(
|
|
path=os.path.join(self._output_dir, 'writePath'))
|
|
self._generate_skps()
|
|
if expectations_path == None:
|
|
expectations_path = self._create_expectations()
|
|
args = [
|
|
'-r', self._input_skp_dir,
|
|
'--readJsonSummaryPath', expectations_path,
|
|
'--writePath', write_path_dir,
|
|
'--writeJsonSummaryPath', output_json_path,
|
|
]
|
|
if additional_args:
|
|
args.extend(additional_args)
|
|
self._run_render_pictures(args)
|
|
if expected_summary_dict == None:
|
|
expected_summary_dict = {
|
|
"header" : EXPECTED_HEADER_CONTENTS,
|
|
"image-base-gs-url" : None,
|
|
"descriptions" : None,
|
|
"actual-results" : {
|
|
"red.skp": {
|
|
"whole-image": RED_WHOLEIMAGE,
|
|
},
|
|
"green.skp": {
|
|
"whole-image": GREEN_WHOLEIMAGE,
|
|
}
|
|
}
|
|
}
|
|
self._assert_json_contents(output_json_path, expected_summary_dict)
|
|
self._assert_directory_contents(
|
|
write_path_dir, ['red_skp.png', 'green_skp.png'])
|
|
|
|
def test_untiled(self):
|
|
"""Basic test without tiles."""
|
|
self._test_untiled()
|
|
|
|
def test_untiled_empty_expectations_file(self):
|
|
"""Same as test_untiled, but with an empty expectations file."""
|
|
expectations_path = os.path.join(self._expectations_dir, 'empty')
|
|
with open(expectations_path, 'w'):
|
|
pass
|
|
expected_summary_dict = {
|
|
"header" : EXPECTED_HEADER_CONTENTS,
|
|
"image-base-gs-url" : None,
|
|
"descriptions" : None,
|
|
"actual-results" : {
|
|
"red.skp": {
|
|
"whole-image": modified_dict(
|
|
RED_WHOLEIMAGE, {"comparisonResult" : "no-comparison"}),
|
|
},
|
|
"green.skp": {
|
|
"whole-image": modified_dict(
|
|
GREEN_WHOLEIMAGE, {"comparisonResult" : "no-comparison"}),
|
|
}
|
|
}
|
|
}
|
|
self._test_untiled(expectations_path=expectations_path,
|
|
expected_summary_dict=expected_summary_dict)
|
|
|
|
def test_untiled_writeChecksumBasedFilenames(self):
|
|
"""Same as test_untiled, but with --writeChecksumBasedFilenames."""
|
|
output_json_path = os.path.join(self._output_dir, 'actuals.json')
|
|
write_path_dir = self.create_empty_dir(
|
|
path=os.path.join(self._output_dir, 'writePath'))
|
|
self._generate_skps()
|
|
self._run_render_pictures([
|
|
'-r', self._input_skp_dir,
|
|
'--descriptions', 'builder=builderName', 'renderMode=renderModeName',
|
|
'--writeChecksumBasedFilenames',
|
|
'--writePath', write_path_dir,
|
|
'--writeJsonSummaryPath', output_json_path,
|
|
])
|
|
expected_summary_dict = {
|
|
"header" : EXPECTED_HEADER_CONTENTS,
|
|
"image-base-gs-url" : None,
|
|
"descriptions" : {
|
|
"builder": "builderName",
|
|
"renderMode": "renderModeName",
|
|
},
|
|
"actual-results" : {
|
|
"red.skp": {
|
|
# Manually verified: 640x400 red rectangle with black border
|
|
"whole-image": {
|
|
"checksumAlgorithm" : "bitmap-64bitMD5",
|
|
"checksumValue" : 2853310525600416231,
|
|
"comparisonResult" : "no-comparison",
|
|
"filepath" :
|
|
"red_skp/bitmap-64bitMD5_2853310525600416231.png",
|
|
},
|
|
},
|
|
"green.skp": {
|
|
# Manually verified: 640x400 green rectangle with black border
|
|
"whole-image": {
|
|
"checksumAlgorithm" : "bitmap-64bitMD5",
|
|
"checksumValue" : 11143979097452425335,
|
|
"comparisonResult" : "no-comparison",
|
|
"filepath" :
|
|
"green_skp/bitmap-64bitMD5_11143979097452425335.png",
|
|
},
|
|
}
|
|
}
|
|
}
|
|
self._assert_json_contents(output_json_path, expected_summary_dict)
|
|
self._assert_directory_contents(write_path_dir, ['red_skp', 'green_skp'])
|
|
self._assert_directory_contents(
|
|
os.path.join(write_path_dir, 'red_skp'),
|
|
['bitmap-64bitMD5_2853310525600416231.png'])
|
|
self._assert_directory_contents(
|
|
os.path.join(write_path_dir, 'green_skp'),
|
|
['bitmap-64bitMD5_11143979097452425335.png'])
|
|
|
|
def test_untiled_validate(self):
|
|
"""Same as test_untiled, but with --validate."""
|
|
self._test_untiled(additional_args=['--validate'])
|
|
|
|
def test_untiled_without_writePath(self):
|
|
"""Same as test_untiled, but without --writePath."""
|
|
output_json_path = os.path.join(self._output_dir, 'actuals.json')
|
|
self._generate_skps()
|
|
expectations_path = self._create_expectations()
|
|
self._run_render_pictures([
|
|
'-r', self._input_skp_dir,
|
|
'--readJsonSummaryPath', expectations_path,
|
|
'--writeJsonSummaryPath', output_json_path])
|
|
expected_summary_dict = {
|
|
"header" : EXPECTED_HEADER_CONTENTS,
|
|
"image-base-gs-url" : None,
|
|
"descriptions" : None,
|
|
"actual-results" : {
|
|
"red.skp": {
|
|
"whole-image": RED_WHOLEIMAGE,
|
|
},
|
|
"green.skp": {
|
|
"whole-image": GREEN_WHOLEIMAGE,
|
|
}
|
|
}
|
|
}
|
|
self._assert_json_contents(output_json_path, expected_summary_dict)
|
|
|
|
def test_tiled(self):
|
|
"""Generate individual tiles."""
|
|
output_json_path = os.path.join(self._output_dir, 'actuals.json')
|
|
write_path_dir = self.create_empty_dir(
|
|
path=os.path.join(self._output_dir, 'writePath'))
|
|
self._generate_skps()
|
|
expectations_path = self._create_expectations()
|
|
self._run_render_pictures([
|
|
'-r', self._input_skp_dir,
|
|
'--bbh', 'grid', '256', '256',
|
|
'--mode', 'tile', '256', '256',
|
|
'--readJsonSummaryPath', expectations_path,
|
|
'--writePath', write_path_dir,
|
|
'--writeJsonSummaryPath', output_json_path])
|
|
expected_summary_dict = {
|
|
"header" : EXPECTED_HEADER_CONTENTS,
|
|
"image-base-gs-url" : None,
|
|
"descriptions" : None,
|
|
"actual-results" : {
|
|
"red.skp": {
|
|
"tiled-images": RED_TILES,
|
|
},
|
|
"green.skp": {
|
|
"tiled-images": GREEN_TILES,
|
|
}
|
|
}
|
|
}
|
|
self._assert_json_contents(output_json_path, expected_summary_dict)
|
|
self._assert_directory_contents(
|
|
write_path_dir,
|
|
['red_skp-tile0.png', 'red_skp-tile1.png', 'red_skp-tile2.png',
|
|
'red_skp-tile3.png', 'red_skp-tile4.png', 'red_skp-tile5.png',
|
|
'green_skp-tile0.png', 'green_skp-tile1.png', 'green_skp-tile2.png',
|
|
'green_skp-tile3.png', 'green_skp-tile4.png', 'green_skp-tile5.png',
|
|
])
|
|
|
|
def test_tiled_mismatches(self):
|
|
"""Same as test_tiled, but only write out mismatching images."""
|
|
output_json_path = os.path.join(self._output_dir, 'actuals.json')
|
|
mismatch_path_dir = self.create_empty_dir(
|
|
path=os.path.join(self._output_dir, 'mismatchPath'))
|
|
self._generate_skps()
|
|
expectations_path = self._create_expectations()
|
|
self._run_render_pictures([
|
|
'-r', self._input_skp_dir,
|
|
'--bbh', 'grid', '256', '256',
|
|
'--mode', 'tile', '256', '256',
|
|
'--readJsonSummaryPath', expectations_path,
|
|
'--mismatchPath', mismatch_path_dir,
|
|
'--writeJsonSummaryPath', output_json_path])
|
|
expected_summary_dict = {
|
|
"header" : EXPECTED_HEADER_CONTENTS,
|
|
"image-base-gs-url" : None,
|
|
"descriptions" : None,
|
|
"actual-results" : {
|
|
"red.skp": {
|
|
"tiled-images": RED_TILES,
|
|
},
|
|
"green.skp": {
|
|
"tiled-images": GREEN_TILES,
|
|
}
|
|
}
|
|
}
|
|
self._assert_json_contents(output_json_path, expected_summary_dict)
|
|
self._assert_directory_contents(
|
|
mismatch_path_dir,
|
|
['red_skp-tile0.png', 'red_skp-tile1.png', 'red_skp-tile2.png',
|
|
'red_skp-tile3.png', 'red_skp-tile4.png', 'red_skp-tile5.png',
|
|
])
|
|
|
|
def test_tiled_writeChecksumBasedFilenames(self):
|
|
"""Same as test_tiled, but with --writeChecksumBasedFilenames."""
|
|
output_json_path = os.path.join(self._output_dir, 'actuals.json')
|
|
write_path_dir = self.create_empty_dir(
|
|
path=os.path.join(self._output_dir, 'writePath'))
|
|
self._generate_skps()
|
|
self._run_render_pictures(['-r', self._input_skp_dir,
|
|
'--bbh', 'grid', '256', '256',
|
|
'--mode', 'tile', '256', '256',
|
|
'--writeChecksumBasedFilenames',
|
|
'--writePath', write_path_dir,
|
|
'--writeJsonSummaryPath', output_json_path])
|
|
expected_summary_dict = {
|
|
"header" : EXPECTED_HEADER_CONTENTS,
|
|
"image-base-gs-url" : None,
|
|
"descriptions" : None,
|
|
"actual-results" : {
|
|
"red.skp": {
|
|
# Manually verified these 6 images, all 256x256 tiles,
|
|
# consistent with a tiled version of the 640x400 red rect
|
|
# with black borders.
|
|
"tiled-images": [{
|
|
"checksumAlgorithm" : "bitmap-64bitMD5",
|
|
"checksumValue" : 5815827069051002745,
|
|
"comparisonResult" : "no-comparison",
|
|
"filepath" :
|
|
"red_skp/bitmap-64bitMD5_5815827069051002745.png",
|
|
}, {
|
|
"checksumAlgorithm" : "bitmap-64bitMD5",
|
|
"checksumValue" : 9323613075234140270,
|
|
"comparisonResult" : "no-comparison",
|
|
"filepath" :
|
|
"red_skp/bitmap-64bitMD5_9323613075234140270.png",
|
|
}, {
|
|
"checksumAlgorithm" : "bitmap-64bitMD5",
|
|
"checksumValue" : 15939355025996362179,
|
|
"comparisonResult" : "no-comparison",
|
|
"filepath" :
|
|
"red_skp/bitmap-64bitMD5_15939355025996362179.png",
|
|
}, {
|
|
"checksumAlgorithm" : "bitmap-64bitMD5",
|
|
"checksumValue" : 649771916797529222,
|
|
"comparisonResult" : "no-comparison",
|
|
"filepath" :
|
|
"red_skp/bitmap-64bitMD5_649771916797529222.png",
|
|
}, {
|
|
"checksumAlgorithm" : "bitmap-64bitMD5",
|
|
"checksumValue" : 8132820002266077288,
|
|
"comparisonResult" : "no-comparison",
|
|
"filepath" :
|
|
"red_skp/bitmap-64bitMD5_8132820002266077288.png",
|
|
}, {
|
|
"checksumAlgorithm" : "bitmap-64bitMD5",
|
|
"checksumValue" : 2406160701181324581,
|
|
"comparisonResult" : "no-comparison",
|
|
"filepath" :
|
|
"red_skp/bitmap-64bitMD5_2406160701181324581.png",
|
|
}],
|
|
},
|
|
"green.skp": {
|
|
# Manually verified these 6 images, all 256x256 tiles,
|
|
# consistent with a tiled version of the 640x400 green rect
|
|
# with black borders.
|
|
"tiled-images": [{
|
|
"checksumAlgorithm" : "bitmap-64bitMD5",
|
|
"checksumValue" : 12587324416545178013,
|
|
"comparisonResult" : "no-comparison",
|
|
"filepath" :
|
|
"green_skp/bitmap-64bitMD5_12587324416545178013.png",
|
|
}, {
|
|
"checksumAlgorithm" : "bitmap-64bitMD5",
|
|
"checksumValue" : 7624374914829746293,
|
|
"comparisonResult" : "no-comparison",
|
|
"filepath" :
|
|
"green_skp/bitmap-64bitMD5_7624374914829746293.png",
|
|
}, {
|
|
"checksumAlgorithm" : "bitmap-64bitMD5",
|
|
"checksumValue" : 11866144860997809880,
|
|
"comparisonResult" : "no-comparison",
|
|
"filepath" :
|
|
"green_skp/bitmap-64bitMD5_11866144860997809880.png",
|
|
}, {
|
|
"checksumAlgorithm" : "bitmap-64bitMD5",
|
|
"checksumValue" : 3893392565127823822,
|
|
"comparisonResult" : "no-comparison",
|
|
"filepath" :
|
|
"green_skp/bitmap-64bitMD5_3893392565127823822.png",
|
|
}, {
|
|
"checksumAlgorithm" : "bitmap-64bitMD5",
|
|
"checksumValue" : 2083084978343901738,
|
|
"comparisonResult" : "no-comparison",
|
|
"filepath" :
|
|
"green_skp/bitmap-64bitMD5_2083084978343901738.png",
|
|
}, {
|
|
"checksumAlgorithm" : "bitmap-64bitMD5",
|
|
"checksumValue" : 89620927366502076,
|
|
"comparisonResult" : "no-comparison",
|
|
"filepath" :
|
|
"green_skp/bitmap-64bitMD5_89620927366502076.png",
|
|
}],
|
|
}
|
|
}
|
|
}
|
|
self._assert_json_contents(output_json_path, expected_summary_dict)
|
|
self._assert_directory_contents(write_path_dir, ['red_skp', 'green_skp'])
|
|
self._assert_directory_contents(
|
|
os.path.join(write_path_dir, 'red_skp'),
|
|
['bitmap-64bitMD5_5815827069051002745.png',
|
|
'bitmap-64bitMD5_9323613075234140270.png',
|
|
'bitmap-64bitMD5_15939355025996362179.png',
|
|
'bitmap-64bitMD5_649771916797529222.png',
|
|
'bitmap-64bitMD5_8132820002266077288.png',
|
|
'bitmap-64bitMD5_2406160701181324581.png'])
|
|
self._assert_directory_contents(
|
|
os.path.join(write_path_dir, 'green_skp'),
|
|
['bitmap-64bitMD5_12587324416545178013.png',
|
|
'bitmap-64bitMD5_7624374914829746293.png',
|
|
'bitmap-64bitMD5_11866144860997809880.png',
|
|
'bitmap-64bitMD5_3893392565127823822.png',
|
|
'bitmap-64bitMD5_2083084978343901738.png',
|
|
'bitmap-64bitMD5_89620927366502076.png'])
|
|
|
|
def _run_render_pictures(self, args):
|
|
binary = find_run_binary.find_path_to_program('render_pictures')
|
|
return find_run_binary.run_command(
|
|
[binary, '--config', '8888'] + args)
|
|
|
|
def _create_expectations(self, missing_some_images=False,
|
|
ignore_some_failures=False,
|
|
rel_path='expectations.json'):
|
|
"""Creates expectations JSON file within self._expectations_dir .
|
|
|
|
Args:
|
|
missing_some_images: (bool) whether to remove expectations for a subset
|
|
of the images
|
|
ignore_some_failures: (bool) whether to ignore some failing tests
|
|
rel_path: (string) relative path within self._expectations_dir to write
|
|
the expectations into
|
|
|
|
Returns: full path to the expectations file created.
|
|
"""
|
|
expectations_dict = {
|
|
"header" : EXPECTED_HEADER_CONTENTS,
|
|
"descriptions" : None,
|
|
"expected-results" : {
|
|
# red.skp: these should fail the comparison
|
|
"red.skp": {
|
|
"tiled-images": modified_list_of_dicts(
|
|
RED_TILES, {'checksumValue': 11111}),
|
|
"whole-image": modified_dict(
|
|
RED_WHOLEIMAGE, {'checksumValue': 22222}),
|
|
},
|
|
# green.skp: these should pass the comparison
|
|
"green.skp": {
|
|
"tiled-images": GREEN_TILES,
|
|
"whole-image": GREEN_WHOLEIMAGE,
|
|
}
|
|
}
|
|
}
|
|
if missing_some_images:
|
|
red_subdict = expectations_dict['expected-results']['red.skp']
|
|
del red_subdict['whole-image']
|
|
del red_subdict['tiled-images'][-1]
|
|
elif ignore_some_failures:
|
|
red_subdict = expectations_dict['expected-results']['red.skp']
|
|
red_subdict['whole-image']['ignoreFailure'] = True
|
|
red_subdict['tiled-images'][-1]['ignoreFailure'] = True
|
|
path = os.path.join(self._expectations_dir, rel_path)
|
|
with open(path, 'w') as fh:
|
|
json.dump(expectations_dict, fh)
|
|
return path
|
|
|
|
def _generate_skps(self):
|
|
"""Runs the skpmaker binary to generate files in self._input_skp_dir."""
|
|
self._run_skpmaker(
|
|
output_path=os.path.join(self._input_skp_dir, 'red.skp'), red=255)
|
|
self._run_skpmaker(
|
|
output_path=os.path.join(self._input_skp_dir, 'green.skp'), green=255)
|
|
|
|
def _run_skpmaker(self, output_path, red=0, green=0, blue=0,
|
|
width=640, height=400):
|
|
"""Runs the skpmaker binary to generate SKP with known characteristics.
|
|
|
|
Args:
|
|
output_path: Filepath to write the SKP into.
|
|
red: Value of red color channel in image, 0-255.
|
|
green: Value of green color channel in image, 0-255.
|
|
blue: Value of blue color channel in image, 0-255.
|
|
width: Width of canvas to create.
|
|
height: Height of canvas to create.
|
|
"""
|
|
binary = find_run_binary.find_path_to_program('skpmaker')
|
|
return find_run_binary.run_command([
|
|
binary,
|
|
'--red', str(red),
|
|
'--green', str(green),
|
|
'--blue', str(blue),
|
|
'--width', str(width),
|
|
'--height', str(height),
|
|
'--writePath', str(output_path),
|
|
])
|
|
|
|
def _assert_directory_contents(self, dir_path, expected_filenames):
|
|
"""Asserts that files found in a dir are identical to expected_filenames.
|
|
|
|
Args:
|
|
dir_path: Path to a directory on local disk.
|
|
expected_filenames: Set containing the expected filenames within the dir.
|
|
|
|
Raises:
|
|
AssertionError: contents of the directory are not identical to
|
|
expected_filenames.
|
|
"""
|
|
self.assertEqual(set(os.listdir(dir_path)), set(expected_filenames))
|
|
|
|
def _assert_json_contents(self, json_path, expected_dict):
|
|
"""Asserts that contents of a JSON file are identical to expected_dict.
|
|
|
|
Args:
|
|
json_path: Path to a JSON file.
|
|
expected_dict: Dictionary indicating the expected contents of the JSON
|
|
file.
|
|
|
|
Raises:
|
|
AssertionError: contents of the JSON file are not identical to
|
|
expected_dict.
|
|
"""
|
|
prettyprinted_expected_dict = json.dumps(expected_dict, sort_keys=True,
|
|
indent=2)
|
|
with open(json_path, 'r') as fh:
|
|
prettyprinted_json_dict = json.dumps(json.load(fh), sort_keys=True,
|
|
indent=2)
|
|
self.assertMultiLineEqual(prettyprinted_expected_dict,
|
|
prettyprinted_json_dict)
|
|
|
|
|
|
def main():
|
|
base_unittest.main(RenderPicturesTest)
|
|
|
|
|
|
if __name__ == '__main__':
|
|
main()
|