Implemented parsing of the ignored failing tests spec and ignoring respective failures.

scripts/common/gtest_utils.py

 #!/usr/bin/env python
 # Copyright (c) 2012 The Chromium Authors. All rights reserved.
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
+from common import chromium_utils
 import json
 import os
 import re
 import tempfile
 
 
 def CompressList(lines, max_length, middle_replacement):
   """Ensures that |lines| is no longer than |max_length|. If |lines| need to
   be compressed then the middle items are replaced by |middle_replacement|.
   """
@@ skipping 396 matching lines @@
 
   def __init__(self):
     self.json_file_path = None
     self.delete_json_file = False
 
     self.disabled_tests = set()
     self.passed_tests = set()
     self.failed_tests = set()
     self.flaky_tests = set()
     self.test_logs = {}
+    self.ignored_failed_tests = set()
 
     self.parsing_errors = []
 
     self.master_name = None
 
   def ProcessLine(self, line):
     # Deliberately do nothing - we parse out-of-band JSON summary
     # instead of in-band stdout.
     pass
 
   def PassedTests(self):
     return sorted(self.passed_tests)
 
   def FailedTests(self, include_fails=False, include_flaky=False):
-    return sorted(self.failed_tests)
+    return sorted(self.failed_tests - self.ignored_failed_tests)
 
   def FailureDescription(self, test):
     return self.test_logs.get(test, [])
 
+  def IgnoredFailedTests(self):
+    return sorted(self.ignored_failed_tests)
+
   @staticmethod
   def SuppressionHashes():
     return []
 
   def ParsingErrors(self):
     return self.parsing_errors
 
   def ClearParsingErrors(self):
     self.parsing_errors = ['Cleared.']
 
@@ skipping 12 matching lines @@
       self.json_file_path = cmdline_path
       # If the caller requested JSON summary, do not delete it.
       self.delete_json_file = False
     else:
       fd, self.json_file_path = tempfile.mkstemp()
       os.close(fd)
       # When we create the file ourselves, delete it to avoid littering.
       self.delete_json_file = True
     return self.json_file_path
 
-  def ProcessJSONFile(self):
+  def ProcessJSONFile(self, build_dir):
     if not self.json_file_path:
       return
 
     with open(self.json_file_path) as json_file:
       try:
         json_output = json_file.read()
         json_data = json.loads(json_output)
       except ValueError:
         # Only signal parsing error if the file is non-empty. Empty file
         # most likely means the binary doesn't support JSON output.
         if json_output:
           self.parsing_errors = json_output.split('\n')
       else:
-        self.ProcessJSONData(json_data)
+        self.ProcessJSONData(json_data, build_dir)
 
     if self.delete_json_file:
       os.remove(self.json_file_path)
 
-  def ProcessJSONData(self, json_data):
+  def _ParseIngoredFailedTestsSpec(self, build_dir, platform_flags):
+    if not build_dir:
+      return
+
+    try:
+      ignored_failed_tests_path = chromium_utils.FindUpward(
+          os.path.abspath(build_dir), 'tools', 'ignorer_bot',
+          'ignored_failed_tests.txt')
+    except chromium_utils.PathNotFound:
+      return
+
+    with open(ignored_failed_tests_path) as ignored_failed_tests_file:
+      ignored_failed_tests_spec = ignored_failed_tests_file.readlines()
+
+    for spec_line in ignored_failed_tests_spec:
+      spec_line = spec_line.strip()
+      if spec_line.startswith('#') or not spec_line:
+        continue
+
+      # Any number of flags separated by whitespace with optional trailing
+      # and/or leading whitespace.
+      platform_spec_regexp = r'\s*\w+(?:\s+\w+)*\s*'
+
+      match = re.match(
+          r'^http://crbug.com/\d+'     # Issue URL.
+          r'\s+'                       # Some whitespace.
+          r'\[(' +                     # Opening square bracket '['.
+            platform_spec_regexp +     # At least one platform, and...
+            r'(?:,' +                  # ...separated by commas...
+              platform_spec_regexp +   # ...any number of additional...
+            r')*'                      # ...platforms.
+          r')\]'                       # Closing square bracket ']'.
+          r'\s+'                       # Some whitespace.
+          r'(\S+)$', spec_line)        # Test name.
+
+      if not match:
+        continue
+
+      platform_specs = match.group(1).strip()
+      test_name = match.group(2).strip()
+
+      platform_flags = set(platform_flags)
+      for platform_spec in platform_specs.split(','):
+        required_platform_flags = set(platform_spec.split())
+        if required_platform_flags.issubset(platform_flags):
+          self.ignored_failed_tests.add(test_name)
+          break
+
+  def ProcessJSONData(self, json_data, build_dir=None):
     # TODO(phajdan.jr): Require disabled_tests to be present (May 2014).
     self.disabled_tests.update(json_data.get('disabled_tests', []))
+    self._ParseIngoredFailedTestsSpec(build_dir,
+                                      json_data.get('global_tags', []))
 
     for iteration_data in json_data['per_iteration_data']:
       for test_name, test_runs in iteration_data.iteritems():
         if test_runs[-1]['status'] == 'SUCCESS':
           self.passed_tests.add(test_name)
         else:
           self.failed_tests.add(test_name)
 
         if len(test_runs) > 1:
           self.flaky_tests.add(test_name)
 
         self.test_logs.setdefault(test_name, [])
         for run_index, run_data in enumerate(test_runs, start=1):
           run_lines = ['%s (run #%d):' % (test_name, run_index)]
           # Make sure the annotations are ASCII to avoid character set related
           # errors. They are mostly informational anyway, and more detailed
           # info can be obtained from the original JSON output.
           ascii_lines = run_data['output_snippet'].encode('ascii',
                                                           errors='replace')
           decoded_lines = CompressList(
               ascii_lines.decode('string_escape').split('\n'),
               self.OUTPUT_SNIPPET_LINES_LIMIT,
               '<truncated, full output is in gzipped JSON '
               'output at end of step>')
           run_lines.extend(decoded_lines)
           self.test_logs[test_name].extend(run_lines)