shaka-packager/tools/valgrind/suppressions.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.

# suppressions.py

"""Post-process Valgrind suppression matcher.

Suppressions are defined as follows:

# optional one-line comments anywhere in the suppressions file.
{
  <Short description of the error>
  Toolname:Errortype
  fun:function_name
  obj:object_filename
  fun:wildcarded_fun*_name
  # an ellipsis wildcards zero or more functions in a stack.
  ...
  fun:some_other_function_name
}

If ran from the command line, suppressions.py does a self-test
of the Suppression class.
"""

import os
import re
import sys

sys.path.insert(0, os.path.join(os.path.dirname(__file__),
                                '..', 'python', 'google'))
import path_utils


ELLIPSIS = '...'


def GetSuppressions():
  suppressions_root = path_utils.ScriptDir()
  JOIN = os.path.join

  result = {}

  supp_filename = JOIN(suppressions_root, "memcheck", "suppressions.txt")
  vg_common = ReadSuppressionsFromFile(supp_filename)
  supp_filename = JOIN(suppressions_root, "tsan", "suppressions.txt")
  tsan_common = ReadSuppressionsFromFile(supp_filename)
  result['common_suppressions'] = vg_common + tsan_common

  supp_filename = JOIN(suppressions_root, "memcheck", "suppressions_linux.txt")
  vg_linux = ReadSuppressionsFromFile(supp_filename)
  supp_filename = JOIN(suppressions_root, "tsan", "suppressions_linux.txt")
  tsan_linux = ReadSuppressionsFromFile(supp_filename)
  result['linux_suppressions'] = vg_linux + tsan_linux

  supp_filename = JOIN(suppressions_root, "memcheck", "suppressions_mac.txt")
  vg_mac = ReadSuppressionsFromFile(supp_filename)
  supp_filename = JOIN(suppressions_root, "tsan", "suppressions_mac.txt")
  tsan_mac = ReadSuppressionsFromFile(supp_filename)
  result['mac_suppressions'] = vg_mac + tsan_mac

  supp_filename = JOIN(suppressions_root, "tsan", "suppressions_win32.txt")
  tsan_win = ReadSuppressionsFromFile(supp_filename)
  result['win_suppressions'] = tsan_win

  supp_filename = JOIN(suppressions_root, "..", "heapcheck", "suppressions.txt")
  result['heapcheck_suppressions'] = ReadSuppressionsFromFile(supp_filename)

  supp_filename = JOIN(suppressions_root, "drmemory", "suppressions.txt")
  result['drmem_suppressions'] = ReadSuppressionsFromFile(supp_filename)
  supp_filename = JOIN(suppressions_root, "drmemory", "suppressions_full.txt")
  result['drmem_full_suppressions'] = ReadSuppressionsFromFile(supp_filename)

  return result


def GlobToRegex(glob_pattern, ignore_case=False):
  """Translate glob wildcards (*?) into regex syntax.  Escape the rest."""
  regex = ''
  for char in glob_pattern:
    if char == '*':
      regex += '.*'
    elif char == '?':
      regex += '.'
    elif ignore_case and char.isalpha():
      regex += '[%s%s]' % (char.lower(), char.upper())
    else:
      regex += re.escape(char)
  return ''.join(regex)


def StripAndSkipCommentsIterator(lines):
  """Generator of (line_no, line) pairs that strips comments and whitespace."""
  for (line_no, line) in enumerate(lines):
    line = line.strip()  # Drop \n
    if line.startswith('#'):
      continue  # Comments
    # Skip comment lines, but not empty lines, they indicate the end of a
    # suppression.  Add one to the line number as well, since most editors use
    # 1-based numberings, and enumerate is 0-based.
    yield (line_no + 1, line)


class Suppression(object):
  """This class represents a single stack trace suppression.

  Attributes:
    description: A string representing the error description.
    type: A string representing the error type, e.g. Memcheck:Leak.
    stack: The lines comprising the stack trace for the suppression.
    regex: The actual regex used to match against scraped reports.
  """

  def __init__(self, description, type, stack, defined_at, regex):
    """Inits Suppression.

    description, type, stack, regex: same as class attributes
    defined_at: file:line identifying where the suppression was defined
    """
    self.description = description
    self.type = type
    self.stack = stack
    self.defined_at = defined_at
    self.regex = re.compile(regex, re.MULTILINE)

  def Match(self, suppression_from_report):
    """Returns bool indicating whether this suppression matches
       the suppression generated from Valgrind error report.

       We match our suppressions against generated suppressions
       (not against reports) since they have the same format
       while the reports are taken from XML, contain filenames,
       they are demangled, and are generally more difficult to
       parse.

    Args:
      suppression_from_report: list of strings (function names).
    Returns:
      True if the suppression is not empty and matches the report.
    """
    if not self.stack:
      return False
    lines = [f.strip() for f in suppression_from_report]
    return self.regex.match('\n'.join(lines) + '\n') is not None


