[dotest] Clean up test folder clean-up

[labath]

Summary

This patch implements a unified way of cleaning the build folder of each
test. This is done by completely removing the build folder before each
test, in the respective setUp() method. Previously, we were using a
combination of several methods, each with it's own drawbacks:

• nuking the entire build tree before running dotest: the issue here is that this did not take place if you ran dotest manually
• running "make clean" before the main "make" target: this relied on the clean command being correctly implemented. This was usually true, but not always.
• for files which were not produced by make, each python file was responsible for ensuring their deleting, using a variety of methods.

With this approach, the previous methods become redundant. I remove the
first two, since they are centralized. For the other various bits of
clean-up code in python files, I indend to delete it when I come
across it.

[aprantl]

Thanks! I think this makes sense.

packages/Python/lldbsuite/test/lldbtest.py

707 ↗

(On Diff #138579)

I was thinking whether this was necessary, since we could just rm -rf the entire --build-dir, but for running individual tests, doing it this way makes it easier.

test/CMakeLists.txt

9 ↗

(On Diff #138579)

That comment is obsolete now?

[clayborg]

I would be nice to have the option to nuke each test build directory if the test passed. Can be an option that we specify. That way, the only folders left over could be the tests that are failing. The options doesn't need to default to true, but if anyone is in that code and would know how to do that, that would be a great option to have. This option could also clean up the log directory and remove any logs for tests that succeeded or were skipped. I alway have to go and nuke these files manually.

Greg

[labath]

Deleting the test build dir is fairly easy. I can whip up a patch for that,
but I'm not sure if that's the part that is bothering you the most here.
Dealing with the log files is a bot more complicated and there doesn't seem
to be a clear consensus on what to do with them. The last discussion about
the (Jan 17: Questions about the LLDB testsuite and improving its
reliability) ended without a clear conclusion. I personally, think it would
be nice to put the log files into the build dir, but I don't feel strongly
enough about it to go around and try to get people to change their habits.

lldb/trunk/packages/Python/lldbsuite/test/functionalities/breakpoint/comp_dir_symlink/TestCompDirSymLink.py

def test_symlink_paths_unset(self):
         self.assertRaises(
             AssertionError,
             lldbutil.run_break_set_by_file_and_line,
             self,
             src_path,
             self.line)
 
     def create_src_symlink(self):
-        self.makeBuildDir()
         pwd_symlink = self.getBuildArtifact('pwd_symlink')
         if os.path.exists(pwd_symlink):
             os.unlink(pwd_symlink)
         os.symlink(self.getBuildDir(), pwd_symlink)
         self.addTearDownHook(lambda: os.remove(pwd_symlink))
         return pwd_symlink
 
     def doBuild(self, pwd_symlink):
-        self.build(None, None, {'PWD': pwd_symlink}, True)
+        self.build(None, None, {'PWD': pwd_symlink})
 
         exe = self.getBuildArtifact(_EXE_NAME)
         self.runCmd('file ' + exe, CURRENT_EXECUTABLE_SET)

lldb/trunk/packages/Python/lldbsuite/test/functionalities/command_script_immediate_output/TestCommandScriptImmediateOutput.py

class CommandScriptImmediateOutputTestCase (PExpectTest):
 
     @skipIfRemote  # test not remote-ready llvm.org/pr24813
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
     @expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr26139")
     def test_command_script_immediate_output_console(self):
         """Test that LLDB correctly allows scripted commands to set immediate output to the console."""
-        self.makeBuildDir()
         self.launch(timeout=10)
 
         script = os.path.join(self.getSourceDir(), 'custom_command.py')
         prompt = "\(lldb\) "
 
         self.sendline('command script import %s' % script, patterns=[prompt])
         self.sendline(
             'command script add -f custom_command.command_function mycommand',
             patterns=[prompt])
         self.sendline(
             'mycommand',
             patterns='this is a test string, just a test string')
         self.sendline('command script delete mycommand', patterns=[prompt])
         self.quit(gracefully=False)
 
     @skipIfRemote  # test not remote-ready llvm.org/pr24813
     @expectedFailureAll(
         oslist=["windows"],
         bugnumber="llvm.org/pr22274: need a pexpect replacement for windows")
     @expectedFailureAll(oslist=["freebsd"], bugnumber="llvm.org/pr26139")
     def test_command_script_immediate_output_file(self):
         """Test that LLDB correctly allows scripted commands to set immediate output to a file."""
-        self.makeBuildDir()
         self.launch(timeout=10)
 
         test_files = {self.getBuildArtifact('read.txt'): 'r',
                       self.getBuildArtifact('write.txt'): 'w',
                       self.getBuildArtifact('append.txt'): 'a',
                       self.getBuildArtifact('write_plus.txt'): 'w+',
                       self.getBuildArtifact('read_plus.txt'): 'r+',
                       self.getBuildArtifact('append_plus.txt'): 'a+'}

lldb/trunk/packages/Python/lldbsuite/test/functionalities/exec/TestExec.py

class ExecTestCase(TestBase):
 
     @skipUnlessDarwin
     @expectedFailureAll(archs=['i386'], bugnumber="rdar://28656532")
     @expectedFailureAll(oslist=["ios", "tvos", "watchos", "bridgeos"], bugnumber="rdar://problem/34559552") # this exec test has problems on ios systems
     def test_skipping_exec (self):
         self.do_test(True)
 
     def do_test(self, skip_exec):
-        self.makeBuildDir()
         exe = self.getBuildArtifact("a.out")
         if self.getArchitecture() == 'x86_64':
             source = self.getSourcePath("main.cpp")
             o_file = self.getBuildArtifact("main.o")
             execute_command(
                 "'%s' -g -O0 -arch i386 -arch x86_64 '%s' -c -o '%s'" %
                 (os.environ["CC"], source, o_file))
             execute_command(

lldb/trunk/packages/Python/lldbsuite/test/linux/add-symbols/TestTargetSymbolsAddCommand.py

def setUp(self):
         self.source = 'main.c'
 
     @no_debug_info_test  # Prevent the genaration of the dwarf version of this test
     @skipUnlessPlatform(['linux'])
     def test_target_symbols_add(self):
         """Test that 'target symbols add' can load the symbols
         even if gnu.build-id and gnu_debuglink are not present in the module.
         Similar to test_add_dsym_mid_execution test for macos."""
-        self.build(clean=True)
+        self.build()
         exe = self.getBuildArtifact("stripped.out")
 
         self.target = self.dbg.CreateTarget(exe)
         self.assertTrue(self.target, VALID_TARGET)
 
         main_bp = self.target.BreakpointCreateByName("main", "stripped.out")
         self.assertTrue(main_bp, VALID_BREAKPOINT)
 

lldb/trunk/packages/Python/lldbsuite/test/linux/sepdebugsymlink/TestTargetSymbolsSepDebugSymlink.py

class TestTargetSymbolsSepDebugSymlink(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @no_debug_info_test  # Prevent the genaration of the dwarf version of this test
     @skipUnlessPlatform(['linux'])
     @skipIf(hostoslist=["windows"])
     @skipIfRemote # llvm.org/pr36237
     def test_target_symbols_sepdebug_symlink_case(self):
-        self.build(clean=True)
+        self.build()
         exe = self.getBuildArtifact("dirsymlink/stripped.symlink")
 
         lldbutil.run_to_name_breakpoint(self, "main", exe_name = exe)

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

def getRerunArgs(self):
             # The test was skipped altogether.
             return ""
         elif self.using_dsym:
             return "-N dwarf " + self.mydir
         else:
             return "-N dsym " + self.mydir
 
     def BuildMakefile(self):
-        self.makeBuildDir()
         makefilePath = self.getBuildArtifact("Makefile")
         if os.path.exists(makefilePath):
             return
 
         categories = {}
 
         for f in os.listdir(self.getSourceDir()):
             t = source_type(f)

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

 import collections
 from functools import wraps
 import gc
 import glob
 import inspect
 import io
 import os.path
 import re
+import shutil
 import signal
 from subprocess import *
 import sys
 import time
 import traceback
 import types
 import distutils.spawn
 
def getSourceDir(self):
         """Return the full path to the current test."""
         return os.path.join(os.environ["LLDB_TEST"], self.mydir)
 
     def getBuildDirBasename(self):
         return self.__class__.__module__ + "." + self.testMethodName
 
     def getBuildDir(self):
         """Return the full path to the current test."""
-        variant = self.getDebugInfo()
-        if variant is None:
-            variant = 'default'
         return os.path.join(os.environ["LLDB_BUILD"], self.mydir,
                             self.getBuildDirBasename())
     
      
     def makeBuildDir(self):
-        """Create the test-specific working directory."""
+        """Create the test-specific working directory, deleting any previous
+        contents."""
         # See also dotest.py which sets up ${LLDB_BUILD}.
-        lldbutil.mkdir_p(self.getBuildDir())
+        bdir = self.getBuildDir()
+        if os.path.isdir(bdir):
+            shutil.rmtree(bdir)
+        lldbutil.mkdir_p(bdir)
  
     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)
def buildProgram(self, sources, exe_name):
         d = {'CXX_SOURCES': sources,
              'EXE': exe_name}
         self.buildDefault(dictionary=d)
 
     def buildDefault(
             self,
             architecture=None,
             compiler=None,
-            dictionary=None,
-            clean=True):
+            dictionary=None):
         """Platform specific way to build the default binaries."""
         testdir = self.mydir
         testname = self.getBuildDirBasename()
         if self.getDebugInfo():
             raise Exception("buildDefault tests must set NO_DEBUG_INFO_TESTCASE")
         module = builder_module()
-        self.makeBuildDir()
         dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
         if not module.buildDefault(self, architecture, compiler,
-                                   dictionary, clean, testdir, testname):
+                                   dictionary, testdir, testname):
             raise Exception("Don't know how to build default binary")
 
     def buildDsym(
             self,
             architecture=None,
             compiler=None,
-            dictionary=None,
-            clean=True):
+            dictionary=None):
         """Platform specific way to build binaries with dsym info."""
         testdir = self.mydir
         testname = self.getBuildDirBasename()
         if self.getDebugInfo() != "dsym":
             raise Exception("NO_DEBUG_INFO_TESTCASE must build with buildDefault")
 
         module = builder_module()
         dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
         if not module.buildDsym(self, architecture, compiler,
-                                dictionary, clean, testdir, testname):
+                                dictionary, testdir, testname):
             raise Exception("Don't know how to build binary with dsym")
 
     def buildDwarf(
             self,
             architecture=None,
             compiler=None,
-            dictionary=None,
-            clean=True):
+            dictionary=None):
         """Platform specific way to build binaries with dwarf maps."""
         testdir = self.mydir
         testname = self.getBuildDirBasename()
         if self.getDebugInfo() != "dwarf":
             raise Exception("NO_DEBUG_INFO_TESTCASE must build with buildDefault")
 
         module = builder_module()
         dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
         if not module.buildDwarf(self, architecture, compiler,
-                                   dictionary, clean, testdir, testname):
+                                   dictionary, testdir, testname):
             raise Exception("Don't know how to build binary with dwarf")
 
     def buildDwo(
             self,
             architecture=None,
             compiler=None,
-            dictionary=None,
-            clean=True):
+            dictionary=None):
         """Platform specific way to build binaries with dwarf maps."""
         testdir = self.mydir
         testname = self.getBuildDirBasename()
         if self.getDebugInfo() != "dwo":
             raise Exception("NO_DEBUG_INFO_TESTCASE must build with buildDefault")
 
         module = builder_module()
         dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
         if not module.buildDwo(self, architecture, compiler,
-                                   dictionary, clean, testdir, testname):
+                                   dictionary, testdir, testname):
             raise Exception("Don't know how to build binary with dwo")
 
     def buildGModules(
             self,
             architecture=None,
             compiler=None,
-            dictionary=None,
-            clean=True):
+            dictionary=None):
         """Platform specific way to build binaries with gmodules info."""
         testdir = self.mydir
         testname = self.getBuildDirBasename()
         if self.getDebugInfo() != "gmodules":
             raise Exception("NO_DEBUG_INFO_TESTCASE must build with buildDefault")
 
         module = builder_module()
         dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
         if not module.buildGModules(self, architecture, compiler,
-                                    dictionary, clean, testdir, testname):
+                                    dictionary, testdir, testname):
             raise Exception("Don't know how to build binary with gmodules")
 
     def buildGo(self):
         """Build the default go binary.
         """
         exe = self.getBuildArtifact("a.out")
         system([[which('go'), 'build -gcflags "-N -l" -o %s main.go' % exe]])
 
