Deprecate -m/+m dotest options in favor of test categories

[labath]

Summary

This change deprecates -m/+m dotest options (the options are still recognized but they print an
error message pointing to the new options) and adds a new lldb-mi test category instead. To just
run lldb-mi tests, use '-G lldb-mi'. To skip lldb-mi tests, use '--skip-category lldb-mi'. All
lldb-mi tests are marked as such using the getCategories method on the base MiTestCaseBase class
and the @lldbmi_test decorator is not needed. In case one still needs to annotate a specific test
function as an lldb-mi test, one can use the @add_test_categories(['lldb-mi']) decorator to
achieve that.

[ki.stfu]

lgtm

[tberghammer]

Before commit please sync with Ying about updating all android build bot to still skip the MI tests after the change.

[labath]

In D14060#274952, @tberghammer wrote:

Before commit please sync with Ying about updating all android build bot to still skip the MI tests after the change.

I've got it covered. :)

I will commit this tomorrow, to give more people a chance to see what is coming.

[tfiala]

LGTM.

Who currently owns the MI tests (or system) these days? I suppose you are doing this to squelch them from failing on the buildbots. On our end, we see the MI tests fail fairly frequently, typically intermittently.

[labath]

We have XFAILed MI tests that were failing on our linux build bot. Atm, I am seeing expected passes, so I might try enabling them soon...

However, these tests are not remote-ready, so we have to skip them on the android built bots.

[tfiala]

In D14060#275211, @labath wrote:

We have XFAILed MI tests that were failing on our linux build bot. Atm, I am seeing expected passes, so I might try enabling them soon...

I have been seeing them fail intermittently on both OS X and Ubuntu 14.04/15.10. They seem to pass most of the time, but I'd say something like one in 3 or 4 runs, at least one of the MI tests fail.

lldb/trunk/test/dotest.py

 
 #
 # Global variables:
 #
 
 # The test suite.
 suite = unittest2.TestSuite()
 
-# 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
 
 dont_do_dsym_test = False
 dont_do_dwarf_test = False
 dont_do_dwo_test = False
 
 # The blacklist is optional (-b blacklistFile) and allows a central place to skip
if platform.system() == "Darwin":
             compile_lock.release()
             del compile_lock
 
         setCrashInfoHook = setCrashInfoHook_Mac
 
     else:
         pass
 
+def shouldSkipBecauseOfCategories(test_categories):
+    global useCategories, categoriesList, skipCategories
+
+    if useCategories:
+        if len(test_categories) == 0 or len(categoriesList & set(test_categories)) == 0:
+            return True
+
+    for category in skipCategories:
+        if category in test_categories:
+            return True
+
+    return False
+
 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_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
     global categoriesList
     global validCategories
def parseOptionsAndInitTestdirs():
     elif args.N == 'dsym':
         dont_do_dsym_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.m or args.plus_m:
+        print("Options '-m' and '+m' have been deprecated. Please use the test category\n"
+              "functionality (-G lldb-mi, --skip-category lldb-mi) 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
         if not os.path.isfile(blacklistFile):
if args.i:
         ignore = True
 
     if args.k:
         runHooks.extend(args.k)
 
     if args.l:
         skip_long_running_test = False
 
-    if args.m:
-        dont_do_lldbmi_test = True
-
-    if args.plus_m:
-        if dont_do_lldbmi_test:
-            print("Warning: -m and +m can't both be specified! Using only -m")
-        else:
-            just_do_lldbmi_test = True
-
     if args.framework:
         lldbFrameworkPath = args.framework
 
     if args.executable:
         lldbtest_config.lldbExec = args.executable
 
     if args.libcxx:
         os.environ["LIBCXX_PATH"] = args.libcxx
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 '-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:
         is_inferior_test_runner = True
 
     # Turn on output_on_sucess if either explicitly added or -v specified.
     if args.output_on_success or args.v:
sys.path.insert(0, toolsLLDBServerPath)  # Adding test/tools/lldb-server to the path makes it easy
                                              # to "import lldbgdbserverutils" from the lldb-server tests
 
     # This is the root of the lldb git/svn checkout
     lldbRootDirectory = os.path.abspath(os.path.join(scriptPath, os.pardir))
 
     # Some of the tests can invoke the 'lldb' command directly.
     # We'll try to locate the appropriate executable right here.
 
-    lldbMiExec = None
-
     # The lldb executable can be set from the command line
     # if it's not set, we try to find it now
     # first, we try the environment
     if not lldbtest_config.lldbExec:
         # First, you can define an environment variable LLDB_EXEC specifying the
         # full pathname of the lldb executable.
         if "LLDB_EXEC" in os.environ:
             lldbtest_config.lldbExec = os.environ["LLDB_EXEC"]
def setupSysPath():
     os.environ["LLDB_IMPLIB_DIR"] = lldbImpLibDir
     if not noHeaders:
         print("LLDB library dir:", os.environ["LLDB_LIB_DIR"])
         print("LLDB import library dir:", os.environ["LLDB_IMPLIB_DIR"])
         os.system('%s -v' % lldbtest_config.lldbExec)
 
     # Assume lldb-mi is in same place as lldb
     # If not found, disable the lldb-mi tests
-    global dont_do_lldbmi_test
+    lldbMiExec = None
     if lldbtest_config.lldbExec and is_exe(lldbtest_config.lldbExec + "-mi"):
         lldbMiExec = lldbtest_config.lldbExec + "-mi"
     if not lldbMiExec:
-        dont_do_lldbmi_test = True
-        if just_do_lldbmi_test:
+        if not shouldSkipBecauseOfCategories(["lldb-mi"]):
             print("The 'lldb-mi' executable cannot be located.  The lldb-mi tests can not be run as a result.")
-        else:
-            print("The 'lldb-mi' executable cannot be located.  Some of the tests may not be run as a result.")
+            skipCategories.append("lldb-mi")
     else:
         os.environ["LLDBMI_EXEC"] = lldbMiExec
 
     # Skip printing svn/git information when running in parsable (lit-test compatibility) mode
     if not svn_silent and not parsable:
         if os.path.isdir(os.path.join(lldbRootDirectory, '.svn')) and which("svn") is not None:
             pipe = subprocess.Popen([which("svn"), "info", lldbRootDirectory], stdout = subprocess.PIPE)
             svn_info = pipe.stdout.read()
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_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
 
     # Do we need to skip build and cleanup?
for ia in range(len(archs) if iterArchs else 1):
                     elif inspect.ismethod(test) and test.__self__ != None and hasattr(test.__self__,"getCategories"):
                         test_categories = test.__self__.getCategories()
                     else:
                         test_categories = []
                     if test_categories == None:
                         test_categories = []
                     return test_categories
 
-                def shouldSkipBecauseOfCategories(self,test):
-                    global useCategories
-                    import inspect
-                    if useCategories:
-                        global categoriesList
-                        test_categories = self.getCategoriesForTest(test)
-                        if len(test_categories) == 0 or len(categoriesList & set(test_categories)) == 0:
-                            return True
-
-                    global skipCategories
-                    for category in skipCategories:
-                        if category in self.getCategoriesForTest(test):
-                            return True
-
-                    return False
-
                 def hardMarkAsSkipped(self,test):
                     getattr(test, test._testMethodName).__func__.__unittest_skip__ = True
                     getattr(test, test._testMethodName).__func__.__unittest_skip_why__ = "test case does not fall in any category of interest for this run"
                     test.__class__.__unittest_skip__ = True
                     test.__class__.__unittest_skip_why__ = "test case does not fall in any category of interest for this run"
 
                 def startTest(self, test):
-                    if self.shouldSkipBecauseOfCategories(test):
+                    if shouldSkipBecauseOfCategories(self.getCategoriesForTest(test)):
                         self.hardMarkAsSkipped(test)
                     global setCrashInfoHook
                     setCrashInfoHook("%s at %s" % (str(test),inspect.getfile(test.__class__)))
                     self.counter += 1
                     #if self.counter == 4:
                     #    import crashinfo
                     #    crashinfo.testCrashReporterDescription(None)
                     test.test_number = self.counter

lldb/trunk/test/dotest_args.py

def create_parser():
     # 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('+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('-X', metavar='directory', help="Exclude a directory from consideration for test discovery. -X types => if 'types' appear in the pathname components of a potential testfile, it will be ignored")
     group.add_argument('-G', '--category', metavar='category', action='append', dest='categoriesList', help=textwrap.dedent('''Specify categories of test cases of interest. Can be specified more than once.'''))
     group.add_argument('--skip-category', metavar='category', action='append', dest='skipCategories', help=textwrap.dedent('''Specify categories of test cases to skip. Takes precedence over -G. Can be specified more than once.'''))
 
     # Configuration options
     group = parser.add_argument_group('Configuration options')
     group.add_argument('-c', metavar='config-file', help='Read a config file specified after this option')  # FIXME: additional doc.
def create_parser():
     # 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')
+    D('-m')
+    D('+m', dest='plus_m')
     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/lldbtest.py

 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:
-            self.skipTest("lldb-mi tests")
-        return func(self, *args, **kwargs)
-
-    # Mark this function as such to separate them from lldb command line tests.
-    wrapper.__lldbmi_test__ = True
-    return wrapper
-
 def benchmarks_test(func):
     """Decorate the item as a benchmarks test."""
     if isinstance(func, type) and issubclass(func, unittest2.TestCase):
         raise Exception("@benchmarks_test can only be used to decorate a test method")
     @wraps(func)
     def wrapper(self, *args, **kwargs):
         if not lldb.just_do_benchmarks_test:
             self.skipTest("benchmarks tests")
def setUp(self):
             self.libcxxPath = os.environ["LIBCXX_PATH"]
         else:
             self.libcxxPath = None
 
         if "LLDBMI_EXEC" in os.environ:
             self.lldbMiExec = os.environ["LLDBMI_EXEC"]
         else:
             self.lldbMiExec = None
-            self.dont_do_lldbmi_test = True
 
         # If we spawn an lldb process for test (via pexpect), do not load the
         # init file unless told otherwise.
         if "NO_LLDBINIT" in os.environ and "NO" == os.environ["NO_LLDBINIT"]:
             self.lldbOption = ""
         else:
             self.lldbOption = "--no-lldbinit"
 
         # 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
 
-        # 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
-                else:
-                    self.skipTest("non lldb-mi test")
-        except AttributeError:
-            pass
-
         # Benchmarks test is decorated with @benchmarks_test,
         # which also sets the "__benchmarks_test__" attribute of the
         # function object to True.
         try:
             if lldb.just_do_benchmarks_test:
                 testMethod = getattr(self, self._testMethodName)
                 if getattr(testMethod, "__benchmarks_test__", False):
                     pass

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'
+    'flakey'        : 'Flakey test cases, i.e. tests that do not reliably pass at each execution',
+    'lldb-mi'       : 'lldb-mi tests'
 }
 
 def unique_string_match(yourentry, list):
     candidate = None
     for item in list:
         if not item.startswith(yourentry):
             continue
         if candidate:

lldb/trunk/test/tools/lldb-mi/TestMiExit.py

 """
 Test that the lldb-mi driver exits properly.
 """
 
 from __future__ import print_function
 
 import lldb_shared
 
 import lldbmi_testcase
 from lldbtest import *
 
 class MiExitTestCase(lldbmi_testcase.MiTestCaseBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_gdb_exit(self):
         """Test that '-gdb-exit' terminates local debug session and exits."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")
 
         # Run to main
         self.runCmd("-break-insert -f main")
         self.expect("\^done,bkpt={number=\"1\"")
         self.runCmd("-exec-run")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
         # Test -gdb-exit: try to exit and check that program is finished
         self.runCmd("-gdb-exit")
         self.expect("\^exit")
         import pexpect
         self.expect(pexpect.EOF)
 
-    @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_quit(self):
         """Test that 'quit' exits immediately."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")
 
         # Run to main
         self.runCmd("-break-insert -f main")
         self.expect("\^done,bkpt={number=\"1\"")
         self.runCmd("-exec-run")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
         # Test quit: try to exit and check that program is finished
         self.runCmd("quit")
         import pexpect
         self.expect(pexpect.EOF)
 
-    @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_q(self):
         """Test that 'q' exits immediately."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable

lldb/trunk/test/tools/lldb-mi/TestMiFile.py

 """
 Test lldb-mi -file-xxx commands.
 """
 
 from __future__ import print_function
 
 import lldb_shared
 
 import lldbmi_testcase
 from lldbtest import *
 
 class MiFileTestCase(lldbmi_testcase.MiTestCaseBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_file_exec_and_symbols_file(self):
         """Test that 'lldb-mi --interpreter' works for -file-exec-and-symbols exe."""
 
         self.spawnLldbMi(args = None)
 
         # Test that -file-exec-and-symbols works for filename
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")
 
         # Run
         self.runCmd("-exec-run")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"exited-normally\"")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_file_exec_and_symbols_absolute_path(self):
         """Test that 'lldb-mi --interpreter' works for -file-exec-and-symbols fullpath/exe."""
 
         self.spawnLldbMi(args = None)
 
         # Test that -file-exec-and-symbols works for absolute path
         import os
         path = os.path.join(os.getcwd(), self.myexe)
         self.runCmd("-file-exec-and-symbols \"%s\"" % path)
         self.expect("\^done")
 
         # Run
         self.runCmd("-exec-run")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"exited-normally\"")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_file_exec_and_symbols_relative_path(self):
         """Test that 'lldb-mi --interpreter' works for -file-exec-and-symbols relpath/exe."""
 
         self.spawnLldbMi(args = None)
 
         # Test that -file-exec-and-symbols works for relative path
         path = "./%s" % self.myexe
         self.runCmd("-file-exec-and-symbols %s" % path)
         self.expect("\^done")
 
         # Run
         self.runCmd("-exec-run")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"exited-normally\"")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_file_exec_and_symbols_unknown_path(self):
         """Test that 'lldb-mi --interpreter' works for -file-exec-and-symbols badpath/exe."""
 
         self.spawnLldbMi(args = None)
 
         # Test that -file-exec-and-symbols fails on unknown path
         path = "unknown_dir/%s" % self.myexe
         self.runCmd("-file-exec-and-symbols %s" % path)
         self.expect("\^error")

lldb/trunk/test/tools/lldb-mi/TestMiGdbSetShow.py

 """
 Test lldb-mi -gdb-set and -gdb-show commands.
 """
 
 from __future__ import print_function
 
 import lldb_shared
 
 import unittest2
 import lldbmi_testcase
 from lldbtest import *
 
 class MiGdbSetShowTestCase(lldbmi_testcase.MiTestCaseBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_gdb_set_target_async_default(self):
         """Test that 'lldb-mi --interpreter' switches to async mode by default."""
 
         self.spawnLldbMi(args = None)
 
         # Switch to sync mode
         self.runCmd("-gdb-set target-async off")
         self.expect("\^done")
         self.runCmd("-gdb-show target-async")
         self.expect("\^done,value=\"off\"")
 
         # Test that -gdb-set switches to async by default
         self.runCmd("-gdb-set target-async")
         self.expect("\^done")
         self.runCmd("-gdb-show target-async")
         self.expect("\^done,value=\"on\"")
 
-    @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_gdb_set_target_async_on(self):
         """Test that 'lldb-mi --interpreter' can execute commands in async mode."""
 
         self.spawnLldbMi(args = None)
 
         # Switch to sync mode
def test_lldbmi_gdb_set_target_async_on(self):
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")
 
         # Test that program is executed in async mode
         self.runCmd("-exec-run")
         self.expect("\*running")
         self.expect("@\"argc=1")
 
-    @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @expectedFailureLinux # Failing in ~11/600 dosep runs (build 3120-3122)
     def test_lldbmi_gdb_set_target_async_off(self):
         """Test that 'lldb-mi --interpreter' can execute commands in sync mode."""
 
         self.spawnLldbMi(args = None)
 
def test_lldbmi_gdb_set_target_async_off(self):
 
         # Test that program is executed in async mode
         self.runCmd("-exec-run")
         unexpected = [ "\*running" ] # "\*running" is async notification
         it = self.expect(unexpected + [ "@\"argc=1\\\\r\\\\n" ])
         if it < len(unexpected):
             self.fail("unexpected found: %s" % unexpected[it])
 
-    @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_gdb_show_target_async(self):
         """Test that 'lldb-mi --interpreter' in async mode by default."""
 
         self.spawnLldbMi(args = None)
 
         # Test that default target-async value is "on"
         self.runCmd("-gdb-show target-async")
         self.expect("\^done,value=\"on\"")
 
-    @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_gdb_show_language(self):
         """Test that 'lldb-mi --interpreter' can get current language."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")
 
         # Run to main
         self.runCmd("-break-insert -f main")
         self.expect("\^done,bkpt={number=\"1\"")
         self.runCmd("-exec-run")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
         # Test that -gdb-show language gets current language
         self.runCmd("-gdb-show language")
         self.expect("\^done,value=\"c\+\+\"")
 
-    @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @unittest2.expectedFailure("-gdb-set ignores unknown properties")
     def test_lldbmi_gdb_set_unknown(self):
         """Test that 'lldb-mi --interpreter' fails when setting an unknown property."""
 
         self.spawnLldbMi(args = None)
 
         # Test that -gdb-set fails if property is unknown
         self.runCmd("-gdb-set unknown some_value")
         self.expect("\^error")
 
-    @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @unittest2.expectedFailure("-gdb-show ignores unknown properties")
     def test_lldbmi_gdb_show_unknown(self):
         """Test that 'lldb-mi --interpreter' fails when showing an unknown property."""
 
         self.spawnLldbMi(args = None)
 
         # Test that -gdb-show fails if property is unknown
         self.runCmd("-gdb-show unknown")
         self.expect("\^error")
 
 
-    @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfLinux # llvm.org/pr22841: lldb-mi tests fail on all Linux buildbots
     def test_lldbmi_gdb_set_ouptut_radix(self):
         """Test that 'lldb-mi --interpreter' works for -gdb-set output-radix."""
 
         self.spawnLldbMi(args = None)
 

