Next batch of test-tree-cleaning changes

[labath]

Summary

The changes here fall into several categories.

• some tests were redirecting inferior stdout/err to a file. For these I make sure we use an absolute path for the file. I also create a lldbutil.read_file_on_target helper function to encapsulate the differences between reading a file locally and remotely.
• some tests were redirecting the pexpect I/O into a file. For these I use a python StringIO object to avoid creating a file altogether.
• the TestSettings inferior was creating a file. Here, I make sure the inferior is launched with pwd=build-dir so that the files end up created there.
• lldb-mi --log (used by some tests) creates a log file in PWD without the ability say differently. To make this work I make sure to run lldb-mi with PWD=build_dir. This in turn necessitated a couple of changes in other lldb-mi tests, which were using relative paths to access the source tree.

lldb/trunk/packages/Python/lldbsuite/test/functionalities/process_launch/TestProcessLaunch.py

 from lldbsuite.test import lldbutil
 
 import six
 
 
 class ProcessLaunchTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
 
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         self.runCmd("settings set auto-confirm true")
 
     def tearDown(self):
         self.runCmd("settings clear auto-confirm")
         TestBase.tearDown(self)
 
     @not_remote_testsuite_ready
     def test_io(self):
         """Test that process launch I/O redirection flags work properly."""
         self.build()
         exe = self.getBuildArtifact("a.out")
         self.expect("file " + exe,
                     patterns=["Current executable set to .*a.out"])
 
         in_file = "input-file.txt"
-        out_file = "output-test.out"
-        err_file = "output-test.err"
+        out_file = lldbutil.append_to_process_working_directory(self, "output-test.out")
+        err_file = lldbutil.append_to_process_working_directory(self, "output-test.err")
 
         # Make sure the output files do not exist before launching the process
         try:
             os.remove(out_file)
         except OSError:
             pass
 
         try:
             os.remove(err_file)
         except OSError:
             pass
 
-        launch_command = "process launch -i " + \
-            in_file + " -o " + out_file + " -e " + err_file
+        launch_command = "process launch -i '{0}' -o '{1}' -e '{2}' -w '{3}'".format(
+                in_file, out_file, err_file, self.get_process_working_directory())
 
         if lldb.remote_platform:
             self.runCmd('platform put-file "{local}" "{remote}"'.format(
                 local=in_file, remote=in_file))
 
         self.expect(launch_command,
                     patterns=["Process .* launched: .*a.out"])
 
-        if lldb.remote_platform:
-            self.runCmd('platform get-file "{remote}" "{local}"'.format(
-                remote=out_file, local=out_file))
-            self.runCmd('platform get-file "{remote}" "{local}"'.format(
-                remote=err_file, local=err_file))
-
         success = True
         err_msg = ""
 
-        # Check to see if the 'stdout' file was created
-        try:
-            out_f = open(out_file)
-        except IOError:
-            success = False
-            err_msg = err_msg + "   ERROR: stdout file was not created.\n"
-        else:
-            # Check to see if the 'stdout' file contains the right output
-            line = out_f.readline()
-            if line != "This should go to stdout.\n":
-                success = False
-                err_msg = err_msg + "    ERROR: stdout file does not contain correct output.\n"
-                out_f.close()
+        out = lldbutil.read_file_on_target(self, out_file)
+        if out != "This should go to stdout.\n":
 
-        # Try to delete the 'stdout' file
-        try:
-            os.remove(out_file)
-        except OSError:
-            pass
 
-        # Check to see if the 'stderr' file was created
-        try:
-            err_f = open(err_file)
-        except IOError:
-            success = False
-            err_msg = err_msg + "     ERROR:  stderr file was not created.\n"
-        else:
-            # Check to see if the 'stderr' file contains the right output
-            line = err_f.readline()
-            if line != "This should go to stderr.\n":
-                success = False
-                err_msg = err_msg + "    ERROR: stderr file does not contain correct output.\n\
-"
-                err_f.close()
-
-        # Try to delete the 'stderr' file
-        try:
-            os.remove(err_file)
-        except OSError:
-            pass
+        err = lldbutil.read_file_on_target(self, err_file)
+        if err != "This should go to stderr.\n":
+            err_msg = err_msg + "    ERROR: stderr file does not contain correct output.\n"
 
         if not success:
             self.fail(err_msg)
 
     # rdar://problem/9056462
     # The process launch flag '-w' for setting the current working directory
     # not working?
     @not_remote_testsuite_ready