def FilenameToTool(filename):
  """Return the name of the tool that a file is related to, or None.

  Example mappings:
    tools/heapcheck/suppressions.txt -> heapcheck
    tools/valgrind/tsan/suppressions.txt -> tsan
    tools/valgrind/drmemory/suppressions.txt -> drmemory
    tools/valgrind/drmemory/suppressions_full.txt -> drmemory
    tools/valgrind/memcheck/suppressions.txt -> memcheck
    tools/valgrind/memcheck/suppressions_mac.txt -> memcheck
  """
  filename = os.path.abspath(filename)
  parts = filename.split(os.sep)
  tool = parts[-2]
  if tool in ('heapcheck', 'drmemory', 'memcheck', 'tsan'):
    return tool
  return None


def ReadSuppressionsFromFile(filename):
  """Read suppressions from the given file and return them as a list"""
  tool_to_parser = {
    "drmemory":  ReadDrMemorySuppressions,
    "memcheck":  ReadValgrindStyleSuppressions,
    "tsan":      ReadValgrindStyleSuppressions,
    "heapcheck": ReadValgrindStyleSuppressions,
  }
  tool = FilenameToTool(filename)
  assert tool in tool_to_parser, (
      "unknown tool %s for filename %s" % (tool, filename))
  parse_func = tool_to_parser[tool]

  # Consider non-existent files to be empty.
  if not os.path.exists(filename):
    return []

  input_file = file(filename, 'r')
  try:
    return parse_func(input_file, filename)
  except SuppressionError:
    input_file.close()
    raise


class ValgrindStyleSuppression(Suppression):
  """A suppression using the Valgrind syntax.

  Most tools, even ones that are not Valgrind-based, use this syntax, ie
  Heapcheck, TSan, etc.

  Attributes:
    Same as Suppression.
  """

  def __init__(self, description, type, stack, defined_at):
    """Creates a suppression using the Memcheck, TSan, and Heapcheck syntax."""
    regex = '{\n.*\n%s\n' % type
    for line in stack:
      if line == ELLIPSIS:
        regex += '(.*\n)*'
      else:
        regex += GlobToRegex(line)
        regex += '\n'
    regex += '(.*\n)*'
    regex += '}'

    # In the recent version of valgrind-variant we've switched
    # from memcheck's default Addr[1248]/Value[1248]/Cond suppression types
    # to simply Unaddressable/Uninitialized.
    # The suppression generator no longer gives us "old" types thus
    # for the "new-type" suppressions:
    #  * Memcheck:Unaddressable should also match Addr* reports,
    #  * Memcheck:Uninitialized should also match Cond and Value reports,
    #
    # We also want to support legacy suppressions (e.g. copied from
    # upstream bugs etc), so:
    #  * Memcheck:Addr[1248] suppressions should match Unaddressable reports,
    #  * Memcheck:Cond and Memcheck:Value[1248] should match Uninitialized.
    # Please note the latest two rules only apply to the
    # tools/valgrind/waterfall.sh suppression matcher and the real
    # valgrind-variant Memcheck will not suppress
    # e.g. Addr1 printed as Unaddressable with Addr4 suppression.
    # Be careful to check the access size while copying legacy suppressions!
    for sz in [1, 2, 4, 8]:
      regex = regex.replace("\nMemcheck:Addr%d\n" % sz,
                            "\nMemcheck:(Addr%d|Unaddressable)\n" % sz)
      regex = regex.replace("\nMemcheck:Value%d\n" % sz,
                            "\nMemcheck:(Value%d|Uninitialized)\n" % sz)
    regex = regex.replace("\nMemcheck:Cond\n",
                          "\nMemcheck:(Cond|Uninitialized)\n")
    regex = regex.replace("\nMemcheck:Unaddressable\n",
                          "\nMemcheck:(Addr.|Unaddressable)\n")
    regex = regex.replace("\nMemcheck:Uninitialized\n",
                          "\nMemcheck:(Cond|Value.|Uninitialized)\n")

    return super(ValgrindStyleSuppression, self).__init__(
        description, type, stack, defined_at, regex)

  def __str__(self):
    """Stringify."""
    lines = [self.description, self.type] + self.stack
    return "{\n   %s\n}\n" % "\n   ".join(lines)


class SuppressionError(Exception):
  def __init__(self, message, happened_at):
    self._message = message
    self._happened_at = happened_at

  def __str__(self):
    return 'Error reading suppressions at %s!\n%s' % (
        self._happened_at, self._message)


