[lldb] Introduce createTestTarget for creating a valid target in API tests

[teemperor]

Summary

At the moment nearly every test calls something similar to self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
and them sometimes checks if the created target is actually valid with something like self.assertTrue(target.IsValid(), "some useless text").

Beside being really verbose the error messages generated by this pattern are always just indicating that the target
failed to be created but now why.

This patch introduces a helper function createTestTarget to our Test class that creates the target with the much more
verbose CreateTarget overload that gives us back an SBError (with a fancy error). If the target couldn't be created the
function prints out the SBError that LLDB returned and asserts for us. It also defaults to the "a.out" build artifact path
that nearly all tests are using to avoid to hardcode "a.out" in every test.

I converted a bunch of tests to the new function but I'll do the rest of the test suite as follow ups.

[teemperor]

• Made test stricter.

[teemperor]

(This isn't really NFC as this now tests that we always return an SBError when we fail to create a target).

[DavidSpickett]

Good idea! I had a test failing to create a target just this morning.

AssertionError: <lldb.SBTarget; proxy of <Swig Object of type 'lldb::SBTarget *' at 0x7f98113702a0> > is not True : Got a valid target

Bit of a head scratcher with the inverted assert message. This will be a lot more helpful.

lldb/test/API/assert_messages_test/TestAssertMessages.py

31

You can ommit the + here.

[JDevlieghere]

Great improvement. Could you add this to the TestSampleTest.py as well? I think it's used a lot as a starting point and thus would help with discoverability.

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

""".format(cmd_status, filecheck_cmd, output, cmd_stdout, cmd_stderr)
 
     """Assert that an lldb.SBError is in the "success" state."""
     def assertSuccess(self, obj, msg=None):
         if not obj.Success():
             error = obj.GetCString()
             self.fail(self._formatMessage(msg,
                 "'{}' is not success".format(error)))
 
+    def createTestTarget(self, file_path=None, msg=None):
+        """
+        Creates a target from the file found at the given file path.
+        Asserts that the resulting target is valid.
+        :param file_path: The file path that should be used to create the target.
+                          The default argument opens the current default test
+                          executable in the current test directory.
+        :param msg: A custom error message.
+        """
+        if file_path is None:
+            file_path = self.getBuildArtifact("a.out")
+        error = lldb.SBError()
+        triple = ""
+        platform = ""
+        load_dependent_modules = True
+        target = self.dbg.CreateTarget(file_path, triple, platform,
+                                       load_dependent_modules, error)
+        if error.Fail():
+            err = "Couldn't create target for path '{}': {}".format(file_path,
+                                                                    str(error))
+            self.fail(self._formatMessage(msg, err))
+
+        self.assertTrue(target.IsValid(), "Got invalid target without error")
+        return target
+
     # =================================================
     # Misc. helper methods for debugging test execution
     # =================================================
 
     def DebugSBValue(self, val):
         """Debug print a SBValue object, if traceAlways is True."""
         from .lldbutil import value_type_to_str
 

lldb/test/API/android/platform/TestDefaultCacheLineSize.py

 
 class DefaultCacheLineSizeTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @skipUnlessTargetAndroid
     def test_cache_line_size(self):
         self.build(dictionary=self.getBuildFlags())
-        exe = self.getBuildArtifact("a.out")
-        target = self.dbg.CreateTarget(exe)
+        target = self.createTestTarget()
         self.assertTrue(target and target.IsValid(), "Target is valid")
 
         breakpoint = target.BreakpointCreateByName("main")
         self.assertTrue(
             breakpoint and breakpoint.IsValid(),
             "Breakpoint is valid")
 
         # Run the program.

lldb/test/API/api/listeners/TestListener.py

def test_clearing_listener(self):
             self.dbg,
             lldb.SBTarget.GetBroadcasterClassName(),
             lldb.SBTarget.eBroadcastBitWatchpointChanged)
         my_third_listener.StartListeningForEventClass(
             self.dbg,
             lldb.SBTarget.GetBroadcasterClassName(),
             lldb.SBTarget.eBroadcastBitModulesUnloaded)
 
-        exe = self.getBuildArtifact("a.out")
-
         my_listener.Clear()
 
-        target = self.dbg.CreateTarget(exe)
+        target = self.createTestTarget()
 
         bkpt = target.BreakpointCreateByName("main")
 
         event = lldb.SBEvent()
         my_listener.WaitForEvent(1, event)
         self.assertTrue(not event.IsValid(), "We don't get events we aren't listening to.")
         
     def test_receiving_breakpoint_added_from_debugger(self):
         """Test that we get breakpoint added events, waiting on event classes on the debugger"""
         self.build()
 
         my_listener = lldb.SBListener("test_listener")
 
         my_listener.StartListeningForEventClass(
             self.dbg,
             lldb.SBTarget.GetBroadcasterClassName(),
             lldb.SBTarget.eBroadcastBitBreakpointChanged)
 
-        exe = self.getBuildArtifact("a.out")
-
-        target = self.dbg.CreateTarget(exe)
+        target = self.createTestTarget()
 
         bkpt = target.BreakpointCreateByName("main")
 
         event = lldb.SBEvent()
         my_listener.WaitForEvent(1, event)
 
         self.assertTrue(event.IsValid(), "Got a valid event.")
         self.assertTrue(
def test_recieving_breakpoint_added_from_target(self):
         self.build()
 
         my_listener = lldb.SBListener("test_listener")
         my_listener.StartListeningForEventClass(
             self.dbg,
             lldb.SBTarget.GetBroadcasterClassName(),
             lldb.SBTarget.eBroadcastBitBreakpointChanged)
 
-        exe = self.getBuildArtifact("a.out")
-
-        target = self.dbg.CreateTarget(exe)
+        target = self.createTestTarget()
         result = target.GetBroadcaster().AddListener(my_listener,
                                                      lldb.SBTarget.eBroadcastBitBreakpointChanged)
         self.assertEqual(result, lldb.SBTarget.eBroadcastBitBreakpointChanged,"Got our bit")
 
         bkpt = target.BreakpointCreateByName("main")
 
         event = lldb.SBEvent()
         my_listener.WaitForEvent(1, event)

lldb/test/API/assert_messages_test/TestAssertMessages.py

def assert_expect_fails_with(self, cmd, expect_args, expected_msg):
             # This expect should fail
             self.expect(cmd, **expect_args)
         except AssertionError as e:
             # Then check message from previous expect
             self.expect(str(e), exe=False, substrs=[dedent(expected_msg)])
         else:
             self.fail("Initial expect should have raised AssertionError!")
 
+    def test_createTestTarget(self):
+        try:
+           self.createTestTarget("doesnt_exist")
+        except AssertionError as e:
+           self.assertIn("Couldn't create target for path 'doesnt_exist': "
+                         "error: unable to find executable for 'doesnt_exist'",
+                         str(e))
+
+
     def test_expect(self):
         """Test format of messages produced by expect(...)"""
 
         # When an expect passes the messages are sent to the trace
         # file which we can't access here. So really, these only
         # check what failures look like, but it *should* be the same
         # content for the trace log too.
 

lldb/test/API/commands/disassemble/basic/TestFrameDisassemble.py

class FrameDisassembleTestCase(TestBase):
 
     def test_frame_disassemble(self):
         """Sample test to ensure SBFrame::Disassemble produces SOME output."""
         self.build()
         self.frame_disassemble_test()
 
     def frame_disassemble_test(self):
         """Sample test to ensure SBFrame::Disassemble produces SOME output"""
-        exe = self.getBuildArtifact("a.out")
-
         # Create a target by the debugger.
-        target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target, VALID_TARGET)
+        target = self.createTestTarget()
 
         # Now create a breakpoint in main.c at the source matching
         # "Set a breakpoint here"
         breakpoint = target.BreakpointCreateBySourceRegex(
             "Set a breakpoint here", lldb.SBFileSpec("main.cpp"))
         self.assertTrue(breakpoint and
                         breakpoint.GetNumLocations() >= 1,
                         VALID_BREAKPOINT)

lldb/test/API/commands/expression/call-function/TestCallBuiltinFunction.py

class ExprCommandCallBuiltinFunction(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
     # Builtins are expanded by Clang, so debug info shouldn't matter.
     NO_DEBUG_INFO_TESTCASE = True
 
     def test(self):
         self.build()
 
-        target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
+        target = self.createTestTarget()
 
         self.expect_expr("__builtin_isinf(0.0f)", result_type="int", result_value="0")
         self.expect_expr("__builtin_isnormal(0.0f)", result_type="int", result_value="0")
         self.expect_expr("__builtin_constant_p(1)", result_type="int", result_value="1")
         self.expect_expr("__builtin_abs(-14)", result_type="int", result_value="14")

lldb/test/API/commands/expression/completion-crash-invalid-iterator/TestInvalidIteratorCompletionCrash.py

 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class TestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @skipIf # rdar://problem/53931074
     def test(self):
         self.build()
-        exe = self.getBuildArtifact("a.out")
-        target = self.dbg.CreateTarget(exe)
+        target = self.createTestTarget()
         callee_break = target.BreakpointCreateByName(
             "SomeClass::SomeClass(ParamClass)", None)
         self.assertTrue(callee_break.GetNumLocations() > 0)
         self.runCmd("run", RUN_SUCCEEDED)
 
         to_complete = "e ParamClass"
         self.dbg.GetCommandInterpreter().HandleCompletion(to_complete, len(to_complete), 0, -1, lldb.SBStringList())

lldb/test/API/commands/expression/completion/TestExprCompletion.py

class CommandLineExprCompletionTestCase(TestBase):
     mydir = TestBase.compute_mydir(__file__)
 
     NO_DEBUG_INFO_TESTCASE = True
 
     def test_expr_completion(self):
         self.build()
         self.main_source = "main.cpp"
         self.main_source_spec = lldb.SBFileSpec(self.main_source)
-        self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
+        self.createTestTarget()
 
         # Try the completion before we have a context to complete on.
         self.assume_no_completions('expr some_expr')
         self.assume_no_completions('expr ')
         self.assume_no_completions('expr f')
 
 
         (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
def test_expr_completion(self):
                               'expr some_expr.Self() .FooNoArgsBar()')
         self.complete_exactly('expr some_expr.Self(). FooNoArgs',
                               'expr some_expr.Self(). FooNoArgsBar()')
 
     def test_expr_completion_with_descriptions(self):
         self.build()
         self.main_source = "main.cpp"
         self.main_source_spec = lldb.SBFileSpec(self.main_source)
-        self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
+        self.createTestTarget()
 
         (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint(self,
                                           '// Break here', self.main_source_spec)
 
         self.check_completion_with_desc("expr ", [
             # builtin types have no description.
             ["int", ""],
             ["float", ""],

lldb/test/API/commands/expression/error-limit/TestExprErrorLimit.py

class TestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @no_debug_info_test
     def test(self):
         # FIXME: The only reason this test needs to create a real target is because
         # the settings of the dummy target can't be changed with `settings set`.
         self.build()
-        target = self.dbg.CreateTarget(self.getBuildArtifact("a.out"))
+        target = self.createTestTarget()
 
         # Our test expression that is just several lines of malformed
         # integer literals (with a 'yerror' integer suffix). Every error
         # has its own unique string (1, 2, 3, 4) and is on its own line
         # that we can later find it when Clang prints the respective source
         # code for each error to the error output.
         # For example, in the error output below we would look for the
         # unique `1yerror` string:

lldb/test/API/commands/expression/expr-in-syscall/TestExpressionInSyscall.py

@expectedFailureAll(
         bugnumber="llvm.org/pr21765, getpid() does not exist on Windows")
     @expectedFailureNetBSD
     @skipIfReproducer
     def test_setpgid(self):
         self.build()
         self.expr_syscall()
 
     def expr_syscall(self):
-        exe = self.getBuildArtifact("a.out")
-
         # Create a target by the debugger.
-        target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target, VALID_TARGET)
+        target = self.createTestTarget()
 
         listener = lldb.SBListener("my listener")
 
         # launch the inferior and don't wait for it to stop
         self.dbg.SetAsync(True)
         error = lldb.SBError()
         flags = target.GetLaunchInfo().GetLaunchFlags()
         process = target.Launch(listener,

lldb/test/API/commands/expression/no-deadlock/TestExprDoesntBlock.py

class ExprDoesntDeadlockTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @add_test_categories(["basic_process"])
     @skipIfReproducer # Timeouts are not currently modeled.
     def test_with_run_command(self):
         """Test that expr will time out and allow other threads to run if it blocks."""
         self.build()
-        exe = self.getBuildArtifact("a.out")
-
-        # Create a target by the debugger.
-        target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target, VALID_TARGET)
+        target = self.createTestTarget()
 
         # Now create a breakpoint at source line before call_me_to_get_lock
         # gets called.
 
         main_file_spec = lldb.SBFileSpec("locking.cpp")
         breakpoint = target.BreakpointCreateBySourceRegex(
             'Break here', main_file_spec)
         if self.TraceOn():

lldb/test/API/commands/expression/test/TestExprs.py

def test_many_expr_commands(self):
                              "a.out"])
         # (const char *) $8 = 0x... "/Volumes/data/lldb/svn/trunk/test/expression_command/test/a.out"
 
     @add_test_categories(['pyapi'])
     @expectedFlakeyNetBSD
     def test_evaluate_expression_python(self):
         """Test SBFrame.EvaluateExpression() API for evaluating an expression."""
         self.build()
-
-        exe = self.getBuildArtifact("a.out")
-
-        target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target, VALID_TARGET)
+        target = self.createTestTarget()
 
         # Create the breakpoint.
         filespec = lldb.SBFileSpec("main.cpp", False)
         breakpoint = target.BreakpointCreateByLocation(filespec, self.line)
         self.assertTrue(breakpoint, VALID_BREAKPOINT)
 
         # Verify the breakpoint just created.
         self.expect(str(breakpoint), BREAKPOINT_CREATED, exe=False,

lldb/test/API/commands/frame/language/TestGuessLanguage.py

class TestFrameGuessLanguage(TestBase):
     def check_language(self, thread, frame_no, test_lang):
         frame = thread.frames[frame_no]
         self.assertTrue(frame.IsValid(), "Frame %d was not valid."%(frame_no))
         lang = frame.GuessLanguage()
         self.assertEqual(lang, test_lang)
 
     def do_test(self):
         """Test GuessLanguage for C & C++."""
-        exe = self.getBuildArtifact("a.out")
-
-        # Create a target by the debugger.
-        target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target, VALID_TARGET)
+        target = self.createTestTarget()
 
         # Now create a breakpoint in main.c at the source matching
         # "Set a breakpoint here"
         breakpoint = target.BreakpointCreateBySourceRegex(
             "Set breakpoint here", lldb.SBFileSpec("somefunc.c"))
         self.assertTrue(breakpoint and
                         breakpoint.GetNumLocations() >= 1,
                         VALID_BREAKPOINT)

lldb/test/API/commands/frame/var/TestFrameVar.py

class TestFrameVar(TestBase):
     # each debug info format.
     NO_DEBUG_INFO_TESTCASE = True
 
     def test_frame_var(self):
         self.build()
         self.do_test()
 
     def do_test(self):
-        exe = self.getBuildArtifact("a.out")
-
-        # Create a target by the debugger.
-        target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target, VALID_TARGET)
+        target = self.createTestTarget()
 
         # Now create a breakpoint in main.c at the source matching
         # "Set a breakpoint here"
         breakpoint = target.BreakpointCreateBySourceRegex(
             "Set a breakpoint here", lldb.SBFileSpec("main.c"))
         self.assertTrue(breakpoint and
                         breakpoint.GetNumLocations() >= 1,
                         VALID_BREAKPOINT)

lldb/test/API/commands/process/launch-with-shellexpand/TestLaunchWithShellExpand.py

@expectedFailureAll(
             "windows",
             "linux",
             "freebsd"],
         bugnumber="llvm.org/pr24778 llvm.org/pr22627 llvm.org/pr48349")
     @skipIfDarwinEmbedded # iOS etc don't launch the binary via a shell, so arg expansion won't happen
     @expectedFailureNetBSD
     def test(self):
         self.build()
-        exe = self.getBuildArtifact("a.out")
-
-        self.runCmd("target create %s" % exe)
-
-        # Create the target
-        target = self.dbg.CreateTarget(exe)
+        target = self.createTestTarget()
 
         # Create any breakpoints we need
         breakpoint = target.BreakpointCreateBySourceRegex(
             'break here', lldb.SBFileSpec("main.cpp", False))
         self.assertTrue(breakpoint, VALID_BREAKPOINT)
 
         # Ensure we do the expansion with /bin/sh on POSIX.
         os.environ["SHELL"] = '/bin/sh'

lldb/test/API/commands/process/launch/TestProcessLaunch.py

class ProcessLaunchTestCase(TestBase):
 
     @skipIfReproducer
     def test_environment_with_special_char(self):
         """Test that environment variables containing '*' and '}' are handled correctly by the inferior."""
         source = 'print_env.cpp'
         d = {'CXX_SOURCES': source}
         self.build(dictionary=d)
         self.setTearDownCleanup(d)
-        exe = self.getBuildArtifact("a.out")
 
         evil_var = 'INIT*MIDDLE}TAIL'
 
-        target = self.dbg.CreateTarget(exe)
+        target = self.createTestTarget()
         main_source_spec = lldb.SBFileSpec(source)
         breakpoint = target.BreakpointCreateBySourceRegex(
             '// Set breakpoint here.', main_source_spec)
 
         process = target.LaunchSimple(None,
                                       ['EVIL=' + evil_var],
                                       self.get_process_working_directory())
         self.assertEqual(

lldb/test/API/commands/register/register/register_command/TestRegisters.py

def write_and_read(self, frame, register, new_value, must_exist=True):
                 new_value])
 
     # This test relies on ftag containing the 'abridged' value.  Linux
     # and *BSD targets have been ported to report the full value instead
     # consistently with GDB.  They are covered by the new-style
     # lldb/test/Shell/Register/x86*-fp-read.test.
     @skipUnlessDarwin
     def fp_special_purpose_register_read(self):
-        exe = self.getBuildArtifact("a.out")
-
-        # Create a target by the debugger.
-        target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target, VALID_TARGET)
+        target = self.createTestTarget()
 
         # Launch the process and stop.
         self.expect("run", PROCESS_STOPPED, substrs=['stopped'])
 
         # Check stop reason; Should be either signal SIGTRAP or EXC_BREAKPOINT
         output = self.res.GetOutput()
         matched = False
         substrs = [
def fp_special_purpose_register_read(self):
                     'ftag' + ' = ', str(
                         "0x%0.4x" %
                         (reg_value_ftag_initial | (
                             1 << fstat_top_pointer_initial)))])
             reg_value_ftag_initial = reg_value_ftag_initial | (
                 1 << fstat_top_pointer_initial)
 
     def fp_register_write(self):
-        exe = self.getBuildArtifact("a.out")
-
-        # Create a target by the debugger.
-        target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target, VALID_TARGET)
+        target = self.createTestTarget()
 
         # Launch the process, stop at the entry point.
         error = lldb.SBError()
         flags = target.GetLaunchInfo().GetLaunchFlags()
         process = target.Launch(
                 lldb.SBListener(),
                 None, None, # argv, envp
                 None, None, None, # stdin/out/err

lldb/test/API/commands/trace/multiple-threads/TestTraceStartStopMultipleThreads.py

class TestTraceStartStopMultipleThreads(TestBase):
     def setUp(self):
         TestBase.setUp(self)
         if 'intel-pt' not in configuration.enabled_plugins:
             self.skipTest("The intel-pt test plugin is not enabled")
 
     @skipIf(oslist=no_match(['linux']), archs=no_match(['i386', 'x86_64']))
     def testStartMultipleLiveThreads(self):
         self.build()
-        exe = self.getBuildArtifact("a.out")
-        target = self.dbg.CreateTarget(exe)
+        target = self.createTestTarget()
 
         self.expect("b main")
         self.expect("b 6")
         self.expect("b 11")
 
         self.expect("r")
         self.expect("proce trace start")
 
 
         # We'll see here the first thread
         self.expect("continue")
         self.expect("thread trace dump instructions", substrs=['main.cpp:9'])
         
         # We'll see here the second thread
         self.expect("continue")
         self.expect("thread trace dump instructions", substrs=['main.cpp:4'])
 
     @skipIf(oslist=no_match(['linux']), archs=no_match(['i386', 'x86_64']))
     def testStartMultipleLiveThreadsWithStops(self):
         self.build()
-        exe = self.getBuildArtifact("a.out")
-        target = self.dbg.CreateTarget(exe)
+        target = self.createTestTarget()
 
         self.expect("b main")
         self.expect("b 6")
         self.expect("b 11")
 
         self.expect("r")
         self.expect("process trace start")
 

lldb/test/API/commands/watchpoints/multiple_hits/TestMultipleHits.py

class MultipleHitsTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
     NO_DEBUG_INFO_TESTCASE = True
 
     @skipIf(bugnumber="llvm.org/pr30758", oslist=["linux"], archs=["arm", "aarch64", "powerpc64le"])
     @skipIfwatchOS
     def test(self):
         self.build()
-        exe = self.getBuildArtifact("a.out")
-        target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target and target.IsValid(), VALID_TARGET)
+        target = self.createTestTarget()
 
         bp = target.BreakpointCreateByName("main")
         self.assertTrue(bp and bp.IsValid(), "Breakpoint is valid")
 
         process = target.LaunchSimple(None, None,
                 self.get_process_working_directory())
         self.assertEqual(process.GetState(), lldb.eStateStopped)
 

lldb/test/API/commands/watchpoints/step_over_watchpoint/TestStepOverWatchpoint.py

@expectedFailureAll(
         bugnumber="llvm.org/pr26031")
     # Read-write watchpoints not supported on SystemZ
     @expectedFailureAll(archs=['s390x'])
     @expectedFailureAll(oslist=["ios", "watchos", "tvos", "bridgeos"], bugnumber="<rdar://problem/34027183>")  # watchpoint tests aren't working on arm64
     @add_test_categories(["basic_process"])
     def test(self):
         """Test stepping over watchpoints."""
         self.build()
-        exe = self.getBuildArtifact("a.out")
-
-        target = self.dbg.CreateTarget(exe)
-        self.assertTrue(self.target, VALID_TARGET)
+        target = self.createTestTarget()
 
         lldbutil.run_break_set_by_symbol(self, 'main')
 
         process = target.LaunchSimple(None, None,
                                       self.get_process_working_directory())
         self.assertTrue(process.IsValid(), PROCESS_IS_VALID)
         self.assertEquals(process.GetState(), lldb.eStateStopped,
                         PROCESS_STOPPED)

lldb/test/API/commands/watchpoints/watchpoint_disable/TestWatchpointDisable.py

class TestWatchpointSetEnable(TestBase):
     def test_disable_enable_works (self):
         """Set a watchpoint, disable it, and make sure it doesn't get hit."""
         self.build()
         self.do_test(True)
 
     def do_test(self, test_enable):
         """Set a watchpoint, disable it and make sure it doesn't get hit."""
 
-        exe = self.getBuildArtifact("a.out")
         main_file_spec = lldb.SBFileSpec("main.c")
 
-        # Create a target by the debugger.
-        self.target = self.dbg.CreateTarget(exe)
-        self.assertTrue(self.target, VALID_TARGET)
+        self.target = self.createTestTarget()
 
         bkpt_before = self.target.BreakpointCreateBySourceRegex("Set a breakpoint here", main_file_spec)
         self.assertEqual(bkpt_before.GetNumLocations(),  1, "Failed setting the before breakpoint.")
 
         bkpt_after = self.target.BreakpointCreateBySourceRegex("We should have stopped", main_file_spec)
         self.assertEqual(bkpt_after.GetNumLocations(), 1, "Failed setting the after breakpoint.")
 
         process = self.target.LaunchSimple(

lldb/test/API/commands/watchpoints/watchpoint_events/TestWatchpointEvents.py

def setUp(self):
         TestBase.setUp(self)
         # Find the line numbers that we will step to in main:
         self.main_source = "main.c"
 
     @add_test_categories(['pyapi'])
     def test_with_python_api(self):
         """Test that adding, deleting and modifying watchpoints sends the appropriate events."""
         self.build()
-
-        exe = self.getBuildArtifact("a.out")
-
-        target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target, VALID_TARGET)
+        target = self.createTestTarget()
 
         self.main_source_spec = lldb.SBFileSpec(self.main_source)
 
         break_in_main = target.BreakpointCreateBySourceRegex(
             '// Put a breakpoint here.', self.main_source_spec)
         self.assertTrue(break_in_main, VALID_BREAKPOINT)
 
         # Now launch the process, and do not stop at entry point.

lldb/test/API/functionalities/asan/TestMemoryHistory.py

def setUp(self):
         # Call super's setUp().
         TestBase.setUp(self)
         self.line_malloc = line_number('main.c', '// malloc line')
         self.line_malloc2 = line_number('main.c', '// malloc2 line')
         self.line_free = line_number('main.c', '// free line')
         self.line_breakpoint = line_number('main.c', '// break line')
 
     def asan_tests(self):
-        exe = self.getBuildArtifact("a.out")
-        target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target, VALID_TARGET)
+        target = self.createTestTarget()
 
         self.registerSanitizerLibrariesWithTarget(target)
 
         self.runCmd("breakpoint set -f main.c -l %d" % self.line_breakpoint)
 
         # "memory history" command should not work without a process
         self.expect("memory history 0",
                     error=True,

lldb/test/API/functionalities/asan/TestReportData.py

def setUp(self):
         self.line_malloc = line_number('main.c', '// malloc line')
         self.line_malloc2 = line_number('main.c', '// malloc2 line')
         self.line_free = line_number('main.c', '// free line')
         self.line_breakpoint = line_number('main.c', '// break line')
         self.line_crash = line_number('main.c', '// BOOM line')
         self.col_crash = 16
 
     def asan_tests(self):
-        exe = self.getBuildArtifact("a.out")
-        target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target, VALID_TARGET)
+        target = self.createTestTarget()
 
         self.registerSanitizerLibrariesWithTarget(target)
 
         self.runCmd("run")
 
         stop_reason = self.dbg.GetSelectedTarget().process.GetSelectedThread().GetStopReason()
         if stop_reason == lldb.eStopReasonExec:
             # On OS X 10.10 and older, we need to re-exec to enable