lldb/trunk/packages/Python/lldbsuite/test/functionalities/single-quote-in-filename-to-lldb/TestSingleQuoteInFilename.py

 """
 Test the lldb command line takes a filename with single quote chars.
 """
 
 from __future__ import print_function
 
 
 import os
 import lldb
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
-
+import six
 
 class SingleQuoteInCommandLineTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
     myexe = "path with '09/a.out"
 
     @classmethod
     def classCleanup(cls):
def test_lldb_invocation_with_single_quote_in_filename(self):
 
         # So that the child gets torn down after the test.
         self.child = pexpect.spawn(
             '%s %s "%s"' %
             (lldbtest_config.lldbExec, self.lldbOption,
              self.getBuildArtifact(self.myexe)))
         child = self.child
         child.setecho(True)
-        # Turn on logging for input/output to/from the child.
-        with open('child_send.txt', 'w') as f_send:
-            with open('child_read.txt', 'w') as f_read:
-                child.logfile_send = f_send
-                child.logfile_read = f_read
-
-                child.expect_exact(prompt)
+        child.logfile_send = send = six.StringIO()
+        child.logfile_read = read = six.StringIO()
 
-                child.send("help watchpoint")
-                child.sendline('')
-                child.expect_exact(prompt)
 
         # Now that the necessary logging is done, restore logfile to None to
         # stop further logging.
         child.logfile_send = None
         child.logfile_read = None
 
-        with open('child_send.txt', 'r') as fs:
-            if self.TraceOn():
-                print("\n\nContents of child_send.txt:")
-                print(fs.read())
-        with open('child_read.txt', 'r') as fr:
-            from_child = fr.read()
-            if self.TraceOn():
-                print("\n\nContents of child_read.txt:")
-                print(from_child)
+            print("\n\nContents of send")
+            print(send.getvalue())
+            print("\n\nContents of read")
+            print(read.getvalue())
 