def ReadValgrindStyleSuppressions(lines, supp_descriptor):
  """Given a list of lines, returns a list of suppressions.

  Args:
    lines: a list of lines containing suppressions.
    supp_descriptor: should typically be a filename.
        Used only when printing errors.
  """
  result = []
  cur_descr = ''
  cur_type = ''
  cur_stack = []
  in_suppression = False
  nline = 0
  for line in lines:
    nline += 1
    line = line.strip()
    if line.startswith('#'):
      continue
    if not in_suppression:
      if not line:
        # empty lines between suppressions
        pass
      elif line.startswith('{'):
        in_suppression = True
        pass
      else:
        raise SuppressionError('Expected: "{"',
                               "%s:%d" % (supp_descriptor, nline))
    elif line.startswith('}'):
      result.append(
          ValgrindStyleSuppression(cur_descr, cur_type, cur_stack,
                                   "%s:%d" % (supp_descriptor, nline)))
      cur_descr = ''
      cur_type = ''
      cur_stack = []
      in_suppression = False
    elif not cur_descr:
      cur_descr = line
      continue
    elif not cur_type:
      if (not line.startswith("Memcheck:") and
          not line.startswith("ThreadSanitizer:") and
          (line != "Heapcheck:Leak")):
        raise SuppressionError(
            'Expected "Memcheck:TYPE", "ThreadSanitizer:TYPE" '
            'or "Heapcheck:Leak", got "%s"' % line,
            "%s:%d" % (supp_descriptor, nline))
      supp_type = line.split(':')[1]
      if not supp_type in ["Addr1", "Addr2", "Addr4", "Addr8",
                           "Cond", "Free", "Jump", "Leak", "Overlap", "Param",
                           "Value1", "Value2", "Value4", "Value8",
                           "Race", "UnlockNonLocked", "InvalidLock",
                           "Unaddressable", "Uninitialized"]:
        raise SuppressionError('Unknown suppression type "%s"' % supp_type,
                               "%s:%d" % (supp_descriptor, nline))
      cur_type = line
      continue
    elif re.match("^fun:.*|^obj:.*|^\.\.\.$", line):
      cur_stack.append(line.strip())
    elif len(cur_stack) == 0 and cur_type == "Memcheck:Param":
      cur_stack.append(line.strip())
    else:
      raise SuppressionError(
          '"fun:function_name" or "obj:object_file" or "..." expected',
          "%s:%d" % (supp_descriptor, nline))
  return result


def PresubmitCheckSuppressions(supps):
  """Check a list of suppressions and return a list of SuppressionErrors.

  Mostly useful for separating the checking logic from the Presubmit API for
  testing.
  """
  known_supp_names = {}  # Key: name, Value: suppression.
  errors = []
  for s in supps:
    if re.search("<.*suppression.name.here>", s.description):
      # Suppression name line is
      # <insert_a_suppression_name_here> for Memcheck,
      # <Put your suppression name here> for TSan,
      # name=<insert_a_suppression_name_here> for DrMemory
      errors.append(
          SuppressionError(
              "You've forgotten to put a suppression name like bug_XXX",
              s.defined_at))
      continue

    if s.description in known_supp_names:
      errors.append(
          SuppressionError(
              'Suppression named "%s" is defined more than once, '
              'see %s' % (s.description,
                          known_supp_names[s.description].defined_at),
              s.defined_at))
    else:
      known_supp_names[s.description] = s
  return errors


def PresubmitCheck(input_api, output_api):
  """A helper function useful in PRESUBMIT.py
     Returns a list of errors or [].
  """
  sup_regex = re.compile('suppressions.*\.txt$')
  filenames = [f.AbsoluteLocalPath() for f in input_api.AffectedFiles()
                   if sup_regex.search(f.LocalPath())]

  errors = []

  # TODO(timurrrr): warn on putting suppressions into a wrong file,
  # e.g. TSan suppression in a memcheck file.

  for f in filenames:
    try:
      supps = ReadSuppressionsFromFile(f)
      errors.extend(PresubmitCheckSuppressions(supps))
    except SuppressionError as e:
      errors.append(e)

  return [output_api.PresubmitError(str(e)) for e in errors]


class DrMemorySuppression(Suppression):
  """A suppression using the DrMemory syntax.

  Attributes:
    instr: The instruction to match.
    Rest inherited from Suppression.
  """

  def __init__(self, name, report_type, instr, stack, defined_at):
    """Constructor."""
    self.instr = instr

    # Construct the regex.
    regex = '{\n'
    if report_type == 'LEAK':
      regex += '(POSSIBLE )?LEAK'
    else:
      regex += report_type
    regex += '\nname=.*\n'

    # TODO(rnk): Implement http://crbug.com/107416#c5 .
    # drmemory_analyze.py doesn't generate suppressions with an instruction in
    # them, so these suppressions will always fail to match.  We should override
    # Match to fetch the instruction from the report and try to match against
    # that.
    if instr:
      regex += 'instruction=%s\n' % GlobToRegex(instr)

    for line in stack:
      if line == ELLIPSIS:
        regex += '(.*\n)*'
      elif '!' in line:
        (mod, func) = line.split('!')
        if func == ELLIPSIS:  # mod!ellipsis frame
          regex += '(%s\!.*\n)+' % GlobToRegex(mod, ignore_case=True)
        else:  # mod!func frame
          # Ignore case for the module match, but not the function match.
          regex += '%s\!%s\n' % (GlobToRegex(mod, ignore_case=True),
                                 GlobToRegex(func, ignore_case=False))
      else:
        regex += GlobToRegex(line)
        regex += '\n'
    regex += '(.*\n)*'  # Match anything left in the stack.
    regex += '}'
    return super(DrMemorySuppression, self).__init__(name, report_type, stack,
                                                     defined_at, regex)

  def __str__(self):
    """Stringify."""
    text = self.type + "\n"
    if self.description:
      text += "name=%s\n" % self.description
    if self.instr:
      text += "instruction=%s\n" % self.instr
    text += "\n".join(self.stack)
    text += "\n"
    return text


