Fix a couple of more tests to not create files in the source tree

[labath]

Summary

These were not being flaky, but they're still making the tree dirty.

These tests were using lldbutil.append_to_process_working_directory to
derive the file path so I fix them by modifying the function to return
the build directory for local tests.

Technically, now the path returned by this function does not point to
the process working directory for local tests, but I think it makes
sense to keep the function name, as I think we should move towards
launching the process in the build directory (and I intend to change
this for the handful of inferiors that actually care about their PWD,
for example because they need to create files there).

[aprantl]

Thanks!

By the way, just in case you are motivated :-), one outstanding task is also to replace all uses of the clean target in the makefiles with simply removing the test build directory.

[davide]

LGTM. This is really good work, thanks

[labath]

In D43506#1013276, @aprantl wrote:

Thanks!

By the way, just in case you are motivated :-), one outstanding task is also to replace all uses of the clean target in the makefiles with simply removing the test build directory.

I think I'll get around to that eventually if someone doesn't beat me to it (right now my goal is to be able to run the tests with the source tree mounted read-only). I'm thinking of nuking the build dir *before* the test and just deleting the post-test cleanup, so you can inspect the built binaries if the test fails for some reason.

[clayborg]

Pavel: I would vote for the same thing, if the test runs fine, nuke the directory, if it fails for any reason, leave it around so we can do post mortem. Might be nice to copy the logs over into the build directory if things fail so it is really easy to just go into the directory that contains all failed test and each log file would be right where it needs to be. Right now, you go look in the log directory, then you need to go find the build directory and put the two together.

lldb/trunk/packages/Python/lldbsuite/test/functionalities/process_attach/attach_denied/TestAttachDenied.py

 from lldbsuite.test import lldbutil
 
 exe_name = 'AttachDenied'  # Must match Makefile
 
 
 class AttachDeniedTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
 
     @skipIfWindows
     @skipIfiOSSimulator
     @skipIfDarwinEmbedded  # ptrace(ATTACH_REQUEST...) won't work on ios/tvos/etc
     def test_attach_to_process_by_id_denied(self):
         """Test attach by process id denied"""
         self.build()
         exe = self.getBuildArtifact(exe_name)
 
         # Use a file as a synchronization point between test and inferior.
-        pid_file_path = lldbutil.append_to_process_working_directory(
+        pid_file_path = lldbutil.append_to_process_working_directory(self,
             "pid_file_%d" % (int(time.time())))
         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)
 
         pid = lldbutil.wait_for_file_on_target(self, pid_file_path)
 
         self.expect('process attach -p ' + pid,
                     startstr='error: attach failed:',
                     error=True)

lldb/trunk/packages/Python/lldbsuite/test/functionalities/process_group/TestChangeProcessGroup.py

 """Test that we handle inferiors which change their process group"""
 
 from __future__ import print_function
 
 
 import os
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class ChangeProcessGroupTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         # Find the line number to break for main.c.
         self.line = line_number('main.c', '// Set breakpoint here')
 
     @skipIfFreeBSD  # Times out on FreeBSD llvm.org/pr23731
     @skipIfWindows  # setpgid call does not exist on Windows
     @expectedFailureAndroid("http://llvm.org/pr23762", api_levels=[16])
     @expectedFailureAll(oslist=['ios', 'watchos', 'tvos', 'bridgeos'], bugnumber="<rdar://problem/34538611>") # old lldb-server has race condition, launching an inferior and then launching debugserver in quick succession sometimes fails
     def test_setpgid(self):
         self.build()
         exe = self.getBuildArtifact("a.out")
 
         # Use a file as a synchronization point between test and inferior.
