[dotest] Centralize initialization commands even more

[labath]

Summary

In r367234 we introduced a central place to hold the set up commands for
the various ways we have of launching lldb. However, a number of
commands still remained outside of that.

This patch moves the remaining set up commands into this function, which
allows us to remove manual clang module path setting code in
TestBatchMode.

One unfortunate victim of this approach is TestSTTYBeforeAndAfter which,
due to how it launches lldb (pexpect->expect->lldb), fails get the
quoting right. It would be possible to fix the quoting there, it would be a bit
icky, and none of the commands in this list are really relevant for what this
test is doing, so I just remove the commands outright.

[JDevlieghere]

packages/Python/lldbsuite/test/lldbtest.py

709

I'm curious why you changed this to use + instead of format?

[labath]

packages/Python/lldbsuite/test/lldbtest.py

709

In that moment, it seemed better to me because it is shorter, so I did it as a drive-by. Though now, it's not clear to me that it is really an improvement. I'll just put that back...

packages/Python/lldbsuite/test/driver/batch_mode/TestBatchMode.py

class DriverBatchModeTest(PExpectTest):
 
     @skipIfRemote  # test not remote-ready llvm.org/pr24813
     @expectedFlakeyFreeBSD("llvm.org/pr25172 fails rarely on the buildbot")
     def test_batch_mode_run_crash(self):
         """Test that the lldb driver's batch mode works correctly."""
         self.build()
 
         exe = self.getBuildArtifact("a.out")
-        module_cache = self.getBuildArtifact("module.cache")
 
         # Pass CRASH so the process will crash and stop in batch mode.
         extra_args = ['-b',
-            '-o', "settings set symbols.clang-modules-cache-path '%s'"%module_cache,
             '-o', 'break set -n main',
             '-o', 'run',
             '-o', 'continue',
             '-k', 'frame var touch_me_not',
             '--', 'CRASH',
         ]
         self.launch(executable=exe, extra_args=extra_args)
         child = self.child
class DriverBatchModeTest(PExpectTest):
 
     @skipIfRemote  # test not remote-ready llvm.org/pr24813
     @expectedFlakeyFreeBSD("llvm.org/pr25172 fails rarely on the buildbot")
     def test_batch_mode_run_exit(self):
         """Test that the lldb driver's batch mode works correctly."""
         self.build()
 
         exe = self.getBuildArtifact("a.out")
-        module_cache = self.getBuildArtifact("module.cache")
 
         # Now do it again, and make sure if we don't crash, we quit:
         extra_args = ['-b',
-            '-o', "settings set symbols.clang-modules-cache-path '%s'"%module_cache,
             '-o', 'break set -n main',
             '-o', 'run',
             '-o', 'continue',
             '--', 'NOCRASH',
         ]
         self.launch(executable=exe, extra_args=extra_args)
         child = self.child
 
class DriverBatchModeTest(PExpectTest):
     @expectedFlakeyFreeBSD("llvm.org/pr25172 fails rarely on the buildbot")
     @expectedFailureNetBSD
     def test_batch_mode_attach_exit(self):
         """Test that the lldb driver's batch mode works correctly."""
         self.build()
         self.setTearDownCleanup()
 
         exe = self.getBuildArtifact("a.out")
-        module_cache = self.getBuildArtifact("module.cache")
 
         # Start up the process by hand, attach to it, and wait for its completion.
         # Attach is funny, since it looks like it stops with a signal on most Unixen so
         # care must be taken not to treat that as a reason to exit batch mode.
 
         # Start up the process by hand and wait for it to get to the wait loop.
         import pexpect
         self.victim = pexpect.spawn('%s WAIT' % (exe))
         if self.victim is None:
             self.fail("Could not spawn ", exe, ".")
 
         self.addTearDownHook(self.closeVictim)
 
         self.victim.expect("PID: ([0-9]+) END")
         victim_pid = int(self.victim.match.group(1))
 
         self.victim.expect("Waiting")
 
         extra_args = [
             '-b',
-            '-o', "settings set symbols.clang-modules-cache-path '%s'"%module_cache,
             '-o', 'process attach -p %d'%victim_pid,
             '-o', "breakpoint set --file '%s' -p 'Stop here to unset keep_waiting' -N keep_waiting"%self.source,
             '-o', 'continue',
             '-o', 'break delete keep_waiting',
             '-o', 'expr keep_waiting = 0',
             '-o', 'continue',
         ]
         self.launch(executable=exe, extra_args=extra_args)

packages/Python/lldbsuite/test/lldbtest.py