# Possible DrMemory error report types.  Keep consistent with suppress_name
# array in drmemory/drmemory/report.c.
DRMEMORY_ERROR_TYPES = [
    'UNADDRESSABLE ACCESS',
    'UNINITIALIZED READ',
    'INVALID HEAP ARGUMENT',
    'GDI USAGE ERROR',
    'HANDLE LEAK',
    'LEAK',
    'POSSIBLE LEAK',
    'WARNING',
    ]


# Regexes to match valid drmemory frames.
DRMEMORY_FRAME_PATTERNS = [
    re.compile(r"^.*\!.*$"),              # mod!func
    re.compile(r"^.*!\.\.\.$"),           # mod!ellipsis
    re.compile(r"^\<.*\+0x.*\>$"),        # <mod+0xoffs>
    re.compile(r"^\<not in a module\>$"),
    re.compile(r"^system call .*$"),
    re.compile(r"^\*$"),                  # wildcard
    re.compile(r"^\.\.\.$"),              # ellipsis
    ]


def ReadDrMemorySuppressions(lines, supp_descriptor):
  """Given a list of lines, returns a list of DrMemory suppressions.

  Args:
    lines: a list of lines containing suppressions.
    supp_descriptor: should typically be a filename.
      Used only when parsing errors happen.
  """
  lines = StripAndSkipCommentsIterator(lines)
  suppressions = []
  for (line_no, line) in lines:
    if not line:
      continue
    if line not in DRMEMORY_ERROR_TYPES:
      raise SuppressionError('Expected a DrMemory error type, '
                             'found %r instead\n  Valid error types: %s' %
                             (line, ' '.join(DRMEMORY_ERROR_TYPES)),
                             "%s:%d" % (supp_descriptor, line_no))

    # Suppression starts here.
    report_type = line
    name = ''
    instr = None
    stack = []
    defined_at = "%s:%d" % (supp_descriptor, line_no)
    found_stack = False
    for (line_no, line) in lines:
      if not found_stack and line.startswith('name='):
        name = line.replace('name=', '')
      elif not found_stack and line.startswith('instruction='):
        instr = line.replace('instruction=', '')
      else:
        # Unrecognized prefix indicates start of stack trace.
        found_stack = True
        if not line:
          # Blank line means end of suppression.
          break
        if not any([regex.match(line) for regex in DRMEMORY_FRAME_PATTERNS]):
          raise SuppressionError(
              ('Unexpected stack frame pattern at line %d\n' +
               'Frames should be one of the following:\n' +
               ' module!function\n' +
               ' module!...\n' +
               ' <module+0xhexoffset>\n' +
               ' <not in a module>\n' +
               ' system call Name\n' +
               ' *\n' +
               ' ...\n') % line_no, defined_at)
        stack.append(line)

    if len(stack) == 0:  # In case we hit EOF or blank without any stack frames.
      raise SuppressionError('Suppression "%s" has no stack frames, ends at %d'
                             % (name, line_no), defined_at)
    if stack[-1] == ELLIPSIS:
      raise SuppressionError('Suppression "%s" ends in an ellipsis on line %d' %
                             (name, line_no), defined_at)

    suppressions.append(
        DrMemorySuppression(name, report_type, instr, stack, defined_at))

  return suppressions


def ParseSuppressionOfType(lines, supp_descriptor, def_line_no, report_type):
  """Parse the suppression starting on this line.

  Suppressions start with a type, have an optional name and instruction, and a
  stack trace that ends in a blank line.
  """



def TestStack(stack, positive, negative, suppression_parser=None):
  """A helper function for SelfTest() that checks a single stack.

  Args:
    stack: the stack to match the suppressions.
    positive: the list of suppressions that must match the given stack.
    negative: the list of suppressions that should not match.
    suppression_parser: optional arg for the suppression parser, default is
      ReadValgrindStyleSuppressions.
  """
  if not suppression_parser:
    suppression_parser = ReadValgrindStyleSuppressions
  for supp in positive:
    parsed = suppression_parser(supp.split("\n"), "positive_suppression")
    assert parsed[0].Match(stack.split("\n")), (
        "Suppression:\n%s\ndidn't match stack:\n%s" % (supp, stack))
  for supp in negative:
    parsed = suppression_parser(supp.split("\n"), "negative_suppression")
    assert not parsed[0].Match(stack.split("\n")), (
        "Suppression:\n%s\ndid match stack:\n%s" % (supp, stack))


