[dotest] Make the set of tests independent of the test configuration

[labath]

Summary

In the magic test duplicator, we were making the decision whether to
create a test variant based on the compiler and the target platform.
This meant that the set of known tests was different for each test
configuration.

This patch makes the set of generated test variants static and handles
the skipping via runtime checks instead. This is more consistent with
how we do other test-skipping decision (e.g. for libc++ tests), and
makes it easier to expose the full set of tests to lit, which now does
not need to know anything about what things can potentially cause tests
to appear or disappear.

lldb/trunk/packages/Python/lldbsuite/test/dotest.py

def checkLibcxxSupport():
     result, reason = canRunLibcxxTests()
     if result:
         return # libc++ supported
     if "libc++" in configuration.categoriesList:
         return # libc++ category explicitly requested, let it run.
     print("Libc++ tests will not be run because: " + reason)
     configuration.skipCategories.append("libc++")
 
+def checkDebugInfoSupport():
+    import lldb
+
+    platform = lldb.DBG.GetSelectedPlatform().GetTriple().split('-')[2]
+    compiler = configuration.compiler
+    skipped = []
+    for cat in test_categories.debug_info_categories:
+        if cat in configuration.categoriesList:
+            continue # Category explicitly requested, let it run.
+        if test_categories.is_supported_on_platform(cat, platform, compiler):
+            continue
+        configuration.skipCategories.append(cat)
+        skipped.append(cat)
+    if skipped:
+        print("Skipping following debug info categories:", skipped)
+
 def run_suite():
     # On MacOS X, check to make sure that domain for com.apple.DebugSymbols defaults
     # does not exist before proceeding to running the test suite.
     if sys.platform.startswith("darwin"):
         checkDsymForUUIDIsNotOn()
 
     #
     # Start the actions by first parsing the options while setting up the test
def run_suite():
     # Note that it's not dotest's job to clean this directory.
     import lldbsuite.test.lldbutil as lldbutil
     build_dir = configuration.test_build_dir
     lldbutil.mkdir_p(build_dir)
 
     target_platform = lldb.DBG.GetSelectedPlatform().GetTriple().split('-')[2]
 
     checkLibcxxSupport()
+    checkDebugInfoSupport()
 
     # Don't do debugserver tests on everything except OS X.
     configuration.dont_do_debugserver_test = "linux" in target_platform or "freebsd" in target_platform or "windows" in target_platform
 
     # Don't do lldb-server (llgs) tests on anything except Linux.
     configuration.dont_do_llgs_test = not ("linux" in target_platform)
 
     #

lldb/trunk/packages/Python/lldbsuite/test/lldbinline.py

def MakeInlineTest(__file, __globals, decorators=None):
     file_basename = os.path.basename(__file)
     InlineTest.mydir = TestBase.compute_mydir(__file)
 
     test_name, _ = os.path.splitext(file_basename)
     # Build the test case
     test = type(test_name, (InlineTest,), {'using_dsym': None})
     test.name = test_name
 
-    target_platform = lldb.DBG.GetSelectedPlatform().GetTriple().split('-')[2]
-    if test_categories.is_supported_on_platform(
-            "dsym", target_platform, configuration.compiler):
-        test.test_with_dsym = ApplyDecoratorsToFunction(
-            test._InlineTest__test_with_dsym, decorators)
-    if test_categories.is_supported_on_platform(
-            "dwarf", target_platform, configuration.compiler):
-        test.test_with_dwarf = ApplyDecoratorsToFunction(
-            test._InlineTest__test_with_dwarf, decorators)
-    if test_categories.is_supported_on_platform(
-            "dwo", target_platform, configuration.compiler):
-        test.test_with_dwo = ApplyDecoratorsToFunction(
-            test._InlineTest__test_with_dwo, decorators)
-    if test_categories.is_supported_on_platform(
-            "gmodules", target_platform, configuration.compiler):
-        test.test_with_gmodules = ApplyDecoratorsToFunction(
-            test._InlineTest__test_with_gmodules, decorators)
 
     # Add the test case to the globals, and hide InlineTest
     __globals.update({test_name: test})
 
     # Keep track of the original test filename so we report it
     # correctly in test results.
     test.test_filename = __file
     return test

lldb/trunk/packages/Python/lldbsuite/test/lldbtest.py

def __new__(cls, name, bases, attrs):
             cls, name, bases, attrs)
         if original_testcase.NO_DEBUG_INFO_TESTCASE:
             return original_testcase
 
         newattrs = {}
         for attrname, attrvalue in attrs.items():
             if attrname.startswith("test") and not getattr(
                     attrvalue, "__no_debug_info_test__", False):
-                target_platform = lldb.DBG.GetSelectedPlatform(
-                ).GetTriple().split('-')[2]
 
                 # If any debug info categories were explicitly tagged, assume that list to be
                 # authoritative.  If none were specified, try with all debug
                 # info formats.
-                all_dbginfo_categories = set(
-                    test_categories.debug_info_categories) - set(configuration.skipCategories)
+                all_dbginfo_categories = set(test_categories.debug_info_categories)
                 categories = set(
                     getattr(
                         attrvalue,
                         "categories",
                         [])) & all_dbginfo_categories
                 if not categories:
                     categories = all_dbginfo_categories
 
-                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"])
+                for cat in categories:
+                    @decorators.add_test_categories([cat])
                     @wraps(attrvalue)
-                    def dsym_test_method(self, attrvalue=attrvalue):
+                    def test_method(self, attrvalue=attrvalue):
                         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):
-                        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):
-                        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):
-                        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
+                    method_name = attrname + "_" + cat
+                    test_method.__name__ = method_name
+                    test_method.debug_info = cat
+                    newattrs[method_name] = test_method
 
             else:
                 newattrs[attrname] = attrvalue
         return super(
             LLDBTestCaseFactory,
             cls).__new__(
             cls,
             name,