create sk_tools::Expectation class, similar to skiagm::Expectations class

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 195 matching lines @@
             "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,
+        "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,
@@ skipping 358 matching lines @@
          'bitmap-64bitMD5_7980646035555096146.png',
          'bitmap-64bitMD5_17817086664365875131.png',
          'bitmap-64bitMD5_10673669813016809363.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:
-      del expectations_dict['expected-results']['red.skp']['whole-image']
-      del expectations_dict['expected-results']['red.skp']['tiled-images'][-1]
+      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(
@@ skipping 55 matching lines @@
     self.assertMultiLineEqual(prettyprinted_expected_dict,
                               prettyprinted_json_dict)
 
 
 def main():
   base_unittest.main(RenderPicturesTest)
 
 
 if __name__ == '__main__':
   main()