lldb/test/API/functionalities/breakpoint/address_breakpoints/TestAddressBreakpoints.py

class AddressBreakpointTestCase(TestBase):
 
     def test_address_breakpoints(self):
         """Test address breakpoints set with shared library of SBAddress work correctly."""
         self.build()
         self.address_breakpoints()
 
     def address_breakpoints(self):
         """Test address breakpoints set with shared library of SBAddress work correctly."""
-        exe = self.getBuildArtifact("a.out")
-
-        # Create a target by the debugger.
-        target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target, VALID_TARGET)
+        target = self.createTestTarget()
 
         # Now create a breakpoint on main.c by name 'c'.
         breakpoint = target.BreakpointCreateBySourceRegex(
             "Set a breakpoint here", lldb.SBFileSpec("main.c"))
         self.assertTrue(breakpoint and
                         breakpoint.GetNumLocations() >= 1,
                         VALID_BREAKPOINT)
 

lldb/test/API/functionalities/breakpoint/auto_continue/TestBreakpointAutoContinue.py

class BreakpointAutoContinue(TestBase):
 
     def test_auto_continue_on_location(self):
         """Set auto-continue on a location and make sure only that location continues"""
         self.build()
         self.auto_continue_location()
 
     def make_target_and_bkpt(self, additional_options=None, num_expected_loc=1,
                              pattern="Set a breakpoint here"):