lldb/trunk/test/tools/lldb-mi/TestMiLibraryLoaded.py

 """
 Test lldb-mi =library-loaded notifications.
 """
 
 from __future__ import print_function
 
 import lldb_shared
 
 import lldbmi_testcase
 from lldbtest import *
 
 class MiLibraryLoadedTestCase(lldbmi_testcase.MiTestCaseBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_library_loaded(self):
         """Test that 'lldb-mi --interpreter' shows the =library-loaded notifications."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable

lldb/trunk/test/tools/lldb-mi/TestMiPrompt.py

 """
 Test that the lldb-mi driver prints prompt properly.
 """
 
 from __future__ import print_function
 
 import lldb_shared
 
 import lldbmi_testcase
 from lldbtest import *
 
 class MiPromptTestCase(lldbmi_testcase.MiTestCaseBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_prompt(self):
         """Test that 'lldb-mi --interpreter' echos '(gdb)' after commands and events."""
 
         self.spawnLldbMi(args = None)
 
         # Test that lldb-mi is ready after unknown command

lldb/trunk/test/tools/lldb-mi/breakpoint/TestMiBreak.py

 """
 Test lldb-mi -break-xxx commands.
 """
 
 from __future__ import print_function
 
 import lldb_shared
 
 import unittest2
 import lldbmi_testcase
 from lldbtest import *
 
 class MiBreakTestCase(lldbmi_testcase.MiTestCaseBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @expectedFailureAll("llvm.org/pr24717", oslist=["linux"])
     def test_lldbmi_break_insert_function_pending(self):
         """Test that 'lldb-mi --interpreter' works for pending function breakpoints."""
 
         self.spawnLldbMi(args = None)
 
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")
 
         self.runCmd("-break-insert -f printf")
         #FIXME function name is unknown on Darwin, fullname should be ??, line is -1
         #self.expect("\^done,bkpt={number=\"1\",type=\"breakpoint\",disp=\"keep\",enabled=\"y\",addr=\"0xffffffffffffffff\",func=\"printf\",file=\"\?\?\",fullname=\"\?\?\",line=\"-1\",pending=\[\"printf\"\],times=\"0\",original-location=\"printf\"}")
         self.expect("\^done,bkpt={number=\"1\",type=\"breakpoint\",disp=\"keep\",enabled=\"y\",addr=\"0xffffffffffffffff\",func=\"\?\?\",file=\"\?\?\",fullname=\"\?\?/\?\?\",line=\"0\",pending=\[\"printf\"\],times=\"0\",original-location=\"printf\"}")
         #FIXME function name is unknown on Darwin, fullname should be ??, line -1
         #self.expect("=breakpoint-modified,bkpt={number=\"1\",type=\"breakpoint\",disp=\"keep\",enabled=\"y\",addr=\"0xffffffffffffffff\",func=\"printf\",file=\"\?\?\",fullname=\"\?\?\",line=\"-1\",pending=\[\"printf\"\],times=\"0\",original-location=\"printf\"}")
         self.expect("=breakpoint-modified,bkpt={number=\"1\",type=\"breakpoint\",disp=\"keep\",enabled=\"y\",addr=\"0xffffffffffffffff\",func=\"\?\?\",file=\"\?\?\",fullname=\"\?\?/\?\?\",line=\"0\",pending=\[\"printf\"\],times=\"0\",original-location=\"printf\"}")
 
         self.runCmd("-exec-run")
         self.expect("\^running")
         self.expect("=breakpoint-modified,bkpt={number=\"1\",type=\"breakpoint\",disp=\"keep\",enabled=\"y\",addr=\"(?!0xffffffffffffffff)0x[0-9a-f]+\",func=\".+?\",file=\".+?\",fullname=\".+?\",line=\"(-1|\d+)\",pending=\[\"printf\"\],times=\"0\",original-location=\"printf\"}")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_break_insert_function(self):
         """Test that 'lldb-mi --interpreter' works for function breakpoints."""
 
         self.spawnLldbMi(args = None)
 
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
def test_lldbmi_break_insert_function(self):
 
         #FIXME: this test is disabled due to lldb bug llvm.org/pr24271.
         # Test that we can set a BP using the global namespace token
         #self.runCmd("-break-insert ::main")
         #self.expect("\^done,bkpt={number=\"7\"")
         #self.runCmd("-break-insert main.cpp:::main")
         #self.expect("\^done,bkpt={number=\"8\"")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_break_insert_file_line_pending(self):
         """Test that 'lldb-mi --interpreter' works for pending file:line breakpoints."""
 
         self.spawnLldbMi(args = None)
 
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")
 
         # Find the line number to break inside main() and set
         # pending BP
         line = line_number('main.cpp', '// BP_return')
         self.runCmd("-break-insert -f main.cpp:%d" % line)
         self.expect("\^done,bkpt={number=\"1\",type=\"breakpoint\",disp=\"keep\",enabled=\"y\",addr=\"(?!0xffffffffffffffff)0x[0-9a-f]+\",func=\"main\",file=\"main\.cpp\",fullname=\".+?main\.cpp\",line=\"%d\",pending=\[\"main.cpp:%d\"\],times=\"0\",original-location=\"main.cpp:%d\"}" % (line, line, line))
         self.expect("=breakpoint-modified,bkpt={number=\"1\",type=\"breakpoint\",disp=\"keep\",enabled=\"y\",addr=\"(?!0xffffffffffffffff)0x[0-9a-f]+\",func=\"main\",file=\"main\.cpp\",fullname=\".+?main\.cpp\",line=\"%d\",pending=\[\"main.cpp:%d\"\],times=\"0\",original-location=\"main.cpp:%d\"}" % (line, line, line))
 
         self.runCmd("-exec-run")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_break_insert_file_line(self):
         """Test that 'lldb-mi --interpreter' works for file:line breakpoints."""
 
         self.spawnLldbMi(args = None)
 
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
def test_lldbmi_break_insert_file_line(self):
         self.runCmd("-break-insert unknown_file:1")
         self.expect("\^error,msg=\"Command 'break-insert'. Breakpoint location 'unknown_file:1' not found\"")
 
         # Test that non-pending BP was set correctly
         self.runCmd("-exec-continue")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @unittest2.expectedFailure("-break-insert doesn't work for absolute path")
     def test_lldbmi_break_insert_file_line_absolute_path(self):
         """Test that 'lldb-mi --interpreter' works for file:line breakpoints."""
 
         self.spawnLldbMi(args = None)
 
def test_lldbmi_break_insert_file_line_absolute_path(self):
         line = line_number('main.cpp', '// BP_return')
         self.runCmd("-break-insert %s:%d" % (path, line))
         self.expect("\^done,bkpt={number=\"2\"")
 
         self.runCmd("-exec-continue")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_break_insert_settings(self):
         """Test that 'lldb-mi --interpreter' can set breakpoints accoridng to global options."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable

lldb/trunk/test/tools/lldb-mi/control/TestMiExec.py

 """
 Test lldb-mi -exec-xxx commands.
 """
 
 from __future__ import print_function
 
 import lldb_shared
 
 import lldbmi_testcase
 from lldbtest import *
 
 class MiExecTestCase(lldbmi_testcase.MiTestCaseBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @expectedFailureLinux # llvm.org/pr25000: lldb-mi does not receive broadcasted notification from Core/Process about process stopped
     def test_lldbmi_exec_run(self):
         """Test that 'lldb-mi --interpreter' can stop at entry."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")
 
         # Test that program is stopped at entry
         self.runCmd("-exec-run --start")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"signal-received\",signal-name=\"SIGSTOP\",signal-meaning=\"Stop\",.*?thread-id=\"1\",stopped-threads=\"all\"")
         # Test that lldb-mi is ready to execute next commands
         self.expect(self.child_prompt, exactly = True)
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @expectedFailureAll("llvm.org/pr23139", oslist=["linux"], compiler="gcc", compiler_version=[">=","4.9"], archs=["i386"])
     def test_lldbmi_exec_abort(self):
         """Test that 'lldb-mi --interpreter' works for -exec-abort."""
 
         self.spawnLldbMi(args = None)
 
def test_lldbmi_exec_abort(self):
         self.runCmd("-data-evaluate-expression argc")
         self.expect("\^done,value=\"2\"")
 
         # Test that program may be aborted again
         self.runCmd("-exec-abort")
         self.expect("\^done")
         self.expect("\*stopped,reason=\"exited-normally\"")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @expectedFailureAll("llvm.org/pr23139", oslist=["linux"], compiler="gcc", compiler_version=[">=","4.9"], archs=["i386"])
     def test_lldbmi_exec_arguments_set(self):
         """Test that 'lldb-mi --interpreter' can pass args using -exec-arguments."""
 
         self.spawnLldbMi(args = None)
 
def test_lldbmi_exec_arguments_set(self):
         #self.expect("\^done,value=\"third_arg\"")
         self.runCmd("-interpreter-exec command \"print argv[3]\"")
         self.expect("\"third_arg\"")
         #self.runCmd("-data-evaluate-expression argv[4]")
         #self.expect("\^done,value=\"fourth=\\\\\\\"4th arg\\\\\\\"\"")
         self.runCmd("-interpreter-exec command \"print argv[4]\"")
         self.expect("\"fourth=\\\\\\\"4th arg\\\\\\\"\"")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @expectedFailureAll("llvm.org/pr23139", oslist=["linux"], compiler="gcc", compiler_version=[">=","4.9"], archs=["i386"])
     def test_lldbmi_exec_arguments_reset(self):
         """Test that 'lldb-mi --interpreter' can reset previously set args using -exec-arguments."""
 
         self.spawnLldbMi(args = None)
 
def test_lldbmi_exec_arguments_reset(self):
         self.runCmd("-exec-run")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
         # Check argc to see if arg passed
         self.runCmd("-data-evaluate-expression argc")
         self.expect("\^done,value=\"1\"")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_exec_next(self):
         """Test that 'lldb-mi --interpreter' works for stepping."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
def test_lldbmi_exec_next(self):
         self.runCmd("-exec-next --thread 10")
         self.expect("\^error,message=\"error: Thread index 10 is out of range")
 
         # Test that an invalid --frame is handled
         # FIXME: no error is returned
         self.runCmd("-exec-next --frame 10")
         #self.expect("\^error: Frame index 10 is out of range")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @expectedFailurei386 #xfail to get buildbot green, failing config: i386 binary running on ubuntu 14.04 x86_64
     @expectedFailureAll("llvm.org/pr23139", oslist=["linux"], compiler="gcc", compiler_version=[">=","4.9"], archs=["i386"])
     def test_lldbmi_exec_next_instruction(self):
         """Test that 'lldb-mi --interpreter' works for instruction stepping."""
 
         self.spawnLldbMi(args = None)
def test_lldbmi_exec_next_instruction(self):
         self.runCmd("-exec-next-instruction --thread 10")
         self.expect("\^error,message=\"error: Thread index 10 is out of range")
 
         # Test that an invalid --frame is handled
         # FIXME: no error is returned
         self.runCmd("-exec-next-instruction --frame 10")
         #self.expect("\^error: Frame index 10 is out of range")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_exec_step(self):
         """Test that 'lldb-mi --interpreter' works for stepping into."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
def test_lldbmi_exec_step(self):
         self.runCmd("-exec-step --thread 10")
         self.expect("\^error,message=\"error: Thread index 10 is out of range")
 
         # Test that an invalid --frame is handled
         # FIXME: no error is returned
         self.runCmd("-exec-step --frame 10")
         #self.expect("\^error: Frame index 10 is out of range")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_exec_step_instruction(self):
         """Test that 'lldb-mi --interpreter' works for instruction stepping into."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
def test_lldbmi_exec_step_instruction(self):
         self.runCmd("-exec-step-instruction --thread 10")
         self.expect("\^error,message=\"error: Thread index 10 is out of range")
 
         # Test that an invalid --frame is handled
         # FIXME: no error is returned
         self.runCmd("-exec-step-instruction --frame 10")
         #self.expect("\^error: Frame index 10 is out of range")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @expectedFailureAll("llvm.org/pr23139", oslist=["linux"], compiler="gcc", compiler_version=[">=","4.9"], archs=["i386"])
     def test_lldbmi_exec_finish(self):
         """Test that 'lldb-mi --interpreter' works for -exec-finish."""
 
         self.spawnLldbMi(args = None)
 

lldb/trunk/test/tools/lldb-mi/data/TestMiData.py

 """
 Test lldb-mi -data-xxx commands.
 """
 
 from __future__ import print_function
 
 import lldb_shared
 
 import unittest2
 import lldbmi_testcase
 from lldbtest import *
 
 class MiDataTestCase(lldbmi_testcase.MiTestCaseBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_data_disassemble(self):
         """Test that 'lldb-mi --interpreter' works for -data-disassemble."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
def test_lldbmi_data_disassemble(self):
         # This matches a line similar to:
         # Darwin: {address="0x0000000100000f18",func-name="hello_world()",offset="8",size="7",inst="leaq 0x65(%rip), %rdi; \"Hello, World!\\n\""},
         # Linux:  {address="0x0000000000400642",func-name="hello_world()",offset="18",size="5",inst="callq 0x4004d0; symbol stub for: printf"}
         # To match the escaped characters in the ouptut, we must use four backslashes per matches backslash
         # See https://docs.python.org/2/howto/regex.html#the-backslash-plague
         self.expect([ "{address=\"0x[0-9a-f]+\",func-name=\"hello_world\(\)\",offset=\"[0-9]+\",size=\"[0-9]+\",inst=\".+?; \\\\\"Hello, World!\\\\\\\\n\\\\\"\"}",
                       "{address=\"0x[0-9a-f]+\",func-name=\"hello_world\(\)\",offset=\"[0-9]+\",size=\"[0-9]+\",inst=\".+?; symbol stub for: printf\"}" ])
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @unittest2.skip("-data-evaluate-expression doesn't work on globals") #FIXME: the global case worked before refactoring
     def test_lldbmi_data_read_memory_bytes_global(self):
         """Test that -data-read-memory-bytes can access global buffers."""
 
         self.spawnLldbMi(args = None)
 
def test_lldbmi_data_read_memory_bytes_global(self):
         self.expect("\^done,value=\"0x[0-9a-f]+\"")
         addr = int(self.child.after.split("\"")[1], 16)
         size = 5
 
         # Test that -data-read-memory-bytes works for static char[] type
         self.runCmd("-data-read-memory-bytes %#x %d" % (addr, size))
         self.expect("\^done,memory=\[{begin=\"0x0*%x\",offset=\"0x0+\",end=\"0x0*%x\",contents=\"1112131400\"}\]" % (addr, addr + size))
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_data_read_memory_bytes_local(self):
         """Test that -data-read-memory-bytes can access local buffers."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
def test_lldbmi_data_read_memory_bytes_local(self):
 
         self.runCmd('-data-read-memory-bytes --thread 1 --frame 0')
         self.expect(r'\^error')
 
         # Test that the count argument is required when other options are present
         self.runCmd('-data-read-memory-bytes --thread 1 &array')
         self.expect(r'\^error')
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_data_list_register_names(self):
         """Test that 'lldb-mi --interpreter' works for -data-list-register-names."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
def test_lldbmi_data_list_register_names(self):
         # Test -data-list-register-names: try to get all registers
         self.runCmd("-data-list-register-names")
         self.expect("\^done,register-names=\[\".+?\",")
 
         # Test -data-list-register-names: try to get specified registers
         self.runCmd("-data-list-register-names 0")
         self.expect("\^done,register-names=\[\".+?\"\]")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_data_list_register_values(self):
         """Test that 'lldb-mi --interpreter' works for -data-list-register-values."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
def test_lldbmi_data_list_register_values(self):
         # Test -data-list-register-values: try to get all registers
         self.runCmd("-data-list-register-values x")
         self.expect("\^done,register-values=\[{number=\"0\",value=\"0x[0-9a-f]+\"")
 
         # Test -data-list-register-values: try to get specified registers
         self.runCmd("-data-list-register-values x 0")
         self.expect("\^done,register-values=\[{number=\"0\",value=\"0x[0-9a-f]+\"}\]")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_data_info_line(self):
         """Test that 'lldb-mi --interpreter' works for -data-info-line."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
def test_lldbmi_data_info_line(self):
         self.expect("\^error,msg=\"Command 'data-info-line'\. Error: The LineEntry is absent or has an unknown format\.\"")
 
         # Test that -data-info-line fails when line has invalid format
         self.runCmd("-data-info-line main.cpp:bad_line")
         self.expect("\^error,msg=\"error: invalid line number string 'bad_line'")
         self.runCmd("-data-info-line main.cpp:0")
         self.expect("\^error,msg=\"error: zero is an invalid line number")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_data_evaluate_expression(self):
         """Test that 'lldb-mi --interpreter' works for -data-evaluate-expression."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable

lldb/trunk/test/tools/lldb-mi/interpreter/TestMiCliSupport.py

 """
 Test lldb-mi can interpret CLI commands directly.
 """
 
 from __future__ import print_function
 
 import lldb_shared
 
 import lldbmi_testcase
 from lldbtest import *
 
 class MiCliSupportTestCase(lldbmi_testcase.MiTestCaseBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_target_create(self):
         """Test that 'lldb-mi --interpreter' can create target by 'target create' command."""
 
         self.spawnLldbMi(args = None)
 
         # Test that "target create" loads executable
         self.runCmd("target create \"%s\"" % self.myexe)
         self.expect("\^done")
 
         # Test that executable was loaded properly
         self.runCmd("-break-insert -f main")
         self.expect("\^done,bkpt={number=\"1\"")
         self.runCmd("-exec-run")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfLinux # llvm.org/pr22841: lldb-mi tests fail on all Linux buildbots
     def test_lldbmi_breakpoint_set(self):
         """Test that 'lldb-mi --interpreter' can set breakpoint by 'breakpoint set' command."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")
 
         # Test that "breakpoint set" sets a breakpoint
         self.runCmd("breakpoint set --name main")
         self.expect("\^done")
         self.expect("=breakpoint-created,bkpt={number=\"1\"")
 
         # Test that breakpoint was set properly
         self.runCmd("-exec-run")
         self.expect("\^running")
         self.expect("=breakpoint-modified,bkpt={number=\"1\"")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfLinux # llvm.org/pr22841: lldb-mi tests fail on all Linux buildbots
     def test_lldbmi_settings_set_target_run_args_before(self):
         """Test that 'lldb-mi --interpreter' can set target arguments by 'setting set target.run-args' command before than target was created."""
 
         self.spawnLldbMi(args = None)
 
         # Test that "settings set target.run-args" passes arguments to executable
         #FIXME: --arg1 causes an error
         self.runCmd("setting set target.run-args arg1 \"2nd arg\" third_arg fourth=\"4th arg\"")
         self.expect("\^done")
 
         # Load executable
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")
 
         # Run
         self.runCmd("-exec-run")
         self.expect("\^running")
 
         # Test that arguments were passed properly
         self.expect("@\"argc=5\\\\r\\\\n\"")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfLinux # llvm.org/pr22841: lldb-mi tests fail on all Linux buildbots
     def test_lldbmi_settings_set_target_run_args_after(self):
         """Test that 'lldb-mi --interpreter' can set target arguments by 'setting set target.run-args' command after than target was created."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")
 
         # Test that "settings set target.run-args" passes arguments to executable
         #FIXME: --arg1 causes an error
         self.runCmd("setting set target.run-args arg1 \"2nd arg\" third_arg fourth=\"4th arg\"")
         self.expect("\^done")
 
         # Run
         self.runCmd("-exec-run")
         self.expect("\^running")
 
         # Test that arguments were passed properly
         self.expect("@\"argc=5\\\\r\\\\n\"")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfLinux # llvm.org/pr22841: lldb-mi tests fail on all Linux buildbots
     def test_lldbmi_process_launch(self):
         """Test that 'lldb-mi --interpreter' can launch process by "process launch" command."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")
 
         # Set breakpoint
         self.runCmd("-break-insert -f main")
         self.expect("\^done,bkpt={number=\"1\"")
 
         # Test that "process launch" launches executable
         self.runCmd("process launch")
         self.expect("\^done")
 
         # Test that breakpoint hit
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfLinux # llvm.org/pr22841: lldb-mi tests fail on all Linux buildbots
     def test_lldbmi_thread_step_in(self):
         """Test that 'lldb-mi --interpreter' can step in by "thread step-in" command."""
 
         self.spawnLldbMi(args = None)
 
def test_lldbmi_thread_step_in(self):
         # Linux:  "*stopped,reason=\"end-stepping-range\",frame={addr="0x[0-9a-f]+\",func=\"__printf\",args=[{name=\"format\",value=\"0x[0-9a-f]+\"}],file=\"printf.c\",fullname=\".+printf.c\",line="\d+"},thread-id=\"1\",stopped-threads=\"all\"
         self.runCmd("thread step-in")
         self.expect("\^done")
         it = self.expect([ "@\"argc=1\\\\r\\\\n\"",
                            "\*stopped,reason=\"end-stepping-range\".+?func=\"(?!main).+?\"" ])
         if it == 0:
             self.expect("\*stopped,reason=\"end-stepping-range\".+?func=\"main\"")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfLinux # llvm.org/pr22841: lldb-mi tests fail on all Linux buildbots
     def test_lldbmi_thread_step_over(self):
         """Test that 'lldb-mi --interpreter' can step over by "thread step-over" command."""
 
         self.spawnLldbMi(args = None)
 
def test_lldbmi_thread_step_over(self):
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
         # Test that "thread step-over" steps over
         self.runCmd("thread step-over")
         self.expect("\^done")
         self.expect("@\"argc=1\\\\r\\\\n\"")
         self.expect("\*stopped,reason=\"end-stepping-range\"")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfLinux # llvm.org/pr22841: lldb-mi tests fail on all Linux buildbots
     def test_lldbmi_thread_continue(self):
         """Test that 'lldb-mi --interpreter' can continue execution by "thread continue" command."""
 
         self.spawnLldbMi(args = None)
 

lldb/trunk/test/tools/lldb-mi/interpreter/TestMiInterpreterExec.py

 """
 Test lldb-mi -interpreter-exec command.
 """
 
 from __future__ import print_function
 
 import lldb_shared
 
 import lldbmi_testcase
 from lldbtest import *
 
 class MiInterpreterExecTestCase(lldbmi_testcase.MiTestCaseBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_target_create(self):
         """Test that 'lldb-mi --interpreter' can create target by 'target create' command."""
 
         self.spawnLldbMi(args = None)
 
         # Test that "target create" loads executable
         self.runCmd("-interpreter-exec console \"target create \\\"%s\\\"\"" % self.myexe)
         self.expect("\^done")
 
         # Test that executable was loaded properly
         self.runCmd("-break-insert -f main")
         self.expect("\^done,bkpt={number=\"1\"")
         self.runCmd("-exec-run")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_breakpoint_set(self):
         """Test that 'lldb-mi --interpreter' can set breakpoint by 'breakpoint set' command."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")
 
         # Test that "breakpoint set" sets a breakpoint
         self.runCmd("-interpreter-exec console \"breakpoint set --name main\"")
         self.expect("\^done")
         self.expect("=breakpoint-created,bkpt={number=\"1\"")
 
         # Test that breakpoint was set properly
         self.runCmd("-exec-run")
         self.expect("\^running")
         self.expect("=breakpoint-modified,bkpt={number=\"1\"")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @expectedFailureLinux  # Failing in ~9/600 dosep runs (build 3120-3122)
     def test_lldbmi_settings_set_target_run_args_before(self):
         """Test that 'lldb-mi --interpreter' can set target arguments by 'setting set target.run-args' command before than target was created."""
 
         self.spawnLldbMi(args = None)
 
def test_lldbmi_settings_set_target_run_args_before(self):
         self.expect("@\"argv.1.=arg1\\\\r\\\\n\"")
         self.expect("@\"argv.2.=2nd arg\\\\r\\\\n\"")
         self.expect("@\"argv.3.=third_arg\\\\r\\\\n\"")
         self.expect("@\"argv.4.=fourth=4th arg\\\\r\\\\n\"")
 
         # Test that program exited normally
         self.expect("\*stopped,reason=\"exited-normally\"")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @expectedFailureLinux  # Failing in ~9/600 dosep runs (build 3120-3122)
     def test_lldbmi_settings_set_target_run_args_after(self):
         """Test that 'lldb-mi --interpreter' can set target arguments by 'setting set target.run-args' command after than target was created."""
 
         self.spawnLldbMi(args = None)
 
def test_lldbmi_settings_set_target_run_args_after(self):
         self.expect("@\"argv.1.=arg1\\\\r\\\\n\"")
         self.expect("@\"argv.2.=2nd arg\\\\r\\\\n\"")
         self.expect("@\"argv.3.=third_arg\\\\r\\\\n\"")
         self.expect("@\"argv.4.=fourth=4th arg\\\\r\\\\n\"")
 
         # Hit BP_return
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_process_launch(self):
         """Test that 'lldb-mi --interpreter' can launch process by "process launch" command."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")
 
         # Set breakpoint
         self.runCmd("-break-insert -f main")
         self.expect("\^done,bkpt={number=\"1\"")
 
         # Test that "process launch" launches executable
         self.runCmd("-interpreter-exec console \"process launch\"")
         self.expect("\^done")
 
         # Test that breakpoint hit
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_thread_step_in(self):
         """Test that 'lldb-mi --interpreter' can step in by "thread step-in" command."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
def test_lldbmi_thread_step_in(self):
         # Linux:  "*stopped,reason=\"end-stepping-range\",frame={addr="0x[0-9a-f]+\",func=\"__printf\",args=[{name=\"format\",value=\"0x[0-9a-f]+\"}],file=\"printf.c\",fullname=\".+printf.c\",line="\d+"},thread-id=\"1\",stopped-threads=\"all\"
         self.runCmd("-interpreter-exec console \"thread step-in\"")
         self.expect("\^done")
         it = self.expect([ "@\"argc=1\\\\r\\\\n\"",
                            "\*stopped,reason=\"end-stepping-range\".+?func=\"(?!main).+?\"" ])
         if it == 0:
             self.expect("\*stopped,reason=\"end-stepping-range\".+?func=\"main\"")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_thread_step_over(self):
         """Test that 'lldb-mi --interpreter' can step over by "thread step-over" command."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")
 
         # Run to main
         self.runCmd("-break-insert -f main")
         self.expect("\^done,bkpt={number=\"1\"")
         self.runCmd("-exec-run")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
         # Test that "thread step-over" steps over
         self.runCmd("-interpreter-exec console \"thread step-over\"")
         self.expect("\^done")
         self.expect("@\"argc=1\\\\r\\\\n\"")
         self.expect("\*stopped,reason=\"end-stepping-range\"")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_thread_continue(self):
         """Test that 'lldb-mi --interpreter' can continue execution by "thread continue" command."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable

lldb/trunk/test/tools/lldb-mi/lldbmi_testcase.py

 """
 Base class for lldb-mi test cases.
 """
 
 from __future__ import print_function
 
 import lldb_shared
 
 from lldbtest import *
 
 class MiTestCaseBase(Base):
 
     mydir = None
     myexe = "a.out"
     mylog = "child.log"
 
+    def getCategories(self):
+        return ['lldb-mi']
+
     @classmethod
     def classCleanup(cls):
         TestBase.RemoveTempFile(cls.myexe)
         TestBase.RemoveTempFile(cls.mylog)
 
     def setUp(self):
         Base.setUp(self)
         self.buildDefault()

lldb/trunk/test/tools/lldb-mi/signal/TestMiSignal.py

 """
 Test that the lldb-mi handles signals properly.
 """
 
 from __future__ import print_function
 
 import lldb_shared
 
 import lldbmi_testcase
 from lldbtest import *
 
 class MiSignalTestCase(lldbmi_testcase.MiTestCaseBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Fails on FreeBSD apparently due to thread race conditions
     def test_lldbmi_stopped_when_interrupt(self):
         """Test that 'lldb-mi --interpreter' interrupt and resume a looping app."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
def test_lldbmi_stopped_when_interrupt(self):
         # Continue (to loop forever)
         self.runCmd("-exec-continue")
         self.expect("\^running")
 
         # Test that Ctrl+C can interrupt an execution
         self.child.sendintr() #FIXME: here uses self.child directly
         self.expect("\*stopped,reason=\"signal-received\",signal-name=\"SIGINT\",signal-meaning=\"Interrupt\",.*thread-id=\"1\",stopped-threads=\"all\"")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Fails on FreeBSD apparently due to thread race conditions
     @skipIfLinux # llvm.org/pr22841: lldb-mi tests fail on all Linux buildbots
     def test_lldbmi_stopped_when_stopatentry_local(self):
         """Test that 'lldb-mi --interpreter' notifies after it was stopped on entry (local)."""
 
         self.spawnLldbMi(args = None)
 
def test_lldbmi_stopped_when_stopatentry_local(self):
 
         # Run to main to make sure we have not exited the application
         self.runCmd("-break-insert -f main")
         self.expect("\^done,bkpt={number=\"1\"")
         self.runCmd("-exec-continue")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipUnlessDarwin
     def test_lldbmi_stopped_when_stopatentry_remote(self):
         """Test that 'lldb-mi --interpreter' notifies after it was stopped on entry (remote)."""
 
         # Prepare debugserver
         import lldbgdbserverutils
         debugserver_exe = lldbgdbserverutils.get_debugserver_exe()
def test_lldbmi_stopped_when_stopatentry_remote(self):
 
         # Test that *stopped is printed
         self.expect("\*stopped,reason=\"signal-received\",signal-name=\"SIGSTOP\",signal-meaning=\"Stop\",.+?thread-id=\"1\",stopped-threads=\"all\"")
 
         # Exit
         self.runCmd("-gdb-exit")
         self.expect("\^exit")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfLinux # llvm.org/pr22841: lldb-mi tests fail on all Linux buildbots
     def test_lldbmi_stopped_when_segfault_local(self):
         """Test that 'lldb-mi --interpreter' notifies after it was stopped when segfault occurred (local)."""
 
         self.spawnLldbMi(args = None)
 
def test_lldbmi_stopped_when_segfault_local(self):
 
         # Test that *stopped is printed
         # Note that message is different in Darwin and Linux:
         # Darwin: "*stopped,reason=\"exception-received\",exception=\"EXC_BAD_ACCESS (code=1, address=0x0)\",thread-id=\"1\",stopped-threads=\"all\""
         # Linux:  "*stopped,reason=\"exception-received\",exception=\"invalid address (fault address: 0x0)\",thread-id=\"1\",stopped-threads=\"all\""
         self.expect([ "\*stopped,reason=\"exception-received\",exception=\"EXC_BAD_ACCESS \(code=1, address=0x0\)\",thread-id=\"1\",stopped-threads=\"all\"",
                       "\*stopped,reason=\"exception-received\",exception=\"invalid address \(fault address: 0x0\)\",thread-id=\"1\",stopped-threads=\"all\"" ])
 
-    @lldbmi_test
     @skipUnlessDarwin
     def test_lldbmi_stopped_when_segfault_remote(self):
         """Test that 'lldb-mi --interpreter' notifies after it was stopped when segfault occurred (remote)."""
 
         # Prepare debugserver
         import lldbgdbserverutils
         debugserver_exe = lldbgdbserverutils.get_debugserver_exe()
         if not debugserver_exe:

lldb/trunk/test/tools/lldb-mi/stack/TestMiStack.py

 """
 Test lldb-mi -stack-xxx commands.
 """
 
 from __future__ import print_function
 
 import lldb_shared
 
 import lldbmi_testcase
 from lldbtest import *
 
 class MiStackTestCase(lldbmi_testcase.MiTestCaseBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_stack_list_arguments(self):
         """Test that 'lldb-mi --interpreter' can shows arguments."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
def test_lldbmi_stack_list_arguments(self):
         # Test that a missing low-frame or high-frame is handled
         self.runCmd("-stack-list-arguments 0 0")
         self.expect("\^error,msg=\"Command 'stack-list-arguments'\. Thread frame range invalid\"")
 
         # Test that an invalid low-frame is handled 
         self.runCmd("-stack-list-arguments 0 0")
         self.expect("\^error,msg=\"Command 'stack-list-arguments'\. Thread frame range invalid\"")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_stack_list_locals(self):
         """Test that 'lldb-mi --interpreter' can shows local variables."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
def test_lldbmi_stack_list_locals(self):
         self.expect("\^done,locals=\[{name=\"test_str\",value=\".*?Rakaposhi.*?\"},{name=\"var_e\",value=\"24\"},{name=\"ptr\",value=\".*?\"}\]")
 
         # Test -stack-list-locals: use 2 or --simple-values
         self.runCmd("-stack-list-locals 2")
         self.expect("\^done,locals=\[{name=\"test_str\",type=\"const char \*\",value=\".*?Rakaposhi.*?\"},{name=\"var_e\",type=\"int\",value=\"24\"},{name=\"ptr\",type=\"int \*\",value=\".*?\"}\]")
         self.runCmd("-stack-list-locals --simple-values")
         self.expect("\^done,locals=\[{name=\"test_str\",type=\"const char \*\",value=\".*?Rakaposhi.*?\"},{name=\"var_e\",type=\"int\",value=\"24\"},{name=\"ptr\",type=\"int \*\",value=\".*?\"}\]")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_stack_list_variables(self):
         """Test that 'lldb-mi --interpreter' can shows local variables and arguments."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
def test_lldbmi_stack_list_variables(self):
         self.expect("\^done,variables=\[{arg=\"1\",name=\"arg_str\",value=\".*?String.*?\"},{arg=\"1\",name=\"arg_ptr\",value=\".*?\"},{name=\"test_str\",value=\".*?Rakaposhi.*?\"},{name=\"var_e\",value=\"24\"},{name=\"ptr\",value=\".*?\"}\]")
 
         # Test -stack-list-variables: use 2 or --simple-values
         self.runCmd("-stack-list-variables 2")
         self.expect("\^done,variables=\[{arg=\"1\",name=\"arg_str\",type=\"const char \*\",value=\".*?String.*?\"},{arg=\"1\",name=\"arg_ptr\",type=\"int \*\",value=\".*?\"},{name=\"test_str\",type=\"const char \*\",value=\".*?Rakaposhi.*?\"},{name=\"var_e\",type=\"int\",value=\"24\"},{name=\"ptr\",type=\"int \*\",value=\".*?\"}\]")
         self.runCmd("-stack-list-variables --simple-values")
         self.expect("\^done,variables=\[{arg=\"1\",name=\"arg_str\",type=\"const char \*\",value=\".*?String.*?\"},{arg=\"1\",name=\"arg_ptr\",type=\"int \*\",value=\".*?\"},{name=\"test_str\",type=\"const char \*\",value=\".*?Rakaposhi.*?\"},{name=\"var_e\",type=\"int\",value=\"24\"},{name=\"ptr\",type=\"int \*\",value=\".*?\"}\]")
         
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_stack_info_depth(self):
         """Test that 'lldb-mi --interpreter' can shows depth of the stack."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
def test_lldbmi_stack_info_depth(self):
         self.runCmd("-stack-info-depth 1")
         #self.expect("\^done,depth=\"1\"")
 
         # Test that invalid max-depth argument is handled
         #FIXME: max-depth argument is ignored
         self.runCmd("-stack-info-depth -1")
         #self.expect("\^error")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @skipUnlessDarwin
     def test_lldbmi_stack_info_frame(self):
         """Test that 'lldb-mi --interpreter' can show information about current frame."""
 
         self.spawnLldbMi(args = None)
 
def test_lldbmi_stack_info_frame(self):
         self.runCmd("-stack-info-frame")
         self.expect("\^done,frame=\{level=\"1\",addr=\"0x[0-9a-f]+\",func=\".+?\",file=\"\?\?\",fullname=\"\?\?\",line=\"-1\"\}")
 
         # Test that -stack-info-frame fails when an argument is specified
         #FIXME: unknown argument is ignored
         self.runCmd("-stack-info-frame unknown_arg")
         #self.expect("\^error")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_stack_list_frames(self):
         """Test that 'lldb-mi --interpreter' can lists the frames on the stack."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")
 
         # Run to main
         self.runCmd("-break-insert -f main")
         self.expect("\^done,bkpt={number=\"1\"")
         self.runCmd("-exec-run")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
         # Test stack frame: get frame #0 info
         self.runCmd("-stack-list-frames 0 0")
         self.expect("\^done,stack=\[frame=\{level=\"0\",addr=\"0x[0-9a-f]+\",func=\"main\",file=\"main\.cpp\",fullname=\".+?main\.cpp\",line=\"\d+\"\}\]")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_stack_select_frame(self):
         """Test that 'lldb-mi --interpreter' can choose current frame."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable

lldb/trunk/test/tools/lldb-mi/startup_options/TestMiStartupOptions.py

 """
 Test lldb-mi startup options.
 """
 
 from __future__ import print_function
 
 import lldb_shared
 
 import lldbmi_testcase
 from lldbtest import *
 
 class MiStartupOptionsTestCase(lldbmi_testcase.MiTestCaseBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_executable_option_file(self):
         """Test that 'lldb-mi --interpreter %s' loads executable file."""
 
         self.spawnLldbMi(args = "%s" % self.myexe)
 
         # Test that the executable is loaded when file was specified
def test_lldbmi_executable_option_file(self):
         self.expect("\^running")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
         # Continue
         self.runCmd("-exec-continue")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"exited-normally\"")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_executable_option_unknown_file(self):
         """Test that 'lldb-mi --interpreter %s' fails on unknown executable file."""
 
         # Prepare path to executable
         path = "unknown_file"
 
         self.spawnLldbMi(args = "%s" % path)
 
         # Test that the executable isn't loaded when unknown file was specified
         self.expect("-file-exec-and-symbols \"%s\"" % path)
         self.expect("\^error,msg=\"Command 'file-exec-and-symbols'. Target binary '%s' is invalid. error: unable to find executable for '%s'\"" % (path, path))
 
         # Test that lldb-mi is ready when executable was loaded
         self.expect(self.child_prompt, exactly = True)
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_executable_option_absolute_path(self):
         """Test that 'lldb-mi --interpreter %s' loads executable which is specified via absolute path."""
 
         # Prepare path to executable
         import os
         path = os.path.join(os.getcwd(), self.myexe)
 
         self.spawnLldbMi(args = "%s" % path)
 
         # Test that the executable is loaded when file was specified using absolute path
         self.expect("-file-exec-and-symbols \"%s\"" % path)
         self.expect("\^done")
 
         # Test that lldb-mi is ready when executable was loaded
         self.expect(self.child_prompt, exactly = True)
 
         # Run
         self.runCmd("-exec-run")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"exited-normally\"")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_executable_option_relative_path(self):
         """Test that 'lldb-mi --interpreter %s' loads executable which is specified via relative path."""
 
         # Prepare path to executable
         path = "./%s" % self.myexe
 
         self.spawnLldbMi(args = "%s" % path)
 
         # Test that the executable is loaded when file was specified using relative path
         self.expect("-file-exec-and-symbols \"%s\"" % path)
         self.expect("\^done")
 
         # Test that lldb-mi is ready when executable was loaded
         self.expect(self.child_prompt, exactly = True)
 
         # Run
         self.runCmd("-exec-run")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"exited-normally\"")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_executable_option_unknown_path(self):
         """Test that 'lldb-mi --interpreter %s' fails on executable file which is specified via unknown path."""
 
         # Prepare path to executable
         path = "unknown_dir/%s" % self.myexe
 
         self.spawnLldbMi(args = "%s" % path)
 
         # Test that the executable isn't loaded when file was specified using unknown path
         self.expect("-file-exec-and-symbols \"%s\"" % path)
         self.expect("\^error,msg=\"Command 'file-exec-and-symbols'. Target binary '%s' is invalid. error: unable to find executable for '%s'\"" % (path, path))
 
         # Test that lldb-mi is ready when executable was loaded
         self.expect(self.child_prompt, exactly = True)
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfLinux # llvm.org/pr22841: lldb-mi tests fail on all Linux buildbots
     def test_lldbmi_source_option_start_script(self):
         """Test that 'lldb-mi --interpreter' can execute user's commands after initial commands were executed."""
 
         # Prepared source file
         sourceFile = "start_script"
def test_lldbmi_source_option_start_script(self):
         # Test that lldb-mi is ready after execution of --source start_script
         self.expect(self.child_prompt, exactly = True)
 
         # Try to evaluate 'a' expression
         self.runCmd("-data-evaluate-expression a")
         self.expect("\^done,value=\"10\"")
         self.expect(self.child_prompt, exactly = True)
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfLinux # llvm.org/pr22841: lldb-mi tests fail on all Linux buildbots
     def test_lldbmi_source_option_start_script_exit(self):
         """Test that 'lldb-mi --interpreter' can execute a prepared file which passed via --source option."""
 
         # Prepared source file
         sourceFile = "start_script_exit"
def test_lldbmi_source_option_start_script_exit(self):
         self.expect("-data-evaluate-expression a")
         self.expect("\^done,value=\"10\"")
 
         # After '-gdb-exit'
         self.expect("-gdb-exit")
         self.expect("\^exit")
         self.expect("\*stopped,reason=\"exited-normally\"")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_source_option_start_script_error(self):
         """Test that 'lldb-mi --interpreter' stops execution of initial commands in case of error."""
 
         # Prepared source file
         sourceFile = "start_script_error"
 
         self.spawnLldbMi(args = "--source %s" % sourceFile)
 
         # After '-file-exec-and-symbols a.out'
         self.expect("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")
 
         # After '-break-ins -f main'
         self.expect("-break-ins -f main")
         self.expect("\^error")
 
         # Test that lldb-mi is ready after execution of --source start_script
         self.expect(self.child_prompt, exactly = True)
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_log_option(self):
         """Test that 'lldb-mi --log' creates a log file in the current directory."""
     
         logDirectory = "."
         self.spawnLldbMi(args = "%s --log" % self.myexe)
 
def test_lldbmi_log_option(self):
 
         if not logFile:
             self.fail("log file not found")
 
         # Delete log
         for f in logFile:
             os.remove(f)
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_log_directory_option(self):
         """Test that 'lldb-mi --log --log-dir' creates a log file in the directory specified by --log-dir."""
     
         # Create log in temp directory
         import tempfile
         logDirectory = tempfile.gettempdir()

lldb/trunk/test/tools/lldb-mi/symbol/TestMiSymbol.py

 """
 Test lldb-mi -symbol-xxx commands.
 """
 
 from __future__ import print_function
 
 import lldb_shared
 
 import lldbmi_testcase
 from lldbtest import *
 
 class MiSymbolTestCase(lldbmi_testcase.MiTestCaseBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_symbol_list_lines_file(self):
         """Test that 'lldb-mi --interpreter' works for -symbol-list-lines when file exists."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable

lldb/trunk/test/tools/lldb-mi/syntax/TestMiSyntax.py

 """
 Test that the lldb-mi driver understands MI command syntax.
 """
 
 from __future__ import print_function
 
 import lldb_shared
 
 import lldbmi_testcase
 from lldbtest import *
 
 class MiSyntaxTestCase(lldbmi_testcase.MiTestCaseBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_tokens(self):
         """Test that 'lldb-mi --interpreter' prints command tokens."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
         self.runCmd("000-file-exec-and-symbols %s" % self.myexe)
         self.expect("000\^done")
 
         # Run to main
         self.runCmd("100000001-break-insert -f main")
         self.expect("100000001\^done,bkpt={number=\"1\"")
         self.runCmd("2-exec-run")
         self.expect("2\^running")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
         # Exit
         self.runCmd("0000000000000000000003-exec-continue")
         self.expect("0000000000000000000003\^running")
         self.expect("\*stopped,reason=\"exited-normally\"")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_specialchars(self):
         """Test that 'lldb-mi --interpreter' handles complicated strings."""
 
         # Create an alias for myexe
         complicated_myexe = "C--mpl-x file's`s @#$%^&*()_+-={}[]| name"
         os.symlink(self.myexe, complicated_myexe)
         self.addTearDownHook(lambda: os.unlink(complicated_myexe))
 
         self.spawnLldbMi(args = "\"%s\"" % complicated_myexe)
 
         # Test that the executable was loaded
         self.expect("-file-exec-and-symbols \"%s\"" % complicated_myexe, exactly = True)
         self.expect("\^done")
 
         # Check that it was loaded correctly
         self.runCmd("-break-insert -f main")
         self.expect("\^done,bkpt={number=\"1\"")
         self.runCmd("-exec-run")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @expectedFailureLinux  # Failing in ~6/600 dosep runs (build 3120-3122)
     def test_lldbmi_process_output(self):
         """Test that 'lldb-mi --interpreter' wraps process output correctly."""
 
         self.spawnLldbMi(args = None)
 

lldb/trunk/test/tools/lldb-mi/target/TestMiTarget.py

 """
 Test lldb-mi -target-xxx commands.
 """
 
 from __future__ import print_function
 
 import lldb_shared
 
 import lldbmi_testcase
 from lldbtest import *
 
 class MiTargetTestCase(lldbmi_testcase.MiTestCaseBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfLinux # cannot attach to process on linux
     def test_lldbmi_target_attach_wait_for(self):
         """Test that 'lldb-mi --interpreter' works for -target-attach -n <name> --waitfor."""
            
         # Build target executable with unique name
         exeName = self.testMethodName
def test_lldbmi_target_attach_wait_for(self):
         # Continue to breakpoint
         self.runCmd("-exec-continue")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
         
         # Detach
         self.runCmd("-target-detach")
         self.expect("\^done")
         
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfLinux # cannot attach to process on linux
     def test_lldbmi_target_attach_name(self):
         """Test that 'lldb-mi --interpreter' works for -target-attach -n <name>."""
            
         # Build target executable with unique name
         exeName = self.testMethodName
def test_lldbmi_target_attach_name(self):
         # Continue to breakpoint
         self.runCmd("-exec-continue")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
         
         # Detach
         self.runCmd("-target-detach")
         self.expect("\^done")
         
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfLinux # cannot attach to process on linux
     def test_lldbmi_target_attach_pid(self):
         """Test that 'lldb-mi --interpreter' works for -target-attach <pid>."""
            
         # Build target executable with unique name
         exeName = self.testMethodName

lldb/trunk/test/tools/lldb-mi/variable/TestMiGdbSetShowPrint.py

def eval_and_check_array(self, var, typ, length):
         self.expect('\^done,name="var\d+",numchild="%d",value="\[%d\]",type="%s \[%d\]",thread-id="1",has_more="0"' % (length, length, typ, length))
 
     # evaluates any type which can be represented as string of characters
     def eval_and_match_string(self, var, value, typ):
         value=value.replace("\\", "\\\\").replace("\"", "\\\"")
         self.runCmd("-var-create - * " + var)
         self.expect('\^done,name="var\d+",numchild="[0-9]+",value="%s",type="%s",thread-id="1",has_more="0"' % (value, typ))
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfLinux # llvm.org/pr22841: lldb-mi tests fail on all Linux buildbots
     def test_lldbmi_gdb_set_show_print_char_array_as_string(self):
         """Test that 'lldb-mi --interpreter' can print array of chars as string."""
 
         self.spawnLldbMi(args = None)
 
def test_lldbmi_gdb_set_show_print_char_array_as_string(self):
         # Test that -gdb-set print char-array-as-string fails if "on"/"off" isn't specified
         self.runCmd("-gdb-set print char-array-as-string")
         self.expect("\^error,msg=\"The request ''print' expects option-name and \"on\" or \"off\"' failed.\"")
 
         # Test that -gdb-set print char-array-as-string fails when option is unknown
         self.runCmd("-gdb-set print char-array-as-string unknown")
         self.expect("\^error,msg=\"The request ''print' expects option-name and \"on\" or \"off\"' failed.\"")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi working on Windows
     @expectedFailureGcc("https://llvm.org/bugs/show_bug.cgi?id=23357")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_gdb_set_show_print_expand_aggregates(self):
         """Test that 'lldb-mi --interpreter' can expand aggregates everywhere."""
 
         self.spawnLldbMi(args = None)
 
def test_lldbmi_gdb_set_show_print_expand_aggregates(self):
         # Test that -gdb-set print expand-aggregates fails if "on"/"off" isn't specified
         self.runCmd("-gdb-set print expand-aggregates")
         self.expect("\^error,msg=\"The request ''print' expects option-name and \"on\" or \"off\"' failed.\"")
 
         # Test that -gdb-set print expand-aggregates fails when option is unknown
         self.runCmd("-gdb-set print expand-aggregates unknown")
         self.expect("\^error,msg=\"The request ''print' expects option-name and \"on\" or \"off\"' failed.\"")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi working on Windows
     @expectedFailureGcc("https://llvm.org/bugs/show_bug.cgi?id=23357")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_gdb_set_show_print_aggregate_field_names(self):
         """Test that 'lldb-mi --interpreter' can expand aggregates everywhere."""
 
         self.spawnLldbMi(args = None)
 

lldb/trunk/test/tools/lldb-mi/variable/TestMiVar.py

 """
 Test lldb-mi -var-xxx commands.
 """
 
 from __future__ import print_function
 
 import lldb_shared
 
 import lldbmi_testcase
 from lldbtest import *
 
 class MiVarTestCase(lldbmi_testcase.MiTestCaseBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @expectedFailureAll("llvm.org/pr23560", oslist=["linux"], compiler="gcc", compiler_version=[">=","4.9"], archs=["i386"])
     def test_lldbmi_eval(self):
         """Test that 'lldb-mi --interpreter' works for evaluating."""
 
         self.spawnLldbMi(args = None)
 
def test_lldbmi_eval(self):
         self.runCmd("-var-evaluate-expression var6")
         self.expect("\^done,value=\"0x[0-9a-f]+ \\\\\\\".*?%s\\\\\\\"\"" % self.myexe)
         self.runCmd("-var-show-attributes var6")
         self.expect("\^done,status=\"editable\"")
         self.runCmd("-var-list-children --all-values var6")
         # FIXME: The name below is not correct. It should be "var.*argv[0]".
         self.expect("\^done,numchild=\"1\",children=\[child=\{name=\"var6\.\*\$[0-9]+\",exp=\"\*\$[0-9]+\",numchild=\"0\",type=\"const char\",thread-id=\"4294967295\",value=\"47 '/'\",has_more=\"0\"\}\],has_more=\"0\"") #FIXME -var-list-children shows invalid thread-id
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfLinux # llvm.org/pr22841: lldb-mi tests fail on all Linux buildbots
     def test_lldbmi_var_update(self):
         """Test that 'lldb-mi --interpreter' works for -var-update."""
 
         self.spawnLldbMi(args = None)
 
def test_lldbmi_var_update(self):
         self.runCmd("-exec-continue")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
         # Test that var_complex_array was updated
         self.runCmd("-var-update --all-values var_complx_array")
         self.expect("\^done,changelist=\[\{name=\"var_complx_array\",value=\"\[2\]\",in_scope=\"true\",type_changed=\"false\",has_more=\"0\"\}\]")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_var_create_register(self):
         """Test that 'lldb-mi --interpreter' works for -var-create $regname."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
def test_lldbmi_var_create_register(self):
         self.runCmd("-var-assign var_reg \"6\"")
         #FIXME: the output has different format for 32bit and 64bit values
         self.expect("\^done,value=\"0x0*?6\"")
 
         # Assert register 0 updated
         self.runCmd("-data-list-register-values d 0")
         self.expect("\^done,register-values=\[{number=\"0\",value=\"6\"")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfLinux # llvm.org/pr22841: lldb-mi tests fail on all Linux buildbots
     def test_lldbmi_var_list_children(self):
         """Test that 'lldb-mi --interpreter' works for -var-list-children."""
 
         self.spawnLldbMi(args = None)
 
def test_lldbmi_var_list_children(self):
         # FIXME: -1 is treated as unsigned int
         self.runCmd("-var-list-children 0 var_complx 0 -1")
         #self.expect("\^error,msg=\"Command 'var-list-children'\. Variable children range invalid\"")
 
         # Test that a missing low-frame or high-frame is handled
         self.runCmd("-var-list-children 0 var_complx 0")
         self.expect("\^error,msg=\"Command 'var-list-children'. Variable children range invalid\"")
 
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfLinux # llvm.org/pr22841: lldb-mi tests fail on all Linux buildbots
     def test_lldbmi_var_create_for_stl_types(self):
         """Test that 'lldb-mi --interpreter' print summary for STL types."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")
 
         # Run to BP_gdb_set_show_print_char_array_as_string_test
         line = line_number('main.cpp', '// BP_cpp_stl_types_test')
         self.runCmd("-break-insert main.cpp:%d" % line)
         self.expect("\^done,bkpt={number=\"1\"")
         self.runCmd("-exec-run")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
         # Test for std::string
         self.runCmd("-var-create - * std_string")
         self.expect('\^done,name="var\d+",numchild="[0-9]+",value="\\\\"hello\\\\"",type="std::[\S]*?string",thread-id="1",has_more="0"')
  
-    @lldbmi_test
     @skipIfWindows #llvm.org/pr24452: Get lldb-mi working on Windows
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfLinux # llvm.org/pr22841: lldb-mi tests fail on all Linux buildbots
     def test_lldbmi_var_create_for_unnamed_objects(self):
         """Test that 'lldb-mi --interpreter' can expand unnamed structures and unions."""
 
         self.spawnLldbMi(args = None)