| """ |
| Test that we can lookup types correctly in the expression parser |
| """ |
| |
| from __future__ import print_function |
| |
| |
| import lldb |
| import lldbsuite.test.lldbutil as lldbutil |
| from lldbsuite.test.lldbtest import * |
| from lldbsuite.test import decorators |
| |
| class TestCppTypeLookup(TestBase): |
| |
| mydir = TestBase.compute_mydir(__file__) |
| |
| def check_value(self, value, ivar_name, ivar_value): |
| self.assertTrue(value.GetError().Success(), |
| "Invalid valobj: %s" % ( |
| value.GetError().GetCString())) |
| ivar = value.GetChildMemberWithName(ivar_name) |
| self.assertTrue(ivar.GetError().Success(), |
| "Failed to fetch ivar named '%s'" % (ivar_name)) |
| self.assertEqual(ivar_value, |
| ivar.GetValueAsSigned(), |
| "Got the right value for ivar") |
| |
| def test_namespace_only(self): |
| """ |
| Test that we fail to lookup a struct type that exists only in a |
| namespace. |
| """ |
| self.build() |
| self.main_source_file = lldb.SBFileSpec("main.cpp") |
| (target, process, thread, bkpt) = lldbutil.run_to_source_breakpoint( |
| self, "Set a breakpoint here", self.main_source_file) |
| |
| # Get frame for current thread |
| frame = thread.GetSelectedFrame() |
| |
| # We are testing LLDB's type lookup machinery, but if we inject local |
| # variables, the types for those will be found because they have been |
| # imported through the variable, not because the type lookup worked. |
| self.runCmd("settings set target.experimental.inject-local-vars false") |
| |
| # Make sure we don't accidentally accept structures that exist only |
| # in namespaces when evaluating expressions with top level types. |
| # Prior to the revision that added this test, we would accidentally |
| # accept types from namespaces, so this will ensure we don't regress |
| # to that behavior again |
| expr_result = frame.EvaluateExpression("*((namespace_only *)&i)") |
| self.assertTrue(expr_result.GetError().Fail(), |
| "'namespace_only' exists in namespace only") |
| |
| # Make sure we can find the correct type in a namespace "a" |
| expr_result = frame.EvaluateExpression("*((a::namespace_only *)&i)") |
| self.check_value(expr_result, "a", 123) |
| # Make sure we can find the correct type in a namespace "b" |
| expr_result = frame.EvaluateExpression("*((b::namespace_only *)&i)") |
| self.check_value(expr_result, "b", 123) |
| |
| # Make sure we can find the correct type in the root namespace |
| expr_result = frame.EvaluateExpression("*((namespace_and_file *)&i)") |
| self.check_value(expr_result, "ff", 123) |
| # Make sure we can find the correct type in a namespace "a" |
| expr_result = frame.EvaluateExpression( |
| "*((a::namespace_and_file *)&i)") |
| self.check_value(expr_result, "aa", 123) |
| # Make sure we can find the correct type in a namespace "b" |
| expr_result = frame.EvaluateExpression( |
| "*((b::namespace_and_file *)&i)") |
| self.check_value(expr_result, "bb", 123) |
| |
| # Make sure we don't accidentally accept structures that exist only |
| # in namespaces when evaluating expressions with top level types. |
| # Prior to the revision that added this test, we would accidentally |
| # accept types from namespaces, so this will ensure we don't regress |
| # to that behavior again |
| expr_result = frame.EvaluateExpression("*((in_contains_type *)&i)") |
| self.assertTrue(expr_result.GetError().Fail(), |
| "'in_contains_type' exists in struct only") |
| |
| # Make sure we can find the correct type in the root namespace |
| expr_result = frame.EvaluateExpression( |
| "*((contains_type::in_contains_type *)&i)") |
| self.check_value(expr_result, "fff", 123) |
| # Make sure we can find the correct type in a namespace "a" |
| expr_result = frame.EvaluateExpression( |
| "*((a::contains_type::in_contains_type *)&i)") |
| self.check_value(expr_result, "aaa", 123) |
| # Make sure we can find the correct type in a namespace "b" |
| expr_result = frame.EvaluateExpression( |
| "*((b::contains_type::in_contains_type *)&i)") |
| self.check_value(expr_result, "bbb", 123) |