-        exe = self.getBuildArtifact("a.out")
-        self.target = self.dbg.CreateTarget(exe)
-        self.assertTrue(self.target.IsValid(), "Target is not valid")
+        self.target = self.createTestTarget()
 
         extra_options_txt = "--auto-continue 1 "
         if additional_options:
             extra_options_txt += additional_options
         bpno = lldbutil.run_break_set_by_source_regexp(self, pattern,
                                             extra_options = extra_options_txt,
                                             num_expected_locations = num_expected_loc)
         return bpno

lldb/test/API/functionalities/breakpoint/breakpoint_by_file_colon_line/TestBreakpointByFileColonLine.py

 
 
 class BreakpointByLineAndColumnTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def testBreakpointSpecWithLine(self):
         self.build()
-        exe = self.getBuildArtifact("a.out")
-
-        target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target, VALID_TARGET)
+        target = self.createTestTarget()
         
         # This one should work:
         lldbutil.run_break_set_by_file_colon_line(self, "main.c:11", "main.c", 11, num_expected_locations = 1)
         # Let's try an illegal specifier to make sure the command fails.  I'm not being exhaustive
         # since the UnitTest has more bad patterns.  I'm just testing that if the SetFromString
         # fails, we propagate the error.
         self.expect("break set -y 'foo.c'", error=True)
         
     ## Skip gcc version less 7.1 since it doesn't support -gcolumn-info
     @skipIf(compiler="gcc", compiler_version=['<', '7.1'])
     def testBreakpointByLine(self):
         self.build()
