Port the python api decorator to use test categories

[labath]

Summary

Per discussions on the mailing list, I have implemented a decorator which annotates individual
test methods with categories. I have used this framework to replace the '-a' and '+a'
command-line switches (now '-G pyapi' and '--skip-category pyapi') and the @python_api_test
decorator (now @categories('pyapi')). The test suite now gives an error message suggesting the
new options if the user specifies the deprecated +/-a switches. If the general direction is good,
I will follow this up with other switches.

[zturner]

Could you call this something less generic than categories? The name of the decorator should be descriptive enough to hint that it can only be applied to test methods. test_categories even.

[labath]

test_categories is the name of .py file. :/ How about add_test_categories ?

[zturner]

Yea that sounds good too.

[tfiala]

I like it.

lldb/trunk/test/dotest.py

 import socket
 import subprocess
 import sys
 import test_results
 from test_results import EventBuilder
 import inspect
 import unittest2
 import lldbtest_config
+import test_categories
 
 import six
 
 def is_exe(fpath):
     """Returns true if fpath is an executable."""
     return os.path.isfile(fpath) and os.access(fpath, os.X_OK)
 
 def which(program):
def writeln(self, arg=None):
         if arg:
             self.write(arg)
         self.write('\n') # text-mode streams translate to \r\n if needed
 
 #
 # Global variables:
 #
 
-# Dictionary of categories
-# When you define a new category for your testcases, be sure to add it here, or the test suite
-# will gladly complain as soon as you try to use it. This allows us to centralize which categories
-# exist, and to provide a description for each one
-validCategories = {
-'dataformatters':'Tests related to the type command and the data formatters subsystem',
-'expression':'Tests related to the expression parser',
-'objc':'Tests related to the Objective-C programming language support',
-'pyapi':'Tests related to the Python API',
-'basic_process': 'Basic process execution sniff tests.',
-'cmdline' : 'Tests related to the LLDB command-line interface',
-'dyntype' : 'Tests related to dynamic type support',
-'stresstest' : 'Tests related to stressing lldb limits',
-'flakey' : 'Flakey test cases, i.e. tests that do not reliably pass at each execution'
-}
-
 # The test suite.
 suite = unittest2.TestSuite()
 