def TestFailPresubmit(supp_text, error_text, suppression_parser=None):
  """A helper function for SelfTest() that verifies a presubmit check fires.

  Args:
    supp_text: suppression text to parse.
    error_text: text of the presubmit error we expect to find.
    suppression_parser: optional arg for the suppression parser, default is
      ReadValgrindStyleSuppressions.
  """
  if not suppression_parser:
    suppression_parser = ReadValgrindStyleSuppressions
  try:
    supps = suppression_parser(supp_text.split("\n"), "<presubmit suppression>")
  except SuppressionError, e:
    # If parsing raised an exception, match the error text here.
    assert error_text in str(e), (
        "presubmit text %r not in SuppressionError:\n%r" %
        (error_text, str(e)))
  else:
    # Otherwise, run the presubmit checks over the supps.  We expect a single
    # error that has text matching error_text.
    errors = PresubmitCheckSuppressions(supps)
    assert len(errors) == 1, (
        "expected exactly one presubmit error, got:\n%s" % errors)
    assert error_text in str(errors[0]), (
        "presubmit text %r not in SuppressionError:\n%r" %
        (error_text, str(errors[0])))


def SelfTest():
  """Tests the Suppression.Match() capabilities."""

  test_memcheck_stack_1 = """{
    test
    Memcheck:Leak
    fun:absolutly
    fun:brilliant
    obj:condition
    fun:detection
    fun:expression
  }"""

  test_memcheck_stack_2 = """{
    test
    Memcheck:Uninitialized
    fun:absolutly
    fun:brilliant
    obj:condition
    fun:detection
    fun:expression
  }"""

  test_memcheck_stack_3 = """{
    test
    Memcheck:Unaddressable
    fun:absolutly
    fun:brilliant
    obj:condition
    fun:detection
    fun:expression
  }"""

  test_memcheck_stack_4 = """{
    test
    Memcheck:Addr4
    fun:absolutly
    fun:brilliant
    obj:condition
    fun:detection
    fun:expression
  }"""

  test_heapcheck_stack = """{
    test
    Heapcheck:Leak
    fun:absolutly
    fun:brilliant
    obj:condition
    fun:detection
    fun:expression
  }"""

  test_tsan_stack = """{
    test
    ThreadSanitizer:Race
    fun:absolutly
    fun:brilliant
    obj:condition
    fun:detection
    fun:expression
  }"""


  positive_memcheck_suppressions_1 = [
    "{\nzzz\nMemcheck:Leak\nfun:absolutly\n}",
    "{\nzzz\nMemcheck:Leak\nfun:ab*ly\n}",
    "{\nzzz\nMemcheck:Leak\nfun:absolutly\nfun:brilliant\n}",
    "{\nzzz\nMemcheck:Leak\n...\nfun:brilliant\n}",
    "{\nzzz\nMemcheck:Leak\n...\nfun:detection\n}",
    "{\nzzz\nMemcheck:Leak\nfun:absolutly\n...\nfun:detection\n}",
    "{\nzzz\nMemcheck:Leak\nfun:ab*ly\n...\nfun:detection\n}",
    "{\nzzz\nMemcheck:Leak\n...\nobj:condition\n}",
    "{\nzzz\nMemcheck:Leak\n...\nobj:condition\nfun:detection\n}",
    "{\nzzz\nMemcheck:Leak\n...\nfun:brilliant\nobj:condition\n}",
  ]

  positive_memcheck_suppressions_2 = [
    "{\nzzz\nMemcheck:Uninitialized\nfun:absolutly\n}",
    "{\nzzz\nMemcheck:Uninitialized\nfun:ab*ly\n}",
    "{\nzzz\nMemcheck:Uninitialized\nfun:absolutly\nfun:brilliant\n}",
    # Legacy suppression types
    "{\nzzz\nMemcheck:Value1\n...\nfun:brilliant\n}",
    "{\nzzz\nMemcheck:Cond\n...\nfun:detection\n}",
    "{\nzzz\nMemcheck:Value8\nfun:absolutly\nfun:brilliant\n}",
  ]

  positive_memcheck_suppressions_3 = [
    "{\nzzz\nMemcheck:Unaddressable\nfun:absolutly\n}",
    "{\nzzz\nMemcheck:Unaddressable\nfun:absolutly\nfun:brilliant\n}",
    "{\nzzz\nMemcheck:Unaddressable\nfun:absolutly\nfun:brilliant\n}",
    # Legacy suppression types
    "{\nzzz\nMemcheck:Addr1\n...\nfun:brilliant\n}",
    "{\nzzz\nMemcheck:Addr8\n...\nfun:detection\n}",
  ]

  positive_memcheck_suppressions_4 = [
    "{\nzzz\nMemcheck:Addr4\nfun:absolutly\n}",
    "{\nzzz\nMemcheck:Unaddressable\nfun:absolutly\n}",
    "{\nzzz\nMemcheck:Addr4\nfun:absolutly\nfun:brilliant\n}",
    "{\nzzz\nMemcheck:Unaddressable\n...\nfun:brilliant\n}",
    "{\nzzz\nMemcheck:Addr4\n...\nfun:detection\n}",
  ]

  positive_heapcheck_suppressions = [
    "{\nzzz\nHeapcheck:Leak\n...\nobj:condition\n}",
    "{\nzzz\nHeapcheck:Leak\nfun:absolutly\n}",
  ]

  positive_tsan_suppressions = [
    "{\nzzz\nThreadSanitizer:Race\n...\nobj:condition\n}",
    "{\nzzz\nThreadSanitizer:Race\nfun:absolutly\n}",
  ]

  negative_memcheck_suppressions_1 = [
    "{\nzzz\nMemcheck:Leak\nfun:abnormal\n}",
    "{\nzzz\nMemcheck:Leak\nfun:ab*liant\n}",
    "{\nzzz\nMemcheck:Leak\nfun:brilliant\n}",
    "{\nzzz\nMemcheck:Leak\nobj:condition\n}",
    "{\nzzz\nMemcheck:Addr8\nfun:brilliant\n}",
  ]

  negative_memcheck_suppressions_2 = [
    "{\nzzz\nMemcheck:Cond\nfun:abnormal\n}",
    "{\nzzz\nMemcheck:Value2\nfun:abnormal\n}",
    "{\nzzz\nMemcheck:Uninitialized\nfun:ab*liant\n}",
    "{\nzzz\nMemcheck:Value4\nfun:brilliant\n}",
    "{\nzzz\nMemcheck:Leak\nobj:condition\n}",
    "{\nzzz\nMemcheck:Addr8\nfun:brilliant\n}",
    "{\nzzz\nMemcheck:Unaddressable\nfun:brilliant\n}",
  ]

  negative_memcheck_suppressions_3 = [
    "{\nzzz\nMemcheck:Addr1\nfun:abnormal\n}",
    "{\nzzz\nMemcheck:Uninitialized\nfun:absolutly\n}",
    "{\nzzz\nMemcheck:Addr2\nfun:ab*liant\n}",
    "{\nzzz\nMemcheck:Value4\nfun:brilliant\n}",
    "{\nzzz\nMemcheck:Leak\nobj:condition\n}",
    "{\nzzz\nMemcheck:Addr8\nfun:brilliant\n}",
  ]

  negative_memcheck_suppressions_4 = [
    "{\nzzz\nMemcheck:Addr1\nfun:abnormal\n}",
    "{\nzzz\nMemcheck:Addr4\nfun:abnormal\n}",
    "{\nzzz\nMemcheck:Unaddressable\nfun:abnormal\n}",
    "{\nzzz\nMemcheck:Addr1\nfun:absolutly\n}",
    "{\nzzz\nMemcheck:Addr2\nfun:ab*liant\n}",
    "{\nzzz\nMemcheck:Value4\nfun:brilliant\n}",
    "{\nzzz\nMemcheck:Leak\nobj:condition\n}",
    "{\nzzz\nMemcheck:Addr8\nfun:brilliant\n}",
  ]

  negative_heapcheck_suppressions = [
    "{\nzzz\nMemcheck:Leak\nfun:absolutly\n}",
    "{\nzzz\nHeapcheck:Leak\nfun:brilliant\n}",
  ]

  negative_tsan_suppressions = [
    "{\nzzz\nThreadSanitizer:Leak\nfun:absolutly\n}",
    "{\nzzz\nThreadSanitizer:Race\nfun:brilliant\n}",
  ]

  TestStack(test_memcheck_stack_1,
            positive_memcheck_suppressions_1,
            negative_memcheck_suppressions_1)
  TestStack(test_memcheck_stack_2,
            positive_memcheck_suppressions_2,
            negative_memcheck_suppressions_2)
  TestStack(test_memcheck_stack_3,
            positive_memcheck_suppressions_3,
            negative_memcheck_suppressions_3)
  TestStack(test_memcheck_stack_4,
            positive_memcheck_suppressions_4,
            negative_memcheck_suppressions_4)
  TestStack(test_heapcheck_stack, positive_heapcheck_suppressions,
            negative_heapcheck_suppressions)
  TestStack(test_tsan_stack, positive_tsan_suppressions,
            negative_tsan_suppressions)

  # TODO(timurrrr): add TestFailPresubmit tests.

  ### DrMemory self tests.

  # http://crbug.com/96010 suppression.
  stack_96010 = """{
    UNADDRESSABLE ACCESS
    name=<insert_a_suppression_name_here>
    *!TestingProfile::FinishInit
    *!TestingProfile::TestingProfile
    *!BrowserAboutHandlerTest_WillHandleBrowserAboutURL_Test::TestBody
    *!testing::Test::Run
  }"""

  suppress_96010 = [
    "UNADDRESSABLE ACCESS\nname=zzz\n...\n*!testing::Test::Run\n",
    ("UNADDRESSABLE ACCESS\nname=zzz\n...\n" +
     "*!BrowserAboutHandlerTest_WillHandleBrowserAboutURL_Test::TestBody\n"),
    "UNADDRESSABLE ACCESS\nname=zzz\n...\n*!BrowserAboutHandlerTest*\n",
    "UNADDRESSABLE ACCESS\nname=zzz\n*!TestingProfile::FinishInit\n",
    # No name should be needed
    "UNADDRESSABLE ACCESS\n*!TestingProfile::FinishInit\n",
    # Whole trace
    ("UNADDRESSABLE ACCESS\n" +
     "*!TestingProfile::FinishInit\n" +
     "*!TestingProfile::TestingProfile\n" +
     "*!BrowserAboutHandlerTest_WillHandleBrowserAboutURL_Test::TestBody\n" +
     "*!testing::Test::Run\n"),
  ]

  negative_96010 = [
    # Wrong type
    "UNINITIALIZED READ\nname=zzz\n*!TestingProfile::FinishInit\n",
    # No ellipsis
    "UNADDRESSABLE ACCESS\nname=zzz\n*!BrowserAboutHandlerTest*\n",
  ]

  TestStack(stack_96010, suppress_96010, negative_96010,
            suppression_parser=ReadDrMemorySuppressions)

  # Invalid heap arg
  stack_invalid = """{
    INVALID HEAP ARGUMENT
    name=asdf
    *!foo
  }"""
  suppress_invalid = [
    "INVALID HEAP ARGUMENT\n*!foo\n",
  ]
  negative_invalid = [
    "UNADDRESSABLE ACCESS\n*!foo\n",
  ]

  TestStack(stack_invalid, suppress_invalid, negative_invalid,
            suppression_parser=ReadDrMemorySuppressions)

  # Suppress only ntdll
  stack_in_ntdll = """{
    UNADDRESSABLE ACCESS
    name=<insert_a_suppression_name_here>
    ntdll.dll!RtlTryEnterCriticalSection
  }"""
  stack_not_ntdll = """{
    UNADDRESSABLE ACCESS
    name=<insert_a_suppression_name_here>
    notntdll.dll!RtlTryEnterCriticalSection
  }"""

  suppress_in_ntdll = [
    "UNADDRESSABLE ACCESS\nntdll.dll!RtlTryEnterCriticalSection\n",
  ]
  suppress_in_any = [
    "UNADDRESSABLE ACCESS\n*!RtlTryEnterCriticalSection\n",
  ]

  TestStack(stack_in_ntdll, suppress_in_ntdll + suppress_in_any, [],
            suppression_parser=ReadDrMemorySuppressions)
  # Make sure we don't wildcard away the "not" part and match ntdll.dll by
  # accident.
  TestStack(stack_not_ntdll, suppress_in_any, suppress_in_ntdll,
            suppression_parser=ReadDrMemorySuppressions)

  # Suppress a POSSIBLE LEAK with LEAK.
  stack_foo_possible = """{
    POSSIBLE LEAK
    name=foo possible
    *!foo
  }"""
  suppress_foo_possible = [ "POSSIBLE LEAK\n*!foo\n" ]
  suppress_foo_leak = [ "LEAK\n*!foo\n" ]
  TestStack(stack_foo_possible, suppress_foo_possible + suppress_foo_leak, [],
            suppression_parser=ReadDrMemorySuppressions)

  # Don't suppress LEAK with POSSIBLE LEAK.
  stack_foo_leak = """{
    LEAK
    name=foo leak
    *!foo
  }"""
  TestStack(stack_foo_leak, suppress_foo_leak, suppress_foo_possible,
            suppression_parser=ReadDrMemorySuppressions)

  # Test case insensitivity of module names.
  stack_user32_mixed_case = """{
    LEAK
    name=<insert>
    USER32.dll!foo
    user32.DLL!bar
    user32.dll!baz
  }"""
  suppress_user32 = [  # Module name case doesn't matter.
      "LEAK\nuser32.dll!foo\nuser32.dll!bar\nuser32.dll!baz\n",
      "LEAK\nUSER32.DLL!foo\nUSER32.DLL!bar\nUSER32.DLL!baz\n",
      ]
  no_suppress_user32 = [  # Function name case matters.
      "LEAK\nuser32.dll!FOO\nuser32.dll!BAR\nuser32.dll!BAZ\n",
      "LEAK\nUSER32.DLL!FOO\nUSER32.DLL!BAR\nUSER32.DLL!BAZ\n",
      ]
  TestStack(stack_user32_mixed_case, suppress_user32, no_suppress_user32,
            suppression_parser=ReadDrMemorySuppressions)

  # Test mod!... frames.
  stack_kernel32_through_ntdll = """{
    LEAK
    name=<insert>
    kernel32.dll!foo
    KERNEL32.dll!bar
    kernel32.DLL!baz
    ntdll.dll!quux
  }"""
  suppress_mod_ellipsis = [
      "LEAK\nkernel32.dll!...\nntdll.dll!quux\n",
      "LEAK\nKERNEL32.DLL!...\nntdll.dll!quux\n",
      ]
  no_suppress_mod_ellipsis = [
      # Need one or more matching frames, not zero, unlike regular ellipsis.
      "LEAK\nuser32.dll!...\nkernel32.dll!...\nntdll.dll!quux\n",
      ]
  TestStack(stack_kernel32_through_ntdll, suppress_mod_ellipsis,
            no_suppress_mod_ellipsis,
            suppression_parser=ReadDrMemorySuppressions)

  # Test that the presubmit checks work.
  forgot_to_name = """
    UNADDRESSABLE ACCESS
    name=<insert_a_suppression_name_here>
    ntdll.dll!RtlTryEnterCriticalSection
  """
  TestFailPresubmit(forgot_to_name, 'forgotten to put a suppression',
                    suppression_parser=ReadDrMemorySuppressions)

  named_twice = """
    UNADDRESSABLE ACCESS
    name=http://crbug.com/1234
    *!foo

    UNADDRESSABLE ACCESS
    name=http://crbug.com/1234
    *!bar
  """
  TestFailPresubmit(named_twice, 'defined more than once',
                    suppression_parser=ReadDrMemorySuppressions)

  forgot_stack = """
    UNADDRESSABLE ACCESS
    name=http://crbug.com/1234
  """
  TestFailPresubmit(forgot_stack, 'has no stack frames',
                    suppression_parser=ReadDrMemorySuppressions)

  ends_in_ellipsis = """
    UNADDRESSABLE ACCESS
    name=http://crbug.com/1234
    ntdll.dll!RtlTryEnterCriticalSection
    ...
  """
  TestFailPresubmit(ends_in_ellipsis, 'ends in an ellipsis',
                    suppression_parser=ReadDrMemorySuppressions)

  bad_stack_frame = """
    UNADDRESSABLE ACCESS
    name=http://crbug.com/1234
    fun:memcheck_style_frame
  """
  TestFailPresubmit(bad_stack_frame, 'Unexpected stack frame pattern',
                    suppression_parser=ReadDrMemorySuppressions)

  # Test FilenameToTool.
  filenames_to_tools = {
    "tools/heapcheck/suppressions.txt": "heapcheck",
    "tools/valgrind/tsan/suppressions.txt": "tsan",
    "tools/valgrind/drmemory/suppressions.txt": "drmemory",
    "tools/valgrind/drmemory/suppressions_full.txt": "drmemory",
    "tools/valgrind/memcheck/suppressions.txt": "memcheck",
    "tools/valgrind/memcheck/suppressions_mac.txt": "memcheck",
    "asdf/tools/valgrind/memcheck/suppressions_mac.txt": "memcheck",
    "foo/bar/baz/tools/valgrind/memcheck/suppressions_mac.txt": "memcheck",
    "foo/bar/baz/tools/valgrind/suppressions.txt": None,
    "tools/valgrind/suppressions.txt": None,
  }
  for (filename, expected_tool) in filenames_to_tools.items():
    filename.replace('/', os.sep)  # Make the path look native.
    tool = FilenameToTool(filename)
    assert tool == expected_tool, (
        "failed to get expected tool for filename %r, expected %s, got %s" %
        (filename, expected_tool, tool))

  # Test ValgrindStyleSuppression.__str__.
  supp = ValgrindStyleSuppression("http://crbug.com/1234", "Memcheck:Leak",
                                  ["...", "fun:foo"], "supp.txt:1")
  # Intentional 3-space indent.  =/
  supp_str = ("{\n"
              "   http://crbug.com/1234\n"
              "   Memcheck:Leak\n"
              "   ...\n"
              "   fun:foo\n"
              "}\n")
  assert str(supp) == supp_str, (
      "str(supp) != supp_str:\nleft: %s\nright: %s" % (str(supp), supp_str))

  # Test DrMemorySuppression.__str__.
  supp = DrMemorySuppression(
      "http://crbug.com/1234", "LEAK", None, ["...", "*!foo"], "supp.txt:1")
  supp_str = ("LEAK\n"
              "name=http://crbug.com/1234\n"
              "...\n"
              "*!foo\n")
  assert str(supp) == supp_str, (
      "str(supp) != supp_str:\nleft: %s\nright: %s" % (str(supp), supp_str))

  supp = DrMemorySuppression(
      "http://crbug.com/1234", "UNINITIALIZED READ", "test 0x08(%eax) $0x01",
      ["ntdll.dll!*", "*!foo"], "supp.txt:1")
  supp_str = ("UNINITIALIZED READ\n"
              "name=http://crbug.com/1234\n"
              "instruction=test 0x08(%eax) $0x01\n"
              "ntdll.dll!*\n"
              "*!foo\n")
  assert str(supp) == supp_str, (
      "str(supp) != supp_str:\nleft: %s\nright: %s" % (str(supp), supp_str))


if __name__ == '__main__':
  SelfTest()
  print 'PASS'