Uses the target platform to determine the platform context.

[flackr]

Summary

Uses the target platform to determine the platform context to use. This fixes an early failure in some tests when running on a different remote target.

[tberghammer]

test/lldbtest.py

698

Please fix (or remove) the comment

859

Please consider unifying the check for Linux and FreeBSD.

[flackr]

Remove platformIsLinux rather than start creating platformIsX for each platform string getPlatform can return.

test/lldbtest.py

698

Removed.

859

Removed platformIsLinux().

[tberghammer]

LGTM

test/functionalities/inferior-crashing/recursive-inferior/TestRecursiveInferior.py

def recursive_inferior_crashing_step_after_break(self):
         """Test that lldb behaves correctly when stepping after a crash."""
         exe = os.path.join(os.getcwd(), "a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         self.runCmd("run", RUN_SUCCEEDED)
         self.check_stop_reason()
 
         expected_state = 'exited' # Provide the exit code.
-        if self.platformIsDarwin() or self.platformIsLinux():
+        if self.platformIsDarwin() or self.getPlatform() == "linux":
             expected_state = 'stopped' # TODO: Determine why 'next' and 'continue' have no effect after a crash.
 
         self.expect("next",
             substrs = ['Process', expected_state])
 
         if expected_state == 'exited':
             self.expect("thread list", error=True,substrs = ['Process must be launched'])
         else:

test/lldbtest.py

def expectedFailureLinux(bugnumber=None, compilers=None):
     return expectedFailureOS(['linux'], bugnumber, compilers)
 
 def expectedFailureWindows(bugnumber=None, compilers=None):
     return expectedFailureOS(['windows'], bugnumber, compilers)
 
 def expectedFailureLLGS(bugnumber=None, compilers=None):
     def fn(self):
         # llgs local is only an option on Linux targets
-        if not self.platformIsLinux():
+        if self.getPlatform() != 'linux':
             return False
         self.runCmd('settings show platform.plugin.linux.use-llgs-for-local')
         return 'true' in self.res.GetOutput() and self.expectedCompiler(compilers)
     return expectedFailure(fn, bugnumber)
 
 def skipIfRemote(func):
     """Decorate the item to skip tests if testing remotely."""
     if isinstance(func, type) and issubclass(func, unittest2.TestCase):
def skipIfWindows(func):
     """Decorate the item to skip tests that should be skipped on Windows."""
     return skipIfPlatform(["windows"])(func)
 
 def skipUnlessDarwin(func):
     """Decorate the item to skip tests that should be skipped on any non Darwin platform."""
     return skipUnlessPlatform(getDarwinOSTriples())(func)
 
 def getPlatform():
+    """Returns the target platform the test suite is running on."""
     platform = lldb.DBG.GetSelectedPlatform().GetTriple().split('-')[2]
     if platform.startswith('freebsd'):
         platform = 'freebsd'
     return platform
 
+def platformIsDarwin():
+    """Returns true if the OS triple for the selected platform is any valid apple OS"""
+    return getPlatform() in getDarwinOSTriples()
+
 def skipIfPlatform(oslist):
     """Decorate the item to skip tests if running on one of the listed platforms."""
     return unittest2.skipIf(getPlatform() in oslist,
                             "skip on %s" % (", ".join(oslist)))
 
 def skipUnlessPlatform(oslist):
     """Decorate the item to skip tests unless running on one of the listed platforms."""
     return unittest2.skipUnless(getPlatform() in oslist,
                                 "requires on of %s" % (", ".join(oslist)))
 
def setUpClass(cls):
         # Change current working directory if ${LLDB_TEST} is defined.
         # See also dotest.py which sets up ${LLDB_TEST}.
         if ("LLDB_TEST" in os.environ):
             if traceAlways:
                 print >> sys.stderr, "Change dir to:", os.path.join(os.environ["LLDB_TEST"], cls.mydir)
             os.chdir(os.path.join(os.environ["LLDB_TEST"], cls.mydir))
 
         # Set platform context.
-        if sys.platform.startswith('darwin'):
+        if platformIsDarwin():
             cls.platformContext = _PlatformContext('DYLD_LIBRARY_PATH', 'lib', 'dylib')
-        elif sys.platform.startswith('linux') or sys.platform.startswith('freebsd'):
+        elif getPlatform() == "linux" or getPlatform() == "freebsd":
             cls.platformContext = _PlatformContext('LD_LIBRARY_PATH', 'lib', 'so')
         else:
             cls.platformContext = None
 
     @classmethod
     def tearDownClass(cls):
         """
         Python unittest framework class teardown fixture.
def getCompilerVersion(self):
         for line in version_output.split(os.linesep):
             m = re.search('version ([0-9\.]+)', line)
             if m:
                 version = m.group(1)
         return version
 
     def platformIsDarwin(self):
         """Returns true if the OS triple for the selected platform is any valid apple OS"""
-        platform_name = self.getPlatform()
-        return platform_name in getDarwinOSTriples()
-
-    def platformIsLinux(self):
-        """Returns true if the OS triple for the selected platform is any valid apple OS"""
-        platform_name = self.getPlatform()
-        return platform_name == "linux"
+        return platformIsDarwin()
 
     def getPlatform(self):
-        """Returns the platform the test suite is running on."""
+        """Returns the target platform the test suite is running on."""
         return getPlatform()
 
     def isIntelCompiler(self):
         """ Returns true if using an Intel (ICC) compiler, false otherwise. """
         return any([x in self.getCompiler() for x in ["icc", "icpc", "icl"]])
 
     def expectedCompilerVersion(self, compiler_version):
         """Returns True iff compiler_version[1] matches the current compiler version.