-# By default, both command line and Python API tests are performed.
-# Use @python_api_test decorator, defined in lldbtest.py, to mark a test as
-# a Python API test.
-dont_do_python_api_test = False
-
-# By default, both command line and Python API tests are performed.
-just_do_python_api_test = False
-
 # By default, lldb-mi tests are performed if lldb-mi can be found.
 # Use @lldbmi_test decorator, defined in lldbtest.py, to mark a test as
 # a lldb-mi test.
 dont_do_lldbmi_test = False
 just_do_lldbmi_test = False
 
 # By default, benchmarks tests are not run.
 just_do_benchmarks_test = False

 o GDB_REMOTE_LOG: if defined, specifies the log file pathname for the
   'process.gdb-remote' subsystem with a default option of 'packets' if
   GDB_REMOTE_LOG_OPTION is not defined.
 
 """)
     sys.exit(0)
 
 
-def unique_string_match(yourentry,list):
-  candidate = None
-  for item in list:
-    if item.startswith(yourentry):
-      if candidate:
-        return None
-      candidate = item
-  return candidate
-
-def validate_categories(categories):
-    """For each category in categories, ensure that it's a valid category (or a prefix thereof).
-       If a category is invalid, print a message and quit.
-       If all categories are valid, return the list of categories. Prefixes are expanded in the
-       returned list.
-    """
-    global validCategories
-    result = []
-    for category in categories:
-        origCategory = category
-        if category not in validCategories:
-            category = unique_string_match(category, validCategories)
-        if (category not in validCategories) or category == None:
-            print("fatal error: category '" + origCategory + "' is not a valid category")
-            print("if you have added a new category, please edit dotest.py, adding your new category to validCategories")
-            print("else, please specify one or more of the following: " + str(list(validCategories.keys())))
-            sys.exit(1)
-        result.append(category)
-    return result
-
 def setCrashInfoHook_Mac(text):
     import crashinfo
     crashinfo.setCrashReporterDescription(text)
 
 # implement this in some suitable way for your platform, and then bind it
 # to setCrashInfoHook
 def setCrashInfoHook_NonMac(text):
     pass
else:
         pass
 
 def parseOptionsAndInitTestdirs():
     """Initialize the list of directories containing our unittest scripts.
 
     '-h/--help as the first option prints out usage info and exit the program.
     """
 
-    global dont_do_python_api_test
-    global just_do_python_api_test
     global dont_do_lldbmi_test
     global just_do_lldbmi_test
     global just_do_benchmarks_test
     global dont_do_dsym_test
     global dont_do_dwarf_test
     global dont_do_dwo_test
     global blacklist
     global blacklistConfig
if args.archs:
             if arch.startswith('arm') and platform_system == 'Darwin' and not args.apple_sdk:
                 os.environ['SDKROOT'] = commands.getoutput('xcrun --sdk iphoneos.internal --show-sdk-path 2> /dev/null')
                 if not os.path.exists(os.environ['SDKROOT']):
                     os.environ['SDKROOT'] = commands.getoutput('xcrun --sdk iphoneos --show-sdk-path 2> /dev/null')
     else:
         archs = [platform_machine]
 
     if args.categoriesList:
-        categoriesList = set(validate_categories(args.categoriesList))
+        categoriesList = set(test_categories.validate(args.categoriesList, False))
         useCategories = True
     else:
         categoriesList = []
 
     if args.skipCategories:
-        skipCategories = validate_categories(args.skipCategories)
+        skipCategories = test_categories.validate(args.skipCategories, False)
 
     if args.D:
         dumpSysPath = True
 
     if args.E:
         cflags_extras = args.E
         os.environ['CFLAGS_EXTRAS'] = cflags_extras
 
     # argparse makes sure we have correct options
     if args.N == 'dwarf':
         dont_do_dwarf_test = True
     elif args.N == 'dwo':
         dont_do_dwo_test = True
     elif args.N == 'dsym':
         dont_do_dsym_test = True
 
-    if args.a:
-        dont_do_python_api_test = True
-
-    if args.plus_a:
-        if dont_do_python_api_test:
-            print("Warning: -a and +a can't both be specified! Using only -a")
-        else:
-            just_do_python_api_test = True
+    if args.a or args.plus_a:
+        print("Options '-a' and '+a' have been deprecated. Please use the test category\n"
+              "functionality (-G pyapi, --skip-category pyapi) instead.")
+        sys.exit(1)
 
     if args.plus_b:
         just_do_benchmarks_test = True
 
     if args.b:
         if args.b.startswith('-'):
             usage(parser)
         blacklistFile = args.b
def parseOptionsAndInitTestdirs():
 
     if sys.platform.startswith('win32'):
         os.environ['LLDB_DISABLE_CRASH_DIALOG'] = str(args.disable_crash_dialog)
         os.environ['LLDB_LAUNCH_INFERIORS_WITHOUT_CONSOLE'] = str(args.hide_inferior_console)
 
     if do_help == True:
         usage(parser)
 
-    # Do not specify both '-a' and '+a' at the same time.
-    if dont_do_python_api_test and just_do_python_api_test:
-        usage(parser)
-
     # Do not specify both '-m' and '+m' at the same time.
     if dont_do_lldbmi_test and just_do_lldbmi_test:
         usage(parser)
 
     if args.no_multiprocess:
         no_multiprocess_test_runner = True
 
     if args.inferior:
else:
         lldb.test_remote = False
 
     # So do the lldbtest_remote_sandbox and lldbtest_remote_shell_template variables.
     lldb.lldbtest_remote_sandbox = lldbtest_remote_sandbox
     lldb.lldbtest_remote_sandboxed_executable = None
     lldb.lldbtest_remote_shell_template = lldbtest_remote_shell_template
 
     # Put all these test decorators in the lldb namespace.
-    lldb.dont_do_python_api_test = dont_do_python_api_test
-    lldb.just_do_python_api_test = just_do_python_api_test
     lldb.dont_do_lldbmi_test = dont_do_lldbmi_test
     lldb.just_do_lldbmi_test = just_do_lldbmi_test
     lldb.just_do_benchmarks_test = just_do_benchmarks_test
     lldb.dont_do_dsym_test = dont_do_dsym_test
     lldb.dont_do_dwarf_test = dont_do_dwarf_test
     lldb.dont_do_dwo_test = dont_do_dwo_test
     lldb.dont_do_debugserver_test = dont_do_debugserver_test
     lldb.dont_do_llgs_test = dont_do_llgs_test

lldb/trunk/test/dotest_args.py

def create_parser():
     # FIXME? This won't work for different extra flags according to each arch.
     group.add_argument('-E', metavar='extra-flags', help=textwrap.dedent('''Specify the extra flags to be passed to the toolchain when building the inferior programs to be debugged
                                                            suggestions: do not lump the "-A arch1 -A arch2" together such that the -E option applies to only one of the architectures'''))
     X('-D', 'Dump the Python sys.path variable')
 
     # Test filtering options
     group = parser.add_argument_group('Test filtering options')
     group.add_argument('-N', choices=['dwarf', 'dwo', 'dsym'], help="Don't do test cases marked with the @dsym_test/@dwarf_test/@dwo_test decorator by passing dsym/dwarf/dwo as the option arg")
-    X('-a', "Don't do lldb Python API tests")
-    X('+a', "Just do lldb Python API tests. Do not specify along with '-a'", dest='plus_a')
     X('+b', 'Just do benchmark tests', dest='plus_b')
     group.add_argument('-b', metavar='blacklist', help='Read a blacklist file specified after this option')
     group.add_argument('-f', metavar='filterspec', action='append', help='Specify a filter, which consists of the test class name, a dot, followed by the test method, to only admit such test into the test suite')  # FIXME: Example?
     X('-g', 'If specified, the filterspec by -f is not exclusive, i.e., if a test module does not match the filterspec (testclass.testmethod), the whole module is still admitted to the test suite')
     X('-l', "Don't skip long running tests")
     X('-m', "Don't do lldb-mi tests")
     X('+m', "Just do lldb-mi tests. Do not specify along with '-m'", dest='plus_m')
     group.add_argument('-p', metavar='pattern', help='Specify a regexp filename pattern for inclusion in the test suite')
group.add_argument(
         action='store',
         help=('Specify comma-separated KEY=VAL entries to add key and value '
               'pairs to all test events generated by this test run.  VAL may '
               'be specified as VAL:TYPE, where TYPE may be int to convert '
               'the value to an int'))
     # Remove the reference to our helper function
     del X
 
+    D = lambda optstr, **kwargs: group.add_argument(optstr, action='store_true', **kwargs)
+    group = parser.add_argument_group('Deprecated options (do not use)')
+    # Deprecated on 23.10.2015. Remove completely after a grace period.
+    D('-a')
+    D('+a', dest='plus_a')
+    del D
+
     group = parser.add_argument_group('Test directories')
     group.add_argument('args', metavar='test-dir', nargs='*', help='Specify a list of directory names to search for test modules named after Test*.py (test discovery). If empty, search from the current working directory instead.')
 
     return parser

lldb/trunk/test/expression_command/test/TestExprs.py

def test_many_expr_commands(self):
             patterns = ["\(const char \*\*\) \$.* = 0x"])
         # (const char *) $7 = ...
 
         self.expect("expression argv[0]",
             substrs = ["(const char *)", 
                        "a.out"])
         # (const char *) $8 = 0x... "/Volumes/data/lldb/svn/trunk/test/expression_command/test/a.out"
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @expectedFailureAll("llvm.org/pr23139", oslist=["linux"], compiler="gcc", compiler_version=[">=","4.9"], archs=["i386"])
     @expectedFailureWindows # Test crashes
     def test_evaluate_expression_python(self):
         """Test SBFrame.EvaluateExpression() API for evaluating an expression."""
         self.build()
 
         exe = os.path.join(os.getcwd(), "a.out")
 

lldb/trunk/test/functionalities/breakpoint/breakpoint_command/TestBreakpointCommandsFromPython.py

 import sys
 from lldbtest import *
 
 class PythonBreakpointCommandSettingTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
     my_var = 10
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_step_out_python(self):
         """Test stepping out using avoid-no-debug with dsyms."""
         self.build()
         self.do_set_python_command_from_python ()
 
     def setUp (self):
         TestBase.setUp(self)
         self.main_source = "main.c"

lldb/trunk/test/functionalities/breakpoint/breakpoint_conditions/TestBreakpointConditions.py

class BreakpointConditionsTestCase(TestBase):
 
     @skipIfWindows # Requires EE to support COFF on Windows (http://llvm.org/pr22232)
     def test_breakpoint_condition_inline_and_run_command(self):
         """Exercise breakpoint condition inline with 'breakpoint set'."""
         self.build()
         self.breakpoint_conditions(inline=True)
 
     @skipIfWindows # Requires EE to support COFF on Windows (http://llvm.org/pr22232)
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_breakpoint_condition_and_python_api(self):
         """Use Python APIs to set breakpoint conditions."""
         self.build()
         self.breakpoint_conditions_python()
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)

lldb/trunk/test/functionalities/breakpoint/breakpoint_ignore_count/TestBreakpointIgnoreCount.py

class BreakpointIgnoreCountTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def test_with_run_command(self):
         """Exercise breakpoint ignore count with 'breakpoint set -i <count>'."""
         self.build()
         self.breakpoint_ignore_count()
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_with_python_api(self):
         """Use Python APIs to set breakpoint ignore count."""
         self.build()
         self.breakpoint_ignore_count_python()
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)

lldb/trunk/test/functionalities/breakpoint/cpp_exception/TestCPPExceptionBreakpoint.py

 import sys
 from lldbtest import *
 
 class TestCPPExceptionBreakpoint (TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
     my_var = 10
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @expectedFailureWindows("llvm.org/pr24538") # clang-cl does not support throw or catch
     def test_cpp_exception_breakpoint(self):
         """Test setting and hitting the C++ exception breakpoint."""
         self.build()
         self.do_cpp_exception_bkpt ()
 
     def setUp (self):
         TestBase.setUp(self)

lldb/trunk/test/functionalities/command_script/import/TestImport.py

 """Test custom import command to import files by path."""
 
 from __future__ import print_function
 
 import lldb_shared
 
 import os, sys, time
 import lldb
 from lldbtest import *
 
 class ImportTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @no_debug_info_test
     def test_import_command(self):
         """Import some Python scripts by path and test them"""
         self.run_test()
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)

lldb/trunk/test/functionalities/command_script/import/rdar-12586188/TestRdar12586188.py

 """Check that we handle an ImportError in a special way when command script importing files."""
 
 from __future__ import print_function
 
 import lldb_shared
 
 import os, sys, time
 import lldb
 from lldbtest import *
 
 class Rdar12586188TestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @no_debug_info_test
     def test_rdar12586188_command(self):
         """Check that we handle an ImportError in a special way when command script importing files."""
         self.run_test()
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
 
     def run_test(self):
         """Check that we handle an ImportError in a special way when command script importing files."""
 
         self.expect("command script import ./fail12586188.py --allow-reload",
                 error=True, substrs = ['raise ImportError("I do not want to be imported")'])
         self.expect("command script import ./fail212586188.py --allow-reload",
                 error=True, substrs = ['raise ValueError("I do not want to be imported")'])

lldb/trunk/test/functionalities/conditional_break/TestConditionalBreak.py

 #
 # This class currently fails for clang as well as llvm-gcc.
 
 class ConditionalBreakTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @expectedFailureWindows("llvm.org/pr24778")
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_with_python(self):
         """Exercise some thread and frame APIs to break if c() is called by a()."""
         self.build()
         self.do_conditional_break()
 
     def test_with_command(self):
         """Simulate a user using lldb commands to break on c() if called from a()."""
         self.build()

lldb/trunk/test/functionalities/data-formatter/data-formatter-stl/libcxx/list/loop/TestDataFormatterLibcxxListLoop.py

 import lldbutil
 
 class LibcxxListDataFormatterTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @skipIfGcc
     @skipIfWindows # libc++ not ported to Windows yet
+    @add_test_categories(["pyapi"])
     def test_with_run_command(self):
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target and target.IsValid(), "Target is valid")
 
         file_spec = lldb.SBFileSpec ("main.cpp", False)
         breakpoint1 = target.BreakpointCreateBySourceRegex('// Set break point at this line.', file_spec)

lldb/trunk/test/functionalities/dynamic_value_child_count/TestDynamicValueChildCount.py

def setUp(self):
                                                        '// Break here and check b has one child now')
         self.main_sixth_call_line = line_number('pass-to-base.cpp',
                                                        '// Break here and check b has 0 children again')
 
     @expectedFailureLinux("llvm.org/pr23039")
     @expectedFailureFreeBSD("llvm.org/pr19311") # continue at a breakpoint does not work
     @expectedFailureWindows("llvm.org/pr24663")
     @expectedFailurei386("to be figured out")
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_get_dynamic_vals(self):
         """Test fetching C++ dynamic values from pointers & references."""
         """Get argument vals for the call stack when stopped on a breakpoint."""
         self.build(dictionary=self.getBuildFlags())
         exe = os.path.join(os.getcwd(), "a.out")
 
         # Create a target from the debugger.
 

lldb/trunk/test/functionalities/inferior-assert/TestInferiorAssert.py

class AssertingInferiorTestCase(TestBase):
 
     @expectedFailurei386("llvm.org/pr17384: lldb needs to be aware of linux-vdso.so to unwind stacks properly")
     @expectedFailureWindows("llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
     def test_inferior_asserting_disassemble(self):
         """Test that lldb reliably disassembles frames after asserting (command)."""
         self.build()
         self.inferior_asserting_disassemble()
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @expectedFailureWindows("llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")
     def test_inferior_asserting_python(self):
         """Test that lldb reliably catches the inferior asserting (Python API)."""
         self.build()
         self.inferior_asserting_python()
 
     @expectedFailurei386('llvm.org/pr17384: lldb needs to be aware of linux-vdso.so to unwind stacks properly')
     @expectedFailureWindows("llvm.org/pr21793: need to implement support for detecting assertion / abort on Windows")

lldb/trunk/test/functionalities/inferior-crashing/TestInferiorCrashing.py

def test_inferior_crashing(self):
         self.inferior_crashing()
 
     @expectedFailureWindows("llvm.org/pr24778")
     def test_inferior_crashing_register(self):
         """Test that lldb reliably reads registers from the inferior after crashing (command)."""
         self.build()
         self.inferior_crashing_registers()
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @expectedFailureWindows("llvm.org/pr24778")
     def test_inferior_crashing_python(self):
         """Test that lldb reliably catches the inferior crashing (Python API)."""
         self.build()
         self.inferior_crashing_python()
 
     @expectedFailureWindows("llvm.org/pr24778")
     def test_inferior_crashing_expr(self):

lldb/trunk/test/functionalities/inferior-crashing/recursive-inferior/TestRecursiveInferior.py

def test_recursive_inferior_crashing(self):
         self.recursive_inferior_crashing()
 
     @expectedFailureWindows("llvm.org/pr24778")
     def test_recursive_inferior_crashing_register(self):
         """Test that lldb reliably reads registers from the inferior after crashing (command)."""
         self.build()
         self.recursive_inferior_crashing_registers()
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @expectedFailureWindows("llvm.org/pr24778")
     def test_recursive_inferior_crashing_python(self):
         """Test that lldb reliably catches the inferior crashing (Python API)."""
         self.build()
         self.recursive_inferior_crashing_python()
 
     @expectedFailureWindows("llvm.org/pr24778")
     def test_recursive_inferior_crashing_expr(self):

lldb/trunk/test/functionalities/inline-stepping/TestInlineStepping.py

 """Test stepping over and into inlined functions."""
 
 from __future__ import print_function
 
 import lldb_shared
 
 import os, time, sys
 import lldb
 import lldbutil
 from lldbtest import *
 
 class TestInlineStepping(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @expectedFailureFreeBSD('llvm.org/pr17214')
     @expectedFailureIcc # Not really a bug.  ICC combines two inlined functions.
     @expectedFailureAll("llvm.org/pr23139", oslist=["linux"], compiler="gcc", compiler_version=[">=","4.9"], archs=["i386"])
     @expectedFailureWindows("llvm.org/pr24778")
     # failed 1/365 dosep runs, (i386-clang), TestInlineStepping.py:237 failed to stop at first breakpoint in main
     @expectedFailureAll(oslist=["linux"], archs=["i386"])
     def test_with_python_api(self):
         """Test stepping over and into inlined functions."""
         self.build()
         self.inline_stepping()
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @expectedFailureAll("llvm.org/pr23139", oslist=["linux"], compiler="gcc", compiler_version=[">=","4.9"], archs=["i386"])
     def test_step_over_with_python_api(self):
         """Test stepping over and into inlined functions."""
         self.build()
         self.inline_stepping_step_over()
     
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_step_in_template_with_python_api(self):
         """Test stepping in to templated functions."""
         self.build()
         self.step_in_template()
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)

lldb/trunk/test/functionalities/return-value/TestReturnValue.py

 from lldbtest import *
 
 class ReturnValueTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @expectedFailurei386
     @expectedFailureWindows("llvm.org/pr24778")
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_with_python(self):
         """Test getting return values from stepping out."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
         error = lldb.SBError()
 
         self.target = self.dbg.CreateTarget(exe)
         self.assertTrue(self.target, VALID_TARGET)

lldb/trunk/test/functionalities/step-avoids-no-debug/TestStepNoDebug.py

 import lldb, lldbutil
 import sys
 from lldbtest import *
 
 class ReturnValueTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_step_out_with_python(self):
         """Test stepping out using avoid-no-debug with dsyms."""
         self.build()
         self.get_to_starting_point()
         self.do_step_out_past_nodebug()
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @expectedFailureGcc("llvm.org/pr19247")
     def test_step_over_with_python(self):
         """Test stepping over using avoid-no-debug with dwarf."""
         self.build()
         self.get_to_starting_point()
         self.do_step_over_past_nodebug()
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @expectedFailureGcc("llvm.org/pr19247")
     def test_step_in_with_python(self):
         """Test stepping in using avoid-no-debug with dwarf."""
         self.build()
         self.get_to_starting_point()
         self.do_step_in_past_nodebug()
 
     def setUp (self):

