Change expectedFailureOS and skipIfPlatform checks to be based on target platform when running test suite remotely.

[flackr]

Summary

Most expected OS failures or skipped tests are about the target platform on which the test binary is being run, not the host platform launching the tests. This changes expectedFailureOS and skipIfPlatform to check against the remote platform when running remote tests.

[tberghammer]

Please check for android also as it use "platform-android" (not platform-linux). I also suggest to use the TargetTriple instead of the given platform to decide the target platform.

[flackr]

Uses GetTriple() to determine remote platform.

[flackr]

In D8611#146810, @tberghammer wrote:

Please check for android also as it use "platform-android" (not platform-linux). I also suggest to use the TargetTriple instead of the given platform to decide the target platform.

Now that it uses Triple, android isn't in the list of OS's for Triple.cc, only an environment, does it return "linux" as well?

[tberghammer]

In D8611#147071, @flackr wrote:

In D8611#146810, @tberghammer wrote:

Please check for android also as it use "platform-android" (not platform-linux). I also suggest to use the TargetTriple instead of the given platform to decide the target platform.

Now that it uses Triple, android isn't in the list of OS's for Triple.cc, only an environment, does it return "linux" as well?

Android using <arch>-unknown-linux-android as the target triple so checking for linux will be fine.

test/dotest.py

1348 ↗

