diff options
Diffstat (limited to 'packages/Python/lldbsuite/test/python_api/hello_world')
3 files changed, 189 insertions, 0 deletions
diff --git a/packages/Python/lldbsuite/test/python_api/hello_world/Makefile b/packages/Python/lldbsuite/test/python_api/hello_world/Makefile new file mode 100644 index 0000000..9976203 --- /dev/null +++ b/packages/Python/lldbsuite/test/python_api/hello_world/Makefile @@ -0,0 +1,7 @@ +LEVEL = ../../make + +C_SOURCES := main.c +# See TestHelloWorld.py, which specifies the executable name with a dictionary. +EXE := hello_world + +include $(LEVEL)/Makefile.rules diff --git a/packages/Python/lldbsuite/test/python_api/hello_world/TestHelloWorld.py b/packages/Python/lldbsuite/test/python_api/hello_world/TestHelloWorld.py new file mode 100644 index 0000000..47c3ba1 --- /dev/null +++ b/packages/Python/lldbsuite/test/python_api/hello_world/TestHelloWorld.py @@ -0,0 +1,147 @@ +"""Test Python APIs for target (launch and attach), breakpoint, and process.""" + +from __future__ import print_function + + + +import os, sys, time +import lldb +import time +from lldbsuite.test.lldbtest import * + +class HelloWorldTestCase(TestBase): + + mydir = TestBase.compute_mydir(__file__) + + def setUp(self): + # Call super's setUp(). + TestBase.setUp(self) + # Get the full path to our executable to be attached/debugged. + self.exe = os.path.join(os.getcwd(), self.testMethodName) + self.d = {'EXE': self.testMethodName} + # Find a couple of the line numbers within main.c. + self.line1 = line_number('main.c', '// Set break point at this line.') + self.line2 = line_number('main.c', '// Waiting to be attached...') + + def tearDown(self): + # Destroy process before TestBase.tearDown() + self.dbg.GetSelectedTarget().GetProcess().Destroy() + # Call super's tearDown(). + TestBase.tearDown(self) + + @add_test_categories(['pyapi']) + @skipIfiOSSimulator + def test_with_process_launch_api(self): + """Create target, breakpoint, launch a process, and then kill it.""" + self.build(dictionary=self.d) + self.setTearDownCleanup(dictionary=self.d) + target = self.dbg.CreateTarget(self.exe) + + breakpoint = target.BreakpointCreateByLocation("main.c", self.line1) + + # The default state after breakpoint creation should be enabled. + self.assertTrue(breakpoint.IsEnabled(), + "Breakpoint should be enabled after creation") + + breakpoint.SetEnabled(False) + self.assertTrue(not breakpoint.IsEnabled(), + "Breakpoint.SetEnabled(False) works") + + breakpoint.SetEnabled(True) + self.assertTrue(breakpoint.IsEnabled(), + "Breakpoint.SetEnabled(True) works") + + # rdar://problem/8364687 + # SBTarget.Launch() issue (or is there some race condition)? + + process = target.LaunchSimple (None, None, self.get_process_working_directory()) + # The following isn't needed anymore, rdar://8364687 is fixed. + # + # Apply some dances after LaunchProcess() in order to break at "main". + # It only works sometimes. + #self.breakAfterLaunch(process, "main") + + process = target.GetProcess() + self.assertTrue(process, PROCESS_IS_VALID) + + thread = process.GetThreadAtIndex(0) + if thread.GetStopReason() != lldb.eStopReasonBreakpoint: + from lldbsuite.test.lldbutil import stop_reason_to_str + self.fail(STOPPED_DUE_TO_BREAKPOINT_WITH_STOP_REASON_AS % + stop_reason_to_str(thread.GetStopReason())) + + # The breakpoint should have a hit count of 1. + self.assertTrue(breakpoint.GetHitCount() == 1, BREAKPOINT_HIT_ONCE) + + @add_test_categories(['pyapi']) + @expectedFailureWindows("llvm.org/pr24600") + @expectedFailurei386("llvm.org/pr25338") + @skipIfiOSSimulator + def test_with_attach_to_process_with_id_api(self): + """Create target, spawn a process, and attach to it with process id.""" + self.build(dictionary=self.d) + self.setTearDownCleanup(dictionary=self.d) + target = self.dbg.CreateTarget(self.exe) + + # Spawn a new process + popen = self.spawnSubprocess(self.exe, ["abc", "xyz"]) + self.addTearDownHook(self.cleanupSubprocesses) + + # Give the subprocess time to start and wait for user input + time.sleep(0.25) + + listener = lldb.SBListener("my.attach.listener") + error = lldb.SBError() + process = target.AttachToProcessWithID(listener, popen.pid, error) + + self.assertTrue(error.Success() and process, PROCESS_IS_VALID) + + # Let's check the stack traces of the attached process. + import lldbsuite.test.lldbutil as lldbutil + stacktraces = lldbutil.print_stacktraces(process, string_buffer=True) + self.expect(stacktraces, exe=False, + substrs = ['main.c:%d' % self.line2, + '(int)argc=3']) + + @add_test_categories(['pyapi']) + @expectedFailureWindows("llvm.org/pr24600") + @expectedFailurei386("llvm.org/pr25338") + @skipIfiOSSimulator + def test_with_attach_to_process_with_name_api(self): + """Create target, spawn a process, and attach to it with process name.""" + self.build(dictionary=self.d) + self.setTearDownCleanup(dictionary=self.d) + target = self.dbg.CreateTarget(self.exe) + + # Spawn a new process + popen = self.spawnSubprocess(self.exe, ["abc", "xyz"]) + self.addTearDownHook(self.cleanupSubprocesses) + + # Give the subprocess time to start and wait for user input + time.sleep(0.25) + + listener = lldb.SBListener("my.attach.listener") + error = lldb.SBError() + # Pass 'False' since we don't want to wait for new instance of "hello_world" to be launched. + name = os.path.basename(self.exe) + + # While we're at it, make sure that passing a None as the process name + # does not hang LLDB. + target.AttachToProcessWithName(listener, None, False, error) + # Also boundary condition test ConnectRemote(), too. + target.ConnectRemote(listener, None, None, error) + + process = target.AttachToProcessWithName(listener, name, False, error) + + self.assertTrue(error.Success() and process, PROCESS_IS_VALID) + + # Verify that after attach, our selected target indeed matches name. + self.expect(self.dbg.GetSelectedTarget().GetExecutable().GetFilename(), exe=False, + startstr = name) + + # Let's check the stack traces of the attached process. + import lldbsuite.test.lldbutil as lldbutil + stacktraces = lldbutil.print_stacktraces(process, string_buffer=True) + self.expect(stacktraces, exe=False, + substrs = ['main.c:%d' % self.line2, + '(int)argc=3']) diff --git a/packages/Python/lldbsuite/test/python_api/hello_world/main.c b/packages/Python/lldbsuite/test/python_api/hello_world/main.c new file mode 100644 index 0000000..31a041e --- /dev/null +++ b/packages/Python/lldbsuite/test/python_api/hello_world/main.c @@ -0,0 +1,35 @@ +#include <stdio.h> + +#if defined(__linux__) +#include <sys/prctl.h> +#endif + +int main(int argc, char const *argv[]) { + +#if defined(__linux__) + // Immediately enable any ptracer so that we can allow the stub attach + // operation to succeed. Some Linux kernels are locked down so that + // only an ancestor process can be a ptracer of a process. This disables that + // restriction. Without it, attach-related stub tests will fail. +#if defined(PR_SET_PTRACER) && defined(PR_SET_PTRACER_ANY) + int prctl_result; + + // For now we execute on best effort basis. If this fails for + // some reason, so be it. + prctl_result = prctl(PR_SET_PTRACER, PR_SET_PTRACER_ANY, 0, 0, 0); + (void) prctl_result; +#endif +#endif + + printf("Hello world.\n"); // Set break point at this line. + if (argc == 1) + return 0; + + // Waiting to be attached by the debugger, otherwise. + char line[100]; + while (fgets(line, sizeof(line), stdin)) { // Waiting to be attached... + printf("input line=>%s\n", line); + } + + printf("Exiting now\n"); +} |
