| """ |
| Test the SBTarget API's to retrieve persistent types |
| and values. |
| """ |
| |
| |
| import lldb |
| import lldbsuite.test.lldbutil as lldbutil |
| from lldbsuite.test.lldbtest import * |
| |
| |
| class TestPersistentDecls(TestBase): |
| NO_DEBUG_INFO_TESTCASE = True |
| |
| def test_persistent_types(self): |
| """Define some types in the expression evaluator and find them.""" |
| self.build() |
| self.main_source_file = lldb.SBFileSpec("main.c") |
| self.types_test() |
| |
| def test_persistent_values(self): |
| """Define some values in the expression evaluator and find them.""" |
| self.build() |
| self.main_source_file = lldb.SBFileSpec("main.c") |
| self.values_test() |
| |
| def types_test(self): |
| (target, _, _, _) = lldbutil.run_to_source_breakpoint( |
| self, "Set a breakpoint here", self.main_source_file |
| ) |
| |
| # Make some types so we aren't succeeding in gettting the only one. |
| |
| typename = "$firstStruct" |
| |
| self.expect(f"expr struct $SomeType {{ int b; int a; int c;}}") |
| self.expect(f"expr struct {typename} {{ int a; int b; char *c;}}") |
| self.expect(f"expr struct $AnotherType {{ int a; char *b; int c;}}") |
| self.expect(f"expr struct $YetAnotherType {{ char *a; int b; int c;}}") |
| |
| language = lldb.eLanguageTypeC_plus_plus |
| error = lldb.SBError() |
| type = target.FindExpressionTypeForLanguage(typename, language, error) |
| self.assertSuccess(error, "Got the right error") |
| self.assertTrue(type.IsValid(), "Got a valid type") |
| |
| # Make sure we got the type we expected: |
| self.assertEqual(type.name, typename, "Got the right type.") |
| # Now check that the fields are right: |
| self.assertEqual(type.num_fields, 3, "Right number of fields") |
| |
| ivar_a = type.fields[0] |
| self.assertEqual(ivar_a.name, "a", "a name is right") |
| self.assertEqual(ivar_a.type.name, "int", "Right type") |
| |
| ivar_b = type.fields[1] |
| self.assertEqual(ivar_b.name, "b", "b name is right") |
| self.assertEqual(ivar_b.type.name, "int", "Right type") |
| |
| ivar_c = type.fields[2] |
| self.assertEqual(ivar_c.name, "c", "c name is right") |
| self.assertEqual(ivar_c.type.name, "char *", "Right type") |
| |
| # Also test the error returns: |
| type = target.FindExpressionTypeForLanguage( |
| typename, lldb.eLanguageTypeUnknown, error |
| ) |
| self.assertFalse(error.Success(), "unknown doesn't support expression types") |
| self.assertFalse(type.IsValid(), "Type is also invalid.") |
| |
| type = target.FindExpressionTypeForLanguage("", language, error) |
| self.assertFalse(error.Success(), "empty type name for search.") |
| self.assertFalse(type.IsValid(), "Type is also invalid.") |
| type = target.FindExpressionTypeForLanguage( |
| "doesnt_start_with_dollar", language, error |
| ) |
| self.assertFalse(error.Success(), "Can't find names that don't exist.") |
| self.assertFalse(type.IsValid(), "Type is also invalid.") |
| |
| def values_test(self): |
| (target, _, _, _) = lldbutil.run_to_source_breakpoint( |
| self, "Set a breakpoint here", self.main_source_file |
| ) |
| |
| type_name = "struct $MyStruct" |
| value_name = "$my_struct" |
| self.expect("expr int $my_int = 100") |
| self.expect('expr char *$my_char_ptr = "Some char pointer."') |
| self.expect( |
| f"expr {type_name} {{int a; int b;}}; {type_name} {value_name} = {{10, 20}}" |
| ) |
| |
| # Now try to find one: |
| language = lldb.eLanguageTypeC_plus_plus |
| |
| value = target.FindExpressionVariableForLanguage(value_name, language) |
| |
| self.assertTrue(value.IsValid(), "Got a valid SBValue") |
| self.assertSuccess(value.GetError(), "Got no errors") |
| |
| value_checker = ValueCheck( |
| name=value_name, |
| type=type_name, |
| children=[ |
| ValueCheck(name="a", type="int", value="10"), |
| ValueCheck(name="b", type="int", value="20"), |
| ], |
| ) |
| value_checker.check_value(self, value, "Found the right value") |
| |
| # Also test that errors are set correctly: |
| value = target.FindExpressionVariableForLanguage( |
| value_name, lldb.eLanguageTypeUnknown |
| ) |
| self.assertFalse(value.error.Success(), "unknown can't compile expressions") |
| value = target.FindExpressionVariableForLanguage(None, language) |
| self.assertFalse(value.error.Success(), "reject empty expression variable name") |
| value = target.FindExpressionVariableForLanguage( |
| "doesnt_start_with_dollar", language |
| ) |
| self.assertFalse(value.error.Success(), "error on unknown variable name") |
