5b386158aa
This removes the dependency LLDB API tests have on lldb/third_party/Python/module/unittest2, and instead uses the standard one provided by Python. This does not actually remove the vendored dep yet, nor update the docs. I'll do both those once this sticks. Non-trivial changes to call out: - expected failures (i.e. "bugnumber") don't have a reason anymore, so those params were removed - `assertItemsEqual` is now called `assertCountEqual` - When a test is marked xfail, our copy of unittest2 considers failures during teardown to be OK, but modern unittest does not. See TestThreadLocal.py. (Very likely could be a real bug/leak). - Our copy of unittest2 was patched to print all test results, even ones that don't happen, e.g. `(5 passes, 0 failures, 1 errors, 0 skipped, ...)`, but standard unittest prints a terser message that omits test result types that didn't happen, e.g. `OK (skipped=1)`. Our lit integration parses this stderr and needs to be updated w/ that expectation. I tested this w/ `ninja check-lldb-api` on Linux. There's a good chance non-Linux tests have similar quirks, but I'm not able to uncover those.
340 lines
13 KiB
Python
340 lines
13 KiB
Python
"""
|
|
Test the printing of anonymous and named namespace variables.
|
|
"""
|
|
|
|
|
|
import unittest
|
|
import lldb
|
|
from lldbsuite.test.decorators import *
|
|
from lldbsuite.test.lldbtest import *
|
|
from lldbsuite.test import lldbutil
|
|
|
|
|
|
class NamespaceLookupTestCase(TestBase):
|
|
def setUp(self):
|
|
# Call super's setUp().
|
|
TestBase.setUp(self)
|
|
# Break inside different scopes and evaluate value
|
|
self.line_break_global_scope = line_number("ns.cpp", "// BP_global_scope")
|
|
self.line_break_file_scope = line_number("ns2.cpp", "// BP_file_scope")
|
|
self.line_break_ns_scope = line_number("ns2.cpp", "// BP_ns_scope")
|
|
self.line_break_nested_ns_scope = line_number(
|
|
"ns2.cpp", "// BP_nested_ns_scope"
|
|
)
|
|
self.line_break_nested_ns_scope_after_using = line_number(
|
|
"ns2.cpp", "// BP_nested_ns_scope_after_using"
|
|
)
|
|
self.line_break_before_using_directive = line_number(
|
|
"ns3.cpp", "// BP_before_using_directive"
|
|
)
|
|
self.line_break_after_using_directive = line_number(
|
|
"ns3.cpp", "// BP_after_using_directive"
|
|
)
|
|
|
|
def runToBkpt(self, command):
|
|
self.runCmd(command, RUN_SUCCEEDED)
|
|
# The stop reason of the thread should be breakpoint.
|
|
self.expect(
|
|
"thread list",
|
|
STOPPED_DUE_TO_BREAKPOINT,
|
|
substrs=["stopped", "stop reason = breakpoint"],
|
|
)
|
|
|
|
@skipIfWindows # This is flakey on Windows: llvm.org/pr38373
|
|
@unittest.expectedFailure # CU-local objects incorrectly scoped
|
|
def test_scope_lookup_with_run_command_globals(self):
|
|
"""Test scope lookup of functions in lldb."""
|
|
self.build()
|
|
|
|
lldbutil.run_to_source_breakpoint(
|
|
self, self.line_break_global_scope, lldb.SBFileSpec("ns.cpp")
|
|
)
|
|
|
|
lldbutil.run_break_set_by_file_and_line(
|
|
self,
|
|
"ns3.cpp",
|
|
self.line_break_before_using_directive,
|
|
num_expected_locations=1,
|
|
loc_exact=False,
|
|
)
|
|
|
|
lldbutil.run_break_set_by_file_and_line(
|
|
self,
|
|
"ns3.cpp",
|
|
self.line_break_after_using_directive,
|
|
num_expected_locations=1,
|
|
loc_exact=False,
|
|
)
|
|
|
|
# Run to BP_global_scope at file scope
|
|
self.runToBkpt("run")
|
|
|
|
# FIXME: LLDB does not correctly scope CU-local objects.
|
|
# LLDB currently lumps functions from all files into
|
|
# a single AST and depending on the order with which
|
|
# functions are considered, LLDB can incorrectly call
|
|
# the static local ns.cpp::func() instead of the expected
|
|
# ::func()
|
|
|
|
# Evaluate func() - should call ::func()
|
|
self.expect_expr("func()", expect_type="int", expect_value="1")
|
|
|
|
# Evaluate ::func() - should call A::func()
|
|
self.expect_expr("::func()", result_type="int", result_value="1")
|
|
|
|
# Continue to BP_before_using_directive at file scope
|
|
self.runToBkpt("continue")
|
|
|
|
# Evaluate func() - should call ::func()
|
|
self.expect_expr("func()", result_type="int", result_value="1")
|
|
|
|
# Evaluate ::func() - should call ::func()
|
|
self.expect_expr("::func()", result_type="int", result_value="1")
|
|
|
|
# Continue to BP_after_using_directive at file scope
|
|
self.runToBkpt("continue")
|
|
|
|
# Evaluate ::func() - should call ::func()
|
|
self.expect_expr("::func()", result_type="int", result_value="1")
|
|
|
|
@skipIfWindows # This is flakey on Windows: llvm.org/pr38373
|
|
def test_scope_lookup_with_run_command(self):
|
|
"""Test scope lookup of functions in lldb."""
|
|
self.build()
|
|
self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
|
|
|
|
lldbutil.run_break_set_by_file_and_line(
|
|
self,
|
|
"ns.cpp",
|
|
self.line_break_global_scope,
|
|
num_expected_locations=1,
|
|
loc_exact=False,
|
|
)
|
|
lldbutil.run_break_set_by_file_and_line(
|
|
self,
|
|
"ns2.cpp",
|
|
self.line_break_ns_scope,
|
|
num_expected_locations=1,
|
|
loc_exact=False,
|
|
)
|
|
lldbutil.run_break_set_by_file_and_line(
|
|
self,
|
|
"ns2.cpp",
|
|
self.line_break_nested_ns_scope,
|
|
num_expected_locations=1,
|
|
loc_exact=False,
|
|
)
|
|
lldbutil.run_break_set_by_file_and_line(
|
|
self,
|
|
"ns2.cpp",
|
|
self.line_break_nested_ns_scope_after_using,
|
|
num_expected_locations=1,
|
|
loc_exact=False,
|
|
)
|
|
lldbutil.run_break_set_by_file_and_line(
|
|
self,
|
|
"ns2.cpp",
|
|
self.line_break_file_scope,
|
|
num_expected_locations=1,
|
|
loc_exact=False,
|
|
)
|
|
lldbutil.run_break_set_by_file_and_line(
|
|
self,
|
|
"ns3.cpp",
|
|
self.line_break_before_using_directive,
|
|
num_expected_locations=1,
|
|
loc_exact=False,
|
|
)
|
|
lldbutil.run_break_set_by_file_and_line(
|
|
self,
|
|
"ns3.cpp",
|
|
self.line_break_after_using_directive,
|
|
num_expected_locations=1,
|
|
loc_exact=False,
|
|
)
|
|
|
|
# Run to BP_global_scope at global scope
|
|
self.runToBkpt("run")
|
|
|
|
# Evaluate A::B::func() - should call A::B::func()
|
|
self.expect_expr("A::B::func()", result_type="int", result_value="4")
|
|
# Evaluate func(10) - should call ::func(int)
|
|
self.expect_expr("func(10)", result_type="int", result_value="11")
|
|
# Evaluate A::foo() - should call A::foo()
|
|
self.expect_expr("A::foo()", result_type="int", result_value="42")
|
|
|
|
# Continue to BP_file_scope at file scope
|
|
self.runToBkpt("continue")
|
|
# FIXME: In DWARF 5 with dsyms, the ordering of functions is slightly
|
|
# different, which also hits the same issues mentioned previously.
|
|
if configuration.dwarf_version <= 4 or self.getDebugInfo() == "dwarf":
|
|
self.expect_expr("func()", result_type="int", result_value="2")
|
|
|
|
# Continue to BP_ns_scope at ns scope
|
|
self.runToBkpt("continue")
|
|
# Evaluate func(10) - should call A::func(int)
|
|
self.expect_expr("func(10)", result_type="int", result_value="13")
|
|
# Evaluate B::func() - should call B::func()
|
|
self.expect_expr("B::func()", result_type="int", result_value="4")
|
|
# Evaluate func() - should call A::func()
|
|
self.expect_expr("func()", result_type="int", result_value="3")
|
|
|
|
# Continue to BP_nested_ns_scope at nested ns scope
|
|
self.runToBkpt("continue")
|
|
# Evaluate func() - should call A::B::func()
|
|
self.expect_expr("func()", result_type="int", result_value="4")
|
|
# Evaluate A::func() - should call A::func()
|
|
self.expect_expr("A::func()", result_type="int", result_value="3")
|
|
|
|
# Evaluate func(10) - should call A::func(10)
|
|
# NOTE: Under the rules of C++, this test would normally get an error
|
|
# because A::B::func() hides A::func(), but lldb intentionally
|
|
# disobeys these rules so that the intended overload can be found
|
|
# by only removing duplicates if they have the same type.
|
|
self.expect_expr("func(10)", result_type="int", result_value="13")
|
|
|
|
# Continue to BP_nested_ns_scope_after_using at nested ns scope after
|
|
# using declaration
|
|
self.runToBkpt("continue")
|
|
# Evaluate A::func(10) - should call A::func(int)
|
|
self.expect_expr("A::func(10)", result_type="int", result_value="13")
|
|
|
|
# Continue to BP_before_using_directive at global scope before using
|
|
# declaration
|
|
self.runToBkpt("continue")
|
|
# Evaluate B::func() - should call B::func()
|
|
self.expect_expr("B::func()", result_type="int", result_value="4")
|
|
|
|
# Continue to BP_after_using_directive at global scope after using
|
|
# declaration
|
|
self.runToBkpt("continue")
|
|
# Evaluate B::func() - should call B::func()
|
|
self.expect_expr("B::func()", result_type="int", result_value="4")
|
|
|
|
@unittest.expectedFailure # lldb scope lookup of functions bugs
|
|
def test_function_scope_lookup_with_run_command(self):
|
|
"""Test scope lookup of functions in lldb."""
|
|
self.build()
|
|
self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
|
|
|
|
lldbutil.run_break_set_by_file_and_line(
|
|
self,
|
|
"ns.cpp",
|
|
self.line_break_global_scope,
|
|
num_expected_locations=1,
|
|
loc_exact=False,
|
|
)
|
|
lldbutil.run_break_set_by_file_and_line(
|
|
self,
|
|
"ns2.cpp",
|
|
self.line_break_ns_scope,
|
|
num_expected_locations=1,
|
|
loc_exact=False,
|
|
)
|
|
|
|
# Run to BP_global_scope at global scope
|
|
self.runToBkpt("run")
|
|
# Evaluate foo() - should call ::foo()
|
|
# FIXME: lldb finds Y::foo because lookup for variables is done
|
|
# before functions.
|
|
self.expect_expr("foo()", result_type="int", result_value="42")
|
|
# Evaluate ::foo() - should call ::foo()
|
|
# FIXME: lldb finds Y::foo because lookup for variables is done
|
|
# before functions and :: is ignored.
|
|
self.expect_expr("::foo()", result_type="int", result_value="42")
|
|
|
|
# Continue to BP_ns_scope at ns scope
|
|
self.runToBkpt("continue")
|
|
# Evaluate foo() - should call A::foo()
|
|
# FIXME: lldb finds Y::foo because lookup for variables is done
|
|
# before functions.
|
|
self.expect_expr("foo()", result_type="int", result_value="42")
|
|
|
|
# NOTE: this test may fail on older systems that don't emit import
|
|
# entries in DWARF - may need to add checks for compiler versions here.
|
|
@skipIf(compiler="gcc", oslist=["linux"], debug_info=["dwo"]) # Skip to avoid crash
|
|
def test_scope_after_using_directive_lookup_with_run_command(self):
|
|
"""Test scope lookup after using directive in lldb."""
|
|
self.build()
|
|
self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
|
|
|
|
lldbutil.run_break_set_by_file_and_line(
|
|
self,
|
|
"ns3.cpp",
|
|
self.line_break_after_using_directive,
|
|
num_expected_locations=1,
|
|
loc_exact=False,
|
|
)
|
|
|
|
# Run to BP_after_using_directive at global scope after using
|
|
# declaration
|
|
self.runToBkpt("run")
|
|
# Evaluate func2() - should call A::func2()
|
|
self.expect_expr("func2()", result_type="int", result_value="3")
|
|
|
|
@unittest.expectedFailure # lldb scope lookup after using declaration bugs
|
|
# NOTE: this test may fail on older systems that don't emit import
|
|
# emtries in DWARF - may need to add checks for compiler versions here.
|
|
def test_scope_after_using_declaration_lookup_with_run_command(self):
|
|
"""Test scope lookup after using declaration in lldb."""
|
|
self.build()
|
|
self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
|
|
|
|
lldbutil.run_break_set_by_file_and_line(
|
|
self,
|
|
"ns2.cpp",
|
|
self.line_break_nested_ns_scope_after_using,
|
|
num_expected_locations=1,
|
|
loc_exact=False,
|
|
)
|
|
|
|
# Run to BP_nested_ns_scope_after_using at nested ns scope after using
|
|
# declaration
|
|
self.runToBkpt("run")
|
|
# Evaluate func() - should call A::func()
|
|
self.expect_expr("func()", result_type="int", result_value="3")
|
|
|
|
@unittest.expectedFailure # lldb scope lookup ambiguity after using bugs
|
|
def test_scope_ambiguity_after_using_lookup_with_run_command(self):
|
|
"""Test scope lookup ambiguity after using in lldb."""
|
|
self.build()
|
|
self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
|
|
|
|
lldbutil.run_break_set_by_file_and_line(
|
|
self,
|
|
"ns3.cpp",
|
|
self.line_break_after_using_directive,
|
|
num_expected_locations=1,
|
|
loc_exact=False,
|
|
)
|
|
|
|
# Run to BP_after_using_directive at global scope after using
|
|
# declaration
|
|
self.runToBkpt("run")
|
|
# Evaluate func() - should get error: ambiguous
|
|
# FIXME: This test fails because lldb removes duplicates if they have
|
|
# the same type.
|
|
self.expect("expr -- func()", startstr="error")
|
|
|
|
def test_scope_lookup_shadowed_by_using_with_run_command(self):
|
|
"""Test scope lookup shadowed by using in lldb."""
|
|
self.build()
|
|
self.runCmd("file " + self.getBuildArtifact("a.out"), CURRENT_EXECUTABLE_SET)
|
|
|
|
lldbutil.run_break_set_by_file_and_line(
|
|
self,
|
|
"ns2.cpp",
|
|
self.line_break_nested_ns_scope,
|
|
num_expected_locations=1,
|
|
loc_exact=False,
|
|
)
|
|
|
|
# Run to BP_nested_ns_scope at nested ns scope
|
|
self.runToBkpt("run")
|
|
# Evaluate func(10) - should call A::func(10)
|
|
# NOTE: Under the rules of C++, this test would normally get an error
|
|
# because A::B::func() shadows A::func(), but lldb intentionally
|
|
# disobeys these rules so that the intended overload can be found
|
|
# by only removing duplicates if they have the same type.
|
|
self.expect_expr("func(10)", result_type="int", result_value="13")
|