Fix TestAttachDenied and TestChangeProcessGroup for remote Windows to Android.

[chaoren]

Summary

Updated append_to_remote_wd to work for both remote and local.

[ovyalov]

LGTM

lldb/trunk/test/functionalities/process_attach/attach_denied/TestAttachDenied.py

class AttachDeniedTestCase(TestBase):
     @skipIfWindows
     def test_attach_to_process_by_id_denied(self):
         """Test attach by process id denied"""
 
         self.buildDefault()
         exe = os.path.join(os.getcwd(), exe_name)
 
         # Use a file as a synchronization point between test and inferior.
-        pid_file_path = os.path.join(self.get_process_working_directory(),
-                                     "pid_file_%d" % (int(time.time())))
+        pid_file_path = lldbutil.append_to_process_working_directory(
         self.addTearDownHook(lambda: self.run_platform_command("rm %s" % (pid_file_path)))
 
         # Spawn a new process
         popen = self.spawnSubprocess(exe, [pid_file_path])
         self.addTearDownHook(self.cleanupSubprocesses)
 
         max_attempts = 5
         for i in range(max_attempts):

lldb/trunk/test/functionalities/process_group/TestChangeProcessGroup.py

def run_platform_command(self, cmd):
         shell_command = lldb.SBPlatformShellCommand(cmd)
         err = platform.Run(shell_command)
         return (err, shell_command.GetStatus(), shell_command.GetOutput())
 
     def setpgid(self):
         exe = os.path.join(os.getcwd(), 'a.out')
 
         # Use a file as a synchronization point between test and inferior.
-        pid_file_path = os.path.join(self.get_process_working_directory(),
-                                     "pid_file_%d" % (int(time.time())))
+        pid_file_path = lldbutil.append_to_process_working_directory(
         self.addTearDownHook(lambda: self.run_platform_command("rm %s" % (pid_file_path)))
 
         popen = self.spawnSubprocess(exe, [pid_file_path])
         self.addTearDownHook(self.cleanupSubprocesses)
 
         max_attempts = 5
         for i in range(max_attempts):
             err, retcode, msg = self.run_platform_command("ls %s" % pid_file_path)

lldb/trunk/test/lldbtest.py

class _RemoteProcess(_BaseProcess):
 
     @property
     def pid(self):
         return self._pid
 
     def launch(self, executable, args):
         if self._install_remote:
             src_path = executable
-            dst_path = lldbutil.append_to_remote_wd(os.path.basename(executable))
+            dst_path = lldbutil.append_to_process_working_directory(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)
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 = lldbutil.append_to_remote_wd(os.path.basename(local_shlib_path))
+                remote_shlib_path = lldbutil.append_to_process_working_directory(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 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)
+def append_to_process_working_directory(*paths):
+    remote = lldb.remote_platform
+    if remote:
+        return join_remote_paths(remote.GetWorkingDirectory(), *paths)
+    return os.path.join(os.getcwd(), *paths)
 
 # ==================================================
 # Utility functions to get the correct signal number
 # ==================================================
 
 import signal
 
 def get_signal_number(signal_name):

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 = lldbutil.append_to_remote_wd("lldb-stdout-redirect.txt")
+            stdout_path = lldbutil.append_to_process_working_directory("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_path = lldbutil.append_to_remote_wd(os.path.basename(exe_path))
+        remote_path = lldbutil.append_to_process_working_directory(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_path = lldbutil.append_to_remote_wd(os.path.basename(inferior_exe_path))
+                remote_path = lldbutil.append_to_process_working_directory(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 = lldbutil.append_to_remote_wd("lldb-stdout-redirect.txt")
+            remote_path = lldbutil.append_to_process_working_directory("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):