-            self.expect(from_child, exe=False,
-                        substrs=["Current executable set to"])
+        self.expect(read.getvalue(), exe=False,

lldb/trunk/packages/Python/lldbsuite/test/lldbutil.py

def skip_if_library_missing(test, target, library):
     return skip_if_callable(
         test,
         find_library_callable,
         "could not find library matching '%s' in target %s" %
         (library,
          target))
 
 
+def read_file_on_target(test, remote):
+    if lldb.remote_platform:
+        local = test.getBuildArtifact("file_from_target")
+        error = lldb.remote_platform.Get(lldb.SBFileSpec(remote, False),
+                    lldb.SBFileSpec(local, True))
+        test.assertTrue(error.Success(), "Reading file {0} failed: {1}".format(remote, error))
+    else:
+        local = remote
+    with open(local, 'r') as f:
+        return f.read()
+
+def read_file_from_process_wd(test, name):
+    path = append_to_process_working_directory(test, name)
+    return read_file_on_target(test, path)
+
 def wait_for_file_on_target(testcase, file_path, max_attempts=6):
     for i in range(max_attempts):
         err, retcode, msg = testcase.run_platform_command("ls %s" % file_path)
         if err.Success() and retcode == 0:
             break
         if i < max_attempts:
             # Exponential backoff!
             import time
             time.sleep(pow(2, i) * 0.25)
     else:
         testcase.fail(
             "File %s not found even after %d attempts." %
             (file_path, max_attempts))
 
-    err, retcode, data = testcase.run_platform_command("cat %s" % (file_path))
-
-    testcase.assertTrue(
-        err.Success() and retcode == 0, "Failed to read file %s: %s, retcode: %d" %
-        (file_path, err.GetCString(), retcode))
-    return data
+    return read_file_on_target(testcase, file_path)

lldb/trunk/packages/Python/lldbsuite/test/settings/TestSettings.py

 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class SettingsCommandTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
+    NO_DEBUG_INFO_TESTCASE = True
 
-    @classmethod
-    def classCleanup(cls):
-        """Cleanup the test byproducts."""
-        cls.RemoveTempFile("output1.txt")
-        cls.RemoveTempFile("output2.txt")
-        cls.RemoveTempFile("stderr.txt")
-        cls.RemoveTempFile("stdout.txt")
-
-    @no_debug_info_test
     def test_apropos_should_also_search_settings_description(self):
         """Test that 'apropos' command should also search descriptions for the settings variables."""
 
         self.expect("apropos 'environment variable'",
                     substrs=["target.env-vars",
                              "environment variables",
                              "executable's environment"])
 
-    @no_debug_info_test
     def test_append_target_env_vars(self):
         """Test that 'append target.run-args' works."""
         # Append the env-vars.
         self.runCmd('settings append target.env-vars MY_ENV_VAR=YES')
         # And add hooks to restore the settings during tearDown().
         self.addTearDownHook(
             lambda: self.runCmd("settings clear target.env-vars"))
 
         # Check it immediately!
         self.expect('settings show target.env-vars',
                     substrs=['MY_ENV_VAR=YES'])
 
-    @no_debug_info_test
     def test_insert_before_and_after_target_run_args(self):
         """Test that 'insert-before/after target.run-args' works."""
         # Set the run-args first.
         self.runCmd('settings set target.run-args a b c')
         # And add hooks to restore the settings during tearDown().
         self.addTearDownHook(
             lambda: self.runCmd("settings clear target.run-args"))
 
         # Now insert-before the index-0 element with '__a__'.
         self.runCmd('settings insert-before target.run-args 0 __a__')
         # And insert-after the index-1 element with '__A__'.
         self.runCmd('settings insert-after target.run-args 1 __A__')
         # Check it immediately!
         self.expect('settings show target.run-args',
                     substrs=['target.run-args',
                              '[0]: "__a__"',
                              '[1]: "a"',
                              '[2]: "__A__"',
                              '[3]: "b"',
                              '[4]: "c"'])
 
-    @no_debug_info_test
     def test_replace_target_run_args(self):
         """Test that 'replace target.run-args' works."""
         # Set the run-args and then replace the index-0 element.
         self.runCmd('settings set target.run-args a b c')
         # And add hooks to restore the settings during tearDown().
         self.addTearDownHook(
             lambda: self.runCmd("settings clear target.run-args"))
 
         # Now replace the index-0 element with 'A', instead.
         self.runCmd('settings replace target.run-args 0 A')
         # Check it immediately!
         self.expect('settings show target.run-args',
                     substrs=['target.run-args (arguments) =',
                              '[0]: "A"',
                              '[1]: "b"',
                              '[2]: "c"'])
 
-    @no_debug_info_test
     def test_set_prompt(self):
         """Test that 'set prompt' actually changes the prompt."""
 
         # Set prompt to 'lldb2'.
         self.runCmd("settings set prompt 'lldb2 '")
 
         # Immediately test the setting.
         self.expect("settings show prompt", SETTING_MSG("prompt"),
                     startstr='prompt (string) = "lldb2 "')
 
         # The overall display should also reflect the new setting.
         self.expect("settings show", SETTING_MSG("prompt"),
                     substrs=['prompt (string) = "lldb2 "'])
 
         # Use '-r' option to reset to the original default prompt.
         self.runCmd("settings clear prompt")
 
-    @no_debug_info_test
     def test_set_term_width(self):
         """Test that 'set term-width' actually changes the term-width."""
 
         self.runCmd("settings set term-width 70")
 
         # Immediately test the setting.
         self.expect("settings show term-width", SETTING_MSG("term-width"),
                     startstr="term-width (int) = 70")
def test_set_frame_format(self):
         format_string = "frame #${frame.index}: ${frame.pc}{ ${module.file.basename}`${function.name}{${function.pc-offset}}}{ at ${line.file.fullpath}:${line.number}}{, lang=${language}}\n"
         self.runCmd("settings set frame-format %s" % format_string)
 
         # Immediately test the setting.
         self.expect("settings show frame-format", SETTING_MSG("frame-format"),
                     substrs=[format_string])
 
         self.runCmd("breakpoint set -n main")
-        self.runCmd("run")
+        self.runCmd("process launch --working-dir '{0}'".format(self.get_process_working_directory()),
+                RUN_SUCCEEDED)
         self.expect("thread backtrace",
                     substrs=["`main", self.getSourceDir()])
 
     def test_set_auto_confirm(self):
         """Test that after 'set auto-confirm true', manual confirmation should not kick in."""
         self.build()
 
         exe = self.getBuildArtifact("a.out")
def test_run_args_and_env_vars(self):
         # And add hooks to restore the settings during tearDown().
         self.runCmd('settings set target.run-args A B C')
         self.addTearDownHook(
             lambda: self.runCmd("settings clear target.run-args"))
         self.runCmd('settings set target.env-vars ["MY_ENV_VAR"]=YES')
         self.addTearDownHook(
             lambda: self.runCmd("settings clear target.env-vars"))
 
-        self.runCmd("run", RUN_SUCCEEDED)
+        self.runCmd("process launch --working-dir '{0}'".format(self.get_process_working_directory()),
+                RUN_SUCCEEDED)
 
         # Read the output file produced by running the program.
-        if lldb.remote_platform:
-            self.runCmd('platform get-file "output2.txt" "output2.txt"')
-        with open('output2.txt', 'r') as f:
-            output = f.read()
+        output = lldbutil.read_file_from_process_wd(self, "output2.txt")
 
         self.expect(
             output,
             exe=False,
             substrs=[
                 "argv[1] matches",
                 "argv[2] matches",
                 "argv[3] matches",
def test_pass_host_env_vars(self):
         os.environ["MY_HOST_ENV_VAR2"] = "VAR2"
 
         # This is the function to unset the two env variables set above.
         def unset_env_variables():
             os.environ.pop("MY_HOST_ENV_VAR1")
             os.environ.pop("MY_HOST_ENV_VAR2")
 
         self.addTearDownHook(unset_env_variables)
-        self.runCmd("run", RUN_SUCCEEDED)
+        self.runCmd("process launch --working-dir '{0}'".format(self.get_process_working_directory()),
+                RUN_SUCCEEDED)
 
         # Read the output file produced by running the program.
-        if lldb.remote_platform:
-            self.runCmd('platform get-file "output1.txt" "output1.txt"')
-        with open('output1.txt', 'r') as f:
-            output = f.read()
+        output = lldbutil.read_file_from_process_wd(self, "output1.txt")
 
         self.expect(
             output,
             exe=False,
             substrs=[
                 "The host environment variable 'MY_HOST_ENV_VAR1' successfully passed.",
                 "The host environment variable 'MY_HOST_ENV_VAR2' successfully passed."])
 
     @skipIfDarwinEmbedded   # <rdar://problem/34446098> debugserver on ios etc can't write files
     def test_set_error_output_path(self):
         """Test that setting target.error/output-path for the launched process works."""
         self.build()
 
         exe = self.getBuildArtifact("a.out")
         self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
 
         # Set the error-path and output-path and verify both are set.
-        self.runCmd("settings set target.error-path stderr.txt")
-        self.runCmd("settings set target.output-path stdout.txt")
+        self.runCmd("settings set target.error-path '{0}'".format(
+            lldbutil.append_to_process_working_directory(self, "stderr.txt")))
+        self.runCmd("settings set target.output-path '{0}".format(
+            lldbutil.append_to_process_working_directory(self, "stdout.txt")))
         # And add hooks to restore the original settings during tearDown().
         self.addTearDownHook(
             lambda: self.runCmd("settings clear target.output-path"))
         self.addTearDownHook(
             lambda: self.runCmd("settings clear target.error-path"))
 
         self.expect("settings show target.error-path",
                     SETTING_MSG("target.error-path"),
-                    substrs=['target.error-path (file) = "stderr.txt"'])
+                    substrs=['target.error-path (file)', 'stderr.txt"'])
 
         self.expect("settings show target.output-path",
                     SETTING_MSG("target.output-path"),
-                    substrs=['target.output-path (file) = "stdout.txt"'])
-
-        self.runCmd("run", RUN_SUCCEEDED)
-
-        if lldb.remote_platform:
-            self.runCmd('platform get-file "stderr.txt" "stderr.txt"')
-            self.runCmd('platform get-file "stdout.txt" "stdout.txt"')
-
-        # The 'stderr.txt' file should now exist.
-        self.assertTrue(os.path.isfile("stderr.txt"),
-                        "'stderr.txt' exists due to target.error-path.")
+                    substrs=['target.output-path (file)', 'stdout.txt"'])
 
-        # Read the output file produced by running the program.
-        with open('stderr.txt', 'r') as f:
-            output = f.read()
+        self.runCmd("process launch --working-dir '{0}'".format(self.get_process_working_directory()),
+                RUN_SUCCEEDED)
 
+        output = lldbutil.read_file_from_process_wd(self, "stderr.txt")
         message = "This message should go to standard error."
         if lldbplatformutil.hasChattyStderr(self):
             self.expect(output, exe=False, substrs=[message])
         else:
             self.expect(output, exe=False, startstr=message)
 
-        # The 'stdout.txt' file should now exist.
-        self.assertTrue(os.path.isfile("stdout.txt"),
-                        "'stdout.txt' exists due to target.output-path.")
-
-        # Read the output file produced by running the program.
-        with open('stdout.txt', 'r') as f:
-            output = f.read()
-
+        output = lldbutil.read_file_from_process_wd(self, "stdout.txt")
         self.expect(output, exe=False,
                     startstr="This message should go to standard out.")
 
-    @no_debug_info_test
     def test_print_dictionary_setting(self):
         self.runCmd("settings clear target.env-vars")
         self.runCmd("settings set target.env-vars [\"MY_VAR\"]=some-value")
         self.expect("settings show target.env-vars",
                     substrs=["MY_VAR=some-value"])
         self.runCmd("settings clear target.env-vars")
 
-    @no_debug_info_test
     def test_print_array_setting(self):
         self.runCmd("settings clear target.run-args")
         self.runCmd("settings set target.run-args gobbledy-gook")
         self.expect("settings show target.run-args",
                     substrs=['[0]: "gobbledy-gook"'])
         self.runCmd("settings clear target.run-args")
 
-    @no_debug_info_test
     def test_settings_with_quotes(self):
         self.runCmd("settings clear target.run-args")
         self.runCmd("settings set target.run-args a b c")
         self.expect("settings show target.run-args",
                     substrs=['[0]: "a"',
                              '[1]: "b"',
                              '[2]: "c"'])
         self.runCmd("settings set target.run-args 'a b c'")
def test_settings_with_quotes(self):
                     'thread-format (format-string) = "abc def"')
         # Make sure when no quotes are provided that we maintain any trailing
         # spaces
         self.runCmd('settings set thread-format abc def   ')
         self.expect("settings show thread-format",
                     'thread-format (format-string) = "abc def   "')
         self.runCmd('settings clear thread-format')
 