class TestBase(Base):
     # Can be overridden by the LLDB_MAX_LAUNCH_COUNT environment variable.
     maxLaunchCount = 3
 
     # Time to wait before the next launching attempt in second(s).
     # Can be overridden by the LLDB_TIME_WAIT_NEXT_LAUNCH environment variable.
     timeWaitNextLaunch = 1.0
 
     def generateSource(self, source):
-        self.makeBuildDir()
         template = source + '.template'
         temp = os.path.join(self.getSourceDir(), template)
         with open(temp, 'r') as f:
             content = f.read()
             
         public_api_dir = os.path.join(
             os.environ["LLDB_SRC"], "include", "lldb", "API")
 
def invoke(self, obj, name, trace=False):
         with recording(self, trace) as sbuf:
             print(str(method) + ":", result, file=sbuf)
         return result
 
     def build(
             self,
             architecture=None,
             compiler=None,
-            dictionary=None,
-            clean=True):
+            dictionary=None):
         """Platform specific way to build the default binaries."""
         module = builder_module()
-        self.makeBuildDir()
 
         dictionary = lldbplatformutil.finalize_build_dictionary(dictionary)
         if self.getDebugInfo() is None:
-            return self.buildDefault(architecture, compiler, dictionary,
-                                     clean)
+            return self.buildDefault(architecture, compiler, dictionary)
         elif self.getDebugInfo() == "dsym":