-        exe = self.getBuildArtifact("a.out")
-
-        target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target, VALID_TARGET)
+        target = self.createTestTarget()
 
         main_c = lldb.SBFileSpec("main.c")
         lldbutil.run_break_set_by_file_colon_line(self, "main.c:11:50", "main.c", 11, num_expected_locations = 1)
         

lldb/test/API/functionalities/breakpoint/breakpoint_by_line_and_column/TestBreakpointByLineAndColumn.py

def testBreakpointByLine(self):
             in_condition |= b_loc.GetColumn() < 30
         self.assertTrue(in_condition)
 
     @skipIfWindows
     ## Skip gcc version less 7.1 since it doesn't support -gcolumn-info
     @skipIf(compiler="gcc", compiler_version=['<', '7.1'])
     def testBreakpointByLineAndColumnNearestCode(self):
         self.build()
-        exe = self.getBuildArtifact("a.out")
 
         patterns = [
             "In the middle of a function name (col:42)",
             "In the middle of the lambda declaration argument (col:23)",
             "Inside the lambda (col:26)"
         ]
 
         source_loc = []
 
         for pattern in patterns:
             line = line_number("main.cpp", pattern) + 1
             column = int(re.search('\(col:([0-9]+)\)', pattern).group(1))
             source_loc.append({'line':line, 'column':column})
 
