os.path.join does not always work for paths on remote platforms.

[chaoren]

Summary

Since we don't yet have remote windows debugging, it should be safe to assume
that the remote target uses unix path separators.

[chaoren]

Mistakenly used global working dir instead of per test working dir.

[vharron]

test/lldbutil.py

899 ↗

(On Diff #25417)

Go ahead and put the Windows remote path in, it can't hurt any more than a comment.

[clayborg]

Looks good.

lldb/trunk/test/lldbtest.py

 import signal
 from subprocess import *
 import StringIO
 import time
 import types
 import unittest2
 import lldb
 import lldbtest_config
+import lldbutil
 from _pyio import __metaclass__
 
 # See also dotest.parseOptionsAndInitTestdirs(), where the environment variables
 # LLDB_COMMAND_TRACE and LLDB_DO_CLEANUP are set from '-t' and '-r dir' options.
 
 # By default, traceAlways is False.
 if "LLDB_COMMAND_TRACE" in os.environ and os.environ["LLDB_COMMAND_TRACE"]=="YES":
     traceAlways = True
def __init__(self, install_remote):
         self._pid = None
         self._install_remote = install_remote
 
     @property
     def pid(self):
         return self._pid
 
     def launch(self, executable, args):
-        remote_work_dir = lldb.remote_platform.GetWorkingDirectory()
-
         if self._install_remote:
             src_path = executable
-            dst_path = os.path.join(remote_work_dir, os.path.basename(executable))
+            dst_path = lldbutil.append_to_remote_wd(os.path.basename(executable))
 
             dst_file_spec = lldb.SBFileSpec(dst_path, False)
             err = lldb.remote_platform.Install(lldb.SBFileSpec(src_path, True), dst_file_spec)
             if err.Fail():
                 raise Exception("remote_platform.Install('%s', '%s') failed: %s" % (src_path, dst_path, err))
         else:
             dst_path = executable
             dst_file_spec = lldb.SBFileSpec(executable, False)
 
         launch_info = lldb.SBLaunchInfo(args)
         launch_info.SetExecutableFile(dst_file_spec, True)
-        launch_info.SetWorkingDirectory(remote_work_dir)
+        launch_info.SetWorkingDirectory(lldb.remote_platform.GetWorkingDirectory())
 
         # Redirect stdout and stderr to /dev/null
         launch_info.AddSuppressFileAction(1, False, True)
         launch_info.AddSuppressFileAction(2, False, True)
 
         err = lldb.remote_platform.Launch(launch_info)
         if err.Fail():
             raise Exception("remote_platform.Launch('%s', '%s') failed: %s" % (dst_path, args, err))
def markExpectedFailure(self,err,bugnumber):
         self.__expected__ = True
         with recording(self, False) as sbuf:
             # False because there's no need to write "expected failure" to the
             # stderr twice.
             # Once by the Python unittest framework, and a second time by us.
             if bugnumber == None:
                 print >> sbuf, "expected failure"
             else:
-                print >> sbuf, "expected failure (problem id:" + str(bugnumber) + ")"  
+                print >> sbuf, "expected failure (problem id:" + str(bugnumber) + ")"
 
     def markSkippedTest(self):
         """Callback invoked when a test is skipped."""
         self.__skipped__ = True
         with recording(self, False) as sbuf:
             # False because there's no need to write "skipped test" to the
             # stderr twice.
             # Once by the Python unittest framework, and a second time by us.
             print >> sbuf, "skipped test"
 
     def markUnexpectedSuccess(self, bugnumber):
         """Callback invoked when an unexpected success occurred."""
         self.__unexpected__ = True
         with recording(self, False) as sbuf:
             # False because there's no need to write "unexpected success" to the
             # stderr twice.
             # Once by the Python unittest framework, and a second time by us.
             if bugnumber == None:
                 print >> sbuf, "unexpected success"
             else:
-                print >> sbuf, "unexpected success (problem id:" + str(bugnumber) + ")"  
+                print >> sbuf, "unexpected success (problem id:" + str(bugnumber) + ")"
 
     def getRerunArgs(self):
         return " -f %s.%s" % (self.__class__.__name__, self._testMethodName)
 
     def getLogBasenameForCurrentTest(self, prefix=None):
         """
         returns a partial path that can be used as the beginning of the name of multiple
         log files pertaining to this test
def setUp(self):
         # And the result object.
         self.res = lldb.SBCommandReturnObject()
 
         # Run global pre-flight code, if defined via the config file.
         if lldb.pre_flight:
             lldb.pre_flight(self)
 
         if lldb.remote_platform:
-            #remote_test_dir = os.path.join(lldb.remote_platform_working_dir, self.mydir)
-            remote_test_dir = os.path.join(lldb.remote_platform_working_dir, 
-                                           self.getArchitecture(), 
-                                           str(self.test_number), 
-                                           self.mydir)
+            remote_test_dir = lldbutil.join_remote_paths(
+                    lldb.remote_platform_working_dir,
+                    self.getArchitecture(),
+                    str(self.test_number),
             error = lldb.remote_platform.MakeDirectory(remote_test_dir, 0700)
             if error.Success():
                 lldb.remote_platform.SetWorkingDirectory(remote_test_dir)
             else:
                 print "error: making remote directory '%s': %s" % (remote_test_dir, error)
     
     def registerSharedLibrariesWithTarget(self, target, shlibs):
         '''If we are remotely running the test suite, register the shared libraries with the target so they get uploaded, otherwise do nothing
def registerSharedLibrariesWithTarget(self, target, shlibs):
                 # Make sure we found the local shared library in the above code
                 self.assertTrue(os.path.exists(local_shlib_path))
 
             # Add the shared library to our target
             shlib_module = target.AddModule(local_shlib_path, None, None, None)
             if lldb.remote_platform:
                 # We must set the remote install location if we want the shared library
                 # to get uploaded to the remote target
-                remote_shlib_path = os.path.join(lldb.remote_platform.GetWorkingDirectory(), os.path.basename(local_shlib_path))
+                remote_shlib_path = lldbutil.append_to_remote_wd(os.path.basename(local_shlib_path))
                 shlib_module.SetRemoteInstallFileSpec(lldb.SBFileSpec(remote_shlib_path, False))
 
         return environment
 
     # utility methods that tests can use to access the current objects
     def target(self):
         if not self.dbg:
             raise Exception('Invalid debugger instance')

lldb/trunk/test/lldbutil.py

def format(self, value, buffer=None):
             else:
                 if child.GetNumChildren() > 0:
                     rdf = RecursiveDecentFormatter(indent_level=new_indent)
                     rdf.format(child, buffer=output)
                 else:
                     BasicFormatter.format(self, child, buffer=output, indent=new_indent)
 
         return output.getvalue()
+
+# ===========================================================
+# Utility functions for path manipulation on remote platforms
+# ===========================================================
+
+def join_remote_paths(*paths):
+    # TODO: update with actual platform name for remote windows once it exists
+    if lldb.remote_platform.GetName() == 'remote-windows':
+        return os.path.join(*paths).replace(os.path.sep, '\\')
+    return os.path.join(*paths).replace(os.path.sep, '/')
+
+def append_to_remote_wd(*paths):
+    return join_remote_paths(lldb.remote_platform.GetWorkingDirectory(), *paths)

lldb/trunk/test/python_api/target/TestTargetAPI.py

def launch_new_process_and_redirect_stdout(self):
         # We should still see the entire stdout redirected once the process is finished.
         line = line_number('main.c', '// a(3) -> c(3)')
         breakpoint = target.BreakpointCreateByLocation('main.c', line)
 
         # Now launch the process, do not stop at entry point, and redirect stdout to "stdout.txt" file.
         # The inferior should run to completion after "process.Continue()" call.
         local_path = "stdout.txt";
         if lldb.remote_platform:
-            stdout_path = os.path.join(lldb.remote_platform.GetWorkingDirectory(), "lldb-stdout-redirect.txt")
+            stdout_path = lldbutil.append_to_remote_wd("lldb-stdout-redirect.txt")
         else:
             stdout_path = local_path
         error = lldb.SBError()
         process = target.Launch (self.dbg.GetListener(), None, None, None, stdout_path, None, None, 0, False, error)
         process.Continue()
         #self.runCmd("process status")
         if lldb.remote_platform:
             # copy output file to host

lldb/trunk/test/tools/lldb-server/TestLldbGdbServer.py

class LldbGdbServerTestCase(gdbremote_testcase.GdbRemoteTestCaseBase):
     def test_list_threads_in_stop_reply_supported_llgs(self):
         self.init_llgs_test()
         self.list_threads_in_stop_reply_supported()
 
     def install_and_create_launch_args(self):
         exe_path = os.path.abspath('a.out')
         if not lldb.remote_platform:
             return [exe_path]
-        remote_work_dir = lldb.remote_platform.GetWorkingDirectory()
-        remote_path = os.path.join(remote_work_dir, os.path.basename(exe_path))
+        remote_path = lldbutil.append_to_remote_wd(os.path.basename(exe_path))
         remote_file_spec = lldb.SBFileSpec(remote_path, False)
         err = lldb.remote_platform.Install(lldb.SBFileSpec(exe_path, True), remote_file_spec)
         if err.Fail():
             raise Exception("remote_platform.Install('%s', '%s') failed: %s" % (exe_path, remote_path, err))
         return [remote_path]
 
     def start_inferior(self):
         launch_args = self.install_and_create_launch_args()

lldb/trunk/test/tools/lldb-server/gdbremote_testcase.py

def prep_debug_monitor_and_inferior(self, inferior_args=None, inferior_sleep_seconds=3, inferior_exe_path=None):
                 attach_pid = inferior.pid
 
         if self._inferior_startup == self._STARTUP_LAUNCH:
             # Build launch args
             if not inferior_exe_path:
                 inferior_exe_path = os.path.abspath("a.out")
 
             if lldb.remote_platform:
-                remote_work_dir = lldb.remote_platform.GetWorkingDirectory()
-                remote_path = os.path.join(remote_work_dir, os.path.basename(inferior_exe_path))
+                remote_path = lldbutil.append_to_remote_wd(os.path.basename(inferior_exe_path))
                 remote_file_spec = lldb.SBFileSpec(remote_path, False)
                 err = lldb.remote_platform.Install(lldb.SBFileSpec(inferior_exe_path, True), remote_file_spec)
                 if err.Fail():
                     raise Exception("remote_platform.Install('%s', '%s') failed: %s" % (inferior_exe_path, remote_path, err))
                 inferior_exe_path = remote_path
 
             launch_args = [inferior_exe_path]
             if inferior_args:

lldb/trunk/test/types/AbstractBase.py

def build_and_run_with_source_atoms_expr(self, source, atoms, expr, dsym=True, bc=False, qd=False):
         else:
             self.generic_type_tester(self.exe_name, atoms, blockCaptured=bc, quotedDisplay=qd)
 
     def process_launch_o(self, localPath):
         # process launch command output redirect always goes to host the process is running on
         if lldb.remote_platform:
             # process launch -o requires a path that is valid on the target
             self.assertIsNotNone(lldb.remote_platform.GetWorkingDirectory())
-            remote_path = os.path.join(lldb.remote_platform.GetWorkingDirectory(), "lldb-stdout-redirect.txt")
+            remote_path = lldbutil.append_to_remote_wd("lldb-stdout-redirect.txt")
             self.runCmd('process launch -o {remote}'.format(remote=remote_path))
             # copy remote_path to local host
             self.runCmd('platform get-file {remote} "{local}"'.format(
                 remote=remote_path, local=self.golden_filename))
         else:
             self.runCmd('process launch -o "{local}"'.format(local=self.golden_filename))
 
     def generic_type_tester(self, exe_name, atoms, quotedDisplay=False, blockCaptured=False):