-            return self.buildDsym(architecture, compiler, dictionary, clean)
+            return self.buildDsym(architecture, compiler, dictionary)
         elif self.getDebugInfo() == "dwarf":
-            return self.buildDwarf(architecture, compiler, dictionary, clean)
+            return self.buildDwarf(architecture, compiler, dictionary)
         elif self.getDebugInfo() == "dwo":
-            return self.buildDwo(architecture, compiler, dictionary,
-                                 clean)
+            return self.buildDwo(architecture, compiler, dictionary)
         elif self.getDebugInfo() == "gmodules":
-            return self.buildGModules(architecture, compiler, dictionary,
-                                      clean)
+            return self.buildGModules(architecture, compiler, dictionary)
         else:
             self.fail("Can't build for debug info: %s" % self.getDebugInfo())
 
     def run_platform_command(self, cmd):
         platform = self.dbg.GetSelectedPlatform()
         shell_command = lldb.SBPlatformShellCommand(cmd)
         err = platform.Run(shell_command)
         return (err, shell_command.GetStatus(), shell_command.GetOutput())

lldb/trunk/packages/Python/lldbsuite/test/macosx/add-dsym/TestAddDsymMidExecutionCommand.py

class AddDsymMidExecutionCommandCase(TestBase):
     def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         self.source = 'main.c'
 
     @no_debug_info_test  # Prevent the genaration of the dwarf version of this test
     def test_add_dsym_mid_execution(self):
         """Test that add-dsym mid-execution loads the symbols at the right place for a slid binary."""