-        # Create a target from the debugger.
-        target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target, VALID_TARGET)
-
+        target = self.createTestTarget()
 
         for loc in source_loc:
             src_file = lldb.SBFileSpec("main.cpp")
             line = loc['line']
             column = loc['column']
             indent = 0
             module_list = lldb.SBFileSpecList()
 

lldb/test/API/functionalities/breakpoint/breakpoint_command/TestBreakpointCommand.py

def breakpoint_command_script_parameters(self):
         self.runCmd("run", RUN_SUCCEEDED)
 
         self.expect(side_effect.frame, exe=False, startstr="frame #0:")
         self.expect(side_effect.bp_loc, exe=False,
                 patterns=["1.* where = .*main .* resolved, hit count = 1"])
 
     def breakpoint_commands_on_creation(self):
         """Test that setting breakpoint commands when creating the breakpoint works"""
-        exe = self.getBuildArtifact("a.out")
-        target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target.IsValid(), "Created an invalid target.")
+        target = self.createTestTarget()
 
         # Add a breakpoint.
         lldbutil.run_break_set_by_file_and_line(
             self, "main.c", self.line, num_expected_locations=1, loc_exact=True,
             extra_options='-C bt -C "thread list" -C continue')
 
         bkpt = target.FindBreakpointByID(1)
         self.assertTrue(bkpt.IsValid(), "Couldn't find breakpoint 1")
         com_list = lldb.SBStringList()
         bkpt.GetCommandLineCommands(com_list)
         self.assertEqual(com_list.GetSize(), 3, "Got the wrong number of commands")
         self.assertEqual(com_list.GetStringAtIndex(0), "bt", "First bt")
         self.assertEqual(com_list.GetStringAtIndex(1), "thread list", "Next thread list")
         self.assertEqual(com_list.GetStringAtIndex(2), "continue", "Last continue")
 
     def test_breakpoint_delete_disabled(self):
         """Test 'break delete --disabled' works"""
         self.build()