-        pid_file_path = lldbutil.append_to_process_working_directory(
+        pid_file_path = lldbutil.append_to_process_working_directory(self,
             "pid_file_%d" % (int(time.time())))
         self.addTearDownHook(
             lambda: self.run_platform_command(
                 "rm %s" %
                 (pid_file_path)))
 
         popen = self.spawnSubprocess(exe, [pid_file_path])
         self.addTearDownHook(self.cleanupSubprocesses)

lldb/trunk/packages/Python/lldbsuite/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_process_working_directory(
-                os.path.basename(executable))
+            dst_path = lldbutil.join_remote_paths(
+                    lldb.remote_platform.GetWorkingDirectory(), 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))
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_process_working_directory(
+                remote_shlib_path = lldbutil.append_to_process_working_directory(self,
                     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):

lldb/trunk/packages/Python/lldbsuite/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_process_working_directory(*paths):
+def append_to_process_working_directory(test, *paths):
     remote = lldb.remote_platform
     if remote:
         return join_remote_paths(remote.GetWorkingDirectory(), *paths)
-    return os.path.join(os.getcwd(), *paths)
+    return os.path.join(test.getBuildDir(), *paths)
 
 # ==================================================
 # Utility functions to get the correct signal number
 # ==================================================
 
 import signal
 
 

lldb/trunk/packages/Python/lldbsuite/test/python_api/target/TestTargetAPI.py

class TargetAPITestCase(TestBase):
 
     @add_test_categories(['pyapi'])
     def test_get_description(self):
         """Exercise SBTarget.GetDescription() API."""
         self.build()
         self.get_description()
 
     @add_test_categories(['pyapi'])
-    def test_launch_new_process_and_redirect_stdout(self):
-        """Exercise SBTarget.Launch() API."""
-        self.build()
-        self.launch_new_process_and_redirect_stdout()
-
-    @add_test_categories(['pyapi'])
     def test_resolve_symbol_context_with_address(self):
         """Exercise SBTarget.ResolveSymbolContextForAddress() API."""
         self.build()
         self.resolve_symbol_context_with_address()
 
     @add_test_categories(['pyapi'])
     def test_get_platform(self):
         d = {'EXE': 'b.out'}
def get_description(self):
 
         desc = get_description(target, option=lldb.eDescriptionLevelFull)
         if not desc:
             self.fail("SBTarget.GetDescription() failed")
         self.expect(desc, exe=False,
                     substrs=['a.out', 'Target', 'Module', 'Breakpoint'])
 
     @not_remote_testsuite_ready
-    def launch_new_process_and_redirect_stdout(self):
+    @add_test_categories(['pyapi'])
+    @no_debug_info_test
+    def test_launch_new_process_and_redirect_stdout(self):
         """Exercise SBTaget.Launch() API with redirected stdout."""
+        self.build()
         exe = self.getBuildArtifact("a.out")
 
         # Create a target by the debugger.
         target = self.dbg.CreateTarget(exe)
         self.assertTrue(target, VALID_TARGET)
 
         # Add an extra twist of stopping the inferior in a breakpoint, and then continue till it's done.
         # 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"
+        local_path = self.getBuildArtifact("stdout.txt")
+        if os.path.exists(local_path):
+            os.remove(local_path)
+
         if lldb.remote_platform:
-            stdout_path = lldbutil.append_to_process_working_directory(
+            stdout_path = lldbutil.append_to_process_working_directory(self,
                 "lldb-stdout-redirect.txt")
         else:
             stdout_path = local_path
         error = lldb.SBError()
         process = target.Launch(
             self.dbg.GetListener(),
             None,
             None,
def test_launch_new_process_and_redirect_stdout(self):
         if lldb.remote_platform:
             # copy output file to host
             lldb.remote_platform.Get(
                 lldb.SBFileSpec(stdout_path),
                 lldb.SBFileSpec(local_path))
 
         # The 'stdout.txt' file should now exist.
         self.assertTrue(
-            os.path.isfile("stdout.txt"),
+            os.path.isfile(local_path),
             "'stdout.txt' exists due to redirected stdout via SBTarget.Launch() API.")
 
         # Read the output file produced by running the program.
-        with open('stdout.txt', 'r') as f:
+        with open(local_path, 'r') as f:
             output = f.read()
 
-        # Let's delete the 'stdout.txt' file as a cleanup step.
-        try:
-            os.remove("stdout.txt")
-            pass
-        except OSError:
-            pass
-
         self.expect(output, exe=False,
                     substrs=["a(1)", "b(2)", "a(3)"])
 
     def resolve_symbol_context_with_address(self):
         """Exercise SBTaget.ResolveSymbolContextForAddress() API."""
         exe = self.getBuildArtifact("a.out")
 
         # Create a target by the debugger.

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/TestGdbRemoteModuleInfo.py

class TestGdbRemoteModuleInfo(gdbremote_testcase.GdbRemoteTestCaseBase):
     def module_info(self):
         procs = self.prep_debug_monitor_and_inferior()
         self.add_process_info_collection_packets()
         context = self.expect_gdbremote_sequence()
         info = self.parse_process_info_response(context)
 
         self.test_sequence.add_log_lines([
             'read packet: $jModulesInfo:[{"file":"%s","triple":"%s"}]]#00' % (
-                lldbutil.append_to_process_working_directory("a.out"),
+                lldbutil.append_to_process_working_directory(self, "a.out"),
                 info["triple"].decode('hex')),
             {"direction": "send",
              "regex": r'^\$\[{(.*)}\]\]#[0-9A-Fa-f]{2}',
              "capture": {1: "spec"}},
         ], True)
 
         context = self.expect_gdbremote_sequence()
         spec = context.get("spec")

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-server/gdbremote_testcase.py

def prep_debug_monitor_and_inferior(
                 attach_pid = inferior.pid
 
         if self._inferior_startup == self._STARTUP_LAUNCH:
             # Build launch args
             if not inferior_exe_path:
                 inferior_exe_path = self.getBuildArtifact("a.out")
 
             if lldb.remote_platform:
-                remote_path = lldbutil.append_to_process_working_directory(
+                remote_path = lldbutil.append_to_process_working_directory(self,
                     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))

     def maybe_strict_output_regex(self, regex):
         return '.*' + regex + \
             '.*' if lldbplatformutil.hasChattyStderr(self) else '^' + regex + '$'
 
     def install_and_create_launch_args(self):
         exe_path = self.getBuildArtifact("a.out")
         if not lldb.remote_platform:
             return [exe_path]
-        remote_path = lldbutil.append_to_process_working_directory(
+        remote_path = lldbutil.append_to_process_working_directory(self,
             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]