-        self.buildDefault(clean=True, dictionary={'MAKE_DSYM':'YES'})
+        self.buildDefault(dictionary={'MAKE_DSYM':'YES'})
         exe = self.getBuildArtifact("a.out")
 
         self.target = self.dbg.CreateTarget(exe)
         self.assertTrue(self.target, VALID_TARGET)
 
         main_bp = self.target.BreakpointCreateByName("main", "a.out")
         self.assertTrue(main_bp, VALID_BREAKPOINT)
 

lldb/trunk/packages/Python/lldbsuite/test/plugins/builder_base.py

except subprocess.CalledProcessError as called_process_error:
         raise build_exception.BuildError(called_process_error)
 
 
 def buildDefault(
         sender=None,
         architecture=None,
         compiler=None,
         dictionary=None,
-        clean=True,
         testdir=None,
         testname=None):
     """Build the binaries the default way."""
     commands = []
-    if clean:
-        commands.append(getMake(testdir, testname) + ["clean", getCmdLine(dictionary)])
     commands.append(getMake(testdir, testname) + ["all", getArchSpec(architecture),
                      getCCSpec(compiler), getCmdLine(dictionary)])
 
     runBuildCommands(commands, sender=sender)
 
     # True signifies that we can handle building default.
     return True
 
 
 def buildDwarf(
         sender=None,
         architecture=None,
         compiler=None,
         dictionary=None,
-        clean=True,
         testdir=None,
         testname=None):
     """Build the binaries with dwarf debug info."""
     commands = []
