[foozzie] Add sources metadata to failure output.

tools/foozzie/v8_foozzie.py

 #!/usr/bin/env python
 # Copyright 2016 the V8 project authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
 """
 V8 correctness fuzzer launcher script.
 """
 
 import argparse
+import hashlib
 import itertools
+import json
 import os
 import re
 import sys
 import traceback
 
 import v8_commands
 import v8_suppressions
 
 CONFIGS = dict(
   default=[],
@@ skipping 86 matching lines @@
   assert options.first_arch in SUPPORTED_ARCHS
   assert options.second_arch in SUPPORTED_ARCHS
   assert options.first_config in CONFIGS
   assert options.second_config in CONFIGS
 
   # Ensure we have a test case.
   assert (os.path.exists(options.testcase) and
           os.path.isfile(options.testcase)), (
       'Test case %s doesn\'t exist' % options.testcase)
 
+  resources_path = os.path.join(
+      os.path.dirname(options.testcase),
+      'resources' + os.path.basename(options.testcase)[len('fuzz'):])
+  assert os.path.exists(resources_path), (
+      'Resources file %s doesn\'t exist' % resources_path)
+
+  with open(resources_path) as f:
+    resources = f.read().strip().splitlines()
+    assert len(resources) == 1
+    options.meta_data_path = os.path.join(
+        os.path.dirname(resources_path), resources[0])
+  assert os.path.exists(options.meta_data_path), (
+      'Metadata %s doesn\'t exist' % options.meta_data_path)
+
   # Use first d8 as default for second d8.
   options.second_d8 = options.second_d8 or options.first_d8
 
   # Ensure absolute paths.
   options.first_d8 = os.path.abspath(options.first_d8)
   options.second_d8 = os.path.abspath(options.second_d8)
 
   # Ensure executables exist.
   assert os.path.exists(options.first_d8)
   assert os.path.exists(options.second_d8)
@@ skipping 46 matching lines @@
 
   # Suppressions are architecture and configuration specific.
   suppress = v8_suppressions.get_suppression(
       options.first_arch, options.first_config,
       options.second_arch, options.second_config,
   )
 
   if test_pattern_bailout(options.testcase, suppress.ignore):
     return RETURN_FAIL
 
+  # Get metadata.
+  with open(options.meta_data_path) as f:
+    metadata = json.load(f)
+
   common_flags = FLAGS + ['--random-seed', str(options.random_seed)]
   first_config_flags = common_flags + CONFIGS[options.first_config]
   second_config_flags = common_flags + CONFIGS[options.second_config]
 
   def run_d8(d8, config_flags):
     args = [d8] + config_flags + PREAMBLE + [options.testcase]
     if d8.endswith('.py'):
       # Wrap with python in tests.
       args = [sys.executable] + args
     return v8_commands.Execute(
@@ skipping 18 matching lines @@
   if fail_bailout(second_config_output, suppress.ignore_by_output2):
     return RETURN_FAIL
 
   difference = suppress.diff(
       first_config_output.stdout, second_config_output.stdout)
   if difference:
     # The first three entries will be parsed by clusterfuzz. Format changes
     # will require changes on the clusterfuzz side.
     first_config_label = '%s,%s' % (options.first_arch, options.first_config)
     second_config_label = '%s,%s' % (options.second_arch, options.second_config)
+    hsh = lambda x: hashlib.sha1(x).hexdigest()[:8]
     print FAILURE_TEMPLATE % dict(
         configs='%s:%s' % (first_config_label, second_config_label),
-        sources='', # TODO
+        sources=','.join(map(hsh, metadata['sources'])),
         suppression='', # We can't tie bugs to differences.
         first_config_label=first_config_label,
         second_config_label=second_config_label,
         first_config_flags=' '.join(first_config_flags),
         second_config_flags=' '.join(second_config_flags),
         first_config_output=first_config_output.stdout,
         second_config_output=second_config_output.stdout,
         difference=difference,
     )
     return RETURN_FAIL
@@ skipping 16 matching lines @@
         configs='', sources='', suppression='wrong_usage')
     result = RETURN_FAIL
   except Exception as e:
     print FAILURE_HEADER_TEMPLATE % dict(
         configs='', sources='', suppression='internal_error')
     print '# Internal error: %s' % e
     traceback.print_exc(file=sys.stdout)
     result = RETURN_FAIL
 
   sys.exit(result)