1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
|
"""
Test Debugger APIs.
"""
import lldb
from lldbsuite.test.decorators import *
from lldbsuite.test.lldbtest import *
from lldbsuite.test import lldbutil
class DebuggerAPITestCase(TestBase):
NO_DEBUG_INFO_TESTCASE = True
def test_debugger_api_boundary_condition(self):
"""Exercise SBDebugger APIs with boundary conditions."""
self.dbg.HandleCommand(None)
self.dbg.SetDefaultArchitecture(None)
self.dbg.GetScriptingLanguage(None)
self.dbg.CreateTarget(None)
self.dbg.CreateTarget(None, None, None, True, lldb.SBError())
self.dbg.CreateTargetWithFileAndTargetTriple(None, None)
self.dbg.CreateTargetWithFileAndArch(None, None)
self.dbg.FindTargetWithFileAndArch(None, None)
self.dbg.SetInternalVariable(None, None, None)
self.dbg.GetInternalVariableValue(None, None)
# FIXME (filcab): We must first allow for the swig bindings to know if
# a Python callback is set. (Check python-typemaps.swig)
# self.dbg.SetLoggingCallback(None)
self.dbg.SetPrompt(None)
self.dbg.SetCurrentPlatform(None)
self.dbg.SetCurrentPlatformSDKRoot(None)
fresh_dbg = lldb.SBDebugger()
self.assertEqual(len(fresh_dbg), 0)
def test_debugger_delete_invalid_target(self):
"""SBDebugger.DeleteTarget() should not crash LLDB given and invalid target."""
target = lldb.SBTarget()
self.assertFalse(target.IsValid())
self.dbg.DeleteTarget(target)
def test_debugger_internal_variables(self):
"""Ensure that SBDebugger reachs the same instance of properties
regardless CommandInterpreter's context initialization"""
self.build()
exe = self.getBuildArtifact("a.out")
# Create a target by the debugger.
target = self.dbg.CreateTarget(exe)
self.assertTrue(target, VALID_TARGET)
property_name = "target.process.memory-cache-line-size"
def get_cache_line_size():
value_list = lldb.SBStringList()
value_list = self.dbg.GetInternalVariableValue(
property_name, self.dbg.GetInstanceName()
)
self.assertEqual(value_list.GetSize(), 1)
try:
return int(value_list.GetStringAtIndex(0))
except ValueError as error:
self.fail("Value is not a number: " + error)
# Get global property value while there are no processes.
global_cache_line_size = get_cache_line_size()
# Run a process via SB interface. CommandInterpreter's execution context
# remains empty.
error = lldb.SBError()
launch_info = lldb.SBLaunchInfo(None)
launch_info.SetLaunchFlags(lldb.eLaunchFlagStopAtEntry)
process = target.Launch(launch_info, error)
self.assertTrue(process, PROCESS_IS_VALID)
# This should change the value of a process's local property.
new_cache_line_size = global_cache_line_size + 512
error = self.dbg.SetInternalVariable(
property_name, str(new_cache_line_size), self.dbg.GetInstanceName()
)
self.assertSuccess(error, property_name + " value was changed successfully")
# Check that it was set actually.
self.assertEqual(get_cache_line_size(), new_cache_line_size)
# Run any command to initialize CommandInterpreter's execution context.
self.runCmd("target list")
# Test the local property again, is it set to new_cache_line_size?
self.assertEqual(get_cache_line_size(), new_cache_line_size)
def test_CreateTarget_platform(self):
exe = self.getBuildArtifact("a.out")
self.yaml2obj("elf.yaml", exe)
error = lldb.SBError()
target1 = self.dbg.CreateTarget(exe, None, "remote-linux", False, error)
self.assertSuccess(error)
platform1 = target1.GetPlatform()
platform1.SetWorkingDirectory("/foo/bar")
# Reuse a platform if it matches the currently selected one...
target2 = self.dbg.CreateTarget(exe, None, "remote-linux", False, error)
self.assertSuccess(error)
platform2 = target2.GetPlatform()
self.assertTrue(
platform2.GetWorkingDirectory().endswith("bar"),
platform2.GetWorkingDirectory(),
)
# ... but create a new one if it doesn't.
self.dbg.SetSelectedPlatform(lldb.SBPlatform("remote-windows"))
target3 = self.dbg.CreateTarget(exe, None, "remote-linux", False, error)
self.assertSuccess(error)
platform3 = target3.GetPlatform()
self.assertIsNone(platform3.GetWorkingDirectory())
def test_CreateTarget_arch(self):
exe = self.getBuildArtifact("a.out")
if lldbplatformutil.getHostPlatform() == "linux":
self.yaml2obj("macho.yaml", exe)
arch = "x86_64-apple-macosx"
expected_platform = "remote-macosx"
else:
self.yaml2obj("elf.yaml", exe)
arch = "x86_64-pc-linux"
expected_platform = "remote-linux"
fbsd = lldb.SBPlatform("remote-freebsd")
self.dbg.SetSelectedPlatform(fbsd)
error = lldb.SBError()
target1 = self.dbg.CreateTarget(exe, arch, None, False, error)
self.assertSuccess(error)
platform1 = target1.GetPlatform()
self.assertEqual(platform1.GetName(), expected_platform)
platform1.SetWorkingDirectory("/foo/bar")
# Reuse a platform even if it is not currently selected.
self.dbg.SetSelectedPlatform(fbsd)
target2 = self.dbg.CreateTarget(exe, arch, None, False, error)
self.assertSuccess(error)
platform2 = target2.GetPlatform()
self.assertEqual(platform2.GetName(), expected_platform)
self.assertTrue(
platform2.GetWorkingDirectory().endswith("bar"),
platform2.GetWorkingDirectory(),
)
def test_SetDestroyCallback(self):
destroy_dbg_id = None
def foo(dbg_id):
# Need nonlocal to modify closure variable.
nonlocal destroy_dbg_id
destroy_dbg_id = dbg_id
self.dbg.SetDestroyCallback(foo)
original_dbg_id = self.dbg.GetID()
self.dbg.Destroy(self.dbg)
self.assertEqual(destroy_dbg_id, original_dbg_id)
|