-    if clean:
-        commands.append(getMake(testdir, testname) +
-                        ["clean", getCmdLine(dictionary)])
     commands.append(getMake(testdir, testname) +
                     ["MAKE_DSYM=NO", getArchSpec(architecture),
                      getCCSpec(compiler), getCmdLine(dictionary)])
 
     runBuildCommands(commands, sender=sender)
     # True signifies that we can handle building dwarf.
     return True
 
 
 def buildDwo(
         sender=None,
         architecture=None,
         compiler=None,
         dictionary=None,
-        clean=True,
         testdir=None,
         testname=None):
     """Build the binaries with dwarf debug info."""
     commands = []
-    if clean:
-        commands.append(getMake(testdir, testname) +
-                        ["clean", getCmdLine(dictionary)])
     commands.append(getMake(testdir, testname) +
                     ["MAKE_DSYM=NO", "MAKE_DWO=YES",
                      getArchSpec(architecture),
                      getCCSpec(compiler),
                      getCmdLine(dictionary)])
 
     runBuildCommands(commands, sender=sender)
     # True signifies that we can handle building dwo.
     return True
 
 
 def buildGModules(
         sender=None,
         architecture=None,
         compiler=None,
         dictionary=None,
-        clean=True,
         testdir=None,
         testname=None):
     """Build the binaries with dwarf debug info."""
     commands = []
-    if clean:
-        commands.append(getMake(testdir, testname) +
-                        ["clean", getCmdLine(dictionary)])
     commands.append(getMake(testdir, testname) +
                     ["MAKE_DSYM=NO",
                      "MAKE_GMODULES=YES",
                      getArchSpec(architecture),
                      getCCSpec(compiler),
                      getCmdLine(dictionary)])
 
     lldbtest.system(commands, sender=sender)
     # True signifies that we can handle building with gmodules.
     return True
 
 
 def cleanup(sender=None, dictionary=None):
     """Perform a platform-specific cleanup after the test."""
     return True

lldb/trunk/packages/Python/lldbsuite/test/plugins/builder_darwin.py

 
 from __future__ import print_function
 import os
 import lldbsuite.test.lldbtest as lldbtest
 
 from builder_base import *
 
 def buildDsym(
         sender=None,
         architecture=None,
         compiler=None,
         dictionary=None,
-        clean=True,
         testdir=None,
         testname=None):
     """Build the binaries with dsym debug info."""
     commands = []
-    if clean:
-        commands.append(getMake(testdir, testname) +
-                        ["clean", getCmdLine(dictionary)])
     commands.append(getMake(testdir, testname) +
                     ["MAKE_DSYM=YES",
                      getArchSpec(architecture),
                      getCCSpec(compiler),
                      "all", getCmdLine(dictionary)])
 
     runBuildCommands(commands, sender=sender)
 
     # True signifies that we can handle building dsym.
     return True

lldb/trunk/packages/Python/lldbsuite/test/plugins/builder_freebsd.py

 from builder_base import *
 
 
 def buildDsym(
         sender=None,
         architecture=None,
         compiler=None,
         dictionary=None,
-        clean=True,
         testdir=None):
     return False

lldb/trunk/packages/Python/lldbsuite/test/plugins/builder_linux.py

 from builder_base import *
 
 
 def buildDsym(
         sender=None,
         architecture=None,
         compiler=None,
         dictionary=None,
-        clean=True,
         testdir=None):
     return False

lldb/trunk/packages/Python/lldbsuite/test/plugins/builder_netbsd.py

 from builder_base import *
 
 
 def buildDsym(
         sender=None,
         architecture=None,
         compiler=None,
         dictionary=None,
-        clean=True,
         testdir=None):
     return False

lldb/trunk/packages/Python/lldbsuite/test/plugins/builder_win32.py

 from builder_base import *
 
 
 def buildDsym(
         sender=None,
         architecture=None,
         compiler=None,
         dictionary=None,
-        clean=True,
         testdir=None):
     return False

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