lldb/trunk/test/functionalities/thread/thread_specific_break/TestThreadSpecificBreakpoint.py

 
 class ThreadSpecificBreakTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @skipIfFreeBSD # test frequently times out or hangs
     @expectedFailureFreeBSD('llvm.org/pr18522') # hits break in another thread in testrun
     @expectedFailureWindows("llvm.org/pr24777")
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @expectedFlakeyLinux # this test fails 6/100 dosep runs
     def test_python(self):
         """Test that we obey thread conditioned breakpoints."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         self.dbg.HandleCommand ("log enable -f /tmp/lldb-testsuite-log.txt lldb step breakpoint process") 
         target = self.dbg.CreateTarget(exe)

lldb/trunk/test/functionalities/watchpoint/watchpoint_events/TestWatchpointEvents.py

class TestWatchpointEvents (TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line numbers that we will step to in main:
         self.main_source = "main.c"
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
     @expectedFailureWindows("llvm.org/pr24446") # WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows
     def test_with_python_api(self):
         """Test that adding, deleting and modifying watchpoints sends the appropriate events."""
         self.build()
         
         exe = os.path.join(os.getcwd(), "a.out")
 

lldb/trunk/test/lang/c/array_types/TestArrayTypes.py

def test_and_run_command(self):
                        '(char) [15]'])
 
         self.expect("frame variable --show-types ushort_matrix", VARIABLES_DISPLAYED_CORRECTLY,
             startstr = '(unsigned short [2][3])')
 
         self.expect("frame variable --show-types long_6", VARIABLES_DISPLAYED_CORRECTLY,
             startstr = '(long [6])')
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_and_python_api(self):
         """Use Python APIs to inspect variables with array types."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 

lldb/trunk/test/lang/c/bitfields/TestBitfields.py

def test_and_run_command(self):
             substrs = ['uint32_t', '3'])
         self.expect("expr (more_bits.b)", VARIABLES_DISPLAYED_CORRECTLY,
             substrs = ['uint8_t', '\\0'])
         self.expect("expr (more_bits.c)", VARIABLES_DISPLAYED_CORRECTLY,
             substrs = ['uint8_t', '\\x01'])
         self.expect("expr (more_bits.d)", VARIABLES_DISPLAYED_CORRECTLY,
             substrs = ['uint8_t', '\\0'])
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @skipIfWindows # BitFields exhibit crashes in record layout on Windows (http://llvm.org/pr21800)
     def test_and_python_api(self):
         """Use Python APIs to inspect a bitfields variable."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

lldb/trunk/test/lang/c/stepping/TestStepAndBreakpoints.py

def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line numbers that we will step to in main:
         self.main_source = "main.c"
 
     @expectedFailureFreeBSD('llvm.org/pr17932')
     @expectedFailureLinux # llvm.org/pr14437
     @expectedFailureWindows("llvm.org/pr24777")
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_and_python_api(self):
         """Test stepping over vrs. hitting breakpoints & subsequent stepping in various forms."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 

lldb/trunk/test/lang/cpp/class_static/TestStaticVariables.py

def test_with_run_command(self):
         if self.platformIsDarwin() or self.getPlatform() == "linux":
             self.expect("target variable A::g_points[1].x", VARIABLES_DISPLAYED_CORRECTLY,
                 startstr = "(int) A::g_points[1].x = 11")
 
     @expectedFailureDarwin(9980907)
     @expectedFailureClang('Clang emits incomplete debug info.')
     @expectedFailureFreeBSD('llvm.org/pr20550 failing on FreeBSD-11')
     @expectedFailureGcc('GCC emits incomplete debug info.')
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_with_python_api(self):
         """Test Python APIs on file and class static variables."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 

lldb/trunk/test/lang/cpp/class_types/TestClassTypes.py

def test_with_run_command(self):
         self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
             substrs = [' resolved, hit count = 1'])
 
         # We should be stopped on the ctor function of class C.
         self.expect("frame variable --show-types this", VARIABLES_DISPLAYED_CORRECTLY,
             substrs = ['C *',
                        ' this = '])
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_with_python_api(self):
         """Use Python APIs to create a breakpoint by (filespec, line)."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 

lldb/trunk/test/lang/cpp/class_types/TestClassTypesDisassembly.py

def test_and_run_command(self):
         for line in raw_output.split(os.linesep):
             match = frameRE.search(line)
             if match:
                 function = match.group(1)
                 #print("line:", line)
                 #print("function:", function)
                 self.runCmd("disassemble -n '%s'" % function)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_and_python_api(self):
         """Disassemble each call frame when stopped on C's constructor."""
         self.build()
         self.breakOnCtor()
 
         # Now use the Python API to get at each function on the call stack and
         # disassemble it.
         target = self.dbg.GetSelectedTarget()

lldb/trunk/test/lang/cpp/dynamic-value/TestCppValueCast.py

 import lldb, lldbutil
 from lldbtest import *
 
 class CppValueCastTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @unittest2.expectedFailure("rdar://problem/10808472 SBValue::Cast test case is failing (virtual inheritance)")
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_value_cast_with_virtual_inheritance(self):
         """Test SBValue::Cast(SBType) API for C++ types with virtual inheritance."""
         self.build(dictionary=self.d_virtual)
         self.setTearDownCleanup(dictionary=self.d_virtual)
         self.do_sbvalue_cast(self.exe_name)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_value_cast_with_regular_inheritance(self):
         """Test SBValue::Cast(SBType) API for C++ types with regular inheritance."""
         self.build(dictionary=self.d_regular)
         self.setTearDownCleanup(dictionary=self.d_regular)
         self.do_sbvalue_cast(self.exe_name)
 
     def setUp(self):
         # Call super's setUp().                                                                                                           

lldb/trunk/test/lang/cpp/dynamic-value/TestDynamicValue.py

def setUp(self):
         self.do_something_line = line_number('pass-to-base.cpp', '// Break here in doSomething.')
         self.main_first_call_line = line_number('pass-to-base.cpp',
                                                  '// Break here and get real addresses of myB and otherB.')
         self.main_second_call_line = line_number('pass-to-base.cpp',
                                                        '// Break here and get real address of reallyA.')
 
     @expectedFailureFreeBSD # FIXME: This needs to be root-caused.
     @expectedFailureWindows("llvm.org/pr24663")
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_get_dynamic_vals(self):
         """Test fetching C++ dynamic values from pointers & references."""
         self.build(dictionary=self.getBuildFlags())
         exe = os.path.join(os.getcwd(), "a.out")
 
         # Create a target from the debugger.
 
         target = self.dbg.CreateTarget (exe)

lldb/trunk/test/lang/cpp/stl/TestSTL.py

def test(self):
         self.expect('expr associative_array.count(hello_world)',
             substrs = [' = 1'])
         self.expect('expr associative_array[hello_world]',
             substrs = [' = 1'])
         self.expect('expr associative_array["hello"]',
             substrs = [' = 2'])
 
     @expectedFailureIcc # icc 13.1 and 14-beta do not emit DW_TAG_template_type_parameter
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_SBType_template_aspects(self):
         """Test APIs for getting template arguments from an SBType."""
         self.build()
         exe = os.path.join(os.getcwd(), 'a.out')
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

