https://github.com/dzhidzhoev created https://github.com/llvm/llvm-project/pull/170555
This reverts commit 5e5937c3d2e493a48837b2bdf179a53e8b80a66a, since the added test fails on the `lldb-x86_64-win` buildbot. https://lab.llvm.org/buildbot/#/builders/211/builds/4246 >From fa21d9ce040706bca821d031e38e9c8ef6252ca9 Mon Sep 17 00:00:00 2001 From: Vladislav Dzhidzhoev <[email protected]> Date: Wed, 3 Dec 2025 21:57:49 +0100 Subject: [PATCH] Revert "[LLDB] Add SBFrameExtensions Tests (#169236)" This reverts commit 5e5937c3d2e493a48837b2bdf179a53e8b80a66a, since the added test fails on the `lldb-x86_64-win` buildbot. https://lab.llvm.org/buildbot/#/builders/211/builds/4246 --- .../python_api/sbframe_extensions/Makefile | 3 - .../TestSBFrameExtensions.py | 534 ------------------ .../API/python_api/sbframe_extensions/main.c | 33 -- 3 files changed, 570 deletions(-) delete mode 100644 lldb/test/API/python_api/sbframe_extensions/Makefile delete mode 100644 lldb/test/API/python_api/sbframe_extensions/TestSBFrameExtensions.py delete mode 100644 lldb/test/API/python_api/sbframe_extensions/main.c diff --git a/lldb/test/API/python_api/sbframe_extensions/Makefile b/lldb/test/API/python_api/sbframe_extensions/Makefile deleted file mode 100644 index 10495940055b6..0000000000000 --- a/lldb/test/API/python_api/sbframe_extensions/Makefile +++ /dev/null @@ -1,3 +0,0 @@ -C_SOURCES := main.c - -include Makefile.rules diff --git a/lldb/test/API/python_api/sbframe_extensions/TestSBFrameExtensions.py b/lldb/test/API/python_api/sbframe_extensions/TestSBFrameExtensions.py deleted file mode 100644 index d3eabfdd979c5..0000000000000 --- a/lldb/test/API/python_api/sbframe_extensions/TestSBFrameExtensions.py +++ /dev/null @@ -1,534 +0,0 @@ -""" -Test SBFrameExtensions API. -""" - -import lldb -from lldbsuite.test.decorators import * -from lldbsuite.test.lldbtest import * -from lldbsuite.test import lldbutil - - -class TestSBFrameExtensions(TestBase): - NO_DEBUG_INFO_TESTCASE = True - - def setUp(self): - TestBase.setUp(self) - self.source = "main.c" - - def _get_frame(self): - """Helper method to get a valid frame for testing.""" - self.build() - target, process, thread, bkpt = lldbutil.run_to_source_breakpoint( - self, "Set breakpoint here", lldb.SBFileSpec(self.source) - ) - frame = thread.GetFrameAtIndex(0) - self.assertTrue(frame.IsValid(), "Frame should be valid") - return frame, thread - - def test_property_pc(self): - """Test SBFrame extension property: pc""" - frame, _ = self._get_frame() - - pc = frame.pc - self.assertIsInstance(pc, int, "pc should be an integer") - self.assertGreater(pc, 0, "pc should be greater than 0") - self.assertEqual(pc, frame.GetPC(), "pc property should match GetPC()") - - def test_property_addr(self): - """Test SBFrame extension property: addr""" - frame, _ = self._get_frame() - - addr = frame.addr - self.assertTrue(addr.IsValid(), "addr should be valid") - self.assertEqual(addr, frame.GetPCAddress(), "addr should match GetPCAddress()") - - def test_property_fp(self): - """Test SBFrame extension property: fp""" - frame, _ = self._get_frame() - - fp = frame.fp - self.assertIsInstance(fp, int, "fp should be an integer") - self.assertEqual(fp, frame.GetFP(), "fp property should match GetFP()") - - def test_property_sp(self): - """Test SBFrame extension property: sp""" - frame, _ = self._get_frame() - - sp = frame.sp - self.assertIsInstance(sp, int, "sp should be an integer") - self.assertEqual(sp, frame.GetSP(), "sp property should match GetSP()") - - def test_property_module(self): - """Test SBFrame extension property: module""" - frame, _ = self._get_frame() - - module = frame.module - self.assertTrue(module.IsValid(), "module should be valid") - self.assertEqual(module, frame.GetModule(), "module should match GetModule()") - - def test_property_compile_unit(self): - """Test SBFrame extension property: compile_unit""" - frame, _ = self._get_frame() - - compile_unit = frame.compile_unit - self.assertTrue(compile_unit.IsValid(), "compile_unit should be valid") - self.assertEqual( - compile_unit, - frame.GetCompileUnit(), - "compile_unit should match GetCompileUnit()", - ) - - def test_property_function(self): - """Test SBFrame extension property: function""" - frame, _ = self._get_frame() - - function = frame.function - self.assertTrue(function.IsValid(), "function should be valid") - self.assertEqual( - function, frame.GetFunction(), "function should match GetFunction()" - ) - - def test_property_symbol(self): - """Test SBFrame extension property: symbol""" - frame, _ = self._get_frame() - - symbol = frame.symbol - self.assertTrue(symbol.IsValid(), "symbol should be valid") - self.assertEqual(symbol, frame.GetSymbol(), "symbol should match GetSymbol()") - - def test_property_block(self): - """Test SBFrame extension property: block""" - frame, _ = self._get_frame() - - block = frame.block - self.assertTrue(block.IsValid(), "block should be valid") - block_direct = frame.GetBlock() - self.assertTrue(block_direct.IsValid(), "GetBlock() should return valid block") - # Verify both blocks are valid and have the same ranges - # by comparing their first range start address. - block_ranges = block.GetRanges() - block_direct_ranges = block_direct.GetRanges() - if block_ranges.GetSize() > 0 and block_direct_ranges.GetSize() > 0: - self.assertEqual( - block.GetRangeStartAddress(0), - block_direct.GetRangeStartAddress(0), - "block should match GetBlock() start address", - ) - - def test_property_is_inlined(self): - """Test SBFrame extension property: is_inlined""" - frame, _ = self._get_frame() - - is_inlined = frame.is_inlined - self.assertIsInstance(is_inlined, bool, "is_inlined should be a boolean") - self.assertEqual( - is_inlined, frame.IsInlined(), "is_inlined should match IsInlined()" - ) - - def test_property_name(self): - """Test SBFrame extension property: name""" - frame, _ = self._get_frame() - - name = frame.name - self.assertIsInstance(name, str, "name should be a string") - self.assertEqual( - name, frame.GetFunctionName(), "name should match GetFunctionName()" - ) - # Should be one of our functions. - self.assertIn( - name, ["func1", "func2", "main"], "name should be a known function" - ) - - def test_property_line_entry(self): - """Test SBFrame extension property: line_entry""" - frame, _ = self._get_frame() - - line_entry = frame.line_entry - self.assertTrue(line_entry.IsValid(), "line_entry should be valid") - self.assertEqual( - line_entry, frame.GetLineEntry(), "line_entry should match GetLineEntry()" - ) - - def test_property_thread(self): - """Test SBFrame extension property: thread""" - frame, thread = self._get_frame() - - thread_prop = frame.thread - self.assertTrue(thread_prop.IsValid(), "thread should be valid") - self.assertEqual( - thread_prop, frame.GetThread(), "thread should match GetThread()" - ) - self.assertEqual( - thread_prop.GetThreadID(), - thread.GetThreadID(), - "thread should be the same thread", - ) - - def test_property_disassembly(self): - """Test SBFrame extension property: disassembly""" - frame, _ = self._get_frame() - - disassembly = frame.disassembly - self.assertIsInstance(disassembly, str, "disassembly should be a string") - self.assertGreater(len(disassembly), 0, "disassembly should not be empty") - self.assertEqual( - disassembly, frame.Disassemble(), "disassembly should match Disassemble()" - ) - - def test_property_idx(self): - """Test SBFrame extension property: idx""" - frame, _ = self._get_frame() - - idx = frame.idx - self.assertIsInstance(idx, int, "idx should be an integer") - self.assertEqual(idx, frame.GetFrameID(), "idx should match GetFrameID()") - self.assertEqual(idx, 0, "First frame should have idx 0") - - def test_property_variables(self): - """Test SBFrame extension property: variables""" - frame, _ = self._get_frame() - - variables = frame.variables - self.assertIsInstance( - variables, lldb.SBValueList, "variables should be SBValueList" - ) - all_vars = frame.GetVariables(True, True, True, True) - self.assertEqual( - variables.GetSize(), - all_vars.GetSize(), - "variables should match GetVariables(True, True, True, True)", - ) - - def test_property_vars(self): - """Test SBFrame extension property: vars (alias for variables)""" - frame, _ = self._get_frame() - - vars_prop = frame.vars - self.assertIsInstance(vars_prop, lldb.SBValueList, "vars should be SBValueList") - variables = frame.variables - self.assertEqual( - vars_prop.GetSize(), - variables.GetSize(), - "vars should match variables", - ) - - def test_property_locals(self): - """Test SBFrame extension property: locals""" - frame, _ = self._get_frame() - - locals_prop = frame.locals - self.assertIsInstance( - locals_prop, lldb.SBValueList, "locals should be SBValueList" - ) - locals_direct = frame.GetVariables(False, True, False, False) - self.assertEqual( - locals_prop.GetSize(), - locals_direct.GetSize(), - "locals should match GetVariables(False, True, False, False)", - ) - - def test_property_args(self): - """Test SBFrame extension property: args""" - frame, _ = self._get_frame() - - args_prop = frame.args - self.assertIsInstance(args_prop, lldb.SBValueList, "args should be SBValueList") - args_direct = frame.GetVariables(True, False, False, False) - self.assertEqual( - args_prop.GetSize(), - args_direct.GetSize(), - "args should match GetVariables(True, False, False, False)", - ) - - def test_property_arguments(self): - """Test SBFrame extension property: arguments (alias for args)""" - frame, _ = self._get_frame() - - arguments_prop = frame.arguments - self.assertIsInstance( - arguments_prop, lldb.SBValueList, "arguments should be SBValueList" - ) - args_prop = frame.args - self.assertEqual( - arguments_prop.GetSize(), - args_prop.GetSize(), - "arguments should match args", - ) - - def test_property_statics(self): - """Test SBFrame extension property: statics""" - frame, _ = self._get_frame() - - statics_prop = frame.statics - self.assertIsInstance( - statics_prop, lldb.SBValueList, "statics should be SBValueList" - ) - statics_direct = frame.GetVariables(False, False, True, False) - self.assertEqual( - statics_prop.GetSize(), - statics_direct.GetSize(), - "statics should match GetVariables(False, False, True, False)", - ) - - def test_property_registers(self): - """Test SBFrame extension property: registers""" - frame, _ = self._get_frame() - - registers = frame.registers - # registers returns an SBValueList that can be iterated. - self.assertTrue(hasattr(registers, "__iter__"), "registers should be iterable") - registers_direct = frame.GetRegisters() - # Compare by iterating and counting. - registers_count = sum(1 for _ in registers) - registers_direct_count = sum(1 for _ in registers_direct) - self.assertEqual( - registers_count, - registers_direct_count, - "registers should match GetRegisters()", - ) - - def test_property_regs(self): - """Test SBFrame extension property: regs (alias for registers)""" - frame, _ = self._get_frame() - - regs = frame.regs - self.assertTrue(hasattr(regs, "__iter__"), "regs should be iterable") - registers = frame.registers - regs_count = sum(1 for _ in regs) - registers_count = sum(1 for _ in registers) - self.assertEqual(regs_count, registers_count, "regs should match registers") - - def test_property_register(self): - """Test SBFrame extension property: register (flattened view)""" - frame, _ = self._get_frame() - - register = frame.register - self.assertIsNotNone(register, "register should not be None") - # register is a helper object with __iter__ and __getitem__. - reg_names = set() - for reg in register: - self.assertTrue(reg.IsValid(), "Register should be valid") - reg_names.add(reg.name) - - # Test register indexing by name. - if len(reg_names) > 0: - first_reg_name = list(reg_names)[0] - reg_by_name = register[first_reg_name] - self.assertTrue(reg_by_name.IsValid(), "Register by name should be valid") - self.assertEqual( - reg_by_name.name, first_reg_name, "Register name should match" - ) - - def test_property_reg(self): - """Test SBFrame extension property: reg (alias for register)""" - frame, _ = self._get_frame() - - reg = frame.reg - self.assertIsNotNone(reg, "reg should not be None") - register = frame.register - reg_names = set() - for r in reg: - reg_names.add(r.name) - reg_names2 = set() - for r in register: - reg_names2.add(r.name) - self.assertEqual(reg_names, reg_names2, "reg should match register") - - def test_property_parent(self): - """Test SBFrame extension property: parent""" - frame0, thread = self._get_frame() - - # If there's a parent frame (frame 1), test parent property. - if thread.GetNumFrames() > 1: - frame1 = thread.GetFrameAtIndex(1) - parent = frame0.parent - self.assertTrue(parent.IsValid(), "parent should be valid") - self.assertEqual( - parent.GetFrameID(), - frame1.GetFrameID(), - "parent should be the next frame", - ) - self.assertEqual( - parent.pc, frame1.GetPC(), "parent PC should match frame 1" - ) - - def test_property_child(self): - """Test SBFrame extension property: child""" - frame0, thread = self._get_frame() - - # Test child property (should be frame -1, which doesn't exist, so should return invalid). - child = frame0.child - # Child of frame 0 would be frame -1, which doesn't exist. - # So it should return an invalid frame. - if thread.GetNumFrames() == 1: - self.assertFalse(child.IsValid(), "child of only frame should be invalid") - - def test_method_get_all_variables(self): - """Test SBFrame extension method: get_all_variables()""" - frame, _ = self._get_frame() - - all_vars = frame.get_all_variables() - self.assertIsInstance( - all_vars, lldb.SBValueList, "get_all_variables should return SBValueList" - ) - all_vars_direct = frame.GetVariables(True, True, True, True) - self.assertEqual( - all_vars.GetSize(), - all_vars_direct.GetSize(), - "get_all_variables should match GetVariables(True, True, True, True)", - ) - - def test_method_get_arguments(self): - """Test SBFrame extension method: get_arguments()""" - frame, _ = self._get_frame() - - args = frame.get_arguments() - self.assertIsInstance( - args, lldb.SBValueList, "get_arguments should return SBValueList" - ) - args_direct = frame.GetVariables(True, False, False, False) - self.assertEqual( - args.GetSize(), - args_direct.GetSize(), - "get_arguments should match GetVariables(True, False, False, False)", - ) - - def test_method_get_locals(self): - """Test SBFrame extension method: get_locals()""" - frame, _ = self._get_frame() - - locals = frame.get_locals() - self.assertIsInstance( - locals, lldb.SBValueList, "get_locals should return SBValueList" - ) - locals_direct = frame.GetVariables(False, True, False, False) - self.assertEqual( - locals.GetSize(), - locals_direct.GetSize(), - "get_locals should match GetVariables(False, True, False, False)", - ) - - def test_method_get_statics(self): - """Test SBFrame extension method: get_statics()""" - frame, _ = self._get_frame() - - statics = frame.get_statics() - self.assertIsInstance( - statics, lldb.SBValueList, "get_statics should return SBValueList" - ) - statics_direct = frame.GetVariables(False, False, True, False) - self.assertEqual( - statics.GetSize(), - statics_direct.GetSize(), - "get_statics should match GetVariables(False, False, True, False)", - ) - - def test_method_var(self): - """Test SBFrame extension method: var()""" - frame, _ = self._get_frame() - - # Test var() method with a variable that should exist. - # First, let's see what variables are available. - all_vars = frame.GetVariables(True, True, True, True) - if all_vars.GetSize() > 0: - var_name = all_vars.GetValueAtIndex(0).GetName() - var_value = frame.var(var_name) - self.assertTrue(var_value.IsValid(), f"var('{var_name}') should be valid") - self.assertEqual( - var_value.GetName(), - var_name, - f"var('{var_name}') should return the correct variable", - ) - # Compare with GetValueForVariablePath. - var_direct = frame.GetValueForVariablePath(var_name) - self.assertEqual( - var_value.GetName(), - var_direct.GetName(), - "var() should match GetValueForVariablePath()", - ) - - # Test var() with non-existent variable. - invalid_var = frame.var("NonExistentVariable12345") - self.assertFalse( - invalid_var.IsValid(), "var() with non-existent variable should be invalid" - ) - - def test_method_get_parent_frame(self): - """Test SBFrame extension method: get_parent_frame()""" - frame0, thread = self._get_frame() - - # Test get_parent_frame. - if thread.GetNumFrames() > 1: - parent = frame0.get_parent_frame() - self.assertTrue( - parent.IsValid(), "get_parent_frame should return valid frame" - ) - frame1 = thread.GetFrameAtIndex(1) - self.assertEqual( - parent.GetFrameID(), - frame1.GetFrameID(), - "get_parent_frame should return frame 1", - ) - else: - # If there's only one frame, parent should be invalid. - parent = frame0.get_parent_frame() - # Note: get_parent_frame might return an invalid frame if idx+1 is out of bounds. - - def test_method_get_child_frame(self): - """Test SBFrame extension method: get_child_frame()""" - frame0, thread = self._get_frame() - - # Test get_child_frame (frame -1 doesn't exist, so should be invalid). - child = frame0.get_child_frame() - if thread.GetNumFrames() == 1: - self.assertFalse( - child.IsValid(), "get_child_frame of only frame should be invalid" - ) - - def test_special_method_int(self): - """Test SBFrame extension special method: __int__""" - frame0, _ = self._get_frame() - - # Test __int__ (converts frame to its frame ID). - frame_id = int(frame0) - self.assertIsInstance(frame_id, int, "__int__ should return an integer") - self.assertEqual( - frame_id, frame0.GetFrameID(), "__int__ should return frame ID" - ) - - def test_special_method_hex(self): - """Test SBFrame extension special method: __hex__""" - frame0, _ = self._get_frame() - - # Test __hex__ (converts frame to its PC). - # Note: __hex__ returns the PC as an integer, not a hex string. - # In Python 3, hex() builtin calls __index__ if __hex__ doesn't exist, - # but since __hex__ is defined, it will be called. - pc_hex = frame0.__hex__() - self.assertIsInstance(pc_hex, int, "__hex__ should return an integer (PC)") - self.assertEqual(pc_hex, frame0.GetPC(), "__hex__ should return PC") - - def test_special_method_eq(self): - """Test SBFrame extension special method: __eq__ and __ne__""" - frame0, thread = self._get_frame() - - # Test __eq__ and __ne__. - frame0_copy = thread.GetFrameAtIndex(0) - self.assertTrue(frame0 == frame0_copy, "Same frame should be equal") - self.assertFalse(frame0 != frame0_copy, "Same frame should not be not-equal") - - if thread.GetNumFrames() > 1: - frame1 = thread.GetFrameAtIndex(1) - self.assertFalse(frame0 == frame1, "Different frames should not be equal") - self.assertTrue(frame0 != frame1, "Different frames should be not-equal") - - def test_pc_property_settable(self): - """Test that pc property is settable""" - frame, _ = self._get_frame() - - original_pc = frame.GetPC() - # Test that we can set pc (though this might not work on all platforms). - # We'll just verify the property exists and can be read. - pc = frame.pc - self.assertIsInstance(pc, int, "pc should be readable") - # Note: Setting pc might not be supported on all platforms, so we just test reading. diff --git a/lldb/test/API/python_api/sbframe_extensions/main.c b/lldb/test/API/python_api/sbframe_extensions/main.c deleted file mode 100644 index 8e2d3ed8e5a5f..0000000000000 --- a/lldb/test/API/python_api/sbframe_extensions/main.c +++ /dev/null @@ -1,33 +0,0 @@ -#include <stdio.h> - -// Global and static variables for testing -int g_global_var = 42; -static int g_static_var = 100; - -// Function declarations -int func1(int arg1, char arg2); -int func2(int arg1, int arg2); - -int func1(int arg1, char arg2) { - static int static_var = 200; - int local1 = arg1 * 2; - char local2 = arg2; - // Set breakpoint here - return local1 + local2 + static_var; -} - -int func2(int arg1, int arg2) { - int local1 = arg1 + arg2; - int local2 = arg1 * arg2; - // Set breakpoint here - return func1(local1, 'X'); -} - -int main(int argc, char const *argv[]) { - int main_local = 10; - static int main_static = 50; - // Set breakpoint here - int result = func2(5, 7); - printf("Result: %d\n", result); - return 0; -} _______________________________________________ lldb-commits mailing list [email protected] https://lists.llvm.org/cgi-bin/mailman/listinfo/lldb-commits
