[dotest] make debug info variant accessible in setUp()

[labath]

Summary

This changes the way we store the debug info variant to make it
available earlier in the test bringup: instead of it being set by the
test wrapper method, it is set as a *property* of the wrapper method.

This way, we can inspect it as soon as self.testMethodName is
initialized. The retrieval is implemented by a new function
TestBase.getDebugInfo(), and all that's necessary to make it work is to
change self.debug_info into self.getDebugInfo().

While searching for debug_info occurences i noticed that TestLogging is
being replicated for no good reason, so I removed the replication there.

[labath]

Move getDebugInfo definition to "Base" class (fixes lldb-mi tests).

[aprantl]

That looks great, to make sure I understand this correctly, is the following accurate?

If we apply this on top of https://reviews.llvm.org/D42763, and we have

tests/my/testA.py:
  class TestA(Base):
    def setUp(self):
       ...
    def testAone(self):
       ...
    def testAtwo(self):
       ...

and we are testing two variants, "dwo", and "dwarf".

dotest.py will instantiate 4 objects:

Aone_dwo = new TestA { debug_info="dwo" }
Aone_dwarf = new TestA { debug_info="dwo" }
Atwo_dwo = new TestA { debug_info="dwo" }
Atwo_dwarf = new TestA { debug_info="dwarf" }

and schedule

Aone_dwo.setUp()
Aone_dwarf.setUp()
Atwo_dwo.setUp()
Atwo_dwarf.setUp()

and then

Aone_dwo.testAone()
Aone_dwarf.testAone()
Atwo_dwo.testAtwo()
Atwo_dwarf.testAtwo()

Is this accurate, or is there something missing to make it behave this way?

[labath]

In D42836#996288, @aprantl wrote:

That looks great, to make sure I understand this correctly, is the following accurate?

If we apply this on top of https://reviews.llvm.org/D42763, and we have

tests/my/testA.py:
  class TestA(Base):
    def setUp(self):
       ...
    def testAone(self):
       ...
    def testAtwo(self):
       ...

and we are testing two variants, "dwo", and "dwarf".

dotest.py will instantiate 4 objects:

Aone_dwo = new TestA { debug_info="dwo" }
Aone_dwarf = new TestA { debug_info="dwo" }
Atwo_dwo = new TestA { debug_info="dwo" }
Atwo_dwarf = new TestA { debug_info="dwarf" }

and schedule

Aone_dwo.setUp()
Aone_dwarf.setUp()
Atwo_dwo.setUp()
Atwo_dwarf.setUp()

and then

Aone_dwo.testAone()
Aone_dwarf.testAone()
Atwo_dwo.testAtwo()
Atwo_dwarf.testAtwo()

Is this accurate, or is there something missing to make it behave this way?

Not completely accurate. The steps are the correct, but the order is different. It will be something like

for test in ["testAdwarf", "testAdwo", "testBdwarf", "testBdwo"]:
  A = new TestA(test) # initializes A._testMethodName
  A.setUp() # can access debug info variant through A._testMethodName (a.k.a A.testMethodName)
  getattr(A, test)()
  A.tearDown()

I don't know whether this distinction matters for you right now (?)

[aprantl]

Great. The important thing for me was that a new object is constructed for each permutation of test function / variant.

packages/Python/lldbsuite/test/decorators.py

