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

1347

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.

1361

Please don't use sys.platfrom here

test/lldbtest.py

588–589

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

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_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)
+dont_do_dsym_test = False
 
 # 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 = {}
 

 # For the time being, let's bracket the test runner within the
 # lldb.SBDebugger.Initialize()/Terminate() pair.
 import lldb
 
 # Create a singleton SBDebugger in the lldb namespace.
 lldb.DBG = lldb.SBDebugger.Create()
 
 if lldb_platform_name:
+    lldb.target_platform = lldb_platform_name
     print "Setting up remote platform '%s'" % (lldb_platform_name)
     lldb.remote_platform = lldb.SBPlatform(lldb_platform_name)
     if not lldb.remote_platform.IsValid():
         print "error: unable to create the LLDB platform named '%s'." % (lldb_platform_name)
         exitTestSuite(1)
     if lldb_platform_url:
         # We must connect to a remote platform if a LLDB platform URL was specified
         print "Connecting to remote platform '%s' at '%s'..." % (lldb_platform_name, lldb_platform_url)
         platform_connect_options = lldb.SBPlatformConnectOptions(lldb_platform_url); 
         err = lldb.remote_platform.ConnectRemote(platform_connect_options)
         if err.Success():
             print "Connected."
         else:
             print "error: failed to connect to remote platform using URL '%s': %s" % (lldb_platform_url, err)
             exitTestSuite(1)
     
     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.target_platform = sys.platform
     lldb.remote_platform = None
     lldb.remote_platform_working_dir = None
+
+# 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 lldb.target_platform or "freebsd" in lldb.target_platform
+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 lldb.target_platform
+
+# Don't do lldb-server (llgs) tests on anything except Linux.
+dont_do_llgs_test = not ("linux" in lldb.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):
     """

test/lldbtest.py

 
 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 fn(self):
-        return os in sys.platform and self.expectedCompiler(compilers)
+        return os in lldb.target_platform and self.expectedCompiler(compilers)
     if bugnumber: return expectedFailure(fn, bugnumber)
 
 def expectedFailureDarwin(bugnumber=None, compilers=None):
     if bugnumber: return expectedFailureOS('darwin', bugnumber, compilers)
 
 def expectedFailureFreeBSD(bugnumber=None, compilers=None):
     if bugnumber: return expectedFailureOS('freebsd', bugnumber, compilers)