-        exe = self.getBuildArtifact("a.out")
-        target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target.IsValid(), "Created an invalid target.")
+        target = self.createTestTarget()
 
         bp_1 = target.BreakpointCreateByName("main")
         bp_2 = target.BreakpointCreateByName("not_here")
         bp_3 = target.BreakpointCreateByName("main")
         bp_3.AddName("DeleteMeNot")
 
         bp_1.SetEnabled(False)
         bp_3.SetEnabled(False)

lldb/test/API/functionalities/breakpoint/breakpoint_command/TestBreakpointCommandsFromPython.py

def test_bkpt_cmd_bad_arguments(self):
         self.do_bad_args_to_python_command()
 
     def setUp(self):
         TestBase.setUp(self)
         self.main_source = "main.c"
         self.main_source_spec = lldb.SBFileSpec(self.main_source)
 
     def do_set_python_command_from_python(self):
-        exe = self.getBuildArtifact("a.out")
         error = lldb.SBError()
 
-        self.target = self.dbg.CreateTarget(exe)
-        self.assertTrue(self.target, VALID_TARGET)
+        self.target = self.createTestTarget()
 
         body_bkpt = self.target.BreakpointCreateBySourceRegex(
             "Set break point at this line.", self.main_source_spec)
         self.assertTrue(body_bkpt, VALID_BREAKPOINT)
 
         func_bkpt = self.target.BreakpointCreateBySourceRegex(
             "Set break point at this line.", self.main_source_spec)
         self.assertTrue(func_bkpt, VALID_BREAKPOINT)
