[lldb/test] Make category-skipping logic "platform"-independent

[labath]

Summary

The decision which categories are relevant for a particular test run
happen very early in the test setup process. They use the SBPlatform
object to determine which categories should be skipped. The platform
object created for this purpose transcends individual test runs.

This setup is not compatible with the direction discussed in
https://discourse.llvm.org/t/multiple-platforms-with-the-same-name/59594

• when platform objects are tied to a specific (SB)Debugger, they need

to be created alongside it, which currently happens in the test setUp
method.

This patch is the first step in that direction -- it rewrites the
category skipping logic to avoid depending on a global SBPlatform
object. Fortunately, the skipping logic is fairly simple (and I believe
it outght to stay that way) and mainly consists of comparing the
platform name against some hardcoded lists. This patch bases this
comparison on the platform name instead of the os part of the triple (as
reported by the platform).

[labath]

lldb/packages/Python/lldbsuite/test/lldbplatformutil.py

125

I'm not sure if this will work for all apple platforms. Can I assume all of them have configuration.apple_sdk set?

[JDevlieghere]

LGTM

lldb/packages/Python/lldbsuite/test/lldbplatformutil.py

125

Only for our "on-device" test suite (i.e. embedded platforms). Seems like the host case is handled below so that should be fine.

[shafik]

I think this PR broke green dragon incremental build: https://green.lab.llvm.org/green/view/LLDB/job/lldb-cmake/42185/

It looks like the failures are all related to platforms in some ways.

[labath]

Yeah, I'm pretty sure its due to this patch. Though the failures don't look near as bad as I feared. :)

I've reverted the patch while I work on a fix. Do let me know if you see some other failures related to this, particularly in some more exotic (remote/on-device/on-simulator) modes.

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

def checkObjcSupport():
     from lldbsuite.test import lldbplatformutil
 
     if not lldbplatformutil.platformIsDarwin():
         if configuration.verbose:
             print("objc tests will be skipped because of unsupported platform")
         configuration.skip_categories.append("objc")
 
 def checkDebugInfoSupport():
-    import lldb
+    from lldbsuite.test import lldbplatformutil
 
-    platform = lldb.selected_platform.GetTriple().split('-')[2]
+    platform = lldbplatformutil.getPlatform()
     compiler = configuration.compiler
     for cat in test_categories.debug_info_categories:
         if cat in configuration.categories_list:
             continue # Category explicitly requested, let it run.
         if test_categories.is_supported_on_platform(cat, platform, compiler):
             continue
         configuration.skip_categories.append(cat)
 
 def checkDebugServerSupport():
     from lldbsuite.test import lldbplatformutil
     import lldb
 
     skip_msg = "Skipping %s tests, as they are not compatible with remote testing on this platform"
     if lldbplatformutil.platformIsDarwin():
         configuration.skip_categories.append("llgs")
-        if lldb.remote_platform:
+        if configuration.lldb_platform_name:
             # <rdar://problem/34539270>
             configuration.skip_categories.append("debugserver")
             if configuration.verbose:
                 print(skip_msg%"debugserver");
     else:
         configuration.skip_categories.append("debugserver")
-        if lldb.remote_platform and lldbplatformutil.getPlatform() == "windows":
+        if configuration.lldb_platform_name and lldbplatformutil.getPlatform() == "windows":
             configuration.skip_categories.append("llgs")
             if configuration.verbose:
                 print(skip_msg%"lldb-server");
 
 
 def checkForkVForkSupport():
     from lldbsuite.test import lldbplatformutil
 
def run_suite():
     # Print a stack trace if the test hangs or is passed SIGTERM.
     registerFaulthandler()
 
     setupSysPath()
 
     import lldb
     lldb.SBDebugger.Initialize()
 
+    checkLibcxxSupport()
+    checkLibstdcxxSupport()
+    checkWatchpointSupport()
+    checkDebugInfoSupport()
+    checkDebugServerSupport()
+    checkObjcSupport()
+    checkForkVForkSupport()
+
     # Use host platform by default.
