add --descriptions flag to render_pictures tool

tools/tests/render_pictures_test.py

 #!/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.
 """
@@ skipping 179 matching lines @@
     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,
+        "descriptions" : None,
         "actual-results" : {
             "red.skp": {
                 "tiled-images": RED_TILES,
                 "whole-image": RED_WHOLEIMAGE,
             },
             "green.skp": {
                 "tiled-images": GREEN_TILES,
                 "whole-image": GREEN_WHOLEIMAGE,
             }
         }
@@ skipping 15 matching lines @@
         '--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,
+        "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,
             }
@@ skipping 24 matching lines @@
         '--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,
+          "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,
+        "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,
-                               '--writeChecksumBasedFilenames',
-                               '--writePath', write_path_dir,
-                               '--writeJsonSummaryPath', output_json_path])
+    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,
+        "descriptions" : {
+            "builder": "builderName",
+            "renderMode": "renderModeName",
+        },
         "actual-results" : {
             "red.skp": {
                 # Manually verified: 640x400 red rectangle with black border
                 "whole-image": {
                     "checksumAlgorithm" : "bitmap-64bitMD5",
                     "checksumValue" : 11092453015575919668,
                     "comparisonResult" : "no-comparison",
                     "filepath" :
                         "red_skp/bitmap-64bitMD5_11092453015575919668.png",
                 },
@@ skipping 27 matching lines @@
     """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,
+        "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,
+        "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)
@@ skipping 14 matching lines @@
     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,
+        "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)
@@ skipping 10 matching lines @@
         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,
+        "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" :
@@ skipping 105 matching lines @@
     Args:
       missing_some_images: (bool) whether to remove expectations for a subset
           of the images
       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": {
@@ skipping 73 matching lines @@
     self.assertMultiLineEqual(prettyprinted_expected_dict,
                               prettyprinted_json_dict)
 
 
 def main():
   base_unittest.main(RenderPicturesTest)
 
 
 if __name__ == '__main__':
   main()