[foozzie] Fix failure state for non-existing source output

tools/foozzie/v8_suppressions.py

 # 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.
 
 """
 Suppressions for V8 correctness fuzzer failures.
 
 We support three types of suppressions:
 1. Ignore test case by pattern.
 Map a regular expression to a bug entry. A new failure will be reported
 when the pattern matches a JS test case.
 Subsequent matches will be recoreded under the first failure.
 
 2. Ignore test run by output pattern:
 Map a regular expression to a bug entry. A new failure will be reported
 when the pattern matches the output of a particular run.
 Subsequent matches will be recoreded under the first failure.
 
 3. Relax line-to-line comparisons with expressions of lines to ignore and
 lines to be normalized (i.e. ignore only portions of lines).
 These are not tied to bugs, be careful to not silently switch off this tool!
 
 Alternatively, think about adding a behavior change to v8_suppressions.js
 to silence a particular class of problems.
 """
 
+import hashlib
 import itertools
 import re
 
 # Max line length for regular experessions checking for lines to ignore.
 MAX_LINE_LENGTH = 512
 
 # For ignoring lines before carets and to ignore caret positions.
 CARET_RE = re.compile(r'^\s*\^\s*$')
 
 # Ignore by original source files. Map from bug->relative file paths in V8,
@@ skipping 104 matching lines @@
 ]
 
 
 ###############################################################################
 # Implementation - you should not need to change anything below this point.
 
 # Compile regular expressions.
 ALLOWED_LINE_DIFFS = [re.compile(exp) for exp in ALLOWED_LINE_DIFFS]
 IGNORE_LINES = [re.compile(exp) for exp in IGNORE_LINES]
 
+# The number of hex digits used from the hash of the original source file path.
+# Keep the number small to avoid duplicate explosion.
+SOURCE_HASH_LENGTH = 3
+
 ORIGINAL_SOURCE_PREFIX = 'v8-foozzie source: '
 
 def line_pairs(lines):
   return itertools.izip_longest(
       lines, itertools.islice(lines, 1, None), fillvalue=None)
 
 
 def caret_match(line1, line2):
   if (not line1 or
       not line2 or
@@ skipping 18 matching lines @@
     match2 = exp.match(line2)
     if match1 and match2:
       # If there are groups in the regexp, ensure the groups matched the same
       # things.
       if match1.groups() == match2.groups():  # tuple comparison
         return True
   return False
 
 
 def diff_output(output1, output2, allowed, ignore1, ignore2):
-  """Returns a tuple (difference, source).
+  """Returns a tuple (difference, source_key).
 
   The difference is None if there's no difference, otherwise a string
   with a readable diff.
 
-  The source is a string with the last source output within the test case.
-  It is the string 'none' if no such output existed.
+  The source_key is a short hash of the last source output within the test
+  case. It is the string 'none' if no such output existed.
   """
   def useful_line(ignore):
     def fun(line):
       return all(not e.match(line) for e in ignore)
     return fun
 
   lines1 = filter(useful_line(ignore1), output1)
   lines2 = filter(useful_line(ignore2), output2)
 
   # This keeps track where we are in the original source file of the fuzz
   # test case.
-  source = 'none'
+  source_key = 'none'
 
   for ((line1, lookahead1), (line2, lookahead2)) in itertools.izip_longest(
       line_pairs(lines1), line_pairs(lines2), fillvalue=(None, None)):
 
     # Only one of the two iterators should run out.
     assert not (line1 is None and line2 is None)
 
     # One iterator ends earlier.
     if line1 is None:
-      return '+ %s' % short_line_output(line2), source
+      return '+ %s' % short_line_output(line2), source_key
     if line2 is None:
-      return '- %s' % short_line_output(line1), source
+      return '- %s' % short_line_output(line1), source_key
 
     # If lines are equal, no further checks are necessary.
     if line1 == line2:
       # Instrumented original-source-file output must be equal in both
       # versions. It only makes sense to update it here when both lines
       # are equal.
       if line1.startswith(ORIGINAL_SOURCE_PREFIX):
         source = line1[len(ORIGINAL_SOURCE_PREFIX):]
+        source_key = hashlib.sha1(source).hexdigest()[:SOURCE_HASH_LENGTH]

[Michael Achenbach, 2017/01/13 08:13:40]

Maybe not ideal that this is in this file. The hashing has nothing to do with
suppression. I'll probably refactor this soonish.

       continue
 
     # Look ahead. If next line is a caret, ignore this line.
     if caret_match(lookahead1, lookahead2):
       continue
 
     # Check if a regexp allows these lines to be different.
     if ignore_by_regexp(line1, line2, allowed):
       continue
 
     # Lines are different.
     return (
         '- %s\n+ %s' % (short_line_output(line1), short_line_output(line2)),
-        source,
+        source_key,
     )
 
   # No difference found.
-  return None, source
+  return None, source_key
 
 
 def get_suppression(arch1, config1, arch2, config2):
   return V8Suppression(arch1, config1, arch2, config2)
 
 
 class Suppression(object):
   def diff(self, output1, output2):
     return None
 
@@ skipping 56 matching lines @@
     bug = check(IGNORE_OUTPUT.get(arch, {}))
     if bug:
       return bug
     bug = check(IGNORE_OUTPUT.get(config, {}))
     if bug:
       return bug
     bug = check(IGNORE_OUTPUT.get('%s,%s' % (arch, config), {}))
     if bug:
       return bug
     return None