(On Diff #22689)

You can get the target triple both on local and remote targets with "triple = lldb.DBG.GetSelectedPlatform().GetTriple()" (after running lldb.DBG.SetSelectedPlatform on remote platforms).
I suggest to use it so we can use the same OS detection on local and remote debugging.

In longer term I would like to get rid of most of the usage of sys.platform (leave it only where we want to check the host OS) from the test system but it is out of scope for this CL.

1362 ↗

(On Diff #22689)

Please don't use sys.platfrom here

test/lldbtest.py

588–592 ↗

(On Diff #22689)

You can use lldb.DBG.GetSelectedPlatform().GetTriple() here also (both for local and remote)

[flackr]

• Use lldb.DBG.GetSelectedPlatform().GetTriple() to get target platform triple whether running local or remote tests.
• Change skipIfPlatform checks to also check remote platform.
• Consider both "macosx" and "darwin" as MacOSX - see Triple::isMacOSX for equivalent check.

[tberghammer]

LGTM

[clayborg]

lgtm

lldb/trunk/test/dotest.py

 # 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
 
-# By default, both dsym and dwarf tests are performed.
-# Use @dsym_test or @dwarf_test decorators, defined in lldbtest.py, to mark a test
-# as a dsym or dwarf test.  Use '-N dsym' or '-N dwarf' to exclude dsym or dwarf
-# tests from running.
-dont_do_dsym_test = "linux" in sys.platform or "freebsd" in sys.platform
+dont_do_dsym_test = False
 dont_do_dwarf_test = False
 
-# Don't do debugserver tests on everything except OS X.
-# Something for Windows here?
-dont_do_debugserver_test = "linux" in sys.platform or "freebsd" in sys.platform
-
-# Don't do lldb-server (llgs) tests on anything except Linux.
-dont_do_llgs_test = not ("linux" in sys.platform)
-
 # The blacklist is optional (-b blacklistFile) and allows a central place to skip
 # testclass's and/or testclass.testmethod's.
 blacklist = None
 
 # The dictionary as a result of sourcing blacklistFile.
 blacklistConfig = {}
 
 # The list of categories we said we care about
if lldb_platform_working_dir:
         print "Setting remote platform working directory to '%s'..." % (lldb_platform_working_dir)
         lldb.remote_platform.SetWorkingDirectory(lldb_platform_working_dir)
     
     lldb.remote_platform_working_dir = lldb_platform_working_dir
     lldb.DBG.SetSelectedPlatform(lldb.remote_platform)
 else:
     lldb.remote_platform = None
     lldb.remote_platform_working_dir = None
+
+target_platform = lldb.DBG.GetSelectedPlatform().GetTriple().split('-')[2]
+
+# By default, both dsym and dwarf tests are performed.
+# Use @dsym_test or @dwarf_test decorators, defined in lldbtest.py, to mark a test
+# as a dsym or dwarf test.  Use '-N dsym' or '-N dwarf' to exclude dsym or dwarf
+# tests from running.
+dont_do_dsym_test = dont_do_dsym_test or "linux" in target_platform or "freebsd" in target_platform
+
+# Don't do debugserver tests on everything except OS X.
+# Something for Windows here?
+dont_do_debugserver_test = "linux" in target_platform or "freebsd" in target_platform
+
+# Don't do lldb-server (llgs) tests on anything except Linux.
+dont_do_llgs_test = not ("linux" in target_platform)
+
 # Put the blacklist in the lldb namespace, to be used by lldb.TestBase.
 lldb.blacklist = blacklist
 
 # The pre_flight and post_flight come from reading a config file.
 lldb.pre_flight = pre_flight
 lldb.post_flight = post_flight
 def getsource_if_available(obj):
     """

lldb/trunk/test/lldbtest.py

def expectedFailureArch(arch, bugnumber=None):
     if bugnumber: return expectedFailure(fn, bugnumber)
 
 def expectedFailurei386(bugnumber=None):
     if bugnumber: return expectedFailureArch('i386', bugnumber)
 
 def expectedFailurex86_64(bugnumber=None):
     if bugnumber: return expectedFailureArch('x86_64', bugnumber)
 
-def expectedFailureOS(os, bugnumber=None, compilers=None):
+def expectedFailureOS(oslist, bugnumber=None, compilers=None):
     def fn(self):
-        return os in sys.platform and self.expectedCompiler(compilers)
+        return (lldb.DBG.GetSelectedPlatform().GetTriple().split('-')[2] in oslist and
+                self.expectedCompiler(compilers))
     if bugnumber: return expectedFailure(fn, bugnumber)
 
 def expectedFailureDarwin(bugnumber=None, compilers=None):
-    if bugnumber: return expectedFailureOS('darwin', bugnumber, compilers)
+    # For legacy reasons, we support both "darwin" and "macosx" as OS X triples.
+    if bugnumber: return expectedFailureOS(['darwin', 'macosx'], bugnumber, compilers)
 
 def expectedFailureFreeBSD(bugnumber=None, compilers=None):
-    if bugnumber: return expectedFailureOS('freebsd', bugnumber, compilers)
+    if bugnumber: return expectedFailureOS(['freebsd'], bugnumber, compilers)
 
 def expectedFailureLinux(bugnumber=None, compilers=None):
-    if bugnumber: return expectedFailureOS('linux', bugnumber, compilers)
+    if bugnumber: return expectedFailureOS(['linux'], bugnumber, compilers)
 
 def expectedFailureWindows(bugnumber=None, compilers=None):
-    if bugnumber: return expectedFailureOS('win32', bugnumber, compilers)
+    if bugnumber: return expectedFailureOS(['windows'], bugnumber, compilers)
 
 def expectedFailureLLGS(bugnumber=None, compilers=None):
     def fn(self):
         # llgs local is only an option on Linux systems
         if 'linux' not in sys.platform:
             return False
         self.runCmd('settings show platform.plugin.linux.use-llgs-for-local')
         return 'true' in self.res.GetOutput() and self.expectedCompiler(compilers)

 def skipIfFreeBSD(func):
     """Decorate the item to skip tests that should be skipped on FreeBSD."""
     if isinstance(func, type) and issubclass(func, unittest2.TestCase):
         raise Exception("@skipIfFreeBSD can only be used to decorate a test method")
     @wraps(func)
     def wrapper(*args, **kwargs):
         from unittest2 import case
         self = args[0]
-        platform = sys.platform
+        platform = lldb.DBG.GetSelectedPlatform().GetTriple().split('-')[2]
         if "freebsd" in platform:
             self.skipTest("skip on FreeBSD")
         else:
             func(*args, **kwargs)
     return wrapper
 
 def skipIfLinux(func):
     """Decorate the item to skip tests that should be skipped on Linux."""
     if isinstance(func, type) and issubclass(func, unittest2.TestCase):
         raise Exception("@skipIfLinux can only be used to decorate a test method")
     @wraps(func)
     def wrapper(*args, **kwargs):
         from unittest2 import case
         self = args[0]
-        platform = sys.platform
+        platform = lldb.DBG.GetSelectedPlatform().GetTriple().split('-')[2]
         if "linux" in platform:
             self.skipTest("skip on linux")
         else:
             func(*args, **kwargs)
     return wrapper
 
 def skipIfNoSBHeaders(func):
     """Decorate the item to mark tests that should be skipped when LLDB is built with no SB API headers."""

 def skipIfWindows(func):
     """Decorate the item to skip tests that should be skipped on Windows."""
     if isinstance(func, type) and issubclass(func, unittest2.TestCase):
         raise Exception("@skipIfWindows can only be used to decorate a test method")
     @wraps(func)
     def wrapper(*args, **kwargs):
         from unittest2 import case
         self = args[0]
-        platform = sys.platform
-        if "win32" in platform:
+        platform = lldb.DBG.GetSelectedPlatform().GetTriple().split('-')[2]
+        if "windows" in platform:
             self.skipTest("skip on Windows")
         else:
             func(*args, **kwargs)
     return wrapper
 
 def skipIfDarwin(func):
     """Decorate the item to skip tests that should be skipped on Darwin."""
     if isinstance(func, type) and issubclass(func, unittest2.TestCase):
         raise Exception("@skipIfDarwin can only be used to decorate a test method")
     @wraps(func)
     def wrapper(*args, **kwargs):
         from unittest2 import case
         self = args[0]
-        platform = sys.platform
-        if "darwin" in platform:
+        platform = lldb.DBG.GetSelectedPlatform().GetTriple().split('-')[2]
+        if "darwin" in platform or "macosx" in platform:
             self.skipTest("skip on darwin")
         else:
             func(*args, **kwargs)
     return wrapper
 
 
 def skipIfLinuxClang(func):
     """Decorate the item to skip tests that should be skipped if building on