-    @no_debug_info_test
     def test_settings_with_trailing_whitespace(self):
 
         # boolean
         # Set to known value
         self.runCmd("settings set target.skip-prologue true")
         # Set to new value with trailing whitespace
         self.runCmd("settings set target.skip-prologue false ")
         # Make sure the setting was correctly set to "false"
def test_settings_with_trailing_whitespace(self):
         self.runCmd("settings clear disassembly-format")  # Set to known value
         # Set to new value with trailing whitespaces
         self.runCmd("settings set disassembly-format foo ")
         self.expect("settings show disassembly-format",
                     SETTING_MSG("disassembly-format"),
                     substrs=['disassembly-format (format-string) = "foo "'])
         self.runCmd("settings clear disassembly-format", check=False)
 
-    @no_debug_info_test
     def test_all_settings_exist(self):
         self.expect("settings show",
                     substrs=["auto-confirm",
                              "frame-format",
                              "notify-void",
                              "prompt",
                              "script-lang",
                              "stop-disassembly-count",

lldb/trunk/packages/Python/lldbsuite/test/terminal/TestSTTYBeforeAndAfter.py

 """
 Test that 'stty -a' displays the same output before and after running the lldb command.
 """
 
 from __future__ import print_function
 
 
 import os
 import lldb
+import six
 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestSTTYBeforeAndAfter(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
def test_stty_dash_a_before_and_afetr_invoking_lldb_command(self):
             child.sendline('set env(TERM) xterm')
         else:
             child.sendline('set env(TERM) vt100')
         child.expect(expect_prompt)
         child.sendline('puts $env(TERM)')
         child.expect(expect_prompt)
 
         # Turn on loggings for input/output to/from the child.
-        with open('child_send1.txt', 'w') as f_send1:
-            with open('child_read1.txt', 'w') as f_read1:
-                child.logfile_send = f_send1
-                child.logfile_read = f_read1
-
-                child.sendline('stty -a')
-                child.expect(expect_prompt)
+        child.logfile_send = child_send1 = six.StringIO()
+        child.logfile_read = child_read1 = six.StringIO()
 
         # Now that the stage1 logging is done, restore logfile to None to
         # stop further logging.
         child.logfile_send = None
         child.logfile_read = None
 
         # Invoke the lldb command.
         child.sendline('%s %s' % (lldbtest_config.lldbExec, self.lldbOption))
         child.expect_exact(lldb_prompt)
 
         # Immediately quit.
         child.sendline('quit')
         child.expect(expect_prompt)
 
-        with open('child_send2.txt', 'w') as f_send2:
-            with open('child_read2.txt', 'w') as f_read2:
-                child.logfile_send = f_send2
-                child.logfile_read = f_read2
-
-                child.sendline('stty -a')
-                child.expect(expect_prompt)
+        child.logfile_send = child_send2 = six.StringIO()
+        child.logfile_read = child_read2 = six.StringIO()
 
-                child.sendline('exit')
 
         # Now that the stage2 logging is done, restore logfile to None to
         # stop further logging.
         child.logfile_send = None
         child.logfile_read = None
 
-        with open('child_send1.txt', 'r') as fs:
-            if self.TraceOn():
-                print("\n\nContents of child_send1.txt:")
-                print(fs.read())
-        with open('child_read1.txt', 'r') as fr:
-            from_child1 = fr.read()
-            if self.TraceOn():
-                print("\n\nContents of child_read1.txt:")
-                print(from_child1)
-
-        with open('child_send2.txt', 'r') as fs:
-            if self.TraceOn():
-                print("\n\nContents of child_send2.txt:")
-                print(fs.read())
-        with open('child_read2.txt', 'r') as fr:
-            from_child2 = fr.read()
-            if self.TraceOn():
-                print("\n\nContents of child_read2.txt:")
-                print(from_child2)
+            print("\n\nContents of child_send1:")
+            print(child_send1.getvalue())
+            print("\n\nContents of child_read1:")
+            print(child_read1.getvalue())
+            print("\n\nContents of child_send2:")
+            print(child_send2.getvalue())
+            print("\n\nContents of child_read2:")
+            print(child_read2.getvalue())
 
-        stty_output1_lines = from_child1.splitlines()
-        stty_output2_lines = from_child2.splitlines()
+        stty_output1_lines = child_read1.getvalue().splitlines()
+        stty_output2_lines = child_read2.getvalue().splitlines()
         zipped = list(zip(stty_output1_lines, stty_output2_lines))
         for tuple in zipped:
             if self.TraceOn():
                 print("tuple->%s" % str(tuple))
             # Every line should compare equal until the first blank line.
             if len(tuple[0]) == 0:
                 break
             self.assertTrue(tuple[0] == tuple[1])

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-mi/TestMiFile.py

class MiFileTestCase(lldbmi_testcase.MiTestCaseBase):
     @skipIfRemote   # We do not currently support remote debugging via the MI.
     def test_lldbmi_file_exec_and_symbols_relative_path(self):
         """Test that 'lldb-mi --interpreter' works for -file-exec-and-symbols relpath/exe."""
 
         self.spawnLldbMi(args=None)
 
         # Test that -file-exec-and-symbols works for relative path
         import os
-        path = os.path.relpath(self.myexe)
+        path = os.path.relpath(self.myexe, self.getBuildDir())
         self.runCmd("-file-exec-and-symbols %s" % path)
         self.expect("\^done")
 
         # Run
         self.runCmd("-exec-run")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"exited-normally\"")
 

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-mi/lldbmi_testcase.py

def tearDown(self):
                 print(open(self.mylog, "r").read())
             except IOError:
                 pass
         Base.tearDown(self)
 
     def spawnLldbMi(self, args=None):
         import pexpect
         self.child = pexpect.spawn("%s --interpreter %s" % (
-            self.lldbMiExec, args if args else ""))
+            self.lldbMiExec, args if args else ""), cwd=self.getBuildDir())
         self.child.setecho(True)
         self.mylog = self.getBuildArtifact("child.log")
         self.child.logfile_read = open(self.mylog, "w")
         # wait until lldb-mi has started up and is ready to go
         self.expect(self.child_prompt, exactly=True)
 
     def runCmd(self, cmd):
         self.child.sendline(cmd)
 
     def expect(self, pattern, exactly=False, *args, **kwargs):
         if exactly:
             return self.child.expect_exact(pattern, *args, **kwargs)
         return self.child.expect(pattern, *args, **kwargs)

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-mi/startup_options/TestMiStartupOptions.py

