llvmorg-github-actions[bot] wrote:
<!--LLVM PR SUMMARY COMMENT--> @llvm/pr-subscribers-lldb Author: Ebuka Ezike (da-viper) <details> <summary>Changes</summary> migrate breakpointLocations, logpoints, setBreakpoints exceptionBreakpoints and functionBreakpoints test --- Patch is 65.93 KiB, truncated to 20.00 KiB below, full version: https://github.com/llvm/llvm-project/pull/208166.diff 5 Files Affected: - (modified) lldb/test/API/tools/lldb-dap/breakpoint/TestDAP_breakpointLocations.py (+55-66) - (modified) lldb/test/API/tools/lldb-dap/breakpoint/TestDAP_logpoints.py (+123-187) - (modified) lldb/test/API/tools/lldb-dap/breakpoint/TestDAP_setBreakpoints.py (+240-237) - (modified) lldb/test/API/tools/lldb-dap/breakpoint/TestDAP_setExceptionBreakpoints.py (+22-13) - (modified) lldb/test/API/tools/lldb-dap/breakpoint/TestDAP_setFunctionBreakpoints.py (+91-98) ``````````diff diff --git a/lldb/test/API/tools/lldb-dap/breakpoint/TestDAP_breakpointLocations.py b/lldb/test/API/tools/lldb-dap/breakpoint/TestDAP_breakpointLocations.py index 1fe5f8b9e2adc..f97b4b403b063 100644 --- a/lldb/test/API/tools/lldb-dap/breakpoint/TestDAP_breakpointLocations.py +++ b/lldb/test/API/tools/lldb-dap/breakpoint/TestDAP_breakpointLocations.py @@ -2,88 +2,77 @@ Test lldb-dap breakpointLocations request """ - -import dap_server -import shutil -from lldbsuite.test.decorators import * -from lldbsuite.test.lldbtest import * -from lldbsuite.test import lldbutil -import lldbdap_testcase import os +from lldbsuite.test.decorators import ( + skipIfTargetDoesNotSupportSharedLibraries, + skipIfWindows, +) +from lldbsuite.test.lldbtest import line_number +from lldbsuite.test.tools.lldb_dap.dap_types import BreakpointLocation, LaunchArgs +from lldbsuite.test.tools.lldb_dap.lldb_dap_testcase import DAPTestCaseBase -@skipIfTargetDoesNotSupportSharedLibraries() -class TestDAP_breakpointLocations(lldbdap_testcase.DAPTestCaseBase): - def setUp(self): - lldbdap_testcase.DAPTestCaseBase.setUp(self) - - self.main_basename = "main-copy.cpp" - self.main_path = os.path.realpath(self.getBuildArtifact(self.main_basename)) +@skipIfTargetDoesNotSupportSharedLibraries() +class TestDAP_breakpointLocations(DAPTestCaseBase): @skipIfWindows def test_column_breakpoints(self): """Test retrieving the available breakpoint locations.""" program = self.getBuildArtifact("a.out") - self.build_and_launch(program, stopOnEntry=True) - loop_line = line_number(self.main_path, "// break loop") - self.dap_server.request_continue() + session = self.build_and_create_session() + main_path = os.path.realpath(self.getBuildArtifact("main-copy.cpp")) - # Ask for the breakpoint locations based only on the line number - response = self.dap_server.request_breakpointLocations( - self.main_path, loop_line - ) - self.assertTrue(response["success"]) - self.assertEqual( - response["body"]["breakpoints"], - [ - {"line": loop_line, "column": 9}, - {"line": loop_line, "column": 13}, - {"line": loop_line, "column": 20}, - {"line": loop_line, "column": 23}, - {"line": loop_line, "column": 25}, - {"line": loop_line, "column": 34}, - {"line": loop_line, "column": 37}, - {"line": loop_line, "column": 39}, - {"line": loop_line, "column": 51}, - ], - ) + process_event = session.launch(LaunchArgs(program, stopOnEntry=True)) + session.verify_stopped_on_entry(after=process_event) - # Ask for the breakpoint locations for a column range - response = self.dap_server.request_breakpointLocations( - self.main_path, - loop_line, - column=24, - end_column=46, - ) - self.assertTrue(response["success"]) - self.assertEqual( - response["body"]["breakpoints"], - [ - {"line": loop_line, "column": 25}, - {"line": loop_line, "column": 34}, - {"line": loop_line, "column": 37}, - {"line": loop_line, "column": 39}, - ], + # Ask for the breakpoint locations based only on the line number. + loop_line = line_number(main_path, "// break loop") + response = session.get_breakpoint_locations(main_path, loop_line) + breakpoint_locations = response.body.breakpoints + + expected_locations = [ + BreakpointLocation(line=loop_line, column=9), + BreakpointLocation(line=loop_line, column=13), + BreakpointLocation(line=loop_line, column=20), + BreakpointLocation(line=loop_line, column=23), + BreakpointLocation(line=loop_line, column=25), + BreakpointLocation(line=loop_line, column=34), + BreakpointLocation(line=loop_line, column=37), + BreakpointLocation(line=loop_line, column=39), + BreakpointLocation(line=loop_line, column=51), + ] + self.assertEqual(breakpoint_locations, expected_locations) + + # Ask for the breakpoint locations for a column range. + response = session.get_breakpoint_locations( + main_path, loop_line, column=24, endColumn=46 ) + breakpoint_locations = response.body.breakpoints + expected_locations = [ + BreakpointLocation(line=loop_line, column=25), + BreakpointLocation(line=loop_line, column=34), + BreakpointLocation(line=loop_line, column=37), + BreakpointLocation(line=loop_line, column=39), + ] + self.assertEqual(breakpoint_locations, expected_locations) - # Ask for the breakpoint locations for a range of line numbers - response = self.dap_server.request_breakpointLocations( - self.main_path, - line=loop_line, - end_line=loop_line + 2, - column=39, + # Ask for the breakpoint locations for a range of line numbers. + response = session.get_breakpoint_locations( + main_path, line=loop_line, column=39, endLine=loop_line + 2 ) self.maxDiff = None - self.assertTrue(response["success"]) # On some systems, there is an additional breakpoint available # at loop_line + 1, column 3, i.e. at the end of the loop. To make # this test more portable, only check that all expected breakpoints # are presented, but also accept additional breakpoints. - expected_breakpoints = [ - {"column": 39, "line": loop_line}, - {"column": 51, "line": loop_line}, - {"column": 3, "line": loop_line + 2}, - {"column": 18, "line": loop_line + 2}, + expected_locations = [ + BreakpointLocation(line=loop_line, column=39), + BreakpointLocation(line=loop_line, column=51), + BreakpointLocation(line=loop_line + 2, column=3), + BreakpointLocation(line=loop_line + 2, column=18), ] - for bp in expected_breakpoints: - self.assertIn(bp, response["body"]["breakpoints"]) + breakpoint_locations = response.body.breakpoints + for bp in expected_locations: + self.assertIn(bp, breakpoint_locations) + + session.continue_to_exit() diff --git a/lldb/test/API/tools/lldb-dap/breakpoint/TestDAP_logpoints.py b/lldb/test/API/tools/lldb-dap/breakpoint/TestDAP_logpoints.py index d633f0b9ffde4..71c7c0cf9097c 100644 --- a/lldb/test/API/tools/lldb-dap/breakpoint/TestDAP_logpoints.py +++ b/lldb/test/API/tools/lldb-dap/breakpoint/TestDAP_logpoints.py @@ -2,109 +2,95 @@ Test lldb-dap logpoints feature. """ - -import dap_server -import shutil -from lldbsuite.test.decorators import * -from lldbsuite.test.lldbtest import * -from lldbsuite.test import lldbutil -import lldbdap_testcase import os +from lldbsuite.test.decorators import ( + skipIfTargetDoesNotSupportSharedLibraries, + skipIfWindows, +) +from lldbsuite.test.lldbtest import line_number +from lldbsuite.test.tools.lldb_dap.dap_types import ( + LaunchArgs, + SourceBreakpoint, + StoppedEvent, +) +from lldbsuite.test.tools.lldb_dap.lldb_dap_testcase import DAPTestCaseBase +from lldbsuite.test.tools.lldb_dap.session_helpers import DAPTestSession + @skipIfTargetDoesNotSupportSharedLibraries() -class TestDAP_logpoints(lldbdap_testcase.DAPTestCaseBase): +class TestDAP_logpoints(DAPTestCaseBase): def setUp(self): - lldbdap_testcase.DAPTestCaseBase.setUp(self) + DAPTestCaseBase.setUp(self) self.main_basename = "main-copy.cpp" self.main_path = os.path.realpath(self.getBuildArtifact(self.main_basename)) - @skipIfWindows - def test_logmessage_basic(self): - """Tests breakpoint logmessage basic functionality.""" + def stop_at_before_loop_line(self, session: DAPTestSession) -> StoppedEvent: + """Launch, set a breakpoint at 'before loop' line and stop there""" before_loop_line = line_number("main.cpp", "// before loop") - loop_line = line_number("main.cpp", "// break loop") - after_loop_line = line_number("main.cpp", "// after loop") - program = self.getBuildArtifact("a.out") - self.build_and_launch(program) - - # Set a breakpoint at a line before loop - before_loop_breakpoint_ids = self.set_source_breakpoints( - self.main_path, [before_loop_line] - ) - self.assertEqual(len(before_loop_breakpoint_ids), 1, "expect one breakpoint") - - self.dap_server.request_continue() + with session.configure(LaunchArgs(program)) as ctx: + [bp] = session.resolve_source_breakpoints( + self.main_path, [before_loop_line] + ) - # Verify we hit the breakpoint before loop line - self.verify_breakpoint_hit(before_loop_breakpoint_ids) + return session.verify_stopped_on_breakpoint(bp, after=ctx.process_event) - # Swallow old console output - self.get_console() + @skipIfWindows + def test_logMessage_basic(self): + """Tests breakpoint logMessage basic functionality.""" + session = self.build_and_create_session() + initial_stop = self.stop_at_before_loop_line(session) + source = self.getSourcePath("main.cpp") + loop_line = line_number(source, "// break loop") + after_loop_line = line_number(source, "// after loop") # Set two breakpoints: - # 1. First at the loop line with logMessage - # 2. Second guard breakpoint at a line after loop + # 1. First at the loop line with logMessage. + # 2. Second guard breakpoint at a line after loop. logMessage_prefix = "This is log message for { -- " logMessage = logMessage_prefix + "{i + 3}, {message}" - [loop_breakpoint_id, post_loop_breakpoint_id] = self.set_source_breakpoints( + [_, post_loop_breakpoint_id] = session.resolve_source_breakpoints( self.main_path, - [loop_line, after_loop_line], - [{"logMessage": logMessage}, {}], + [ + SourceBreakpoint(loop_line, logMessage=logMessage), + SourceBreakpoint(after_loop_line), + ], ) - # Continue to trigger the breakpoint with log messages - self.dap_server.request_continue() + # Continue and verify we hit the breakpoint after loop line. + post_loop_stop = session.continue_to_breakpoint(post_loop_breakpoint_id) - # Verify we hit the breakpoint after loop line - self.verify_breakpoint_hit([post_loop_breakpoint_id]) - - output = self.get_console() - lines = output.splitlines() - logMessage_output = [] - for line in lines: - if line.startswith(logMessage_prefix): - logMessage_output.append(line) - - # Verify logMessage count - loop_count = 10 - self.assertEqual(len(logMessage_output), loop_count) + captured = session.collect_console(after=initial_stop, until=post_loop_stop) + logMessage_output = [ + line + for line in captured.seen_texts.splitlines() + if line.startswith(logMessage_prefix) + ] + # Verify logMessage count. + self.assertEqual(len(logMessage_output), 10) message_addr_pattern = r"\b0x[0-9A-Fa-f]+\b" message_content = '"Hello from main!"' - # Verify log message match + + # Verify logMessage match. for idx, logMessage_line in enumerate(logMessage_output): result = idx + 3 - reg_str = ( - f"{logMessage_prefix}{result}, {message_addr_pattern} {message_content}" + self.assertRegex( + logMessage_line, + f"{logMessage_prefix}{result}, {message_addr_pattern} {message_content}", ) - self.assertRegex(logMessage_line, reg_str) + session.continue_to_exit() @skipIfWindows def test_logmessage_advanced(self): """Tests breakpoint logmessage functionality for complex expression.""" - before_loop_line = line_number("main.cpp", "// before loop") - loop_line = line_number("main.cpp", "// break loop") - after_loop_line = line_number("main.cpp", "// after loop") - - program = self.getBuildArtifact("a.out") - self.build_and_launch(program) - - # Set a breakpoint at a line before loop - before_loop_breakpoint_ids = self.set_source_breakpoints( - self.main_path, [before_loop_line] - ) - self.assertEqual(len(before_loop_breakpoint_ids), 1, "expect one breakpoint") - - self.dap_server.request_continue() - - # Verify we hit the breakpoint before loop line - self.verify_breakpoint_hit(before_loop_breakpoint_ids) - - # Swallow old console output - self.get_console() + session = self.build_and_create_session() + initial_stop = self.stop_at_before_loop_line(session) + source = self.getSourcePath("main.cpp") + before_loop_line = line_number(source, "// break loop") + after_loop_line = line_number(source, "// after loop") # Set two breakpoints: # 1. First at the loop line with logMessage @@ -114,91 +100,64 @@ def test_logmessage_advanced(self): logMessage_prefix + "{int y = 0; if (i % 3 == 0) { y = i + 3;} else {y = i * 3;} y}" ) - [loop_breakpoint_id, post_loop_breakpoint_id] = self.set_source_breakpoints( + [_, post_loop_breakpoint_id] = session.resolve_source_breakpoints( self.main_path, - [loop_line, after_loop_line], - [{"logMessage": logMessage}, {}], + [ + SourceBreakpoint(before_loop_line, logMessage=logMessage), + SourceBreakpoint(after_loop_line), + ], ) - # Continue to trigger the breakpoint with log messages - self.dap_server.request_continue() - - # Verify we hit the breakpoint after loop line - self.verify_breakpoint_hit([post_loop_breakpoint_id]) - - output = self.get_console() - lines = output.splitlines() - logMessage_output = [] - for line in lines: - if line.startswith(logMessage_prefix): - logMessage_output.append(line) - - # Verify logMessage count - loop_count = 10 - self.assertEqual(len(logMessage_output), loop_count) - - # Verify log message match + post_loop_stop = session.continue_to_breakpoint(post_loop_breakpoint_id) + captured = session.collect_console(after=initial_stop, until=post_loop_stop) + logMessage_output = [ + line + for line in captured.seen_texts.splitlines() + if line.startswith(logMessage_prefix) + ] + # Verify logMessage count. + self.assertEqual(len(logMessage_output), 10) + + # Verify logMessage match. for idx, logMessage_line in enumerate(logMessage_output): result = idx + 3 if idx % 3 == 0 else idx * 3 self.assertEqual(logMessage_line, logMessage_prefix + str(result)) @skipIfWindows def test_logmessage_format(self): - """ - Tests breakpoint logmessage functionality with format. - """ - before_loop_line = line_number("main.cpp", "// before loop") - loop_line = line_number("main.cpp", "// break loop") - after_loop_line = line_number("main.cpp", "// after loop") - - program = self.getBuildArtifact("a.out") - self.build_and_launch(program) - - # Set a breakpoint at a line before loop - before_loop_breakpoint_ids = self.set_source_breakpoints( - self.main_path, [before_loop_line] - ) - self.assertEqual(len(before_loop_breakpoint_ids), 1, "expect one breakpoint") - - self.dap_server.request_continue() - - # Verify we hit the breakpoint before loop line - self.verify_breakpoint_hit(before_loop_breakpoint_ids) - - # Swallow old console output - self.get_console() + """Tests breakpoint logmessage functionality with format.""" + session = self.build_and_create_session() + initial_stop = self.stop_at_before_loop_line(session) + source = self.getSourcePath("main.cpp") + loop_line = line_number(source, "// break loop") + after_loop_line = line_number(source, "// after loop") # Set two breakpoints: - # 1. First at the loop line with logMessage - # 2. Second guard breakpoint at a line after loop + # 1. First at the loop line with logMessage. + # 2. Second guard breakpoint at a line after loop. logMessage_prefix = "This is log message for -- " logMessage_with_format = "part1\tpart2\bpart3\x64part4" logMessage_with_format_raw = r"part1\tpart2\bpart3\x64part4" logMessage = logMessage_prefix + logMessage_with_format_raw + "{i - 1}" - [loop_breakpoint_id, post_loop_breakpoint_id] = self.set_source_breakpoints( + [_, post_loop_breakpoint_id] = session.resolve_source_breakpoints( self.main_path, - [loop_line, after_loop_line], - [{"logMessage": logMessage}, {}], + [ + SourceBreakpoint(loop_line, logMessage=logMessage), + SourceBreakpoint(after_loop_line), + ], ) - # Continue to trigger the breakpoint with log messages - self.dap_server.request_continue() - - # Verify we hit the breakpoint after loop line - self.verify_breakpoint_hit([post_loop_breakpoint_id]) - - output = self.get_console() - lines = output.splitlines() - logMessage_output = [] - for line in lines: - if line.startswith(logMessage_prefix): - logMessage_output.append(line) - - # Verify logMessage count - loop_count = 10 - self.assertEqual(len(logMessage_output), loop_count) - - # Verify log message match + post_loop_stop = session.continue_to_breakpoint(post_loop_breakpoint_id) + captured = session.collect_console(after=initial_stop, until=post_loop_stop) + logMessage_output = [ + line + for line in captured.seen_texts.splitlines() + if line.startswith(logMessage_prefix) + ] + # Verify logMessage count. + self.assertEqual(len(logMessage_output), 10) + + # Verify logMessage match. for idx, logMessage_line in enumerate(logMessage_output): result = idx - 1 self.assertEqual( @@ -208,64 +167,41 @@ def test_logmessage_format(self): @skipIfWindows def test_logmessage_format_failure(self): - """ - Tests breakpoint logmessage format with parsing failure. - """ - before_loop_line = line_number("main.cpp", "// before loop") - loop_line = line_number("main.cpp", "// break loop") - after_loop_line = line_number("main.cpp", "// after loop") - - program = self.getBuildArtifact("a.out") - self.build_and_launch(program) - - # Set a breakpoint at a line before loop - before_loop_breakpoint_ids = self.set_source_breakpoints( - self.main_path, [before_loop_line] - ) - self.assertEqual(len(before_loop_breakpoint_ids), 1, "expect one breakpoint") - - self.dap_server.request_continue() - - # Verify we hit the breakpoint before loop line - self.verify_breakpoint_hit(before_loop_breakpoint_ids) - - # Swallow old console output - self.get_console() + """Tests breakpoint logmessage format with parsing failure.""" + session = self.build_and_create_session() + initial_stop = self.stop_at_before_loop_line(session) + source = self.getSourcePath("main.cpp") + loop_line = line_number(source, "// break loop") + after_loop_line = line_number(source, "// after loop") # Set two breakpoints: - # 1. First at the loop line with log... [truncated] `````````` </details> https://github.com/llvm/llvm-project/pull/208166 _______________________________________________ lldb-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