def do_set_python_command_from_python(self):
 
         self.assertEquals("callback was here", side_effect.callback)
         self.assertEquals("function was here", side_effect.bktptcmd)
         self.assertEquals("I am fancy", side_effect.fancy)
         self.assertEquals("I am fancier", side_effect.fancier)
         self.assertEquals("Not so fancy", side_effect.not_so_fancy)
 
     def do_bad_args_to_python_command(self):
-        exe = self.getBuildArtifact("a.out")
         error = lldb.SBError()
 
-        self.target = self.dbg.CreateTarget(exe)
-        self.assertTrue(self.target, VALID_TARGET)
-
+        self.target = self.createTestTarget()
 
         self.expect("command script import --allow-reload ./bktptcmd.py")
 
         bkpt = self.target.BreakpointCreateBySourceRegex(
             "Set break point at this line.", self.main_source_spec)
         self.assertTrue(bkpt, VALID_BREAKPOINT)
 
         # Pass a breakpoint command function that doesn't take extra_args,

lldb/test/API/functionalities/breakpoint/breakpoint_conditions/TestBreakpointConditions.py

def breakpoint_conditions(self, inline=False):
             "frame variable --show-types val",
             VARIABLES_DISPLAYED_CORRECTLY,
             startstr='(int) val = 1')
 
         self.runCmd("process kill")
 
     def breakpoint_conditions_python(self):
         """Use Python APIs to set breakpoint conditions."""