lldb/trunk/test/lang/go/goroutines/TestGoroutines.py

 """Test the Go OS Plugin."""
 
 from __future__ import print_function
 
 import lldb_shared
 
 import os, time
 import lldb
 import lldbutil
 from lldbtest import *
 
 class TestGoASTContext(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @skipIfFreeBSD # llvm.org/pr24895 triggers assertion failure
     @skipIfRemote # Not remote test suite ready
     @no_debug_info_test
     @skipUnlessGoInstalled
     def test_goroutine_plugin(self):
         """Test goroutine as threads support."""
         self.buildGo()
         self.launchProcess()

lldb/trunk/test/lang/go/types/TestGoASTContext.py

 """Test the go DWARF type parsing."""
 
 from __future__ import print_function
 
 import lldb_shared
 
 import os, time
 import lldb
 import lldbutil
 from lldbtest import *
 
 class TestGoASTContext(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @skipIfFreeBSD # llvm.org/pr24895 triggers assertion failure
     @skipIfRemote # Not remote test suit ready
     @no_debug_info_test
     @skipUnlessGoInstalled
     def test_with_dsym_and_python_api(self):
         """Test GoASTContext dwarf parsing."""
         self.buildGo()
         self.launchProcess()

lldb/trunk/test/lang/objc/blocks/TestObjCIvarsInBlocks.py

def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line numbers to break inside main().
         self.main_source = "main.m"
         self.class_source = "ivars-in-blocks.m"
         self.class_source_file_spec = lldb.SBFileSpec(self.class_source)
 
     @skipUnlessDarwin
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @expectedFailurei386 # This test requires the 2.0 runtime, so it will fail on i386.
     def test_with_python_api(self):
         """Test printing the ivars of the self when captured in blocks"""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

lldb/trunk/test/lang/objc/foundation/TestObjCMethods.py

#            startstr = "Breakpoint created: 1: name = '-[MyString description]', locations = 1")
         # rdar://problem/8542091
         # test/foundation: expr -o -- my not working?
         #
         # Test new feature with r115115:
         # Add "-o" option to "expression" which prints the object description if available.
         self.expect("expression --object-description -- my", "Object description displayed correctly",
             patterns = ["Hello from.*a.out.*with timestamp: "])
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_print_ivars_correctly (self):
         self.build()
         # See: <rdar://problem/8717050> lldb needs to use the ObjC runtime symbols for ivar offsets
         # Only fails for the ObjC 2.0 runtime.
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

lldb/trunk/test/lang/objc/foundation/TestObjectDescriptionAPI.py

def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break at.
         self.source = 'main.m'
         self.line = line_number(self.source, '// Set break point at this line.')
 
     # rdar://problem/10857337
     @skipUnlessDarwin
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_find_global_variables_then_object_description(self):
         """Exercise SBTarget.FindGlobalVariables() API."""
         d = {'EXE': 'b.out'}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
         exe = os.path.join(os.getcwd(), 'b.out')
 
         # Create a target by the debugger.

lldb/trunk/test/lang/objc/foundation/TestSymbolTable.py

symbols_list = ['-[MyString initWithNSString:]',
                     '-[MyString setDescriptionPauses:]', # synthesized property
                     'Test_Selector',
                     'Test_NSString',
                     'Test_MyString',
                     'Test_NSArray',
                     'main'
                     ]
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_with_python_api(self):
         """Test symbol table access with Python APIs."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

lldb/trunk/test/lang/objc/objc-baseclass-sbtype/TestObjCBaseClassSBType.py

class ObjCDynamicValueTestCase(TestBase):
 
     def setUp(self):
         # Call super's setUp().                                                                                                           
         TestBase.setUp(self)
 
         self.line = line_number('main.m', '// Set breakpoint here.')
 
     @skipUnlessDarwin
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_get_baseclass(self):
         """Test fetching ObjC dynamic values."""
         if self.getArchitecture() == 'i386':
             # rdar://problem/9946499
             self.skipTest("Dynamic types for ObjC V1 runtime not implemented")
 
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")

lldb/trunk/test/lang/objc/objc-builtin-types/TestObjCBuiltinTypes.py

class TestObjCBuiltinTypes(TestBase):
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line numbers to break inside main().
         self.main_source = "main.cpp"
         self.break_line = line_number(self.main_source, '// Set breakpoint here.')
 
     @skipUnlessDarwin
-    @python_api_test
+    @add_test_categories(['pyapi'])
     #<rdar://problem/10591460> [regression] Can't print ivar value: error: reference to 'id' is ambiguous
     def test_with_python_api(self):
         """Test expression parser respect for ObjC built-in types."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

lldb/trunk/test/lang/objc/objc-checker/TestObjCCheckers.py

class ObjCCheckerTestCase(TestBase):
     def setUp(self):
         # Call super's setUp().                                                                                                           
         TestBase.setUp(self)
 
         # Find the line number to break for main.c.                                                                                       
         self.source_name = 'main.m'
 
     @skipUnlessDarwin
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_objc_checker(self):
         """Test that checkers catch unrecognized selectors"""
         if self.getArchitecture() == 'i386':
             self.skipTest("requires Objective-C 2.0 runtime")
 
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 

lldb/trunk/test/lang/objc/objc-class-method/TestObjCClassMethod.py

def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line numbers to break inside main().
         self.main_source = "class.m"
         self.break_line = line_number(self.main_source, '// Set breakpoint here.')
 
     @skipUnlessDarwin
     @expectedFailurei386
-    @python_api_test
+    @add_test_categories(['pyapi'])
     #rdar://problem/9745789 "expression" can't call functions in class methods
     def test_with_python_api(self):
         """Test calling functions in class methods."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

lldb/trunk/test/lang/objc/objc-dynamic-value/TestObjCDynamicValue.py

def setUp(self):
         self.source_name = 'dynamic-value.m'
         self.set_property_line = line_number(self.source_name, '// This is the line in setProperty, make sure we step to here.')
         self.handle_SourceBase = line_number(self.source_name,
                                                  '// Break here to check dynamic values.')
         self.main_before_setProperty_line = line_number(self.source_name,
                                                        '// Break here to see if we can step into real method.')
 
     @skipUnlessDarwin
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @expectedFailureDarwin("llvm.org/pr20271 rdar://18684107")
     def test_get_objc_dynamic_vals(self):
         """Test fetching ObjC dynamic values."""
         if self.getArchitecture() == 'i386':
             # rdar://problem/9946499
             self.skipTest("Dynamic types for ObjC V1 runtime not implemented")
 
         self.build()

lldb/trunk/test/lang/objc/objc-ivar-offsets/TestObjCIvarOffsets.py

class TestObjCIvarOffsets(TestBase):
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line numbers to break inside main().
         self.main_source = "main.m"
         self.stop_line = line_number(self.main_source, '// Set breakpoint here.')
 
     @skipUnlessDarwin
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_with_python_api(self):
         """Test printing ObjC objects that use unbacked properties"""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 

lldb/trunk/test/lang/objc/objc-ivar-stripped/TestObjCIvarStripped.py

def setUp(self):
         TestBase.setUp(self)
         # Find the line numbers to break inside main().
         self.main_source = "main.m"
         self.stop_line = line_number(self.main_source, '// Set breakpoint here.')
 
     @skipUnlessDarwin
     @skipIfDwarf    # This test requires a stripped binary and a dSYM
     @skipIfDWO      # This test requires a stripped binary and a dSYM
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_with_python_api(self):
         """Test that we can find stripped Objective-C ivars in the runtime"""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out.stripped")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 

lldb/trunk/test/lang/objc/objc-property/TestObjCProperty.py

class ObjCPropertyTestCase(TestBase):
     def setUp(self):
         # Call super's setUp().                                                                                                           
         TestBase.setUp(self)
 
         # Find the line number to break for main.c.                                                                                       
         self.source_name = 'main.m'
 
     @skipUnlessDarwin
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_objc_properties(self):
         """Test that expr uses the correct property getters and setters"""
         if self.getArchitecture() == 'i386':
             self.skipTest("requires modern objc runtime")
 
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 

lldb/trunk/test/lang/objc/objc-static-method-stripped/TestObjCStaticMethodStripped.py

class TestObjCStaticMethodStripped(TestBase):
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line numbers to break inside main().
         self.main_source = "static.m"
         self.break_line = line_number(self.main_source, '// Set breakpoint here.')
 
     @skipUnlessDarwin
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @skipIfDwarf    # This test requires a stripped binary and a dSYM
     @skipIfDWO      # This test requires a stripped binary and a dSYM
     #<rdar://problem/12042992>
     def test_with_python_api(self):
         """Test calling functions in static methods with a stripped binary."""
         if self.getArchitecture() == 'i386':
             self.skipTest("requires modern objc runtime")
         self.build()

lldb/trunk/test/lang/objc/objc-static-method/TestObjCStaticMethod.py

class TestObjCStaticMethod(TestBase):
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line numbers to break inside main().
         self.main_source = "static.m"
         self.break_line = line_number(self.main_source, '// Set breakpoint here.')
 
     @skipUnlessDarwin
-    @python_api_test
+    @add_test_categories(['pyapi'])
     #<rdar://problem/9745789> "expression" can't call functions in class methods
     def test_with_python_api(self):
         """Test calling functions in static methods."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

lldb/trunk/test/lang/objc/objc-stepping/TestObjCStepping.py

def setUp(self):
         self.main_source = "stepping-tests.m"
         self.source_randomMethod_line = line_number (self.main_source, '// Source randomMethod start line.')
         self.sourceBase_randomMethod_line = line_number (self.main_source, '// SourceBase randomMethod start line.')
         self.source_returnsStruct_start_line = line_number (self.main_source, '// Source returnsStruct start line.')
         self.sourceBase_returnsStruct_start_line = line_number (self.main_source, '// SourceBase returnsStruct start line.')
         self.stepped_past_nil_line = line_number (self.main_source, '// Step over nil should stop here.')
 
     @skipUnlessDarwin
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_with_python_api(self):
         """Test stepping through ObjC method dispatch in various forms."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 

lldb/trunk/test/lang/objc/objc-struct-argument/TestObjCStructArgument.py

class TestObjCStructArgument(TestBase):
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line numbers to break inside main().
         self.main_source = "test.m"
         self.break_line = line_number(self.main_source, '// Set breakpoint here.')
 
     @skipUnlessDarwin
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_with_python_api(self):
         """Test passing structs to Objective-C methods."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 

lldb/trunk/test/lang/objc/objc-struct-return/TestObjCStructReturn.py

class TestObjCClassMethod(TestBase):
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line numbers to break inside main().
         self.main_source = "test.m"
         self.break_line = line_number(self.main_source, '// Set breakpoint here.')
 
     @skipUnlessDarwin
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_with_python_api(self):
         """Test calling functions in class methods."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 

lldb/trunk/test/lang/objc/objc-super/TestObjCSuper.py

def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line numbers to break inside main().
         self.main_source = "class.m"
         self.break_line = line_number(self.main_source, '// Set breakpoint here.')
 
     @skipUnlessDarwin
     @expectedFailurei386
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_with_python_api(self):
         """Test calling methods on super."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 

lldb/trunk/test/lldbtest.py

 import signal
 from subprocess import *
 import time
 import types
 import unittest2
 import lldb
 import lldbtest_config
 import lldbutil
+import test_categories
 
 from six import add_metaclass
 from six import StringIO as SixStringIO
 from six.moves.urllib import parse as urlparse
 
 # dosep.py starts lots and lots of dotest instances
 # This option helps you find if two (or more) dotest instances are using the same
 # directory at the same time
if not hasattr(android_device_api, 'result'):
                 ">>> Unable to determine the API level of the Android device.\n"
                 ">>> stdout:\n%s\n"
                 ">>> stderr:\n%s\n" % (stdout, stderr))
     return android_device_api.result
 
 #
 # Decorators for categorizing test cases.
 #
-
 from functools import wraps
-def python_api_test(func):
-    """Decorate the item as a Python API only test."""
-    if isinstance(func, type) and issubclass(func, unittest2.TestCase):
-        raise Exception("@python_api_test can only be used to decorate a test method")
-    @wraps(func)
-    def wrapper(self, *args, **kwargs):
-        if lldb.dont_do_python_api_test:
-            self.skipTest("python api tests")
-        return func(self, *args, **kwargs)
-
-    # Mark this function as such to separate them from lldb command line tests.
-    wrapper.__python_api_test__ = True
-    return wrapper
+def add_test_categories(cat):
+    """Decorate an item with test categories"""
+    cat = test_categories.validate(cat, True)
+    def impl(func):
+        func.getCategories = lambda test: cat
+        return func
+    return impl
 
 def lldbmi_test(func):
     """Decorate the item as a lldb-mi only test."""
     if isinstance(func, type) and issubclass(func, unittest2.TestCase):
         raise Exception("@lldbmi_test can only be used to decorate a test method")
     @wraps(func)
     def wrapper(self, *args, **kwargs):
         if lldb.dont_do_lldbmi_test:
def setUp(self):
         # Assign the test method name to self.testMethodName.
         #
         # For an example of the use of this attribute, look at test/types dir.
         # There are a bunch of test cases under test/types and we don't want the
         # module cacheing subsystem to be confused with executable name "a.out"
         # used for all the test cases.
         self.testMethodName = self._testMethodName
 
-        # Python API only test is decorated with @python_api_test,
-        # which also sets the "__python_api_test__" attribute of the
-        # function object to True.
-        try:
-            if lldb.just_do_python_api_test:
-                testMethod = getattr(self, self._testMethodName)
-                if getattr(testMethod, "__python_api_test__", False):
-                    pass
-                else:
-                    self.skipTest("non python api test")
-        except AttributeError:
-            pass
-
         # lldb-mi only test is decorated with @lldbmi_test,
         # which also sets the "__lldbmi_test__" attribute of the
         # function object to True.
         try:
             if lldb.just_do_lldbmi_test:
                 testMethod = getattr(self, self._testMethodName)
                 if getattr(testMethod, "__lldbmi_test__", False):
                     pass

 # testing. The name of the new test method will be '<original-name>_<debug-info>' and with adding
 # the new test method we remove the old method at the same time.
 class LLDBTestCaseFactory(type):
     def __new__(cls, name, bases, attrs):
         newattrs = {}
         for attrname, attrvalue in attrs.items():
             if attrname.startswith("test") and not getattr(attrvalue, "__no_debug_info_test__", False):
                 @dsym_test
+                @wraps(attrvalue)
                 def dsym_test_method(self, attrvalue=attrvalue):
                     self.debug_info = "dsym"
                     return attrvalue(self)
                 dsym_method_name = attrname + "_dsym"
                 dsym_test_method.__name__ = dsym_method_name
                 newattrs[dsym_method_name] = dsym_test_method
 
                 @dwarf_test
+                @wraps(attrvalue)
                 def dwarf_test_method(self, attrvalue=attrvalue):
                     self.debug_info = "dwarf"
                     return attrvalue(self)
                 dwarf_method_name = attrname + "_dwarf"
                 dwarf_test_method.__name__ = dwarf_method_name
                 newattrs[dwarf_method_name] = dwarf_test_method
                 
                 @dwo_test
+                @wraps(attrvalue)
                 def dwo_test_method(self, attrvalue=attrvalue):
                     self.debug_info = "dwo"
                     return attrvalue(self)
                 dwo_method_name = attrname + "_dwo"
                 dwo_test_method.__name__ = dwo_method_name
                 newattrs[dwo_method_name] = dwo_test_method
             else:
                 newattrs[attrname] = attrvalue

lldb/trunk/test/macosx/indirect_symbol/TestIndirectSymbols.py

class TestIndirectFunctions(TestBase):
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line numbers that we will step to in main:
         self.main_source = "main.c"
 
     @skipUnlessDarwin
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_with_python_api(self):
         """Test stepping and setting breakpoints in indirect and re-exported symbols."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 

lldb/trunk/test/macosx/queues/TestQueues.py

 import lldbutil
 from lldbtest import *
 
 class TestQueues(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @skipUnlessDarwin
-    @python_api_test      
+    @add_test_categories(['pyapi'])      
     @unittest2.expectedFailure("rdar://22531180")
     def test_with_python_api(self):
         """Test queues inspection SB APIs."""
         self.build()
         self.queues()
         self.queues_with_libBacktraceRecording()
 
     def setUp(self):

lldb/trunk/test/macosx/safe-to-func-call/TestSafeFuncCalls.py

class TestSafeFuncCalls(TestBase):
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line numbers that we will step to in main:
         self.main_source = "main.c"
 
     @skipUnlessDarwin
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_with_python_api(self):
         """Test function call thread safety."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
         self.main_source_spec = lldb.SBFileSpec (self.main_source)

lldb/trunk/test/macosx/universal/TestUniversal.py

class UniversalTestCase(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break inside main().
         self.line = line_number('main.c', '// Set break point at this line.')
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @skipUnlessDarwin
     @unittest2.skipUnless(hasattr(os, "uname") and os.uname()[4] in ['i386', 'x86_64'],
             "requires i386 or x86_64")
     def test_sbdebugger_create_target_with_file_and_target_triple(self):
         """Test the SBDebugger.CreateTargetWithFileAndTargetTriple() API."""
         # Invoke the default build rule.
         self.build()
 

lldb/trunk/test/python_api/breakpoint/TestBreakpointAPI.py

 import re
 import lldb, lldbutil
 from lldbtest import *
 
 class BreakpointAPITestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_breakpoint_is_valid(self):
         """Make sure that if an SBBreakpoint gets deleted its IsValid returns false."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

lldb/trunk/test/python_api/class_members/TestSBTypeClassMembers.py

def setUp(self):
         TestBase.setUp(self)
         # We'll use the test method name as the exe_name.
         self.exe_name = self.testMethodName
         # Find the line number to break at.
         self.source = 'main.mm'
         self.line = line_number(self.source, '// set breakpoint here')
 
     @skipUnlessDarwin
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test(self):
         """Test SBType APIs to fetch member function types."""
         d = {'EXE': self.exe_name}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
         exe = os.path.join(os.getcwd(), self.exe_name)
 
         # Create a target by the debugger.

lldb/trunk/test/python_api/debugger/TestDebuggerAPI.py

 """
 Test Debugger APIs.
 """
 
 import os
 import lldb
 from lldbtest import *
 
 
 class DebuggerAPITestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @no_debug_info_test
     def test_debugger_api_boundary_condition(self):
         """Exercise SBDebugger APIs with boundary conditions."""
         self.dbg.HandleCommand(None)
         self.dbg.SetDefaultArchitecture(None)
         self.dbg.GetScriptingLanguage(None)
         self.dbg.CreateTarget(None)
         self.dbg.CreateTarget(None, None, None, True, lldb.SBError())
         self.dbg.CreateTargetWithFileAndTargetTriple(None, None)
         self.dbg.CreateTargetWithFileAndArch(None, None)
         self.dbg.FindTargetWithFileAndArch(None, None)
         self.dbg.SetInternalVariable(None, None, None)
         self.dbg.GetInternalVariableValue(None, None)
         # FIXME (filcab): We must first allow for the swig bindings to know if
         # a Python callback is set. (Check python-typemaps.swig)
         #self.dbg.SetLoggingCallback(None)
         self.dbg.SetPrompt(None)
         self.dbg.SetCurrentPlatform(None)
         self.dbg.SetCurrentPlatformSDKRoot(None)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_debugger_delete_invalid_target(self):
         """SBDebugger.DeleteTarget() should not crash LLDB given and invalid target."""
         target = lldb.SBTarget()
         self.assertFalse(target.IsValid())
         self.dbg.DeleteTarget(target)

lldb/trunk/test/python_api/default-constructor/TestDefaultConstructorForAPIObjects.py

 import re
 import lldb, lldbutil
 from lldbtest import *
 
 class APIDefaultConstructorTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @no_debug_info_test
     def test_SBAddress(self):
         obj = lldb.SBAddress()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_address
         sb_address.fuzz_obj(obj)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @no_debug_info_test
     def test_SBBlock(self):
         obj = lldb.SBBlock()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_block
         sb_block.fuzz_obj(obj)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @no_debug_info_test
     def test_SBBreakpoint(self):
         obj = lldb.SBBreakpoint()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_breakpoint
         sb_breakpoint.fuzz_obj(obj)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @no_debug_info_test
     def test_SBBreakpointLocation(self):
         obj = lldb.SBBreakpointLocation()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_breakpointlocation
         sb_breakpointlocation.fuzz_obj(obj)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @no_debug_info_test
     def test_SBBroadcaster(self):
         obj = lldb.SBBroadcaster()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_broadcaster
         sb_broadcaster.fuzz_obj(obj)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @no_debug_info_test
     def test_SBCommandReturnObject(self):
         """SBCommandReturnObject object is valid after default construction."""
         obj = lldb.SBCommandReturnObject()
         if self.TraceOn():
             print(obj)
         self.assertTrue(obj)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @no_debug_info_test
     def test_SBCommunication(self):
         obj = lldb.SBCommunication()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_communication
         sb_communication.fuzz_obj(obj)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @no_debug_info_test
     def test_SBCompileUnit(self):
         obj = lldb.SBCompileUnit()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_compileunit
         sb_compileunit.fuzz_obj(obj)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @no_debug_info_test
     def test_SBDebugger(self):
         obj = lldb.SBDebugger()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_debugger
         sb_debugger.fuzz_obj(obj)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @no_debug_info_test
     # darwin: This test passes with swig 3.0.2, fails w/3.0.5 other tests fail with 2.0.12 http://llvm.org/pr23488
     def test_SBError(self):
         obj = lldb.SBError()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_error
         sb_error.fuzz_obj(obj)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @no_debug_info_test
     def test_SBEvent(self):
         obj = lldb.SBEvent()
         # This is just to test that typemap, as defined in lldb.swig, works.
         obj2 = lldb.SBEvent(0, "abc")
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_event
         sb_event.fuzz_obj(obj)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_SBFileSpec(self):
         obj = lldb.SBFileSpec()
         # This is just to test that FileSpec(None) does not crash.
         obj2 = lldb.SBFileSpec(None, True)
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_filespec
         sb_filespec.fuzz_obj(obj)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @no_debug_info_test
     def test_SBFrame(self):
         obj = lldb.SBFrame()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_frame
         sb_frame.fuzz_obj(obj)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @no_debug_info_test
     def test_SBFunction(self):
         obj = lldb.SBFunction()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_function
         sb_function.fuzz_obj(obj)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @no_debug_info_test
     def test_SBInstruction(self):
         obj = lldb.SBInstruction()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_instruction
         sb_instruction.fuzz_obj(obj)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @no_debug_info_test
     def test_SBInstructionList(self):
         obj = lldb.SBInstructionList()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_instructionlist
         sb_instructionlist.fuzz_obj(obj)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @no_debug_info_test
     def test_SBLineEntry(self):
         obj = lldb.SBLineEntry()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_lineentry
         sb_lineentry.fuzz_obj(obj)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @no_debug_info_test
     def test_SBListener(self):
         obj = lldb.SBListener()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_listener
         sb_listener.fuzz_obj(obj)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @no_debug_info_test
     def test_SBModule(self):
         obj = lldb.SBModule()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_module
         sb_module.fuzz_obj(obj)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @no_debug_info_test
     def test_SBProcess(self):
         obj = lldb.SBProcess()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_process
         sb_process.fuzz_obj(obj)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @no_debug_info_test
     def test_SBSection(self):
         obj = lldb.SBSection()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_section
         sb_section.fuzz_obj(obj)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @no_debug_info_test
     def test_SBStream(self):
         """SBStream object is valid after default construction."""
         obj = lldb.SBStream()
         if self.TraceOn():
             print(obj)
         self.assertTrue(obj)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @no_debug_info_test
     def test_SBStringList(self):
         obj = lldb.SBStringList()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_stringlist
         sb_stringlist.fuzz_obj(obj)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @no_debug_info_test
     def test_SBSymbol(self):
         obj = lldb.SBSymbol()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_symbol
         sb_symbol.fuzz_obj(obj)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @no_debug_info_test
     def test_SBSymbolContext(self):
         obj = lldb.SBSymbolContext()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_symbolcontext
         sb_symbolcontext.fuzz_obj(obj)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @no_debug_info_test
     def test_SBSymbolContextList(self):
         """SBSymbolContextList object is valid after default construction."""
         obj = lldb.SBSymbolContextList()
         if self.TraceOn():
             print(obj)
         self.assertTrue(obj)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @no_debug_info_test
     def test_SBTarget(self):
         obj = lldb.SBTarget()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_target
         sb_target.fuzz_obj(obj)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @no_debug_info_test
     def test_SBThread(self):
         obj = lldb.SBThread()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_thread
         sb_thread.fuzz_obj(obj)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @no_debug_info_test
     def test_SBType(self):
         try:
             obj = lldb.SBType()
             if self.TraceOn():
                 print(obj)
             self.assertFalse(obj)
             # If we reach here, the test fails.
             self.fail("lldb.SBType() should fail, not succeed!")
         except:
             # Exception is expected.
             return
             
         # Unreachable code because lldb.SBType() should fail.
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_type
         sb_type.fuzz_obj(obj)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @no_debug_info_test
     def test_SBTypeList(self):
         """SBTypeList object is valid after default construction."""
         obj = lldb.SBTypeList()
         if self.TraceOn():
             print(obj)
         self.assertTrue(obj)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @no_debug_info_test
     def test_SBValue(self):
         obj = lldb.SBValue()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_value
         sb_value.fuzz_obj(obj)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @no_debug_info_test
     def test_SBValueList(self):
         obj = lldb.SBValueList()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_valuelist
         sb_valuelist.fuzz_obj(obj)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @no_debug_info_test
     def test_SBWatchpoint(self):
         obj = lldb.SBWatchpoint()
         if self.TraceOn():
             print(obj)
         self.assertFalse(obj)
         # Do fuzz testing on the invalid obj, it should not crash lldb.
         import sb_watchpoint
         sb_watchpoint.fuzz_obj(obj)

lldb/trunk/test/python_api/disassemble-raw-data/TestDisassembleRawData.py

 import re
 import lldb, lldbutil
 from lldbtest import *
 
 class DisassembleRawDataTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @no_debug_info_test
     def test_disassemble_raw_data(self):
         """Test disassembling raw bytes with the API."""
         # Create a target from the debugger.
         target = self.dbg.CreateTargetWithFileAndTargetTriple ("", "x86_64")
         self.assertTrue(target, VALID_TARGET)
 
         raw_bytes = bytearray([0x48, 0x89, 0xe5])

lldb/trunk/test/python_api/disassemble-raw-data/TestDisassemble_VST1_64.py

 import lldb, lldbutil
 from lldbtest import *
 
 class Disassemble_VST1_64(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @skipIf(True) # llvm.org/pr24575: all tests get ERRORs in dotest.py after this
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @no_debug_info_test
     def test_disassemble_invalid_vst_1_64_raw_data(self):
         """Test disassembling invalid vst1.64 raw bytes with the API."""
         # Create a target from the debugger.
         target = self.dbg.CreateTargetWithFileAndTargetTriple ("", "thumbv7")
         self.assertTrue(target, VALID_TARGET)
 
         raw_bytes = bytearray([0xf0, 0xb5, 0x03, 0xaf,

lldb/trunk/test/python_api/event/TestEvents.py

class EventAPITestCase(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to of function 'c'.
         self.line = line_number('main.c', '// Find the line number of function "c" here.')
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @expectedFailureLinux("llvm.org/pr23730") # Flaky, fails ~1/10 cases
     @skipIfLinux # skip to avoid crashes
     def test_listen_for_and_print_event(self):
         """Exercise SBEvent API."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         self.dbg.SetAsync(True)
def test_listen_for_and_print_event(self):
 
         # Use Python API to kill the process.  The listening thread should be
         # able to receive the state changed event, too.
         process.Kill()
 
         # Wait until the 'MyListeningThread' terminates.
         my_thread.join()
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_wait_for_event(self):
         """Exercise SBListener.WaitForEvent() API."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         self.dbg.SetAsync(True)
 
         # Create a target by the debugger.
def test_wait_for_event(self):
 
         # Wait until the 'MyListeningThread' terminates.
         my_thread.join()
 
         self.assertTrue(event,
                         "My listening thread successfully received an event")
 
     @skipIfFreeBSD # llvm.org/pr21325
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @expectedFlakeyLinux("llvm.org/pr23617")  # Flaky, fails ~1/10 cases
     @expectedFailureWindows("llvm.org/pr24778")
     def test_add_listener_to_broadcaster(self):
         """Exercise some SBBroadcaster APIs."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         self.dbg.SetAsync(True)

lldb/trunk/test/python_api/findvalue_duplist/TestSBFrameFindValue.py

 """Test that SBFrame::FindValue finds things but does not duplicate the entire variables list"""
 
 from __future__ import print_function
 
 import lldb_shared
 
 import os, sys, time
 import lldb
 from lldbtest import *
 import lldbutil
 
 class SBFrameFindValueTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_formatters_api(self):
         """Test that SBFrame::FindValue finds things but does not duplicate the entire variables list"""
         self.build()
         self.setTearDownCleanup()
 
         exe_name = "a.out"
         exe = os.path.join(os.getcwd(), exe_name)
 

lldb/trunk/test/python_api/formatters/TestFormattersSBAPI.py

class SBFormattersAPITestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         self.line = line_number('main.cpp', '// Set break point at this line.')
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_formatters_api(self):
         """Test Python APIs for working with formatters"""
         self.build()
         self.setTearDownCleanup()
         
         """Test Python APIs for working with formatters"""
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
 
def test_formatters_api(self):
 
         self.assertTrue(summary.IsValid(), "no summary found for foo* when one was in place")
         self.assertTrue(summary.GetData() == "hello static world", "wrong summary found for foo*")
 
         self.expect("frame variable e1", substrs=["I am an empty Empty1 {}"])
         self.expect("frame variable e2", substrs=["I am an empty Empty2"])
         self.expect("frame variable e2", substrs=["I am an empty Empty2 {}"], matching=False)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_force_synth_off(self):
         """Test that one can have the public API return non-synthetic SBValues if desired"""
         self.build(dictionary={'EXE':'no_synth'})
         self.setTearDownCleanup()
 
         self.runCmd("file no_synth", CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)

lldb/trunk/test/python_api/frame/TestFrames.py

 import re
 import lldb, lldbutil
 from lldbtest import *
 
 class FrameAPITestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @expectedFailureWindows("llvm.org/pr24778")
     def test_get_arg_vals_for_call_stack(self):
         """Exercise SBFrame.GetVariables() API to get argument vals."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
def test_get_arg_vals_for_call_stack(self):
         if self.TraceOn():
             print("Full stack traces when stopped on the breakpoint 'c':")
             print(session.getvalue())
         self.expect(session.getvalue(), "Argugment values displayed correctly",
                     exe=False,
             substrs = ["a((int)val=1, (char)ch='A')",
                        "a((int)val=3, (char)ch='A')"])
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_frame_api_boundary_condition(self):
         """Exercise SBFrame APIs with boundary condition inputs."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
def test_frame_api_boundary_condition(self):
         val2 = frame.FindVariable(None, False)
         val3 = frame.FindValue(None, lldb.eValueTypeVariableGlobal)
         if self.TraceOn():
             print("val1:", val1)
             print("val2:", val2)
 
         frame.EvaluateExpression(None)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_frame_api_IsEqual(self):
         """Exercise SBFrame API IsEqual."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

lldb/trunk/test/python_api/frame/inlines/TestInlinedFrame.py

class InlinedFrameAPITestCase(TestBase):
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to of function 'c'.
         self.source = 'inlines.c'
         self.first_stop = line_number(self.source, '// This should correspond to the first break stop.')
         self.second_stop = line_number(self.source, '// This should correspond to the second break stop.')
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_stop_at_outer_inline(self):
         """Exercise SBFrame.IsInlined() and SBFrame.GetFunctionName()."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

lldb/trunk/test/python_api/function_symbol/TestDisasmAPI.py

class DisasmAPITestCase(TestBase):
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to of function 'c'.
         self.line1 = line_number('main.c', '// Find the line number for breakpoint 1 here.')
         self.line2 = line_number('main.c', '// Find the line number for breakpoint 2 here.')
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test(self):
         """Exercise getting SBAddress objects, disassembly, and SBAddress APIs."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

lldb/trunk/test/python_api/function_symbol/TestSymbolAPI.py

class SymbolAPITestCase(TestBase):
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to of function 'c'.
         self.line1 = line_number('main.c', '// Find the line number for breakpoint 1 here.')
         self.line2 = line_number('main.c', '// Find the line number for breakpoint 2 here.')
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @expectedFailureWindows("llvm.org/pr24778")
     def test(self):
         """Exercise some SBSymbol and SBAddress APIs."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)

lldb/trunk/test/python_api/hello_world/TestHelloWorld.py

def setUp(self):
         self.line2 = line_number('main.c', '// Waiting to be attached...')
 
     def tearDown(self):
         # Destroy process before TestBase.tearDown()
         self.dbg.GetSelectedTarget().GetProcess().Destroy()
         # Call super's tearDown().
         TestBase.tearDown(self)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_with_process_launch_api(self):
         """Create target, breakpoint, launch a process, and then kill it."""
         self.build(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
         target = self.dbg.CreateTarget(self.exe)
 
         breakpoint = target.BreakpointCreateByLocation("main.c", self.line1)
 
def test_with_process_launch_api(self):
         if thread.GetStopReason() != lldb.eStopReasonBreakpoint:
             from lldbutil import stop_reason_to_str
             self.fail(STOPPED_DUE_TO_BREAKPOINT_WITH_STOP_REASON_AS %
                       stop_reason_to_str(thread.GetStopReason()))
 
         # The breakpoint should have a hit count of 1.
         self.assertTrue(breakpoint.GetHitCount() == 1, BREAKPOINT_HIT_ONCE)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @expectedFailurei386 # llvm.org/pr17384: lldb needs to be aware of linux-vdso.so to unwind stacks properly
     @expectedFailureWindows("llvm.org/pr24600")
     def test_with_attach_to_process_with_id_api(self):
         """Create target, spawn a process, and attach to it with process id."""
         self.build(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
         target = self.dbg.CreateTarget(self.exe)
 
def test_with_attach_to_process_with_id_api(self):
 
         # Let's check the stack traces of the attached process.
         import lldbutil
         stacktraces = lldbutil.print_stacktraces(process, string_buffer=True)
         self.expect(stacktraces, exe=False,
             substrs = ['main.c:%d' % self.line2,
                        '(int)argc=3'])
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @expectedFailurei386 # llvm.org/pr17384: lldb needs to be aware of linux-vdso.so to unwind stacks properly
     @expectedFailureWindows("llvm.org/pr24600")
     def test_with_attach_to_process_with_name_api(self):
         """Create target, spawn a process, and attach to it with process name."""
         self.build(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
         target = self.dbg.CreateTarget(self.exe)
 

lldb/trunk/test/python_api/interpreter/TestCommandInterpreterAPI.py

class CommandInterpreterAPICase(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break on inside main.cpp.
         self.line = line_number('main.c', 'Hello world.')
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_with_process_launch_api(self):
         """Test the SBCommandInterpreter APIs."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

lldb/trunk/test/python_api/lldbutil/frame/TestFrameUtils.py

class FrameUtilsTestCase(TestBase):
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break inside main().
         self.line = line_number('main.c',
                                 "// Find the line number here.")
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_frame_utils(self):
         """Test utility functions for the frame object."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 

lldb/trunk/test/python_api/lldbutil/iter/TestLLDBIterator.py

class LLDBIteratorTestCase(TestBase):
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line numbers to break inside main().
         self.line1 = line_number('main.cpp', '// Set break point at this line.')
         self.line2 = line_number('main.cpp', '// And that line.')
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_lldb_iter_module(self):
         """Test module_iter works correctly for SBTarget -> SBModule."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
def test_lldb_iter_module(self):
         self.assertTrue(len(yours) == len(mine))
         for i in range(len(yours)):
             if self.TraceOn():
                 print("yours[%d]='%s'" % (i, get_description(yours[i])))
                 print("mine[%d]='%s'" % (i, get_description(mine[i])))
             self.assertTrue(yours[i] == mine[i],
                             "UUID+FileSpec of yours[{0}] and mine[{0}] matches".format(i))
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_lldb_iter_breakpoint(self):
         """Test breakpoint_iter works correctly for SBTarget -> SBBreakpoint."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
def test_lldb_iter_breakpoint(self):
         self.assertTrue(len(yours) == len(mine))
         for i in range(len(yours)):
             if self.TraceOn():
                 print("yours[%d]='%s'" % (i, get_description(yours[i])))
                 print("mine[%d]='%s'" % (i, get_description(mine[i])))
             self.assertTrue(yours[i] == mine[i],
                             "ID of yours[{0}] and mine[{0}] matches".format(i))
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_lldb_iter_frame(self):
         """Test iterator works correctly for SBProcess->SBThread->SBFrame."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 

lldb/trunk/test/python_api/lldbutil/iter/TestRegistersIterator.py

class RegistersIteratorTestCase(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break inside main().
         self.line1 = line_number('main.cpp', '// Set break point at this line.')
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @expectedFailureWindows # Test crashes
     def test_iter_registers(self):
         """Test iterator works correctly for lldbutil.iter_registers()."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

lldb/trunk/test/python_api/lldbutil/process/TestPrintStackTraces.py

class ThreadsStackTracesTestCase(TestBase):
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break inside main().
         self.line = line_number('main.cpp', '// Set break point at this line.')
 
     @expectedFailureAll("llvm.org/pr23043", ["linux"], archs=["i386"]) # We are unable to produce a backtrace of the main thread when the thread is blocked in fgets
     @expectedFailureWindows("llvm.org/pr24778")
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_stack_traces(self):
         """Test SBprocess and SBThread APIs with printing of the stack traces."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 

lldb/trunk/test/python_api/module_section/TestModuleAndSection.py

 import lldb
 from lldbtest import *
 from lldbutil import symbol_type_to_str
 
 class ModuleAndSectionAPIsTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_module_and_section(self):
         """Test module and section APIs."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
         self.assertTrue(target.GetNumModules() > 0)
def test_module_and_section(self):
             else:
                 for subsec in sec:
                     print(INDENT + str(subsec))
                     # Now print the symbols belonging to the subsection....
                     for sym in exe_module.symbol_in_section_iter(subsec):
                         print(INDENT2 + str(sym))
                         print(INDENT2 + "symbol type: %s" % symbol_type_to_str(sym.GetType()))
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_module_and_section_boundary_condition(self):
         """Test module and section APIs by passing None when it expects a Python string."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
         self.assertTrue(target.GetNumModules() > 0)
def test_module_and_section_boundary_condition(self):
             sec1 = exe_module.GetSectionAtIndex(1)
             print(sec1)
         else:
             sec1 = None
 
         if sec1:
             sec1.FindSubSection(None)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_module_compile_unit_iter(self):
         """Test module's compile unit iterator APIs."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
         self.assertTrue(target.GetNumModules() > 0)

lldb/trunk/test/python_api/objc_type/TestObjCType.py

class ObjCSBTypeTestCase(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         self.line = line_number("main.m", '// Break at this line')
 
     @skipUnlessDarwin
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test(self):
         """Test SBType for ObjC classes."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

lldb/trunk/test/python_api/process/TestProcessAPI.py

class ProcessAPITestCase(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break inside main().
         self.line = line_number("main.cpp", "// Set break point at this line and check variable 'my_char'.")
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_read_memory(self):
         """Test Python SBProcess.ReadMemory() API."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
def test_read_memory(self):
         if not error.Success():
             self.fail("SBProcess.ReadCStringFromMemory() failed")
         if self.TraceOn():
             print("uint32 read is:", my_uint32)
 
         if my_uint32 != 12345:
             self.fail("Result from SBProcess.ReadUnsignedFromMemory() does not match our expected output")
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_write_memory(self):
         """Test Python SBProcess.WriteMemory() API."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
def test_write_memory(self):
             self.fail("SBProcess.ReadMemory() failed")
         if self.TraceOn():
             print("memory content:", content)
 
         self.expect(content, "Result from SBProcess.ReadMemory() matches our expected output: 'a'",
                     exe=False,
             startstr = 'a')
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_access_my_int(self):
         """Test access 'my_int' using Python SBProcess.GetByteOrder() and other APIs."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
def test_access_my_int(self):
         if new_value != 256:
             self.fail("Memory content read from 'my_int' does not match (int)256")
 
         # Dump the memory content....
         if self.TraceOn():
             for i in new_bytes:
                 print("byte:", i)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_remote_launch(self):
         """Test SBProcess.RemoteLaunch() API with a process not in eStateConnected, and it should fail."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         # Launch the process, and do not stop at the entry point.
         process = target.LaunchSimple (None, None, self.get_process_working_directory())
 
         if self.TraceOn():
             print("process state:", state_type_to_str(process.GetState()))
         self.assertTrue(process.GetState() != lldb.eStateConnected)
 
         error = lldb.SBError()
         success = process.RemoteLaunch(None, None, None, None, None, None, 0, False, error)
         self.assertTrue(not success, "RemoteLaunch() should fail for process state != eStateConnected")
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_get_num_supported_hardware_watchpoints(self):
         """Test SBProcess.GetNumSupportedHardwareWatchpoints() API with a process."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

lldb/trunk/test/python_api/process/io/TestProcessIO.py

def setUp(self):
         self.local_error_file  = os.path.join(os.getcwd(), "error.txt")
 
         self.input_file  = os.path.join(self.get_process_working_directory(), "input.txt")
         self.output_file = os.path.join(self.get_process_working_directory(), "output.txt")
         self.error_file  = os.path.join(self.get_process_working_directory(), "error.txt")
         self.lines = ["Line 1", "Line 2", "Line 3"]
 
     @skipIfWindows # stdio manipulation unsupported on Windows
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_stdin_by_api(self):
         """Exercise SBProcess.PutSTDIN()."""
         self.build()
         self.create_target()
         self.run_process(True)
         output = self.process.GetSTDOUT(1000)
         self.check_process_output(output, output)
 
     @skipIfWindows # stdio manipulation unsupported on Windows
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_stdin_redirection(self):
         """Exercise SBLaunchInfo::AddOpenFileAction() for STDIN without specifying STDOUT or STDERR."""
         self.build()
         self.create_target()
         self.redirect_stdin()
         self.run_process(False)
         output = self.process.GetSTDOUT(1000)        
         self.check_process_output(output, output)
 
     @skipIfWindows # stdio manipulation unsupported on Windows
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_stdout_redirection(self):
         """Exercise SBLaunchInfo::AddOpenFileAction() for STDOUT without specifying STDIN or STDERR."""
         self.build()
         self.create_target()
         self.redirect_stdout()
         self.run_process(True)
         output = self.read_output_file_and_delete()
         error = self.process.GetSTDOUT(1000)
         self.check_process_output(output, error)
 
     @skipIfWindows # stdio manipulation unsupported on Windows
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_stderr_redirection(self):
         """Exercise SBLaunchInfo::AddOpenFileAction() for STDERR without specifying STDIN or STDOUT."""
         self.build()
         self.create_target()
         self.redirect_stderr()
         self.run_process(True)
         output = self.process.GetSTDOUT(1000)
         error = self.read_error_file_and_delete()
         self.check_process_output(output, error)
 
     @skipIfWindows # stdio manipulation unsupported on Windows
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_stdout_stderr_redirection(self):
         """Exercise SBLaunchInfo::AddOpenFileAction() for STDOUT and STDERR without redirecting STDIN."""
         self.build()
         self.create_target()
         self.redirect_stdout()
         self.redirect_stderr()
         self.run_process(True)
         output = self.read_output_file_and_delete()

lldb/trunk/test/python_api/sbdata/TestSBData.py

class SBDataAPICase(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break on inside main.cpp.
         self.line = line_number('main.cpp', '// set breakpoint here')
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_with_run_command(self):
         """Test the SBData APIs."""
         self.build()
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
         
         lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=1, loc_exact=True)
         
         self.runCmd("run", RUN_SUCCEEDED)

lldb/trunk/test/python_api/sbvalue_persist/TestSBValuePersist.py

 """Test SBValue::Persist"""
 
 from __future__ import print_function
 
 import lldb_shared
 
 import os, sys, time
 import lldb
 from lldbtest import *
 import lldbutil
 
 class SBValuePersistTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @expectedFailureWindows("llvm.org/pr24772")
     def test(self):
         """Test SBValue::Persist"""
         self.build()
         self.setTearDownCleanup()
         self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
 
         lldbutil.run_break_set_by_source_regexp (self, "break here")

lldb/trunk/test/python_api/section/TestSectionAPI.py

 """
 Test SBSection APIs.
 """
 
 from __future__ import print_function
 
 import lldb_shared
 
 from lldbtest import *
 
 class SectionAPITestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_get_target_byte_size(self):
         d = {'EXE': 'b.out'}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
         exe = os.path.join(os.getcwd(), 'b.out')
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 

lldb/trunk/test/python_api/signals/TestSignalsAPI.py

 """
 Test SBProcess APIs, including ReadMemory(), WriteMemory(), and others.
 """
 
 from __future__ import print_function
 
 import lldb_shared
 
 import os, time
 import lldb
 from lldbutil import get_stopped_thread, state_type_to_str
 from lldbtest import *
 
 class SignalsAPITestCase(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @expectedFlakeyLinux # this test fails 1/100 dosep runs
     @skipIfWindows # Windows doesn't have signals
     def test_ignore_signal(self):
         """Test Python SBUnixSignals.Suppress/Stop/Notify() API."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 

lldb/trunk/test/python_api/symbol-context/TestSymbolContext.py

class SymbolContextAPITestCase(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to of function 'c'.
         self.line = line_number('main.c', '// Find the line number of function "c" here.')
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @expectedFailureWindows("llvm.org/pr24778")
     def test(self):
         """Exercise SBSymbolContext API extensively."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)

lldb/trunk/test/python_api/target/TestTargetAPI.py

class TargetAPITestCase(TestBase):
 
     #rdar://problem/9700873
     # Find global variable value fails for dwarf if inferior not started
     # (Was CrashTracer: [USER] 1 crash in Python at _lldb.so: lldb_private::MemoryCache::Read + 94)
     #
     # It does not segfaults now.  But for dwarf, the variable value is None if
     # the inferior process does not exist yet.  The radar has been updated.
     #@unittest232.skip("segmentation fault -- skipping")
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_find_global_variables(self):
         """Exercise SBTarget.FindGlobalVariables() API."""
         d = {'EXE': 'b.out'}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
         self.find_global_variables('b.out')
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @expectedFailureWindows("llvm.org/pr24778")
     def test_find_functions(self):
         """Exercise SBTarget.FindFunctions() API."""
         d = {'EXE': 'b.out'}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
         self.find_functions('b.out')
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_get_description(self):
         """Exercise SBTarget.GetDescription() API."""
         self.build()
         self.get_description()
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_launch_new_process_and_redirect_stdout(self):
         """Exercise SBTarget.Launch() API."""
         self.build()
         self.launch_new_process_and_redirect_stdout()
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_resolve_symbol_context_with_address(self):
         """Exercise SBTarget.ResolveSymbolContextForAddress() API."""
         self.build()
         self.resolve_symbol_context_with_address()
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_get_platform(self):
         d = {'EXE': 'b.out'}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
         target = self.create_simple_target('b.out')
         platform = target.platform
         self.assertTrue(platform, VALID_PLATFORM)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_get_data_byte_size(self):
         d = {'EXE': 'b.out'}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
         target = self.create_simple_target('b.out')
         self.assertEquals(target.data_byte_size, 1)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_get_code_byte_size(self):
         d = {'EXE': 'b.out'}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
         target = self.create_simple_target('b.out')
         self.assertEquals(target.code_byte_size, 1)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_resolve_file_address(self):
         d = {'EXE': 'b.out'}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
         target = self.create_simple_target('b.out')
 
         # find the file address in the .data section of the main
         # module            
         data_section = self.find_data_section(target)
         data_section_addr = data_section.file_addr
 
         # resolve the above address, and compare the address produced
         # by the resolution against the original address/section       
         res_file_addr = target.ResolveFileAddress(data_section_addr)
         self.assertTrue(res_file_addr.IsValid())
 
         self.assertEquals(data_section_addr, res_file_addr.file_addr) 
 
         data_section2 = res_file_addr.section
         self.assertIsNotNone(data_section2)
         self.assertEquals(data_section.name, data_section2.name) 
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_read_memory(self):
         d = {'EXE': 'b.out'}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
         target = self.create_simple_target('b.out')
 
         breakpoint = target.BreakpointCreateByLocation("main.c", self.line_main)
         self.assertTrue(breakpoint, VALID_BREAKPOINT)

lldb/trunk/test/python_api/thread/TestThreadAPI.py

 import lldb
 from lldbutil import get_stopped_thread, get_caller_symbol
 from lldbtest import *
 
 class ThreadAPITestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_get_process(self):
         """Test Python SBThread.GetProcess() API."""
         self.build()
         self.get_process()
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_get_stop_description(self):
         """Test Python SBThread.GetStopDescription() API."""
         self.build()
         self.get_stop_description()
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_run_to_address(self):
         """Test Python SBThread.RunToAddress() API."""
         # We build a different executable than the default build() does.
         d = {'CXX_SOURCES': 'main2.cpp', 'EXE': self.exe_name}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
         self.run_to_address(self.exe_name)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @expectedFailureFreeBSD # llvm.org/pr20476
     @expectedFailureWindows # Test crashes
     def test_step_out_of_malloc_into_function_b(self):
         """Test Python SBThread.StepOut() API to step out of a malloc call where the call site is at function b()."""
         # We build a different executable than the default build() does.
         d = {'CXX_SOURCES': 'main2.cpp', 'EXE': self.exe_name}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
         self.step_out_of_malloc_into_function_b(self.exe_name)
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_step_over_3_times(self):
         """Test Python SBThread.StepOver() API."""
         # We build a different executable than the default build() does.
         d = {'CXX_SOURCES': 'main2.cpp', 'EXE': self.exe_name}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
         self.step_over_3_times(self.exe_name)
 

lldb/trunk/test/python_api/type/TestTypeList.py

def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # We'll use the test method name as the exe_name.
         self.exe_name = self.testMethodName
         # Find the line number to break at.
         self.source = 'main.cpp'
         self.line = line_number(self.source, '// Break at this line')
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test(self):
         """Exercise SBType and SBTypeList API."""
         d = {'EXE': self.exe_name}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
         exe = os.path.join(os.getcwd(), self.exe_name)
 
         # Create a target by the debugger.

lldb/trunk/test/python_api/value/TestValueAPI.py

def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # We'll use the test method name as the exe_name.
         self.exe_name = self.testMethodName
         # Find the line number to of function 'c'.
         self.line = line_number('main.c', '// Break at this line')
 
     @expectedFailureWindows("llvm.org/pr24772")
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test(self):
         """Exercise some SBValue APIs."""
         d = {'EXE': self.exe_name}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
         exe = os.path.join(os.getcwd(), self.exe_name)
 
         # Create a target by the debugger.

lldb/trunk/test/python_api/value/change_values/TestChangeValueAPI.py

def setUp(self):
         # We'll use the test method name as the exe_name.
         self.exe_name = self.testMethodName
         # Find the line number to of function 'c'.
         self.line = line_number('main.c', '// Stop here and set values')
         self.check_line = line_number('main.c', '// Stop here and check values')
         self.end_line = line_number ('main.c', '// Set a breakpoint here at the end')
 
     @expectedFailureWindows("llvm.org/pr24772")
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_change_value(self):
         """Exercise the SBValue::SetValueFromCString API."""
         d = {'EXE': self.exe_name}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
         exe = os.path.join(os.getcwd(), self.exe_name)
 
         # Create a target by the debugger.

lldb/trunk/test/python_api/value/linked_list/TestValueAPILinkedList.py

class ValueAsLinkedListTestCase(TestBase):
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # We'll use the test method name as the exe_name.
         self.exe_name = self.testMethodName
         # Find the line number to break at.
         self.line = line_number('main.cpp', '// Break at this line')
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test(self):
         """Exercise SBValue API linked_list_iter."""
         d = {'EXE': self.exe_name}
         self.build(dictionary=d)
         self.setTearDownCleanup(dictionary=d)
         exe = os.path.join(os.getcwd(), self.exe_name)
 
         # Create a target by the debugger.

lldb/trunk/test/python_api/value_var_update/TestValueVarUpdate.py

class HelloWorldTestCase(TestBase):
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Get the full path to our executable to be attached/debugged.
         self.exe = os.path.join(os.getcwd(), self.testMethodName)
         self.d = {'EXE': self.testMethodName}
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_with_process_launch_api(self):
         """Test SBValue::GetValueDidChange"""
         self.build(dictionary=self.d)
         self.setTearDownCleanup(dictionary=self.d)
         target = self.dbg.CreateTarget(self.exe)
 
         breakpoint = target.BreakpointCreateBySourceRegex("break here", lldb.SBFileSpec("main.c"))
 

lldb/trunk/test/python_api/watchpoint/TestSetWatchpoint.py

class SetWatchpointAPITestCase(TestBase):
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Our simple source filename.
         self.source = 'main.c'
         # Find the line number to break inside main().
         self.line = line_number(self.source, '// Set break point at this line.')
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
     @expectedFailureWindows("llvm.org/pr24446") # WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows
     def test_watch_val(self):
         """Exercise SBValue.Watch() API to set a watchpoint."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         # Create a target by the debugger.

lldb/trunk/test/python_api/watchpoint/TestWatchpointIgnoreCount.py

class WatchpointIgnoreCountTestCase(TestBase):
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Our simple source filename.
         self.source = 'main.c'
         # Find the line number to break inside main().
         self.line = line_number(self.source, '// Set break point at this line.')
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
     @expectedFailureWindows("llvm.org/pr24446") # WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows
     def test_set_watch_ignore_count(self):
         """Test SBWatchpoint.SetIgnoreCount() API."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         # Create a target by the debugger.

lldb/trunk/test/python_api/watchpoint/TestWatchpointIter.py

class WatchpointIteratorTestCase(TestBase):
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Our simple source filename.
         self.source = 'main.c'
         # Find the line number to break inside main().
         self.line = line_number(self.source, '// Set break point at this line.')
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
     @expectedFailureWindows("llvm.org/pr24446") # WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows
     def test_watch_iter(self):
         """Exercise SBTarget.watchpoint_iter() API to iterate on the available watchpoints."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         # Create a target by the debugger.

lldb/trunk/test/python_api/watchpoint/watchlocation/TestSetWatchlocation.py

def setUp(self):
         TestBase.setUp(self)
         # Our simple source filename.
         self.source = 'main.cpp'
         # Find the line number to break inside main().
         self.line = line_number(self.source, '// Set break point at this line.')
         # This is for verifying that watch location works.
         self.violating_func = "do_bad_thing_with_location";
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
     @expectedFailureWindows("llvm.org/pr24446") # WINDOWS XFAIL TRIAGE - Watchpoints not supported on Windows
     def test_watch_location(self):
         """Exercise SBValue.WatchPointee() API to set a watchpoint."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         # Create a target by the debugger.

lldb/trunk/test/python_api/watchpoint/watchlocation/TestTargetWatchAddress.py

def setUp(self):
         TestBase.setUp(self)
         # Our simple source filename.
         self.source = 'main.cpp'
         # Find the line number to break inside main().
         self.line = line_number(self.source, '// Set break point at this line.')
         # This is for verifying that watch location works.
         self.violating_func = "do_bad_thing_with_location";
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
     @expectedFailureWindows("llvm.org/pr24446")
     def test_watch_address(self):
         """Exercise SBTarget.WatchAddress() API to set a watchpoint."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         # Create a target by the debugger.
def test_watch_address(self):
         self.DebugSBValue(value)
         self.DebugSBValue(pointee)
 
         self.expect(lldbutil.print_stacktrace(thread, string_buffer=True), exe=False,
             substrs = [self.violating_func])
 
         # This finishes our test.
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     @expectedFailureAndroid(archs=['arm', 'aarch64']) # Watchpoints not supported
     @skipIf(archs=['mips', 'mipsel', 'mips64', 'mips64el']) # No size constraint on MIPS for watches
     def test_watch_address_with_invalid_watch_size(self):
         """Exercise SBTarget.WatchAddress() API but pass an invalid watch_size."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
 
         # Create a target by the debugger.

lldb/trunk/test/source-manager/TestSourceManager.py

class SourceManagerTestCase(TestBase):
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break inside main().
         self.line = line_number('main.c', '// Set break point at this line.')
         lldb.skip_build_and_cleanup = False
 
-    @python_api_test
+    @add_test_categories(['pyapi'])
     def test_display_source_python(self):
         """Test display of source using the SBSourceManager API."""
         self.build()
         exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)

lldb/trunk/test/test_categories.py

+"""
+Provides definitions for various lldb test categories
+"""
+
+import sys
+
+all_categories = {
+    'dataformatters': 'Tests related to the type command and the data formatters subsystem',
+    'expression'    : 'Tests related to the expression parser',
+    'objc'          : 'Tests related to the Objective-C programming language support',
+    'pyapi'         : 'Tests related to the Python API',
+    'basic_process' : 'Basic process execution sniff tests.',
+    'cmdline'       : 'Tests related to the LLDB command-line interface',
+    'dyntype'       : 'Tests related to dynamic type support',
+    'stresstest'    : 'Tests related to stressing lldb limits',
+    'flakey'        : 'Flakey test cases, i.e. tests that do not reliably pass at each execution'
+}
+
+def unique_string_match(yourentry, list):
+    candidate = None
+    for item in list:
+        if not item.startswith(yourentry):
+            continue
+        if candidate:
+            return None
+        candidate = item
+    return candidate
+
+def validate(categories, exact_match):
+    """
+    For each category in categories, ensure that it's a valid category (if exact_match is false,
+    unique prefixes are also accepted). If a category is invalid, print a message and quit.
+       If all categories are valid, return the list of categories. Prefixes are expanded in the
+       returned list.
+    """
+    result = []
+    for category in categories:
+        origCategory = category
+        if category not in all_categories and not exact_match:
+            category = unique_string_match(category, all_categories)
+        if (category not in all_categories) or category == None:
+            print("fatal error: category '" + origCategory + "' is not a valid category")
+            print("if you have added a new category, please edit test_categories.py, adding your new category to all_categories")
+            print("else, please specify one or more of the following: " + str(list(all_categories.keys())))
+            sys.exit(1)
+        result.append(category)
+    return result