class Base(unittest2.TestCase):
     def getBuildArtifact(self, name="a.out"):
         """Return absolute path to an artifact in the test's build directory."""
         return os.path.join(self.getBuildDir(), name)
 
     def getSourcePath(self, name):
         """Return absolute path to a file in the test's source directory."""
         return os.path.join(self.getSourceDir(), name)
 
-    @staticmethod
-    def setUpCommands():
-        return [
+    @classmethod
+    def setUpCommands(cls):
+        commands = [
             # Disable Spotlight lookup. The testsuite creates
             # different binaries with the same UUID, because they only
             # differ in the debug info, which is not being hashed.
             "settings set symbols.enable-external-lookup false",
 
             # Testsuite runs in parallel and the host can have also other load.
-            "settings set plugin.process.gdb-remote.packet-timeout 60"]
+            "settings set plugin.process.gdb-remote.packet-timeout 60",
+
+            'settings set symbols.clang-modules-cache-path "{}"'.format(
+                configuration.module_cache_dir),
+            "settings set use-color false",
+        ]
+        # Make sure that a sanitizer LLDB's environment doesn't get passed on.
+        if cls.platformContext and cls.platformContext.shlib_environment_var in os.environ:
+            commands.append('settings set target.env-vars {}='
+                    .format(cls.platformContext.shlib_environment_var))
+
+        # Set environment variables for the inferior.
+        if lldbtest_config.inferior_env:
+            commands.append('settings set target.env-vars ' +
+                    lldbtest_config.inferior_env)
+        return commands
 
     def setUp(self):
         """Fixture for unittest test case setup.
 
         It works with the test driver to conditionally skip tests and does other
         initializations."""
         #import traceback
         # traceback.print_stack()
class TestBase(Base):
     def setUp(self):
         #import traceback
         # traceback.print_stack()
 
         # Works with the test driver to conditionally skip tests via
         # decorators.
         Base.setUp(self)
 
-        # Set the clang modules cache path used by LLDB.
-        self.runCmd(
-            'settings set symbols.clang-modules-cache-path "{}"'.format(
-                configuration.module_cache_dir))
-
         for s in self.setUpCommands():
             self.runCmd(s)
 
-        # Disable color.
-        self.runCmd("settings set use-color false")
-
-        # Make sure that a sanitizer LLDB's environment doesn't get passed on.
-        if 'DYLD_LIBRARY_PATH' in os.environ:
-            self.runCmd('settings set target.env-vars DYLD_LIBRARY_PATH=')
-
-        # Set environment variables for the inferior.
-        if lldbtest_config.inferior_env:
-            self.runCmd('settings set target.env-vars {}'.format(lldbtest_config.inferior_env))
-
         if "LLDB_MAX_LAUNCH_COUNT" in os.environ:
             self.maxLaunchCount = int(os.environ["LLDB_MAX_LAUNCH_COUNT"])
 
         if "LLDB_TIME_WAIT_NEXT_LAUNCH" in os.environ:
             self.timeWaitNextLaunch = float(
                 os.environ["LLDB_TIME_WAIT_NEXT_LAUNCH"])
 
         # We want our debugger to be synchronous.

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

def test_stty_dash_a_before_and_afetr_invoking_lldb_command(self):
         child.expect(expect_prompt)
 
         # 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.sendline(lldbtest_config.lldbExec)
         child.expect_exact(lldb_prompt)
 
         # Immediately quit.
         child.sendline('quit')
         child.expect(expect_prompt)
 
         child.logfile_send = child_send2 = six.StringIO()
         child.logfile_read = child_read2 = six.StringIO()

packages/Python/lldbsuite/test/tools/lldb-vscode/lldbvscode_testcase.py

 from __future__ import print_function
 
 from lldbsuite.test.lldbtest import *
 import os
 import vscode
 
 
 class VSCodeTestCaseBase(TestBase):
 
     def create_debug_adaptor(self):
         '''Create the Visual Studio Code debug adaptor'''
         self.assertTrue(os.path.exists(self.lldbVSCodeExec),
                         'lldb-vscode must exist')
         self.vscode = vscode.DebugAdaptor(
-            executable=self.lldbVSCodeExec, init_commands=Base.setUpCommands())
+            executable=self.lldbVSCodeExec, init_commands=self.setUpCommands())
 
     def build_and_create_debug_adaptor(self):
         self.build()
         self.create_debug_adaptor()
 
     def set_source_breakpoints(self, source_path, lines, condition=None,
                                hitCondition=None):
         '''Sets source breakpoints and returns an array of strings containing