def fn(self):
         skip_for_hostos = _match_decorator_property(
             lldbplatform.translate(hostoslist),
             lldbplatformutil.getHostPlatform())
         skip_for_compiler = _match_decorator_property(
             compiler, self.getCompiler()) and self.expectedCompilerVersion(compiler_version)
         skip_for_arch = _match_decorator_property(
             archs, self.getArchitecture())
         skip_for_debug_info = _match_decorator_property(
-            debug_info, self.debug_info)
+            debug_info, self.getDebugInfo())
         skip_for_triple = _match_decorator_property(
             triple, lldb.DBG.GetSelectedPlatform().GetTriple())
         skip_for_remote = _match_decorator_property(
             remote, lldb.remote_platform is not None)
 
         skip_for_swig_version = (
             swig_version is None) or (
             not hasattr(
def expectedFlakey(expected_fn, bugnumber=None):
     if six.callable(bugnumber):
         return expectedFailure_impl(bugnumber)
     else:
         return expectedFailure_impl
 
 
 def expectedFlakeyDwarf(bugnumber=None):
     def fn(self):
-        return self.debug_info == "dwarf"
+        return self.getDebugInfo() == "dwarf"
     return expectedFlakey(fn, bugnumber)
 
 
 def expectedFlakeyDsym(bugnumber=None):
     def fn(self):
-        return self.debug_info == "dwarf"
+        return self.getDebugInfo() == "dwarf"
     return expectedFlakey(fn, bugnumber)
 
 
 def expectedFlakeyOS(oslist, bugnumber=None, compilers=None):
     def fn(self):
         return (self.getPlatform() in oslist and
                 self.expectedCompiler(compilers))
     return expectedFlakey(fn, bugnumber)

packages/Python/lldbsuite/test/functionalities/exec/TestExec.py

def do_test(self, skip_exec):
             source = self.getSourcePath("main.cpp")
             o_file = self.getBuildArtifact("main.o")
             execute_command(
                 "'%s' -g -O0 -arch i386 -arch x86_64 '%s' -c -o '%s'" %
                 (os.environ["CC"], source, o_file))
             execute_command(
                 "'%s' -g -O0 -arch i386 -arch x86_64 '%s' -o '%s'" %
                 (os.environ["CC"], o_file, exe))
-            if self.debug_info != "dsym":
+            if self.getDebugInfo() != "dsym":
                 dsym_path = self.getBuildArtifact("a.out.dSYM")
                 execute_command("rm -rf '%s'" % (dsym_path))
         else:
             self.build()
 
         # Create the target
         target = self.dbg.CreateTarget(exe)
 

packages/Python/lldbsuite/test/lldbinline.py

def BuildMakefile(self):
         makefile.write("include $(LEVEL)/Makefile.rules\n")
         makefile.write("\ncleanup:\n\trm -f Makefile *.d\n\n")
         makefile.flush()
         makefile.close()
 
     @add_test_categories(["dsym"])
     def __test_with_dsym(self):
         self.using_dsym = True
-        self.debug_info = "dsym"
         self.BuildMakefile()
         self.build()
         self.do_test()
+    __test_with_dsym.debug_info = "dsym"
 
     @add_test_categories(["dwarf"])
     def __test_with_dwarf(self):
         self.using_dsym = False
-        self.debug_info = "dwarf"
         self.BuildMakefile()
         self.build()
         self.do_test()
+    __test_with_dwarf.debug_info = "dwarf"
 
     @add_test_categories(["dwo"])
     def __test_with_dwo(self):
         self.using_dsym = False
-        self.debug_info = "dwo"
         self.BuildMakefile()
         self.build()
         self.do_test()
+    __test_with_dwo.debug_info = "dwo"
 
     @add_test_categories(["gmodules"])
     def __test_with_gmodules(self):
         self.using_dsym = False
-        self.debug_info = "gmodules"
         self.BuildMakefile()
         self.build()
         self.do_test()
+    __test_with_gmodules.debug_info = "gmodules"
 
     def execute_user_command(self, __command):
         exec(__command, globals(), locals())
 
     def do_test(self):
         exe = self.getBuildArtifact("a.out")
         source_files = [f for f in os.listdir(self.getSourceDir())
                         if source_type(f)]

packages/Python/lldbsuite/test/lldbtest.py

def setUp(self):
             raise Exception('Could not get the command interpreter')
 
         # And the result object.
         self.res = lldb.SBCommandReturnObject()
 
         self.setPlatformWorkingDir()
         self.enableLogChannelsForCurrentTest()
 
-        # Initialize debug_info
-        self.debug_info = None
-
         lib_dir = os.environ["LLDB_LIB_DIR"]
         self.dsym = None
         self.framework_dir = None
         self.darwinWithFramework = self.platformIsDarwin()
         if sys.platform.startswith("darwin"):
             # Handle the framework environment variable if it is set
             if hasattr(lldbtest_config, 'lldbFrameworkPath'):
                 framework_path = lldbtest_config.lldbFrameworkPath
def buildDefault(
             architecture=None,
             compiler=None,
             dictionary=None,
             clean=True,
             testdir=None):
         """Platform specific way to build the default binaries."""
         if not testdir:
             testdir = self.mydir
-        if self.debug_info:
+        if self.getDebugInfo():
             raise Exception("buildDefault tests must set NO_DEBUG_INFO_TESTCASE")
         module = builder_module()
         self.makeBuildDir()
         dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
         if not module.buildDefault(self, architecture, compiler,
                                    dictionary, clean, testdir):
             raise Exception("Don't know how to build default binary")
 
     def buildDsym(
             self,
             architecture=None,
             compiler=None,
             dictionary=None,
             clean=True,
             testdir=None):
         """Platform specific way to build binaries with dsym info."""
         if not testdir:
             testdir = self.mydir
-        if self.debug_info <> "dsym":
+        if self.getDebugInfo() != "dsym":
             raise Exception("NO_DEBUG_INFO_TESTCASE must build with buildDefault")
 
         module = builder_module()
         dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
         if not module.buildDsym(self, architecture, compiler,
                                 dictionary, clean, testdir):
             raise Exception("Don't know how to build binary with dsym")
 
     def buildDwarf(
             self,
             architecture=None,
             compiler=None,
             dictionary=None,
             clean=True,
             testdir=None):
         """Platform specific way to build binaries with dwarf maps."""
         if not testdir:
             testdir = self.mydir
-        if self.debug_info <> "dwarf":
+        if self.getDebugInfo() != "dwarf":
             raise Exception("NO_DEBUG_INFO_TESTCASE must build with buildDefault")
 
         module = builder_module()
         dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
         if not module.buildDwarf(self, architecture, compiler,
                                    dictionary, clean, testdir):
             raise Exception("Don't know how to build binary with dwarf")
 
     def buildDwo(
             self,
             architecture=None,
             compiler=None,
             dictionary=None,
             clean=True,
             testdir=None):
         """Platform specific way to build binaries with dwarf maps."""
         if not testdir:
             testdir = self.mydir
-        if self.debug_info <> "dwo":
+        if self.getDebugInfo() != "dwo":
             raise Exception("NO_DEBUG_INFO_TESTCASE must build with buildDefault")
 
         module = builder_module()
         dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
         if not module.buildDwo(self, architecture, compiler,
                                    dictionary, clean, testdir):
             raise Exception("Don't know how to build binary with dwo")
 
     def buildGModules(
             self,
             architecture=None,
             compiler=None,
             dictionary=None,
             clean=True,
             testdir=None):
         """Platform specific way to build binaries with gmodules info."""
         if not testdir:
             testdir = self.mydir
-        if self.debug_info <> "gmodules":
+        if self.getDebugInfo() != "gmodules":
             raise Exception("NO_DEBUG_INFO_TESTCASE must build with buildDefault")
 
         module = builder_module()
         dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
         if not module.buildGModules(self, architecture, compiler,
                                    dictionary, clean, testdir):
             raise Exception("Don't know how to build binary with gmodules")
 
def __new__(cls, name, bases, attrs):
 
                 supported_categories = [
                     x for x in categories if test_categories.is_supported_on_platform(
                         x, target_platform, configuration.compiler)]
                 if "dsym" in supported_categories:
                     @decorators.add_test_categories(["dsym"])
                     @wraps(attrvalue)
                     def dsym_test_method(self, attrvalue=attrvalue):
-                        self.debug_info = "dsym"
                         return attrvalue(self)
                     dsym_method_name = attrname + "_dsym"
                     dsym_test_method.__name__ = dsym_method_name
+                    dsym_test_method.debug_info = "dsym"
                     newattrs[dsym_method_name] = dsym_test_method
 
                 if "dwarf" in supported_categories:
                     @decorators.add_test_categories(["dwarf"])
                     @wraps(attrvalue)
                     def dwarf_test_method(self, attrvalue=attrvalue):
-                        self.debug_info = "dwarf"
                         return attrvalue(self)
                     dwarf_method_name = attrname + "_dwarf"
                     dwarf_test_method.__name__ = dwarf_method_name
+                    dwarf_test_method.debug_info = "dwarf"
                     newattrs[dwarf_method_name] = dwarf_test_method
 
                 if "dwo" in supported_categories:
                     @decorators.add_test_categories(["dwo"])
                     @wraps(attrvalue)
                     def dwo_test_method(self, attrvalue=attrvalue):
-                        self.debug_info = "dwo"
                         return attrvalue(self)
                     dwo_method_name = attrname + "_dwo"
                     dwo_test_method.__name__ = dwo_method_name
+                    dwo_test_method.debug_info = "dwo"
                     newattrs[dwo_method_name] = dwo_test_method
 
                 if "gmodules" in supported_categories:
                     @decorators.add_test_categories(["gmodules"])
                     @wraps(attrvalue)
                     def gmodules_test_method(self, attrvalue=attrvalue):
-                        self.debug_info = "gmodules"
                         return attrvalue(self)
                     gmodules_method_name = attrname + "_gmodules"
                     gmodules_test_method.__name__ = gmodules_method_name
+                    gmodules_test_method.debug_info = "gmodules"
                     newattrs[gmodules_method_name] = gmodules_test_method
 
             else:
                 newattrs[attrname] = attrvalue
         return super(
             LLDBTestCaseFactory,
             cls).__new__(
             cls,
def invoke(self, obj, name, trace=False):
         import inspect
         self.assertTrue(inspect.ismethod(method),
                         name + "is a method name of object: " + str(obj))
         result = method()
         with recording(self, trace) as sbuf:
             print(str(method) + ":", result, file=sbuf)
         return result
 
+    def getDebugInfo(self):
+        method = getattr(self, self.testMethodName)
+        return getattr(method, "debug_info", None)
+
     def build(
             self,
             architecture=None,
             compiler=None,
             dictionary=None,
             clean=True):
         """Platform specific way to build the default binaries."""
         module = builder_module()
         self.makeBuildDir()
 
         dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
-        if self.debug_info is None:
+        if self.getDebugInfo() is None:
             return self.buildDefault(architecture, compiler, dictionary,
                                      clean, self.mydir)
-        elif self.debug_info == "dsym":
+        elif self.getDebugInfo() == "dsym":
             return self.buildDsym(architecture, compiler, dictionary,
                                   clean, self.mydir)
-        elif self.debug_info == "dwarf":
+        elif self.getDebugInfo() == "dwarf":
             return self.buildDwarf(architecture, compiler, dictionary,
                                    clean, self.mydir)
-        elif self.debug_info == "dwo":
+        elif self.getDebugInfo() == "dwo":
             return self.buildDwo(architecture, compiler, dictionary,
                                  clean, self.mydir)
-        elif self.debug_info == "gmodules":
+        elif self.getDebugInfo() == "gmodules":
             return self.buildGModules(architecture, compiler, dictionary,
                                       clean, self.mydir)
         else:
-            self.fail("Can't build for debug info: %s" % self.debug_info)
+            self.fail("Can't build for debug info: %s" % self.getDebugInfo())
 
     def run_platform_command(self, cmd):
         platform = self.dbg.GetSelectedPlatform()
         shell_command = lldb.SBPlatformShellCommand(cmd)
         err = platform.Run(shell_command)
         return (err, shell_command.GetStatus(), shell_command.GetOutput())
 
     # =================================================

packages/Python/lldbsuite/test/logging/TestLogging.py

 from lldbsuite.test import lldbutil
 
 
 class LogTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
     append_log_file = "lldb-commands-log-append.txt"
     truncate_log_file = "lldb-commands-log-truncate.txt"
+    NO_DEBUG_INFO_TESTCASE = True
 
     @classmethod
     def classCleanup(cls):
         """Cleanup the test byproducts."""
         cls.RemoveTempFile(cls.truncate_log_file)
         cls.RemoveTempFile(cls.append_log_file)
 
     def test(self):
         self.build()
-        if self.debug_info == "dsym":
-            self.command_log_tests("dsym")
-        else:
-            self.command_log_tests("dwarf")
-
-    def command_log_tests(self, type):
         exe = self.getBuildArtifact("a.out")
         self.expect("file " + exe,
                     patterns=["Current executable set to .*a.out"])
 
-        log_file = os.path.join(
-            self.getBuildDir(),
-            "lldb-commands-log-%s-%s-%s.txt" %
-            (type,
-             os.path.basename(
-                 self.getCompiler()),
-                self.getArchitecture()))
+        log_file = os.path.join(self.getBuildDir(), "lldb-commands-log.txt")
 
         if (os.path.exists(log_file)):
             os.remove(log_file)
 
         # By default, Debugger::EnableLog() will set log options to
         # PREPEND_THREAD_NAME + OPTION_THREADSAFE. We don't want the
         # threadnames here, so we enable just threadsafe (-t).
         self.runCmd("log enable -t -f '%s' lldb commands" % (log_file))
def test(self):
         os.remove(log_file)
 
         self.assertGreater(
             len(log_lines),
             0,
             "Something was written to the log file.")
 
     # Check that lldb truncates its log files
-    @no_debug_info_test
     def test_log_truncate(self):
         if (os.path.exists(self.truncate_log_file)):
             os.remove(self.truncate_log_file)
 
         # put something in our log file
         with open(self.truncate_log_file, "w") as f:
             for i in range(1, 1000):
                 f.write("bacon\n")
 
         self.runCmd(
             "log enable -t -f '%s' lldb commands" %
             (self.truncate_log_file))
         self.runCmd("help log")
         self.runCmd("log disable lldb")
 
         self.assertTrue(os.path.isfile(self.truncate_log_file))
         with open(self.truncate_log_file, "r") as f:
             contents = f.read()
 
         # check that it got removed
         self.assertEquals(contents.find("bacon"), -1)
 
     # Check that lldb can append to a log file
-    @no_debug_info_test
     def test_log_append(self):
         if (os.path.exists(self.append_log_file)):
             os.remove(self.append_log_file)
 
         # put something in our log file
         with open(self.append_log_file, "w") as f:
             f.write("bacon\n")