class MiStartupOptionsTestCase(lldbmi_testcase.MiTestCaseBase):
     @skipIfRemote   # We do not currently support remote debugging via the MI.
     @skipIfWindows  # llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD  # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfDarwin
     def test_lldbmi_executable_option_relative_path(self):
         """Test that 'lldb-mi --interpreter %s' loads executable which is specified via relative path."""
 
         # Prepare path to executable
-        path = os.path.relpath(self.myexe)
+        path = os.path.relpath(self.myexe, self.getBuildDir())
         self.spawnLldbMi(args="%s" % path)
 
         # Test that the executable is loaded when file was specified using
         # relative path
         self.expect("-file-exec-and-symbols \"%s\"" % path)
         self.expect("\^done")
 
         # Test that lldb-mi is ready when executable was loaded
class MiStartupOptionsTestCase(lldbmi_testcase.MiTestCaseBase):
 
     @skipIfRemote   # We do not currently support remote debugging via the MI.
     @skipIfWindows  # llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD  # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfDarwin
     def test_lldbmi_log_option(self):
         """Test that 'lldb-mi --log' creates a log file in the current directory."""
 
-        logDirectory = "."
+        logDirectory = self.getBuildDir()
         self.spawnLldbMi(args="%s --log" % self.myexe)
 
         # Test that the executable is loaded when file was specified
         self.expect("-file-exec-and-symbols \"%s\"" % self.myexe)
         self.expect("\^done")
 
         # Test that lldb-mi is ready when executable was loaded
         self.expect(self.child_prompt, exactly=True)

lldb/trunk/packages/Python/lldbsuite/test/tools/lldb-mi/syntax/TestMiSyntax.py

class MiSyntaxTestCase(lldbmi_testcase.MiTestCaseBase):
 
     @skipIfWindows  # llvm.org/pr24452: Get lldb-mi tests working on Windows
     @skipIfFreeBSD  # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfRemote   # We do not currently support remote debugging via the MI.
     def test_lldbmi_specialchars(self):
         """Test that 'lldb-mi --interpreter' handles complicated strings."""
 
         # Create an alias for myexe
-        complicated_myexe = "C--mpl-x file's`s @#$%^&*()_+-={}[]| name"
+        complicated_myexe = self.getBuildArtifact("C--mpl-x file's`s @#$%^&*()_+-={}[]| name")
         os.symlink(self.myexe, complicated_myexe)
         self.addTearDownHook(lambda: os.unlink(complicated_myexe))
 
         self.spawnLldbMi(args="\"%s\"" % complicated_myexe)
 
         # Test that the executable was loaded
         self.expect(
             "-file-exec-and-symbols \"%s\"" %