-        exe = self.getBuildArtifact("a.out")
-
-        # Create a target by the debugger.
-        target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target, VALID_TARGET)
+        target = self.createTestTarget()
 
         # Now create a breakpoint on main.c by name 'c'.
         breakpoint = target.BreakpointCreateByName('c', 'a.out')
         self.trace("breakpoint:", breakpoint)
         self.assertTrue(breakpoint and
                         breakpoint.GetNumLocations() == 1,
                         VALID_BREAKPOINT)
 

lldb/test/API/functionalities/breakpoint/breakpoint_hit_count/TestBreakpointHitCount.py

class BreakpointHitCountTestCase(TestBase):
     def test_breakpoint_location_hit_count(self):
         """Use Python APIs to check breakpoint hit count."""
         self.build()
         self.do_test_breakpoint_location_hit_count()
 
     def test_breakpoint_one_shot(self):
         """Check that one-shot breakpoints trigger only once."""
         self.build()
-
-        exe = self.getBuildArtifact("a.out")
-        target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target, VALID_TARGET)
+        target = self.createTestTarget()
 
         self.runCmd("tb a")
         process = target.LaunchSimple(
             None, None, self.get_process_working_directory())
         self.assertTrue(process, PROCESS_IS_VALID)
 
         from lldbsuite.test.lldbutil import get_stopped_thread
         thread = get_stopped_thread(process, lldb.eStopReasonBreakpoint)
def setUp(self):
         TestBase.setUp(self)
         self.a_int_body_line_no = line_number(
             'main.cpp', '// Breakpoint Location 1')
         self.a_float_body_line_no = line_number(
             'main.cpp', '// Breakpoint Location 2')
 
     def do_test_breakpoint_location_hit_count(self):
         """Use Python APIs to check breakpoint hit count."""
-        exe = self.getBuildArtifact("a.out")
-
-        target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target, VALID_TARGET)
+        target = self.createTestTarget()
 
         # Create a breakpoint in main.cpp by name 'a',
         # there should be two locations.
         breakpoint = target.BreakpointCreateByName('a', 'a.out')
         self.assertTrue(breakpoint and
                         breakpoint.GetNumLocations() == 2,
                         VALID_BREAKPOINT)
 

lldb/test/API/functionalities/breakpoint/breakpoint_ignore_count/TestBreakpointIgnoreCount.py

def breakpoint_ignore_count(self):
         # in function name 'c'.  And frame #2 should point to main.c:45.
         self.expect("thread backtrace", STOPPED_DUE_TO_BREAKPOINT_IGNORE_COUNT,
                     #substrs = ["stop reason = breakpoint"],
                     patterns=["frame #0.*main.c:%d" % self.line1,
                               "frame #1.*main.c:%d" % self.line5])
 
     def breakpoint_ignore_count_python(self):
         """Use Python APIs to set breakpoint ignore count."""
-        exe = self.getBuildArtifact("a.out")
-
-        # Create a target by the debugger.
-        target = self.dbg.CreateTarget(exe)
-        self.assertTrue(target, VALID_TARGET)
+        target = self.createTestTarget()
 
         # Now create a breakpoint on main.c by name 'c'.
         breakpoint = target.BreakpointCreateByName('c', 'a.out')
         self.assertTrue(breakpoint and
                         breakpoint.GetNumLocations() == 1,
                         VALID_BREAKPOINT)
 
         # Get the breakpoint location from breakpoint after we verified that,

lldb/test/API/sample_test/TestSampleTest.py

def sample_test(self):
                                    "Set a breakpoint here", self.main_source_file)
 
         frame = thread.GetFrameAtIndex(0)
         test_var = frame.FindVariable("test_var")
         self.assertTrue(test_var.GetError().Success(), "Failed to fetch test_var")
         test_value = test_var.GetValueAsUnsigned()
         self.assertEqual(test_value, 10, "Got the right value for test_var")
 
+    def sample_test_no_launch(self):
+        """ Same as above but doesn't launch a process."""
+
+        target = self.createTestTarget()
+        self.expect_expr("test_var", result_value="10")

lldb/test/API/sample_test/main.c

 #include <stdio.h>
 
+int test_var = 10;
+
 int
 main()
 {
-  int test_var = 10;
   printf ("Set a breakpoint here: %d.\n", test_var);
   //% test_var = self.frame().FindVariable("test_var")
   //% test_value = test_var.GetValueAsUnsigned()
   //% self.assertTrue(test_var.GetError().Success(), "Failed to fetch test_var")
   //% self.assertEqual(test_value, 10, "Failed to get the right value for test_var")
   return 0;
 }