def classCleanup(cls):
         if cls.mylog:
             TestBase.RemoveTempFile(cls.mylog)
 
     def setUp(self):
         if not self.mydir:
             raise("mydir is empty")
 
         Base.setUp(self)
-        self.makeBuildDir()
         self.buildDefault()
         self.child_prompt = "(gdb)"
         self.myexe = self.getBuildArtifact("a.out")
 
     def tearDown(self):
         if self.TraceOn():
             print("\n\nContents of %s:" % self.mylog)
             try:

lldb/trunk/packages/Python/lldbsuite/test/warnings/uuid/TestAddDsymCommand.py

def setUp(self):
         self.teardown_hook_added = False
 
     @no_debug_info_test
     def test_add_dsym_command_with_error(self):
         """Test that the 'add-dsym' command informs the user about failures."""
 
         # Call the program generator to produce main.cpp, version 1.
         self.generate_main_cpp(version=1)
-        self.buildDefault(clean=True, dictionary={'MAKE_DSYM':'YES'})
+        self.buildDefault(dictionary={'MAKE_DSYM':'YES'})
 
         # Insert some delay and then call the program generator to produce
         # main.cpp, version 2.
         time.sleep(5)
         self.generate_main_cpp(version=101)
         # Now call make again, but this time don't generate the dSYM.
-        self.buildDefault(clean=False, dictionary={'MAKE_DSYM':'NO'})
+        self.buildDefault(dictionary={'MAKE_DSYM':'NO'})
 
         self.exe_name = 'a.out'
         self.do_add_dsym_with_error(self.exe_name)
 
     @no_debug_info_test
     def test_add_dsym_command_with_success(self):
         """Test that the 'add-dsym' command informs the user about success."""
 
         # Call the program generator to produce main.cpp, version 1.
         self.generate_main_cpp(version=1)
-        self.buildDefault(clean=True, dictionary={'MAKE_DSYM':'YES'})
+        self.buildDefault(dictionary={'MAKE_DSYM':'YES'})
 
         self.exe_name = 'a.out'
         self.do_add_dsym_with_success(self.exe_name)
 
     @no_debug_info_test
     def test_add_dsym_with_dSYM_bundle(self):
         """Test that the 'add-dsym' command informs the user about success."""
 
         # Call the program generator to produce main.cpp, version 1.
         self.generate_main_cpp(version=1)
-        self.buildDefault(clean=True, dictionary={'MAKE_DSYM':'YES'})
+        self.buildDefault(dictionary={'MAKE_DSYM':'YES'})
 
         self.exe_name = 'a.out'
         self.do_add_dsym_with_dSYM_bundle(self.exe_name)
 
     def generate_main_cpp(self, version=0):
         """Generate main.cpp from main.cpp.template."""
         temp = os.path.join(self.getSourceDir(), self.template)
         with open(temp, 'r') as f:
             content = f.read()
 
         new_content = content.replace(
             '%ADD_EXTRA_CODE%',
             'printf("This is version %d\\n");' %
             version)
-        self.makeBuildDir()
         src = os.path.join(self.getBuildDir(), self.source)
         with open(src, 'w') as f:
             f.write(new_content)
 
         # The main.cpp has been generated, add a teardown hook to remove it.
         if not self.teardown_hook_added:
             self.addTearDownHook(lambda: os.remove(src))
             self.teardown_hook_added = True

lldb/trunk/test/CMakeLists.txt

 function(add_python_test_target name test_script args comment)
   set(PYTHON_TEST_COMMAND
     ${PYTHON_EXECUTABLE}
     ${test_script}
     ${args}
     )
 
   add_custom_target(${name}
-    # Clear the test directory first.
-    COMMAND ${CMAKE_COMMAND} -E remove_directory ${CMAKE_BINARY_DIR}/lldb-test-build.noindex
     COMMAND ${PYTHON_TEST_COMMAND} ${ARG_DEFAULT_ARGS}
     COMMENT "${comment}"
     DEPENDS ${LLDB_TEST_DEPS}
     USES_TERMINAL
     )
 endfunction()
 
 set(LLDB_TEST_DEPS lldb)