+    lldb.remote_platform = None
     lldb.selected_platform = lldb.SBPlatform.GetHostPlatform()
 
     # Now we can also import lldbutil
     from lldbsuite.test import lldbutil
 
     if configuration.lldb_platform_name:
         print("Setting up remote platform '%s'" %
               (configuration.lldb_platform_name))
         lldb.remote_platform = lldb.SBPlatform(
             configuration.lldb_platform_name)
+        lldb.selected_platform = lldb.remote_platform
         if not lldb.remote_platform.IsValid():
             print(
                 "error: unable to create the LLDB platform named '%s'." %
                 (configuration.lldb_platform_name))
             exitTestSuite(1)
         if configuration.lldb_platform_url:
             # We must connect to a remote platform if a LLDB platform URL was
             # specified
else:
         lldb.remote_platform = None
         configuration.lldb_platform_working_dir = None
         configuration.lldb_platform_url = None
 
     # Set up the working directory.
     # Note that it's not dotest's job to clean this directory.
     lldbutil.mkdir_p(configuration.test_build_dir)
 
-    checkLibcxxSupport()
-    checkLibstdcxxSupport()
-    checkWatchpointSupport()
-    checkDebugInfoSupport()
-    checkDebugServerSupport()
-    checkObjcSupport()
-    checkForkVForkSupport()
-
     print("Skipping the following test categories: {}".format(configuration.skip_categories))
 
     for testdir in configuration.testdirs:
         for (dirpath, dirnames, filenames) in os.walk(testdir):
             visit('Test', dirpath, filenames)
 
     #
     # Now that we have loaded all the test cases, run the whole test suite.

lldb/packages/Python/lldbsuite/test/lldbplatformutil.py

p = subprocess.Popen(
         full_cmd,
         stdout=subprocess.PIPE,
         stderr=subprocess.PIPE)
     stdout, stderr = p.communicate()
     return p.returncode, stdout, stderr
 
 
 def target_is_android():
-    if not hasattr(target_is_android, 'result'):
-        triple = lldb.selected_platform.GetTriple()
-        match = re.match(".*-.*-.*-android", triple)
-        target_is_android.result = match is not None
-    return target_is_android.result
-
+    return configuration.lldb_platform_name == "remote-android"
 
 def android_device_api():
     if not hasattr(android_device_api, 'result'):
         assert configuration.lldb_platform_url is not None
         device_id = None
         parsed_url = urlparse.urlparse(configuration.lldb_platform_url)
         host_name = parsed_url.netloc.split(":")[0]
         if host_name != 'localhost':
elif sys.platform.startswith('netbsd'):
         return 'netbsd'
     else:
         return sys.platform
 
 
 def getDarwinOSTriples():
     return lldbplatform.translate(lldbplatform.darwin_all)
 
 def getPlatform():
     """Returns the target platform which the tests are running on."""
     # Use the Apple SDK to determine the platform if set.
     if configuration.apple_sdk:
         platform = configuration.apple_sdk
         dot = platform.find('.')
         if dot != -1:
             platform = platform[:dot]
         if platform == 'iphoneos':
             platform = 'ios'
         return platform
 
-    # Use the triple to determine the platform if set.
-    triple = lldb.selected_platform.GetTriple()
-    if triple:
-        platform = triple.split('-')[2]
-        if platform.startswith('freebsd'):
-            platform = 'freebsd'
-        elif platform.startswith('netbsd'):
-            platform = 'netbsd'
-        return platform
+    platform = configuration.lldb_platform_name
+    if platform is None:
+        platform = "host"
+    if platform == "qemu-user":
+        platform = "host"
+    if platform == "host":
+        return getHostPlatform()
+    if platform.startswith("remote-"):
+        return platform[7:]
 
-    # It still might be an unconnected remote platform.
-    return ''
-
 
 def platformIsDarwin():
     """Returns true if the OS triple for the selected platform is any valid apple OS"""
     return getPlatform() in getDarwinOSTriples()
 
 
 def findMainThreadCheckerDylib():
     if not platformIsDarwin():