Verify the default cache line size for android targets
"""
+import lldb_shared
+
import os
-import unittest2
import lldb
from lldbtest import *
import lldbutil
# Run to completion.
process.Continue()
self.assertEqual(process.GetState(), lldb.eStateExited, PROCESS_EXITED)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
import lldb_shared
import os, re
-import unittest2
from lldbtest import *
import lldbutil
'stop reason = breakpoint'])
self.runCmd('frame variable')
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
import lldb_shared
import os, re
-import unittest2
from lldbtest import *
import lldbutil
import lldb
else:
with open(os.devnull, 'w') as fnull:
check_call([self.driver_exe, self.inferior_exe], env=env, stdout=fnull, stderr=fnull)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
import lldb_shared
import os, re
-import unittest2
from lldbtest import *
import lldbutil
import subprocess
def build_program(self, sources, program):
return self.buildDriver(sources, program)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test some ARM instruction emulation.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
print output
self.assertTrue (success, 'Emulation test succeeded.')
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
-
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbbench import *
import lldbutil
lldbutil_sw.stop()
print "runCmd: %s\nlldbutil: %s" % (runCmd_sw,lldbutil_sw)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Disassemble lldb's Driver::MainLoop() functions comparing lldb against gdb."""
+import lldb_shared
+
import os, sys
-import unittest2
import lldb
from lldbbench import *
if self.TraceOn():
print "gdb disassembly benchmark:", str(self.stopwatch)
self.child = None
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
inferior and traverses the stack for thread0 to arrive at frame with function
'MainLoop'. It is important to specify an lldb executable as the inferior."""
+import lldb_shared
+
import os, sys
-import unittest2
import lldb
from lldbbench import *
with self.stopwatch:
# Disassemble the function.
self.runCmd("disassemble -f")
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Disassemble lldb's Driver::MainLoop() functions comparing Xcode 4.1 vs. 4.2's gdb."""
+import lldb_shared
+
import os, sys
-import unittest2
import lldb
from lldbbench import *
if self.TraceOn():
print "gdb disassembly benchmark:", str(self.stopwatch)
self.child = None
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test lldb's expression evaluations and collect statistics."""
+import lldb_shared
+
import os, sys
-import unittest2
import lldb
from lldbbench import *
pass
self.child = None
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test evaluating expressions repeatedly comparing lldb against gdb."""
+import lldb_shared
+
import os, sys
-import unittest2
import lldb
from lldbbench import *
if self.TraceOn():
print "gdb expression benchmark:", str(self.stopwatch)
self.child = None
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test lldb's response time for 'frame variable' command."""
+import lldb_shared
+
import os, sys
-import unittest2
import lldb
from lldbbench import *
# The test is about to end and if we come to here, the child process has
# been terminated. Mark it so.
self.child = None
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test lldb's startup delays creating a target, setting a breakpoint, and run to breakpoint stop."""
+import lldb_shared
+
import os, sys
-import unittest2
import lldb
from lldbbench import *
# The test is about to end and if we come to here, the child process has
# been terminated. Mark it so.
self.child = None
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test lldb's stepping speed."""
+import lldb_shared
+
import os, sys
-import unittest2
import lldb
from lldbbench import *
pass
self.child = None
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test lldb's stepping speed."""
+import lldb_shared
+
import os, sys
-import unittest2
import lldb
from lldbbench import *
pass
self.child = None
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Benchmark the turnaround time starting a debugger and run to the breakpont with lldb vs. gdb."""
+import lldb_shared
+
import os, sys
-import unittest2
import lldb
from lldbbench import *
self.gdb_avg = self.stopwatch.avg()
self.child = None
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test that the lldb driver's batch mode works correctly.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
-try:
- import pexpect
-except:
- pexpect = None
from lldbtest import *
class DriverBatchModeTest (TestBase):
self.source = 'main.c'
def expect_string (self, string):
+ import pexpect
"""This expects for "string", with timeout & EOF being test fails."""
try:
self.child.expect_exact(string)
self.fail ("Timed out waiting for '%s'"%(string))
def batch_mode (self):
+ import pexpect
exe = os.path.join(os.getcwd(), "a.out")
prompt = "(lldb) "
Test calling std::String member functions.
"""
-import unittest2
+import lldb_shared
+
import lldb
import lldbutil
from lldbtest import *
# const char *, and thus don't invoke the Summary formatter.
self.expect("print str.c_str()",
substrs = ['Hello world'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test calling a function, stopping in the call, continue and gather the result on stop.
"""
-import unittest2
+import lldb_shared
+
import lldb
import lldbutil
from lldbtest import *
self.expect ("thread list",
substrs = ['stop reason = User Expression thread plan',
r'Completed expression: (Five) $0 = (number = 5, name = "five")'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""
-import unittest2
+import lldb_shared
+
import lldb
import lldbutil
from lldbtest import *
# Test function with pointer paramter
self.expect("exp stringCompare((const char*) \"Hello world\")", substrs = ['$4 = true'])
self.expect("exp stringCompare((const char*) \"Hellworld\")", substrs = ['$5 = false'])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test calling a function that hits a signal set to auto-restart, make sure the call completes.
"""
-import unittest2
+import lldb_shared
+
import lldb
import lldbutil
from lldbtest import *
frame = self.thread.GetFrameAtIndex(0)
self.assertTrue (frame.GetPC() == self.orig_frame_pc, "Continuing returned to the place we started.")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test calling a function that throws an ObjC exception, make sure that it doesn't propagate the exception.
"""
-import unittest2
+import lldb_shared
+
import lldb
import lldbutil
from lldbtest import *
self.assertTrue (value.IsValid() and value.GetError().Success() == False)
self.check_after_call()
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
-import unittest2
+import lldb_shared
+
import lldb
import lldbutil
from lldbtest import *
@expectedFailureWindows("llvm.org/pr21765")
def test_unsigned_char(self):
self.do_test(dictionary={'CFLAGS_EXTRAS': '-funsigned-char'})
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test that we are able to evaluate expressions when the inferior is blocked in a syscall"""
+import lldb_shared
+
import os
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.assertEqual(process.GetState(), lldb.eStateExited)
self.assertEqual(process.GetExitStatus(), 0)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test using LLDB data formatters with frozen objects coming from the expression parser.
"""
-import unittest2
+import lldb_shared
+
import lldb
import lldbutil
from lldbtest import *
self.assertTrue(a_data.GetUnsignedInt32(error, 8) == 3, 'numbers[2] == 3')
self.assertTrue(a_data.GetUnsignedInt32(error, 12) == 4, 'numbers[3] == 4')
self.assertTrue(a_data.GetUnsignedInt32(error, 16) == 5, 'numbers[4] == 5')
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
expected in a SyntheticChildrenProvider
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
import lldbutil
from lldbtest import *
"load_address = ",
hex(addr)[2:].rstrip("L"),
str(addr)])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test expression command options.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
import lldbutil
from lldbtest import *
val = frame.EvaluateExpression('foo != nullptr', options)
self.assertTrue(val.IsValid())
self.assertFalse(val.GetError().Success())
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test that we can p *objcObject
"""
-import unittest2
+import lldb_shared
+
import lldb
import lldbutil
from lldbtest import *
'_sc_name6 = nil',
'_sc_name7 = nil',
'_sc_name8 = nil'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test that we can have persistent pointer variables
"""
-import unittest2
+import lldb_shared
+
import lldb
import lldbutil
from lldbtest import *
self.runCmd("continue")
self.expect("expr $foo", substrs=['$foo','0x0'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test that nested persistent types work.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
self.expect("expression $my_bar.end.b",
substrs = ['(int)', '5'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test that lldb persistent types works correctly.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
self.expect("expression struct A { int x; int y; }; struct { struct A a; int z; } object; object.a.y = 1; object.z = 3; object.a.x = 2; object",
substrs = ['x = 2', 'y = 1', 'z = 3'])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test that lldb persistent variables works correctly.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
self.expect("expression (long)$4",
startstr = "(long) $6 = -2")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test that the po command acts correctly.
"""
-import unittest2
+import lldb_shared
+
import lldb
import lldbutil
from lldbtest import *
self.expect("expr -O -v -- 22",
substrs = ['(int) $', ' = 22'])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test the robustness of lldb expression parser.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
self.expect("expression &val",
startstr = "(int *) $2 = ")
# (int *) $2 = 0x....
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
The evaluating printf(...) after break stop and then up a stack frame.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
# This does not currently.
self.runCmd('expression (int)printf("argc is: %d.\\n", argc)')
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test example snippets from the lldb 'help expression' output.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
substrs = ["'f'"])
# runCmd: expr char c[] = "foo"; c[0]
# output: (char) $0 = 'f'
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Throw some expression commands with quotes at lldb.
"""
-import os, time
+import lldb_shared
+
import unittest2
+
+import os, time
import lldb
import lldbutil
from lldbtest import *
self.expect('print_hi',
substrs = ['(int) $',
'6'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test some more expression commands.
"""
+import lldb_shared
+
import os
-import unittest2
import lldb
import lldbutil
from lldbtest import *
self.expect("expression $4 + 1",
startstr = "(int) $5 = 24")
# (int) $5 = 6
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test calling a function that waits a while, and make sure the timeout option to expr works.
"""
-import unittest2
+import lldb_shared
+
import lldb
import lldbutil
from lldbtest import *
value = frame.EvaluateExpression ("wait_a_while (1000)", options)
self.assertTrue(value.IsValid())
self.assertTrue (value.GetError().Success() == True)
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
The expression parser's type search only looks in the current compilation unit for types.
"""
-import unittest2
+import lldb_shared
+
import lldb
from lldbtest import *
import lldbutil
self.expect("expression (NSArray*)array_token",
substrs = ['(NSArray *) $0 = 0x'])
# (NSArray *) $0 = 0x00007fff70118398
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test some lldb command abbreviations and aliases for proper resolution.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
#self.runCmd("se cl prompt")
#self.expect("set sh prompt",
# startstr = 'prompt (string) = "(lldb) "')
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
-
many commands remain available even after we add/delete commands in the future.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
command_interpreter.ResolveCommand(short, result)
self.assertTrue(result.Succeeded())
self.assertEqual(long, result.GetOutput())
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
-
"""Test breaking inside functions defined within a BSD archive file libfoo.a."""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
substrs = ['(int) arg = 2'])
self.expect("frame variable __b_global", VARIABLES_DISPLAYED_CORRECTLY,
substrs = ['(int) __b_global = 2'])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test that ASan memory history provider returns correct stack traces
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.expect("memory history 'another_pointer'",
substrs = [
'Memory allocated at', 'a.out`f1', 'main.c:%d' % self.line_malloc2])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test the AddressSanitizer runtime support for report breakpoint and data extraction.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
s = s.GetData()
data2 = json.loads(s)
self.assertEqual(data, data2)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test process attach/resume.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
# make sure to detach while in running state (r204759)
self.runCmd("detach")
lldbutil.expect_state_changes(self, listener, [lldb.eStateDetached])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test whether a process started by lldb has no extra file descriptors open.
"""
+import lldb_shared
+
import os
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.assertTrue(process2.GetState() == lldb.eStateExited, "Process should have exited.")
self.assertTrue(process2.GetExitStatus() == 0,
"Process returned non-zero status. Were incorrect file descriptors passed?")
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test that backticks without a target should work (not infinite looping).
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
"""A simple test of backticks without a target."""
self.expect("print `1+2-3`",
substrs = [' = 0'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb breakpoint command add/list/delete.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
# Now remove 'output-2.txt'
os.remove ('output-2.txt')
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test that you can set breakpoint commands successfully with the Python API's:
"""
+import lldb_shared
+
import os
import re
-import unittest2
import lldb, lldbutil
import sys
from lldbtest import *
self.assertTrue(os.path.isfile("output2.txt"),
"'output2.txt' exists due to breakpoint command for breakpoint function.")
self.RemoveTempFile("output2.txt")
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test _regexp-break command which uses regular expression matching to dispatch to other built in breakpoint commands.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped',
'stop reason = breakpoint'])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test breakpoint conditions with 'breakpoint modify -c <expr> id'.
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb, lldbutil
from lldbtest import *
self.assertTrue(breakpoint.GetHitCount() == 1)
process.Continue()
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb breakpoint ids.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.expect ("breakpoint enable 2.*",
patterns = [ ".* breakpoints enabled."] )
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
-
Test breakpoint ignore count features.
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb, lldbutil
from lldbtest import *
self.assertTrue(breakpoint.GetHitCount() == 3)
process.Continue()
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test breakpoint commands for a breakpoint ID with multiple locations.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
patterns = ["1\.1: .+ unresolved, hit count = 0 +Options: disabled",
"1\.2: .+ resolved, hit count = 1",
"1\.3: .+ resolved, hit count = 1"])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test breakpoint command for different options.
"""
+import lldb_shared
+
import os
-import unittest2
import lldb
from lldbtest import *
import lldbutil
# We should exit.
self.expect("process status", "Process exited successfully",
patterns = ["^Process [0-9]+ exited with status = 0"])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""
Test breakpoint command with AT_comp_dir set to symbolic link.
"""
+import lldb_shared
+
import os
-import unittest2
import lldb
from lldbtest import *
import lldbutil
exe = os.path.join(os.getcwd(), _EXE_NAME)
self.runCmd('file ' + exe, CURRENT_EXECUTABLE_SET)
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test continue from a breakpoint when there is a breakpoint on the next instruction also.
"""
+import lldb_shared
+
import unittest2
import lldb, lldbutil
from lldbtest import *
# Run the process until termination
process.Continue()
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
-
Test lldb breakpoint ids.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
for bp_dict in bp_dicts:
self.verify_breakpoint_locations(target, bp_dict)
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
-
Test that you can set breakpoint and hit the C++ language exception breakpoint
"""
+import lldb_shared
+
import os
import re
-import unittest2
import lldb, lldbutil
import sys
from lldbtest import *
thread_list = lldbutil.get_threads_stopped_at_breakpoint (process, exception_bkpt)
self.assertTrue (len(thread_list) == 1, "One thread stopped at the exception breakpoint.")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test breakpoint commands set before we have a target
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
# Stopped again.
self.expect("thread backtrace", STOPPED_DUE_TO_BREAKPOINT,
substrs = ["stop reason = breakpoint 2."])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
another source file) works correctly.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
substrs = ['stopped',
'stop reason = breakpoint',
'basic_type.cpp:%d' % self.line])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
parser.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
# Check breakpoints again, this time using the symbol table only
self.check_category_breakpoints()
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test the command history mechanism
"""
+import lldb_shared
+
import os
-import unittest2
import lldb
from lldbtest import *
self.expect ("command history -c 1 -e 3 -s 5",error=True, inHistory=True,
substrs = ['error: --count, --start-index and --end-index cannot be all specified in the same invocation'])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb 'commands regex' command which allows the user to create a regular expression command.
"""
+import lldb_shared
+
import os
-import unittest2
import lldb
from lldbtest import *
child.sendline('Help__')
child.expect_exact("error: 'Help__' is not a valid command")
child.expect_exact(prompt)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb Python commands.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
self.runCmd('command script add -f bug11569 bug11569')
# This should not crash.
self.runCmd('bug11569', check=False)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
-
"""Test custom import command to import files by path."""
+import lldb_shared
+
import os, sys, time
-import unittest2
import lldb
from lldbtest import *
substrs = ['barutil says', 'bar told me', 'hello'])
self.expect("foobarcmd hello",
substrs = ['foobar says', 'hello'])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Check that we handle an ImportError in a special way when command script importing files."""
+import lldb_shared
+
import os, sys, time
-import unittest2
import lldb
from lldbtest import *
error=True, substrs = ['raise ImportError("I do not want to be imported")'])
self.expect("command script import ./fail212586188.py --allow-reload",
error=True, substrs = ['raise ValueError("I do not want to be imported")'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
See also http://llvm.org/viewvc/llvm-project?view=rev&revision=109673.
"""
+import lldb_shared
+
import os, sys
-import unittest2
import lldb
from lldbtest import *
self.expect(result.GetOutput(), "script my.date() runs successfully",
exe=False,
substrs = [str(datetime.date.today())])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test the lldb command line completion mechanism.
"""
+import lldb_shared
+
import os
-import unittest2
import lldb
from lldbtest import *
else:
self.expect(from_child, msg=COMPLETION_MSG(str_input, p), exe=False,
patterns = [p])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test conditionally break on a function and inspect its variables.
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb, lldbutil
from lldbtest import *
self.runCmd("frame select 1")
self.expect("frame info", "The immediate caller should be a()",
substrs = ["a.out`a"])
-
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import datetime
substrs = ['YES'])
self.expect('frame variable no',
substrs = ['NO'])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
'(vSInt16) valueS16 = (1, 0, 4, 0, 0, 1, 0, 4)',
'(vSInt32) valueS32 = (4, 3, 2, 1)',
'(vBool32) valueBool32 = (0, 1, 0, 1)'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
'o_2'])
self.expect('frame variable a_long_guy --show-all-children', matching=False,
substrs = ['...'])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.expect('frame variable r2',
substrs = ['w = 9',
'h = 16'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.expect("frame variable iAmInt --format hex", substrs = ['(int) iAmInt = 0x00000001'])
self.expect("frame variable iAmInt", matching=False, substrs = ['(int) iAmInt = 0x00000001'])
self.expect("frame variable iAmInt", substrs = ['(int) iAmInt = 1'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
# last check - our cleanup will re-enable everything
self.runCmd('type category disable *')
self.expect('type category list', substrs = ['system','disabled'])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
'(int) y = Case45',
'(int) z = 43'
]);
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.expect("target variable g_point_pointer",
substrs = ['(Point *) g_point_pointer ='])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.expect("frame variable first",matching=False,
substrs = ['FirstAndFriends: x=12',
'y=34'])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import datetime
self.runCmd("continue")
self.expect("frame variable _cmd",substrs = ['setAtoms:'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import datetime
self.expect('po strwithNULs2', substrs=['a very much boring task to write'])
self.expect('expr [strwithNULs2 length]', substrs=['52'])
self.expect('frame variable strwithNULs2', substrs=['@"a very much boring task to write\\0a string this way!!'])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import datetime
substrs = ['1 byte'])
self.expect('frame variable immutableData', matching=False,
substrs = ['1 bytes'])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
substrs = ['01 00 00 00 02 00 00 00 03 00 00 00'])
self.expect('p *(int (*)[3])foo', matching=False,
substrs = ['0x000000030000000200000001'])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.assertTrue(str_cast.find('T') != -1, 'could not find T in output')
self.assertTrue(str_cast.find('F') != -1, 'could not find F in output')
self.assertTrue(str_cast.find("4 = '\\0'") != -1, 'could not find item 4 == 0')
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.expect("frame variable array",
substrs = ['Python summary'])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
substrs = ['(DeepData_5) data2.m_child4.m_child2.m_child2 = {',
'm_some_text = "Just a test"',
'}'])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
substrs = ['intarr = arr = ',
'09 00 00 00',
'....,07 00 00 00'])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.expect("frame variable ils", substrs = ['[4] = "surprise it is a long string!! yay!!"'])
self.expect('image list', substrs = self.getLibcPlusPlusLibs())
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.expect('frame variable svI', substrs = ['item = "hello"'])
self.expect('expr svI', substrs = ['item = "hello"'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time, re
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.assertTrue(countingList.GetChildAtIndex(0).GetValueAsUnsigned(0) == 3141, "uniqued list[0] == 3141")
self.assertTrue(countingList.GetChildAtIndex(1).GetValueAsUnsigned(0) == 3142, "uniqued list[1] == 3142")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
corruption).
"""
+import lldb_shared
+
import os, time, re
-import unittest2
import lldb
from lldbtest import *
import lldbutil
# Run to completion.
process.Continue()
self.assertEqual(process.GetState(), lldb.eStateExited, PROCESS_EXITED)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.expect('frame variable ss',
substrs = ['size=0',
'{}'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.expect('frame variable ss',
substrs = ['size=0',
'{}'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.expect("frame variable ss[2]",substrs = [' = "b"'])
lldbutil.continue_to_breakpoint(self.process(), bkpt)
self.expect("frame variable ss",substrs = ["size=3",'[0] = "a"','[1] = "a very long string is right here"','[2] = "c"'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.expect("frame variable ss[2]",substrs = [' = "b"'])
lldbutil.continue_to_breakpoint(self.process(), bkpt)
self.expect("frame variable ss",substrs = ["size=3",'[0] = "a"','[1] = "a very long string is right here"','[2] = "c"'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
'(std::__1::string) Q = "quite a long std::strin with lots of info inside it"',
'(std::__1::string) IHaveEmbeddedZeros = "a\\0b\\0c\\0d"',
'(std::__1::wstring) IHaveEmbeddedZerosToo = L"hello world!\\0てざ ル゜䋨ミ㠧槊 きゅへ狦穤襩 じゃ馩リョ 䤦監"'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
def look_for_content_and_continue(self, var_name, patterns):
self.expect( ("frame variable %s" % var_name), patterns=patterns)
self.runCmd("continue")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.expect("expr vBool",
substrs = ['size=49','[0] = false','[1] = true','[18] = false','[27] = true','[36] = false','[47] = true','[48] = true'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.expect("frame variable strings",
substrs = ['vector has 0 items'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.expect('frame variable svI', substrs = ['item = "hello"'])
self.expect('expr svI', substrs = ['item = "hello"'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
# check that MightHaveChildren() gets it right
self.assertTrue(self.frame().FindVariable("text_list").MightHaveChildren(), "text_list.MightHaveChildren() says False for non empty!")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.expect('frame variable ss',
substrs = ['map has 0 items',
'{}'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.runCmd("next")
self.assertTrue(var_S.GetSummary() == 'L"!!!!!"', "new S summary wrong")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.expect("expr vBool",
substrs = ['size=49','[0] = false','[1] = true','[18] = false','[27] = true','[36] = false','[47] = true','[48] = true'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.expect("frame variable strings",
substrs = ['vector has 0 items'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.runCmd('type summary add -e -h -s "I am really empty" EmptyStruct')
self.expect('frame variable es', substrs = ["I am really empty"])
self.expect('frame variable es', substrs = ["I am really empty {}"], matching=False)
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.assertEqual(ma.GetNumChildren(15), 15)
self.assertEqual(ma.GetNumChildren(16), 16)
self.assertEqual(ma.GetNumChildren(17), 16)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Check if changing Format on an SBValue correctly propagates that new format to children as it should
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
Y.SetFormat(lldb.eFormatDefault)
self.assertTrue(X.GetValue() == "0x00000004", "X is not hex as it asked")
self.assertTrue(Y.GetValue() == "2", "Y is not defaulted")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test that the user can input a format but it will not prevail over summary format's choices.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
'stop reason = breakpoint'])
self.expect("thread list", substrs = ['addPair(p=(x = 3, y = -3))'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.runCmd("type summary add -s \"${var.first%X} and ${var.second%X}\" foo")
self.expect('frame variable mine',
substrs = ['(foo) mine = 0xAABBCCDD and 0xFF00FF00'])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import datetime
self.assertTrue(self.frame().FindVariable("arr").MightHaveChildren(), "arr says it does not have children!")
self.assertTrue(self.frame().FindVariable("other_arr").MightHaveChildren(), "arr says it does not have children!")
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import datetime
self.assertTrue(self.frame().FindVariable("dictionary").MightHaveChildren(), "dictionary says it does not have children!")
self.assertTrue(self.frame().FindVariable("mutabledict").MightHaveChildren(), "mutable says it does not have children!")
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import datetime
substrs = ['4 elements'])
self.expect('frame variable mutable --ptr-depth 1 -d run -T',
substrs = ['4 elements','[0]','[1]','[2]','[3]','hello','world','(int)1','(int)2'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import datetime
# Now check that we use the right summary for OSType
self.expect('frame variable',
substrs = ["'test'","'best'"])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
# the match.
self.expect("frame variable y", substrs = ['(Foo &', ') y = 0x','IntLRef'])
self.expect("frame variable z", substrs = ['(Foo &&', ') z = 0x','IntRRef'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test that ValueObjectPrinter does not cause an infinite loop when a reference to a struct that contains a pointer to itself is printed.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.expect("frame variable foo --ptr-depth=1", substrs = ['ID = 1']);
self.expect("frame variable foo --ptr-depth=2", substrs = ['ID = 1']);
self.expect("frame variable foo --ptr-depth=3", substrs = ['ID = 1']);
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.expect('frame variable mine',
substrs = ['mine = ',
'1', '<parent is NULL>'])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Check for an issue where capping does not work because the Target pointer appears to be changing behind our backs
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.expect("frame variable f00_1", matching=True,
substrs = ['r = 33']);
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import datetime
self.assertFalse(id_x.GetNumChildren() == 7, "dictionary still looks synthetic")
id_x.SetPreferSyntheticValue(True)
self.assertTrue(id_x.GetSummary() == "7 key/value pairs", "dictionary does not get correct summary")
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test that the user can input a format but it will not prevail over summary format's choices.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.expect("frame variable p1", substrs = ['(Pair) p1 = x=0x00000003,y=4294967293']);
self.expect("frame variable -f d p1", substrs = ['(Pair) p1 = x=3,y=-3'],matching=False);
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
substrs = ['(TwoSummarizes) twos = TwoSummarizes @ ',
'first = SUMMARY SUCCESS 1',
'second = SUMMARY SUCCESS 3'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.expect("frame variable x", substrs = ['T is a non-pointer type']);
self.expect("frame variable y", substrs = ['T is a pointer type']);
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Check that vector types format properly
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
v.SetFormat(lldb.eFormatVectorOfFloat32)
oldValueAgain = v.GetChildAtIndex(0).GetValue()
self.assertTrue(oldValue == oldValueAgain, "same format but different values")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test that breakpoint works correctly in the presence of dead-code stripping.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
# The breakpoint should have a hit count of 1.
self.expect("breakpoint list -f 3", BREAKPOINT_HIT_ONCE,
substrs = [' resolved, hit count = 1'])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test some lldb command abbreviations.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
# make sure a few reasonable assembly instructions are here
self.expect(disassembly, exe=False, startstr = "a.out`sum", substrs = instructions)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
-
Test that dynamic values update their child count correctly
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb, lldbutil
from lldbtest import *
self.assertTrue(b.GetNumChildren() != 0, "b now has 1 child")
self.runCmd("continue")
self.assertTrue(b.GetNumChildren() == 0, "b didn't go back to 0 children")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test convenience variables when you drop in from lldb prompt into an embedded interpreter."""
+import lldb_shared
+
import os
-import unittest2
import lldb
from lldbtest import *
child.expect_exact(python_prompt)
self.expect(child.before, exe=False,
patterns = ['frame #0: 0x[0-9a-f]+ a\.out`main\(argc=1, argv=0x[0-9a-f]+\) \+ \d+ at main\.c:%d' % self.line])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""
Test some lldb command abbreviations.
"""
+import lldb_shared
+
import commands
import lldb
import os
import time
-import unittest2
from lldbtest import *
import lldbutil
# Run and we should stop at breakpoint in main after exec
process.Continue()
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
-
Test that expr will time out and allow other threads to run if it blocks.
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb, lldbutil
from lldbtest import *
var = frame0.EvaluateExpression ("call_me_to_get_lock()")
self.assertTrue (var.IsValid())
self.assertTrue (var.GetValueAsSigned (0) == 567)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""
Test some lldb command abbreviations.
"""
+import lldb_shared
+
import commands
import lldb
import os
import time
-import unittest2
from lldbtest import *
import lldbutil
self.assertTrue(function.IsValid(), "Verify breakpoint in fat BSD archive has valid function debug info")
self.assertTrue(line_entry.GetFileSpec(), "Verify breakpoint in fat BSD archive has source file information")
self.assertTrue(line_entry.GetLine() != 0, "Verify breakpoint in fat BSD archive has source line information")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
-
Test the command history mechanism
"""
+import lldb_shared
+
import os
-import unittest2
import lldb
from lldbtest import *
# child.sendline('Help__')
# child.expect_exact("error: 'Help__' is not a valid command")
# child.expect_exact(prompt)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test that lldb functions correctly after the inferior has asserted."""
+import lldb_shared
+
import os, time
-import unittest2
import lldb, lldbutil, lldbplatformutil
from lldbtest import *
self.expect("thread backtrace all",
substrs = [stop_reason,
'main.c:%d' % self.line])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test lldb reloads the inferior after it was changed during the session."""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
substrs = ['= 7'])
self.expect("expression *int_ptr",
substrs = ['= 7'])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test that lldb functions correctly after the inferior has crashed."""
+import lldb_shared
+
import os, time
-import unittest2
import lldb, lldbutil, lldbplatformutil
from lldbtest import *
# The lldb expression interpreter should be able to read from addresses of the inferior after a crash.
self.expect("p argv[0]",
substrs = ['a.out'])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test that lldb functions correctly after the inferior has crashed while in a recursive routine."""
+import lldb_shared
+
import os, time
-import unittest2
import lldb, lldbutil, lldbplatformutil
import sys
from lldbtest import *
startstr = '(char *) $1 = 0x0')
self.check_stop_reason()
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test stepping over and into inlined functions."""
+import lldb_shared
+
import os, time, sys
-import unittest2
import lldb
import lldbutil
from lldbtest import *
step_sequence = [["// In max_value specialized", "into"]]
self.run_step_sequence(step_sequence)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test for the JITLoaderGDB interface"""
-import os
+import lldb_shared
+
import unittest2
+import os
import lldb
from lldbtest import *
import lldbutil
self.assertEqual(process.GetState(), lldb.eStateExited)
self.assertEqual(process.GetExitStatus(), 0)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""
Test that argdumper is a viable launching strategy.
"""
+import lldb_shared
+
import lldb
import os
import time
-import unittest2
from lldbtest import *
import lldbutil
"Thread in process stopped in 'main' should have a stop reason of eStopReasonBreakpoint");
self.expect("frame variable argv[1]", substrs=['foo bar'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
-
Test that breakpoint by symbol name works correctly with dynamic libs.
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.expect("thread list", "step over succeeded.",
substrs = ['stopped',
'stop reason = step over'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test the use of setjmp/longjmp for non-local goto operations in a single-threaded inferior.
"""
+import lldb_shared
+
import os
-import unittest2
import lldb
import lldbutil
from lldbtest import *
self.runCmd("thread step-in", RUN_SUCCEEDED)
self.runCmd("thread step-out", RUN_SUCCEEDED)
self.check_status()
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test the 'memory read' command.
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb
from lldbtest import *
import lldbutil
# 0x7fff5fbff598: error: unsupported byte size (20) for float format
self.expect("memory read --format 'float' --count 1 --size 20 `&my_double`",
substrs = ['unsupported byte size (20) for float format'])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test evaluating expressions which ref. index variable 'i' which just goes
from out of scope to in scope when stopped at the breakpoint."""
-import unittest2
+import lldb_shared
+
import lldb
from lldbtest import *
import lldbutil
self.runCmd('expr ptr[0]->point.y')
self.runCmd('expr ptr[i]->point.x')
self.runCmd('expr ptr[i]->point.y')
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""
Test that using a non-existent architecture name does not crash LLDB.
"""
+import lldb_shared
+
import lldb
-import unittest2
from lldbtest import *
import lldbutil
# Now just create the target with the default arch and check it's fine
target = self.dbg.CreateTarget(exe)
self.assertTrue(target.IsValid(), "This target should now be valid")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
-
foreign-architecture object files.
"""
+import lldb_shared
+
import os.path
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.match("image list -t -A", [expected_triple_and_arch_regex])
# Revert to the host platform after all of this is done
self.runCmd("platform select host")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""
Test some lldb command abbreviations.
"""
+import lldb_shared
+
import lldb
import os
import time
-import unittest2
from lldbtest import *
import lldbutil
fspec = lldb.SBFileSpec("C:\\dummy1\\dummy2//unknown_file", True);
self.assertEqual(os.path.normpath(fspec.GetDirectory()), os.path.normpath("C:/dummy1/dummy2"));
self.assertEqual(fspec.GetFilename(), "unknown_file");
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
-
Test some lldb platform commands.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
self.skipTest("due to taking too long to complete.")
self.expect("platform shell sleep 15", error=True,
substrs = ["error: timed out waiting for shell command to complete"])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test that plugins that load commands work correctly.
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb
from lldbtest import *
import lldbutil
print retobj.GetOutput()
self.expect(retobj,substrs = ['abc def ghi'], exe=False)
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test that the Python operating system plugin works correctly
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.assertTrue(line_entry.GetFileSpec().GetFilename() == 'main.c', "Make sure we stepped from line 5 to line 6 in main.c")
self.assertTrue(line_entry.GetLine() == 6, "Make sure we stepped from line 5 to line 6 in main.c")
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test basics of mini dump debugging.
"""
-import unittest2
+import lldb_shared
+
import lldb
from lldbtest import *
import lldbutil
self.dbg.CreateTarget("")
self.target = self.dbg.GetSelectedTarget()
self.process = self.target.LoadCore("fizzbuzz_no_heap.dmp")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test process attach.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
# Call super's tearDown().
TestBase.tearDown(self)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test denied process attach.
"""
+import lldb_shared
+
import os
import time
-import unittest2
import lldb
from lldbtest import *
self.expect('process attach -p ' + pid,
startstr = 'error: attach failed:',
error = True)
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test that we handle inferiors which change their process group"""
+import lldb_shared
+
import os
-import unittest2
import lldb
from lldbtest import *
import lldbutil
shell_command = lldb.SBPlatformShellCommand(cmd)
err = platform.Run(shell_command)
return (err, shell_command.GetStatus(), shell_command.GetOutput())
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb process launch flags.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
if not success:
self.fail(err_msg)
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
-
Test lldb data formatter subsystem.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.assertTrue(child.GetChildAtIndex(0).IsValid(),"the deep ValueObject has no value")
self.assertTrue(child.GetChildAtIndex(0).GetValueAsUnsigned() != 0,"the deep ValueObject has a zero value")
self.assertTrue(child.GetChildAtIndex(1).GetValueAsUnsigned() != 0, "the deep ValueObject has no next")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test the 'register' command.
"""
+import lldb_shared
+
import os, sys, time
import re
-import unittest2
import lldb
from lldbtest import *
import lldbutil
if test_16bit_regs:
self.expect("expr -- $ax == (($ah << 8) | $al)",
substrs = ['true'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""
Test that argdumper is a viable launching strategy.
"""
+import lldb_shared
+
import lldb
import os
import time
-import unittest2
from lldbtest import *
import lldbutil
self.expect("frame variable argv[1]", substrs=['1'])
self.expect("frame variable argv[2]", substrs=['2'])
self.expect("frame variable argv[3]", substrs=['3'])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
-
Test getting return-values correctly when stepping out
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb, lldbutil
from lldbtest import *
ret_child_str = ret_child.GetValue()
self.assertEqual(in_child_str, ret_child_str)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Set the contents of variables and registers using raw data
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.expect("fr var -d run-target string", VARIABLES_DISPLAYED_CORRECTLY,
substrs = ['NSString *', 'nil'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test that lldb command 'process signal SIGUSR1' to send a signal to the inferior works."""
+import lldb_shared
+
import os, time, signal
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.assertTrue(state == expected_state,
"It was the %s state." %
lldb.SBDebugger_StateAsCString(expected_state))
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test that we can debug inferiors that handle SIGSEGV by themselves"""
+import lldb_shared
+
import os
-import unittest2
import lldb
from lldbtest import *
import lldbutil
process.Continue()
self.assertEqual(process.GetState(), lldb.eStateExited)
self.assertEqual(process.GetExitStatus(), 0)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test that we handle inferiors that send signals to themselves"""
+import lldb_shared
+
import os
-import unittest2
import lldb
from lldbtest import *
import lldbutil
# We are done
process.Kill()
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test the lldb command line takes a filename with single quote chars.
"""
+import lldb_shared
+
import os
-import unittest2
import lldb
from lldbtest import *
self.expect(from_child, exe=False,
substrs = ["Current executable set to"])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test thread step-in, step-over and step-out work with the "Avoid no debug" option.
"""
+import lldb_shared
+
import os
import re
-import unittest2
import lldb, lldbutil
import sys
from lldbtest import *
# frame. In gdb, step-over/step-in move to the end of the line they stepped out to.
# If we ever change this we will need to fix this test.
self.hit_correct_line ("int return_value = no_debug_caller(5, called_from_nodebug)")
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
import lldb_shared
import os
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.expect('target stop-hook list', 'Stop Hook deleted successfully',
substrs = ['No stop hooks.'])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb target stop-hook mechanism to see whether it fires off correctly .
"""
+import lldb_shared
+
import os
-import unittest2
import lldb
from lldbtest import *
# Verify that the 'Stop Hooks' mechanism is NOT BEING fired off.
self.expect(child.before, exe=False, matching=False,
substrs = ['(void *) $'])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test that lldb stop-hook works for multiple threads.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
# Continue and expect to find the output emitted by the firing of our stop hook.
child.sendline('continue')
child.expect_exact('(uint32_t) ::g_val = ')
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test some target commands: create, list, select, variable.
"""
-import unittest2
+import lldb_shared
+
import lldb
import sys
from lldbtest import *
substrs = ['a'])
self.expect("target variable my_global_char", VARIABLES_DISPLAYED_CORRECTLY,
substrs = ["my_global_char", "'X'"])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test number of threads.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
# Using std::thread may involve extra threads, so we assert that there are
# at least 4 rather than exactly 4.
self.assertTrue(num_threads >= 4, 'Number of expected threads and actual threads do not match.')
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test number of threads.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
# At this point, the inferior process should have exited.
self.assertTrue(process.GetState() == lldb.eStateExited, PROCESS_EXITED)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
verified to match the expected number of events.
"""
-import os, time
+import lldb_shared
+
import unittest2
+import os, time
import lldb
from lldbtest import *
import lldbutil
watchpoint_hit_count = self.thread_watchpoint.GetHitCount() if expected_watchpoint_threads > 0 else 0
self.assertEqual(expected_watchpoint_threads, watchpoint_hit_count,
"Expected %d watchpoint hits, got %d" % (expected_watchpoint_threads, watchpoint_hit_count))
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test that step-inst over a crash behaves correctly.
"""
+import lldb_shared
+
import os
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.assertEqual(process.GetState(), lldb.eStateStopped, PROCESS_STOPPED)
self.assertTrue(lldbutil.is_thread_crashed(self, thread), "Thread has crashed")
process.Kill()
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test thread creation after process attach.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
# At this point, the inferior process should have exited.
self.assertTrue(process.GetState() == lldb.eStateExited, PROCESS_EXITED)
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test number of threads.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
# At this point, the inferior process should have exited.
self.assertTrue(process.GetState() == lldb.eStateExited, PROCESS_EXITED)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test number of threads.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
# At this point, the inferior process should have exited.
self.assertTrue(process.GetState() == lldb.eStateExited, PROCESS_EXITED)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test number of threads.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
# At this point, the inferior process should have exited.
self.assertTrue(process.GetState() == lldb.eStateExited, PROCESS_EXITED)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test jumping to different places.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.runCmd("thread step-out") # return out
self.runCmd("thread step-over") # assign to the global
self.expect("expr %s" % var, substrs = [value]) # check it
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test number of threads.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
# At this point, the inferior process should have exited.
self.assertTrue(process.GetState() == lldb.eStateExited, PROCESS_EXITED)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test thread states.
"""
-import os, time
+import lldb_shared
+
import unittest2
+import os, time
import lldb
from lldbtest import *
import lldbutil
# At this point, the inferior process should have exited.
self.assertTrue(process.GetState() == lldb.eStateExited, PROCESS_EXITED)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test stepping out from a function in a multi-threaded program.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
# At this point, the inferior process should have exited.
self.assertTrue(self.inferior_process.GetState() == lldb.eStateExited, PROCESS_EXITED)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test number of threads.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
# At this point, the inferior process should have exited.
self.assertTrue(process.GetState() == lldb.eStateExited, PROCESS_EXITED)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test that we obey thread conditioned breakpoints.
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb, lldbutil
from lldbtest import *
next_stop_state = process.GetState()
self.assertTrue (next_stop_state == lldb.eStateExited, "We should have not hit the breakpoint again.")
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb command aliases.
"""
-import os, time
+import lldb_shared
+
import unittest2
+import os, time
import lldb
from lldbtest import *
import lldbutil
self.assertTrue(error.Success(), "Make sure launch happened successfully in a terminal window")
# Running in synchronous mode our process should have run and already exited by the time target.Launch() returns
self.assertTrue(process.GetState() == lldb.eStateExited)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
-
Check that types only get completed when necessary.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
string = field0.GetType().GetPointeeType()
self.assertTrue(string.IsValid(), 'std::string should be valid')
self.assertTrue(string.IsTypeComplete(), 'std::string should now be complete')
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test type lookup command.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import datetime
self.expect('type lookup NSURL', substrs=['NSURL'])
self.expect('type lookup NSArray', substrs=['NSArray'])
self.expect('type lookup NSObject', substrs=['NSObject', 'isa'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test that we can backtrace correctly with 'noreturn' functions on the stack
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
if thread.GetFrameAtIndex (main_frame_number).GetFunctionName() != "main":
self.fail("Did not find main() above func_a().")
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test that we can backtrace correctly with 'sigtramp' functions on the stack
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
if found_main == False:
self.fail("Unable to find main() in backtrace.")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
after escaping some special characters).
"""
-import os, time
+import lldb_shared
+
import unittest2
+import os, time
import lldb
from lldbtest import *
import lldbutil
test_function_dwarf.__name__ = test_name
setattr(StandardUnwindTest, test_function_dwarf.__name__, test_function_dwarf)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Verify that the hash computing logic for ValueObject's values can't crash us.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
v = value.GetValue()
# if we are here, instead of crashed, the test succeeded
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb watchpoint that uses '-s size' to watch a pointed location with size.
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb
from lldbtest import *
import lldbutil
substrs = ['hit_count = 1'])
self.runCmd("thread backtrace all")
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test my first lldb watchpoint.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
# The hit count should now be 1.
self.expect("watchpoint list -v",
substrs = ['hit_count = 1'])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test that lldb watchpoint works for multiple threads.
"""
+import lldb_shared
+
import os, time
-import unittest2
import re
import lldb
from lldbtest import *
continue
else:
self.fail("The stop reason should be either break or watchpoint")
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test stepping over watchpoints."""
-import unittest2
+import lldb_shared
+
import lldb
import lldbutil
from lldbtest import *
self.assertTrue(stop_reason == lldb.eStopReasonPlanComplete,
STOPPED_DUE_TO_STEP_IN)
self.assertTrue(watchpoint_hit, "Watchpoint never hit.")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test that a variable watchpoint should only hit when in scope.
"""
-import os, time
+import lldb_shared
+
import unittest2
+import os, time
import lldb
from lldbtest import *
import lldbutil
# The hit count should now be 1.
self.expect("watchpoint list -v",
substrs = ['hit_count = 1'])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test watchpoint list, enable, disable, and delete commands.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
# The hit count should be 1.
self.expect("watchpoint list -v",
substrs = ['hit_count = 1'])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test 'watchpoint command'.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
# be 'exited'.
self.expect("process status",
substrs = ['exited'])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test 'watchpoint command'.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
# The watchpoint command "forced" our global variable 'cookie' to become 777.
self.expect("frame variable --show-globals cookie",
substrs = ['(int32_t)', 'cookie = 777'])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test watchpoint modify command to set condition on a watchpoint.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
# The hit count should now be 2.
self.expect("watchpoint list -v",
substrs = ['hit_count = 5'])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test that adding, deleting and modifying watchpoints sends the appropriate events."""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
import lldbutil
from lldbtest import *
print "Found an event I didn't expect: ", event
self.assertTrue (not found_event, "Only one event per change.")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test displayed value of a vector variable while doing watchpoint operations
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
# Value of a vector variable should be displayed correctly
self.expect("watchpoint set variable global_vector", WATCHPOINT_CREATED,
substrs = ['new value: (1, 2, 3, 4)'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb watchpoint that uses 'watchpoint set -w write -s size' to watch a pointed location with size.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
substrs = ['hit_count = 1'])
self.runCmd("thread backtrace all")
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test error cases for the 'watchpoint set' command to make sure it errors out when necessary.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
# Wrong size parameter is an error.
self.expect("watchpoint set variable -s -128", error=True,
substrs = ['invalid enumeration value'])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
See also CommandInterpreter::OutputFormattedHelpText().
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
substrs = ['The following subcommands are supported:'],
patterns = ['expression +--',
'variable +--'])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test that anonymous structs/unions are transparent to member access"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
# The breakpoint should have a hit count of 1.
self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
substrs = [' resolved, hit count = 1'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test breakpoint by file/line number; and list variables with array types."""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.assertTrue(argc.GetValueType() == lldb.eValueTypeVariableArgument,
"Variable 'argc' should have '%s' value type." %
value_type_to_str(lldb.eValueTypeVariableArgument))
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Show bitfields and check that they display correctly."""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
# Now kill the process, and we are done.
rc = target.GetProcess().Kill()
self.assertTrue(rc.Success())
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test that lldb can invoke blocks and access variables inside them"""
-import os, time
+import lldb_shared
+
import unittest2
+import os, time
import lldb
from lldbtest import *
import lldbutil
self.expect("thread list", STOPPED_DUE_TO_BREAKPOINT,
substrs = ['stopped',
'stop reason = breakpoint'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Check that compiler-generated constant values work correctly"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
substrs = ['(int) $1 = 256'])
self.runCmd("kill")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Look up enum type information and check for correct display."""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.expect("frame variable day", 'check for valid enumeration value',
substrs = [enum_value])
lldbutil.continue_to_breakpoint (self.process(), bkpt)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test that forward declaration of a data structure gets resolved correctly."""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
substrs = ['(bar)',
'(int) a = 1',
'(int) b = 2'])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test variable with function ptr type and that break on the function works."""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
# The breakpoint should have a hit count of 1.
self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
substrs = [' resolved, hit count = 1'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Show global variables and check that they do indeed have global scopes."""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
substrs = ['g_marked_spot.y', '21'])
self.expect("target variable g_marked_spot.y", VARIABLES_DISPLAYED_CORRECTLY, matching=False,
substrs = ["can't be resolved"])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test that importing modules in C works as expected."""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
import platform
import lldbutil
TestBase.setUp(self)
# Find the line number to break inside main().
self.line = line_number('main.c', '// Set breakpoint 0 here.')
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Check that compiler-generated register values work correctly"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
substrs = ['(int) $3 = 5'])
self.runCmd("kill")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test settings and readings of program variables."""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.runCmd("expression i = 1.5")
self.expect("frame variable --show-types", VARIABLES_DISPLAYED_CORRECTLY,
startstr = "(long double) i = 1.5")
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test that types defined in shared libraries work correctly."""
+import lldb_shared
+
import unittest2
import lldb
from lldbtest import *
# The breakpoint should have a hit count of 1.
self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
substrs = [' resolved, hit count = 1'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test that types defined in shared libraries with stripped symbols work correctly."""
+import lldb_shared
+
import unittest2
import lldb
from lldbtest import *
# The breakpoint should have a hit count of 1.
self.expect("breakpoint list -f", BREAKPOINT_HIT_ONCE,
substrs = [' resolved, hit count = 1'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test stepping over vrs. hitting breakpoints & subsequent stepping in various forms."""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
import lldbutil
from lldbtest import *
thread.StepInto("NoSuchFunction")
self.assertTrue (thread.GetFrameAtIndex(0).GetFunctionName() == "main")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test thread stepping features in combination with frame select.
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb, lldbutil
from lldbtest import *
import lldbutil
self.expect("thread backtrace", STEP_OUT_SUCCEEDED,
substrs = ["stop reason = step out"],
patterns = ["frame #0.*main.c:%d" % self.line4])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
self.expect("expression !z",
substrs = ['false'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test that thread-local storage can be read correctly."""
-import os, time
+import lldb_shared
+
import unittest2
+import os, time
import lldb
from lldbtest import *
import lldbutil
patterns = ["\(int\) \$.* = 44"])
self.expect("expr var_shared", VARIABLES_DISPLAYED_CORRECTLY,
patterns = ["\(int\) \$.* = 33"])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Look up type information for typedefs of same name at different lexical scope and check for correct display."""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.expect("image lookup -t a", DATA_TYPES_DISPLAYED_CORRECTLY,
substrs = ['name = "' + t + '"'])
self.runCmd("continue")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
self.expect("expression -- my_bool = true",
startstr = "(bool) $1 = true")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb breakpoint command for CPP methods & functions in a namespace.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
a_out_module,
nested_comp_unit)
self.assertTrue (plain_method_break.GetNumLocations() == 1)
-
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
self.expect("expression -- a_function_to_call()",
startstr = "(int) $0 = 0")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
test_result = frame.EvaluateExpression("get(t) && get(t)")
self.assertTrue(test_result.IsValid() and test_result.GetValue() == "true", "get(t) && get(t) = true")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test that the C++11 support for char16_t and char32_t works correctly.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
# Check that we can run expressions that return charN_t
self.expect("expression u'a'",substrs = ['(char16_t) $',"61 u'a'"])
self.expect("expression U'a'",substrs = ['(char32_t) $',"61 U'a'"])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test display and Python APIs on file and class static variables.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
val = frame.FindValue("hello_world", lldb.eValueTypeVariableLocal)
self.DebugSBValue(val)
self.assertTrue(val.GetName() == 'hello_world')
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test breakpoint on a class constructor; and variable list the this object."""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
import lldbutil
from lldbtest import *
self.assertTrue (frame.IsValid(), "Got a valid frame.")
self.assertTrue ("C::C" in frame.name, "Constructor name includes class name.")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test the lldb disassemble command on each call frame when stopped on C's ctor.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
# We should be stopped on the ctor function of class C.
# self.expect("thread backtrace", BACKTRACE_DISPLAYED_CORRECTLY,
# substrs = ['C::C'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
# Some compilers (for example GCC 4.4.7 and 4.6.1) emit multiple locations for the statement with the ternary
# operator in the test program, while others emit only 1.
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", line, num_expected_locations=-1, loc_exact=False)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb Python API SBValue::Cast(SBType) for C++ types.
"""
+import lldb_shared
+
+import unittest2
import os, time
import re
-import unittest2
import lldb, lldbutil
from lldbtest import *
b_member_val = instanceB.GetChildMemberWithName('m_b_val')
self.DebugSBValue(b_member_val)
self.assertTrue(b_member_val.GetValueAsUnsigned(error, 0) == 36)
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Use lldb Python API to test dynamic values in C++
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb, lldbutil
from lldbtest import *
contained_b_static_addr = int (contained_b_static.GetValue(), 16)
self.assertTrue (contained_b_addr < contained_b_static_addr)
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Look up enum type information and check for correct display."""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.expect("frame variable day", 'check for valid enumeration value',
substrs = [enum_value])
lldbutil.continue_to_breakpoint (self.process(), bkpt)
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb exception breakpoint command for CPP.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
import lldbutil
from lldbtest import *
self.assertTrue (frame_functions.count ("throws_exception_on_even(int)") == 0, "At catch our throw function is off the stack")
self.assertTrue (frame_functions.count ("intervening_function(int)") == 0, "At catch our intervening function is off the stack")
self.assertTrue (frame_functions.count ("catches_exception(int)") == 1, "At catch our catch function is on the stack")
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
test_result = frame.EvaluateExpression("operator==(s2, s3)")
self.assertTrue(test_result.IsValid() and test_result.GetValue() == "false", "operator==(s2, s3) = false")
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
# Get frame for current thread
return thread.GetSelectedFrame()
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test the printing of anonymous and named namespace variables.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.expect("p variadic_sum",
patterns = ['\(anonymous namespace\)::variadic_sum\(int, ...\)'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
# Test function inside namespace
test_result = frame.EvaluateExpression("fun_var")
self.assertTrue(test_result.IsValid() and test_result.GetValueAsSigned() == 5, "fun_var = 5")
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
self.expect("expression -- Static()",
startstr = "(int) $1 = 1")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test that the expression parser returns proper Unicode strings.
"""
-import os, time
+import lldb_shared
+
import unittest2
+import os, time
import lldb
from lldbtest import *
import lldbutil
if expr == 2: self.expect('expression u"hello"', substrs = ['hello'])
if expr == 3: self.expect('expression U"hello"', substrs = ['hello'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
def set_breakpoint(self, line):
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", line, num_expected_locations=1, loc_exact=True)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
value = frame.EvaluateExpression(name)
assert_value = global_variables_assert[name]
self.assertTrue(value.IsValid() and value.GetValueAsSigned() == assert_value, name + " = " + str(assert_value))
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test that variables with signed types display correctly.
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb
from lldbtest import *
import lldbutil
substrs = ["(int) the_signed_int = 99",
"(long) the_signed_long = 99",
"(long long) the_signed_long_long = 99"])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""
Tests that C++ member and static variables have correct layout and scope.
"""
+
+import lldb_shared
+
+import unittest2
import lldb
from lldbtest import *
import lldbutil
def set_breakpoint(self, line):
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", line, num_expected_locations=1, loc_exact=False)
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
self.expect("expression -- my_a.getMemberValue()",
startstr = "(int) $1 = 3")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test some expressions involving STL data types.
"""
-import os, time
+import lldb_shared
+
import unittest2
+import os, time
import lldb
import lldbutil
from lldbtest import *
# Check that both entries of the dictionary have 'True' as the value.
self.assertTrue(all(expected_types.values()))
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test the lldb disassemble command on lib stdc++.
"""
-import os, time
+import lldb_shared
+
import unittest2
+import os, time
import lldb
from lldbtest import *
import lldbutil
else:
# This entry is not a Code entry. Reset SA = None.
SA = None
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
def set_breakpoint(self, line):
lldbutil.run_break_set_by_file_and_line (self, "main.cpp", line, num_expected_locations=1, loc_exact=False)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test that template instaniations of std::vector<long> and <short> in the same module have the correct types.
"""
-import unittest2
+import lldb_shared
+
import lldb
import lldbutil
from lldbtest import *
continue
self.expect(x, "Expect type 'short'", exe=False,
substrs = ['short'])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test that variables with unsigned types display correctly.
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb
from lldbtest import *
import lldbutil
"(unsigned long) the_unsigned_long = 99",
"(unsigned long long) the_unsigned_long_long = 99",
"(uint32_t) the_uint32 = 99"])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test that C++ supports wchar_t correctly.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.expect('frame variable wchar_zero', substrs=["L'\\0'"])
self.expect('expression wchar_zero', substrs=["L'\\0'"])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test the Go OS Plugin."""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
import lldbutil
from lldbtest import *
self.dbg.HandleCommand("settings set plugin.os.goroutines.enable false")
self.thread().StepInstruction(False)
self.assertLess(len(self.process().threads), 20)
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test the go DWARF type parsing."""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
import lldbutil
from lldbtest import *
self.assertEqual(5, v.GetNumChildren())
for i in xrange(5):
self.assertEqual(str(i + 1), v.GetChildAtIndex(i).value)
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test that lldb works correctly on compile units form different languages."""
+import lldb_shared
+
import os, time, re
-import unittest2
import lldb
from lldbtest import *
# (note: C++11 is enabled by default for C++).
self.expect("expr foo != nullptr",
patterns = ["true"])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test printing ivars and ObjC objects captured in blocks that are made in methods of an ObjC class."""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
ret_value_signed = expr.GetValueAsSigned (error)
# print 'ret_value_signed = %i' % (ret_value_signed)
self.assertTrue (ret_value_signed == 5, "The local variable in the block was what we expected.")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test that a forward-declared class works when its complete definition is in a library"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
# This should display correctly.
self.expect("expression [j getMember]", VARIABLES_DISPLAYED_CORRECTLY,
substrs = ["= 0x"])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
parser.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.expect('expression (int)[@"123" length]',
startstr = "(int) $3 = 3")
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test the lldb disassemble command on foundation framework.
"""
-import os, time
+import lldb_shared
+
import unittest2
+import os, time
import lldb
from lldbtest import *
import lldbutil
# Do the disassemble for the currently stopped function.
self.runCmd("disassemble -f")
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Also lookup objective-c data types and evaluate expressions.
"""
+import lldb_shared
+
import os, os.path, time
-import unittest2
import lldb
import string
from lldbtest import *
self.expect("thread backtrace", "Stop at -[NSAutoreleasePool release]",
substrs = ["Foundation`-[NSAutoreleasePool release]"])
- #@unittest2.expectedFailure
# rdar://problem/8542091
# rdar://problem/8492646
def test_data_type_and_expr(self):
print line,
self.assertTrue(num_errors == 0, "Spurious lookups detected")
f.close()
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test more expression command sequences with objective-c.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
error = True,
patterns = ["no known method", "cast the message send to the method's return type"])
self.runCmd("process continue")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test SBValue.GetObjectDescription() with the value from SBTarget.FindGlobalVariables().
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb, lldbutil
from lldbtest import *
print "object description:", v.GetObjectDescription()
if v.GetName() == 'my_global_str':
self.assertTrue(v.GetObjectDescription() == 'This is a global string')
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test that Objective-C methods from the runtime work correctly.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.expect("po $1", VARIABLES_DISPLAYED_CORRECTLY,
substrs = ["foo"])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test symbol table access for main.m.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
#print "symbols unaccounted for:", expected_symbols
self.assertTrue(len(expected_symbols) == 0,
"All the known symbols are accounted for")
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test that hidden ivars in a shared library are visible from the main executable."""
-import os, time
+import lldb_shared
+
import unittest2
+import os, time
import lldb
from lldbtest import *
import lldbutil
else:
self.expect("frame variable *k", VARIABLES_DISPLAYED_CORRECTLY,
substrs = ["foo = 2", "bar = 3", '_filteredDataSource = 0x', '"2 elements"'])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test that dynamically discovered ivars of type IMP do not crash LLDB
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb, lldbutil
from lldbtest import *
import commands
self.expect('disassemble --start-address `((MyClass*)object)->myImp`', substrs=[
'-[MyClass init]'
])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test that importing modules in Objective-C works as expected."""
-import os, time
+import lldb_shared
+
import unittest2
+import os, time
import lldb
import platform
import lldbutil
self.expect("p getpid()", VARIABLES_DISPLAYED_CORRECTLY,
substrs = ["pid_t"])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test that DWARF types are trusted over module types"""
-import os, time
+import lldb_shared
+
import unittest2
+import os, time
import lldb
import platform
import lldbutil
self.expect("expr MAX(2,3)", "#undefd macro was correcltly not found",
error=True)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test that inline functions from modules are imported correctly"""
-import os, time
+import lldb_shared
+
import unittest2
+import os, time
import lldb
import platform
import lldbutil
self.expect("expr isInline(2)", VARIABLES_DISPLAYED_CORRECTLY,
substrs = ["4"])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test that importing modules in Objective-C works as expected."""
-import os, time
+import lldb_shared
+
import unittest2
+import os, time
import lldb
import platform
import lldbutil
self.expect("p [NSURL URLWithString:@\"http://lldb.llvm.org\"].scheme", VARIABLES_DISPLAYED_CORRECTLY,
substrs = ["http"])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Make sure that ivars of Objective-C++ classes are visible in LLDB.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.expect("expr f->f", "Found ivar in class",
substrs = ["= 3"])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Use lldb Python API to test base class resolution for ObjC classes
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb, lldbutil
from lldbtest import *
self.assertTrue(var_pte_type.GetDirectBaseClassAtIndex(0).IsValid(), "Foo * has a valid base class")
self.assertTrue(var_ptr_type.GetDirectBaseClassAtIndex(0).GetName() == var_pte_type.GetDirectBaseClassAtIndex(0).GetName(), "Foo and its pointer type don't agree on their base class")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test that the expression parser doesn't get confused by 'id' and 'Class'"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
import lldbutil
from lldbtest import *
self.expect("expr (foo)", patterns = ["\(ns::id\) \$.* = 0"])
self.expect("expr id my_id = 0; my_id", patterns = ["\(id\) \$.* = nil"])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Use lldb Python API to make sure the dynamic checkers are doing their jobs.
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb, lldbutil
from lldbtest import *
# Make sure the error is helpful:
err_string = expr_error.GetCString()
self.assertTrue ("selector" in err_string)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test calling functions in class methods."""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
import lldbutil
from lldbtest import *
cmd_value = frame.EvaluateExpression ("(int)[Foo doSomethingWithString:@\"Hello\"]")
self.assertTrue (cmd_value.IsValid())
self.assertTrue (cmd_value.GetValueAsUnsigned() == 5)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test that we are able to properly report a usable dynamic type
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.assertTrue(object_pointee_type.GetNumberOfFields() == 2, "The dynamic type for NSObject has 2 fields")
self.assertTrue(base_pointee_type.GetNumberOfFields() == 2, "The dynamic type for Base has 2 fields")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Use lldb Python API to test dynamic values in ObjC
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb, lldbutil
from lldbtest import *
derivedValue = object.GetChildMemberWithName ('_derivedValue')
self.assertTrue (derivedValue)
self.assertTrue (int (derivedValue.GetValue(), 0) == 30)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test printing ObjC objects that use unbacked properties - so that the static ivar offsets are incorrect."""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
flag2_value = mine_flag2.GetValueAsUnsigned (error)
self.assertTrue (error.Success())
self.assertTrue (flag2_value == 7)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test printing ObjC objects that use unbacked properties - so that the static ivar offsets are incorrect."""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
ivar_value = ivar.GetValueAsSigned (error)
self.assertTrue (error.Success())
self.assertTrue (ivar_value == 3)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test that the Objective-C syntax for dictionary/array literals and indexing works"""
-import os, time
+import lldb_shared
+
import unittest2
+import os, time
import lldb
import platform
import lldbutil
substrs = ["4"])
self.expect("expr -- @((char*)\"Hello world\" + 6)", VARIABLES_DISPLAYED_CORRECTLY,
substrs = ["NSString", "world"])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
optimized it into a register.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.expect('expression self->non_member', error=True,
substrs = ["does not have a member named 'non_member'"])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Use lldb Python API to verify that expression evaluation for property references uses the correct getters and setters
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb, lldbutil
from lldbtest import *
idWithProtocol_error = idWithProtocol_value.GetError()
self.assertTrue (idWithProtocol_error.Success())
self.assertTrue (idWithProtocol_value.GetTypeName() == "id")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test calling functions in static methods with a stripped binary."""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
import lldbutil
from lldbtest import *
self.assertTrue (cmd_value.IsValid())
string_length = cmd_value.GetValueAsUnsigned()
self.assertTrue (string_length == 27, "Got the right value from another class method on the same class.")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test calling functions in static methods."""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
import lldbutil
from lldbtest import *
self.assertTrue (cmd_value.IsValid())
string_length = cmd_value.GetValueAsUnsigned()
self.assertTrue (string_length == 27, "Got the right value from another class method on the same class.")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test stepping through ObjC method dispatch in various forms."""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
import lldbutil
from lldbtest import *
thread.StepInto()
line_number = thread.GetFrameAtIndex(0).GetLineEntry().GetLine()
self.assertTrue (line_number == self.stepped_past_nil_line, "Step in over dispatch to nil stepped over.")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test passing structs to Objective-C methods."""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
import lldbutil
from lldbtest import *
# Now make sure we can call a method that returns a struct without crashing.
cmd_value = frame.EvaluateExpression ("[provider getRange]")
self.assertTrue (cmd_value.IsValid())
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test calling functions in class methods."""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
import lldbutil
from lldbtest import *
# Now make sure we can call a method that returns a struct without crashing.
cmd_value = frame.EvaluateExpression ("[provider getRange]")
self.assertTrue (cmd_value.IsValid())
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test calling methods on super."""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
import lldbutil
from lldbtest import *
cmd_value = frame.EvaluateExpression ("[super get]")
self.assertTrue (cmd_value.IsValid())
self.assertTrue (cmd_value.GetValueAsUnsigned() == 1)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test "print object" where another thread blocks the print object from making progress.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
self.expect("po lock_me", OBJECT_PRINTED_CORRECTLY,
substrs = ['I am pretty special.'])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test that objective-c method returning BOOL works correctly.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
# rdar://problem/9691614
self.runCmd('p (int)[my isValid]')
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test that CoreFoundation classes CFGregorianDate and CFRange are not improperly uniqued
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.expect("frame variable cf_range --raw", substrs = ['location','length'])
# check that printing both does not somehow confuse LLDB
self.expect("frame variable --raw", substrs = ['year','month','day','hour','minute','second','location','length'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test that we do not attempt to make a dynamic type for a 'const char*'
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
# check that expr also gets it right
self.expect("expr my_foolie", substrs = ['FoolMeOnce *'])
self.expect("expr -d run -- my_foolie", substrs = ['FoolMeOnce *'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test that we are able to find out how many children NSWindow has
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.assertTrue(window_dynamic.GetNumChildren() > 1, "NSWindow (dynamic) only has 1 child!")
self.assertTrue(window.GetChildAtIndex(0).IsValid(), "NSWindow (static) has an invalid child")
self.assertTrue(window_dynamic.GetChildAtIndex(0).IsValid(), "NSWindow (dynamic) has an invalid child")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test that types defined in shared libraries work correctly."""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
# Break inside the foo function which takes a bar_ptr argument.
line = line_number('main.m', '// Set breakpoint in main')
lldbutil.run_break_set_by_file_and_line (self, "main.m", line, num_expected_locations=1, loc_exact=True)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
def set_breakpoint(self, line):
lldbutil.run_break_set_by_file_and_line (self, "main.m", line, num_expected_locations=1, loc_exact=True)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
'__builtin_trap' intrinsic, which GCC (4.6) encodes to an illegal opcode.
"""
+import lldb_shared
+
import os
-import unittest2
import lldb
from lldbtest import *
import lldbutil
# evaluate a local
self.expect('p foo', substrs = ['= 5'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
over a thread creation instruction.
"""
+import lldb_shared
+
import os
-import unittest2
import lldb
from lldbtest import *
import lldbutil
# At this point, the inferior process should have exited.
self.assertEqual(process.GetState(), lldb.eStateExited, PROCESS_EXITED)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
from lldbtest import *
import lldbutil
import os
-import unittest2
import sys
def source_type(filename):
+import lldb_shared
+
import lldb
from lldbtest import *
import lldbutil
import os
-import unittest2
import sys
import pexpect
Test lldb logging. This test just makes sure logging doesn't crash, and produces some output.
"""
+import lldb_shared
+
import os, time, string
-import unittest2
import lldb
from lldbtest import *
# check that it is still there
self.assertTrue(string.find(contents, "bacon") == 0)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
-
"""Test that the 'add-dsym', aka 'target symbols add', succeeds in the middle of debug session."""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
import sys
from lldbtest import *
self.expect("frame select",
substrs = ['a.out`main at main.c'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test that clang produces the __apple accelerator tables, for example, __apple_types, correctly.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
from lldbutil import symbol_type_to_str
self.assertTrue(dwarf_section.FindSubSection("__apple_names") and
dwarf_section.FindSubSection("__apple_namespac") and
dwarf_section.FindSubSection("__apple_objc"))
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test stepping and setting breakpoints in indirect and re-exported symbols."""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
import lldbutil
from lldbtest import *
self.assertTrue (len(threads) == 1, "Stopped at breakpoint in reexported function target.")
curr_function = thread.GetFrameAtIndex(0).GetFunctionName()
self.assertTrue (curr_function == "call_through_indirect_hidden", "Stepped into indirect symbols.")
-
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test that debug symbols have the correct order as specified by the order file.
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb
from lldbtest import *
"Symbols have correct order by the order file")
self.runCmd("run", RUN_COMPLETED)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test queues inspection SB APIs."""
-import os, time
+import lldb_shared
+
import unittest2
+import os, time
import lldb
import lldbutil
from lldbtest import *
self.assertTrue(queue_performer_2.GetPendingItemAtIndex(9998).IsValid(), "queue 2's pending item #9998 is valid")
self.assertTrue(queue_performer_2.GetPendingItemAtIndex(9998).GetAddress().GetSymbol().GetName() == "doing_the_work_2", "queue 2's pending item #0 should be doing_the_work_2")
self.assertTrue(queue_performer_2.GetPendingItemAtIndex(9999).IsValid() == False, "queue 2's pending item #9999 is invalid")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test function call thread safety."""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
import lldbutil
from lldbtest import *
def safe_to_call_func_on_select_thread (self, select_thread):
self.assertTrue(select_thread.SafeToCallFunctions() == False, "It is not safe to call functions on the select thread")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test aspects of lldb commands on universal binaries."""
-import os, time
+import lldb_shared
+
import unittest2
+import os, time
import lldb
from lldbtest import *
import lldbutil
substrs = ['Name: eax'])
self.runCmd("continue")
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test SBBreakpoint APIs.
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb, lldbutil
from lldbtest import *
# Finally make sure the original breakpoint is no longer valid.
self.assertTrue (not breakpoint, "Breakpoint we deleted is no longer valid.")
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test SBType APIs to fetch member function types.
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb, lldbutil
from lldbtest import *
self.assertTrue(Thingy.GetMemberFunctionAtIndex(0).GetReturnType().GetName() == "id", "Thingy::init returns an id")
self.assertTrue(Thingy.GetMemberFunctionAtIndex(1).GetNumberOfArguments() == 2, "Thingy::foo takes two arguments")
self.assertTrue(Thingy.GetMemberFunctionAtIndex(1).GetArgumentTypeAtIndex(0).GetName() == "int", "Thingy::foo takes an int")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
after default construction.
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb, lldbutil
from lldbtest import *
# Do fuzz testing on the invalid obj, it should not crash lldb.
import sb_watchpoint
sb_watchpoint.fuzz_obj(obj)
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Use lldb Python API to disassemble raw machine code bytes
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb, lldbutil
from lldbtest import *
self.assertTrue (inst.GetMnemonic(target) == "movq")
self.assertTrue (inst.GetOperands(target) == '%' + "rsp, " + '%' + "rbp")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Use lldb Python API to disassemble raw machine code bytes
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb, lldbutil
from lldbtest import *
print "Disassembled%s" % str(inst)
self.assertTrue (inst.GetMnemonic(target) == "vst1.64")
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb Python event APIs.
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb, lldbutil
from lldbtest import *
# The final judgement. :-)
self.assertTrue(self.state == 'stopped',
"Both expected state changed events received")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test that SBFrame::FindValue finds things but does not duplicate the entire variables list"""
+import lldb_shared
+
import os, sys, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.assertTrue(self.frame.GetVariables(True,True,False,True).GetSize() == 2, "variable count is off after failed FindValue()")
self.assertTrue(self.frame.FindValue("a",lldb.eValueTypeVariableArgument,lldb.eDynamicCanRunTarget).IsValid(), "FindValue() didn't find an argument")
self.assertTrue(self.frame.GetVariables(True,True,False,True).GetSize() == 2, "variable count is off after successful FindValue()")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test Python APIs for working with formatters"""
+import lldb_shared
+
import os, sys, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
if self.TraceOn():
print int_vector
self.assertTrue(int_vector.GetNumChildren() == 0, 'synthetic vector is still empty')
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
import os, time
import re
-import unittest2
import lldb, lldbutil
from lldbtest import *
# The latest two frames should not be equal.
self.assertFalse(frameOutOfC.IsEqual(frameNow))
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Testlldb Python SBFrame APIs IsInlined() and GetFunctionName().
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb, lldbutil
from lldbtest import *
print stack_traces2
self.expect(stack_traces2, "Second stop at %s:%d" % (self.source, self.second_stop), exe=False,
substrs = ['%s:%d' % (self.source, self.second_stop)])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test retrieval of SBAddress from function/symbol, disassembly, and SBAddress APIs.
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb, lldbutil
from lldbtest import *
desc2 = get_description(sa2)
self.assertTrue(desc1 and desc2 and desc1 == desc2,
"SBAddress.GetDescription() API of sa1 and sa2 should return the same string")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test newly added SBSymbol and SBAddress APIs.
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb, lldbutil
from lldbtest import *
if self.TraceOn():
print "UUID:", addr_line1.GetModule().GetUUIDString()
self.assertTrue(addr_line1.GetModule().GetUUIDString() == addr_line2.GetModule().GetUUIDString())
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test Python APIs for target (launch and attach), breakpoint, and process."""
+import lldb_shared
+
import os, sys, time
-import unittest2
import lldb
import time
from lldbtest import *
self.expect(stacktraces, exe=False,
substrs = ['main.c:%d' % self.line2,
'(int)argc=3'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test the SBCommandInterpreter APIs."""
+import lldb_shared
+
import os
-import unittest2
import lldb
from lldbtest import *
if self.TraceOn():
lldbutil.print_stacktraces(process)
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test utility functions for the frame object.
"""
+import lldb_shared
+
import os
-import unittest2
import lldb
from lldbtest import *
lldbutil.print_stacktrace(thread)
print "Current frame: %s" % frame0_args
print "Parent frame: %s" % parent_args
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test the iteration protocol for some lldb container objects.
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb
from lldbtest import *
print frame
self.assertTrue(stopped_due_to_breakpoint)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test the iteration protocol for frame registers.
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb
from lldbtest import *
# We've finished dumping the registers for frame #0.
break
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test SBprocess and SBThread APIs with printing of the stack traces using lldbutil.
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb
from lldbtest import *
stacktraces = lldbutil.print_stacktraces(process, string_buffer=True)
self.expect(stacktraces, exe=False,
substrs = ['(int)argc=3'])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test some SBModule and SBSection APIs.
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb
from lldbtest import *
from lldbutil import symbol_type_to_str
INDENT2 = INDENT * 2
for cu in exe_module.compile_unit_iter():
print cu
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test SBType for ObjC classes.
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb, lldbutil
from lldbtest import *
aBarField = aBarType.GetFieldAtIndex(0)
self.assertTrue(aBarField.GetName() == "_iVar", "The field has the right name")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test SBProcess APIs, including ReadMemory(), WriteMemory(), and others.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbutil import get_stopped_thread, state_type_to_str
from lldbtest import *
num = process.GetNumSupportedHardwareWatchpoints(error)
if self.TraceOn() and error.Success():
print "Number of supported hardware watchpoints: %d" % num
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test Python APIs for process IO."""
+import lldb_shared
+
import os, sys, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
for line in self.lines:
check_line = 'input line to stderr: %s' % (line)
self.assertTrue(check_line in error, "verify stderr line shows up in STDERR")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Check that SBValue.GetValueAsSigned() does the right thing for a 32-bit -1.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.assertTrue(self.frame().FindVariable("myvar").GetValueAsUnsigned() != -1, "GetValueAsUnsigned() does not say -1")
self.assertTrue(self.frame().FindVariable("myvar").GetValueAsUnsigned() == 0xFFFFFFFFFFFFFFFF, "GetValueAsUnsigned() says 0xFFFFFFFFFFFFFFFF")
self.assertTrue(self.frame().FindVariable("myvar").GetValueAsSigned() != 0xFFFFFFFF, "GetValueAsUnsigned() does not say 0xFFFFFFFF")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test the SBData APIs."""
+import lldb_shared
+
import os
-import unittest2
import lldb
from lldbtest import *
from math import fabs
arg,
stream.GetData()))
self.assertTrue(expected == result, "%s(error, %s) == %s != %s" % (func.__name__, arg, result, expected))
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test SBValue::Persist"""
+import lldb_shared
+
import os, sys, time
-import unittest2
import lldb
from lldbtest import *
import lldbutil
self.assertTrue(bazPersist.GetSummary() == '"85"', "bazPersist != 85")
self.expect("expr *(%s)" % (barPersist.GetName()), substrs = ['= 4'])
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test SBSection APIs.
"""
-import unittest2
+import lldb_shared
+
from lldbtest import *
class SectionAPITestCase(TestBase):
self.assertIsNotNone(data_section)
self.assertEquals(data_section.target_byte_size, 1)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test SBProcess APIs, including ReadMemory(), WriteMemory(), and others.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbutil import get_stopped_thread, state_type_to_str
from lldbtest import *
process.Continue()
self.assertTrue(process.state == lldb.eStateExited, "The process should have exited")
self.assertTrue(process.GetExitStatus() == 0, "The process should have returned 0")
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test SBSymbolContext APIs.
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb, lldbutil
from lldbtest import *
symbol = context.GetSymbol()
self.assertTrue(function.GetName() == symbol.GetName() and symbol.GetName() == 'c',
"The symbol name should be 'c'")
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test SBTarget APIs.
"""
+import lldb_shared
+
+import unittest2
import os, time
import re
-import unittest2
import lldb, lldbutil
from lldbtest import *
desc2 = get_description(symbol2)
self.assertTrue(desc1 and desc2 and desc1 == desc2,
"The two addresses should resolve to the same symbol")
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test SBThread APIs.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbutil import get_stopped_thread, get_caller_symbol
from lldbtest import *
thread.RunToAddress(start_addr)
self.runCmd("process status")
#self.runCmd("thread backtrace")
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test SBType and SBTypeList API.
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb, lldbutil
from lldbtest import *
# SBType.GetBasicType() takes an enum 'BasicType' (lldb-enumerations.h).
int_type = id_type.GetBasicType(lldb.eBasicTypeInt)
self.assertTrue(id_type == int_type)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test some SBValue APIs.
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb, lldbutil
from lldbtest import *
val_a = target.EvaluateExpression('a')
self.assertTrue(val_s.GetChildMemberWithName('a').AddressOf(), VALID_VARIABLE)
self.assertTrue(val_a.Cast(val_i.GetType()).AddressOf(), VALID_VARIABLE)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test some SBValue APIs.
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb, lldbutil
from lldbtest import *
self.assertTrue(thread == None, "We should not have managed to hit our second breakpoint with sp == 1")
process.Kill()
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
supports iteration till the end of list is reached.
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb, lldbutil
from lldbtest import *
list.append(int(t.GetChildMemberWithName("id").GetValue()))
self.assertTrue(len(list) == 3)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test SBValue::GetValueDidChange"""
+import lldb_shared
+
import os, sys, time
-import unittest2
import lldb
import time
from lldbtest import *
# Check complex type
self.assertTrue(c.GetChildAtIndex(0).GetChildAtIndex(0).GetValueDidChange() and
not c.GetChildAtIndex(1).GetValueDidChange(), "GetValueDidChange() is saying a lie")
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Use lldb Python SBValue API to create a watchpoint for read_write of 'globl' var.
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb, lldbutil
from lldbtest import *
# At this point, the inferior process should have exited.
self.assertTrue(process.GetState() == lldb.eStateExited, PROCESS_EXITED)
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Use lldb Python SBWatchpoint API to set the ignore count.
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb, lldbutil
from lldbtest import *
self.assertTrue(watchpoint.GetWatchSize() == 4)
self.assertTrue(watchpoint.GetHitCount() == 2)
print watchpoint
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Use lldb Python SBTarget API to iterate on the watchpoint(s) for the target.
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb, lldbutil
from lldbtest import *
self.assertTrue(watchpoint.GetWatchSize() == 4)
self.assertTrue(watchpoint.GetHitCount() == 1)
print watchpoint
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test watchpoint condition API.
"""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
import lldbutil
from lldbtest import *
# Verify that the condition is met.
self.assertTrue(value.GetValueAsUnsigned() == 5)
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Use lldb Python SBValue.WatchPointee() API to create a watchpoint for write of '*g_char_ptr'.
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb, lldbutil
from lldbtest import *
substrs = [self.violating_func])
# This finishes our test.
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Use lldb Python SBtarget.WatchAddress() API to create a watchpoint for write of '*g_char_ptr'.
"""
+import lldb_shared
+
import os, time
import re
-import unittest2
import lldb, lldbutil
from lldbtest import *
self.assertFalse(watchpoint)
self.expect(error.GetCString(), exe=False,
substrs = ['watch size of %d is not supported' % 365])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test lldb settings command.
"""
+import lldb_shared
+
import os, time, re
-import unittest2
import lldb
from lldbtest import *
"target.process.extra-startup-command",
"target.process.thread.step-avoid-regexp",
"target.process.thread.trace-thread"])
-
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test quoting of arguments to lldb commands
"""
+import lldb_shared
+
import os, time, re
-import unittest2
import lldb
from lldbtest import *
self.RemoveTempFile("stdout.txt")
self.assertEqual(output, args_out)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test the caching mechanism of the source manager.
"""
-import unittest2
+import lldb_shared
+
import lldb
from lldbtest import *
import lldbutil
# Display the source code again. We should see the updated line.
self.expect("source list -f main.c -l %d" % self.line, SOURCE_DISPLAYED_CORRECTLY,
substrs = ['Hello lldb'])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test that 'stty -a' displays the same output before and after running the lldb command.
"""
+import lldb_shared
+
import os
-import unittest2
import lldb
from lldbtest import *
if len(tuple[0]) == 0:
break
self.assertTrue(tuple[0] == tuple[1])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test that the lldb-mi driver exits properly.
"""
+import lldb_shared
+
import lldbmi_testcase
from lldbtest import *
-import unittest2
class MiExitTestCase(lldbmi_testcase.MiTestCaseBase):
self.runCmd("q")
import pexpect
self.expect(pexpect.EOF)
-
-if __name__ == '__main__':
- unittest2.main()
Test lldb-mi -file-xxx commands.
"""
+import lldb_shared
+
import lldbmi_testcase
from lldbtest import *
-import unittest2
class MiFileTestCase(lldbmi_testcase.MiTestCaseBase):
path = "unknown_dir/%s" % self.myexe
self.runCmd("-file-exec-and-symbols %s" % path)
self.expect("\^error")
-
-if __name__ == '__main__':
- unittest2.main()
Test lldb-mi -gdb-set and -gdb-show commands.
"""
+import lldb_shared
+
+import unittest2
import lldbmi_testcase
from lldbtest import *
-import unittest2
class MiGdbSetShowTestCase(lldbmi_testcase.MiTestCaseBase):
self.expect("\^done");
self.runCmd("-var-evaluate-expression var_a");
self.expect("\^done,value=\"10\"");
-
-if __name__ == '__main__':
- unittest2.main()
Test lldb-mi =library-loaded notifications.
"""
+import lldb_shared
+
import lldbmi_testcase
from lldbtest import *
-import unittest2
class MiLibraryLoadedTestCase(lldbmi_testcase.MiTestCaseBase):
def add_slashes(x): return x.replace("\\", "\\\\").replace("\"", "\\\"").replace("\'", "\\\'").replace("\0", "\\\0")
self.expect([ "=library-loaded,id=\"%s\",target-name=\"%s\",host-name=\"%s\",symbols-loaded=\"1\",symbols-path=\"%s\",loaded_addr=\"-\",size=\"[0-9]+\"" % (add_slashes(path), add_slashes(path), add_slashes(path), add_slashes(symbols_path)),
"=library-loaded,id=\"%s\",target-name=\"%s\",host-name=\"%s\",symbols-loaded=\"0\",loaded_addr=\"-\",size=\"[0-9]+\"" % (add_slashes(path), add_slashes(path), add_slashes(path)) ])
-
-if __name__ == '__main__':
- unittest2.main()
Test that the lldb-mi driver prints prompt properly.
"""
+import lldb_shared
+
import lldbmi_testcase
from lldbtest import *
-import unittest2
class MiPromptTestCase(lldbmi_testcase.MiTestCaseBase):
# Test that lldb-mi is ready after program exited
self.expect("\*stopped,reason=\"exited-normally\"")
self.expect(self.child_prompt, exactly = True)
-
-if __name__ == '__main__':
- unittest2.main()
Test lldb-mi -break-xxx commands.
"""
+import lldb_shared
+
+import unittest2
import lldbmi_testcase
from lldbtest import *
-import unittest2
class MiBreakTestCase(lldbmi_testcase.MiTestCaseBase):
self.runCmd("-exec-continue")
self.expect("\^running")
self.expect("\*stopped,reason=\"exited-normally\"")
-
-if __name__ == '__main__':
- unittest2.main()
Test lldb-mi -exec-xxx commands.
"""
+import lldb_shared
+
import lldbmi_testcase
from lldbtest import *
-import unittest2
class MiExecTestCase(lldbmi_testcase.MiTestCaseBase):
self.runCmd("-exec-finish --thread 1 --frame 0")
self.expect("\^running")
self.expect("\*stopped,reason=\"end-stepping-range\".+?func=\"main\"")
-
-if __name__ == '__main__':
- unittest2.main()
Test lldb-mi -data-xxx commands.
"""
+import lldb_shared
+
+import unittest2
import lldbmi_testcase
from lldbtest import *
-import unittest2
class MiDataTestCase(lldbmi_testcase.MiTestCaseBase):
# Check 2d array
self.runCmd("-data-evaluate-expression array2d")
self.expect("\^done,value=\"\{\[0\] = \{\[0\] = 1, \[1\] = 2, \[2\] = 3\}, \[1\] = \{\[0\] = 4, \[1\] = 5, \[2\] = 6\}\}\"")
-
-if __name__ == '__main__':
- unittest2.main()
Test lldb-mi can interpret CLI commands directly.
"""
+import lldb_shared
+
import lldbmi_testcase
from lldbtest import *
-import unittest2
class MiCliSupportTestCase(lldbmi_testcase.MiTestCaseBase):
self.expect("\^done")
self.expect("@\"argc=1\\\\r\\\\n")
self.expect("\*stopped,reason=\"exited-normally\"")
-
-if __name__ == '__main__':
- unittest2.main()
Test lldb-mi -interpreter-exec command.
"""
+import lldb_shared
+
import lldbmi_testcase
from lldbtest import *
-import unittest2
class MiInterpreterExecTestCase(lldbmi_testcase.MiTestCaseBase):
self.expect("\^done")
self.expect("@\"argc=1\\\\r\\\\n")
self.expect("\*stopped,reason=\"exited-normally\"")
-
-if __name__ == '__main__':
- unittest2.main()
Base class for lldb-mi test cases.
"""
+import lldb_shared
+
from lldbtest import *
-import unittest2
class MiTestCaseBase(Base):
Test that the lldb-mi handles signals properly.
"""
+import lldb_shared
+
import lldbmi_testcase
from lldbtest import *
-import unittest2
class MiSignalTestCase(lldbmi_testcase.MiTestCaseBase):
# Exit
self.runCmd("-gdb-exit")
self.expect("\^exit")
-
-if __name__ == '__main__':
- unittest2.main()
Test lldb-mi -stack-xxx commands.
"""
+import lldb_shared
+
import lldbmi_testcase
from lldbtest import *
-import unittest2
class MiStackTestCase(lldbmi_testcase.MiTestCaseBase):
# Test that current frame is #0 and it has the same information
self.runCmd("-stack-info-frame")
self.expect("\^done,frame=\{level=\"0\",addr=\"0x[0-9a-f]+\",func=\"main\",file=\"main\.cpp\",fullname=\".+?main\.cpp\",line=\"\d+\"\}")
-
-if __name__ == '__main__':
- unittest2.main()
Test lldb-mi startup options.
"""
+import lldb_shared
+
import lldbmi_testcase
from lldbtest import *
-import unittest2
class MiStartupOptionsTestCase(lldbmi_testcase.MiTestCaseBase):
# Delete log
for f in logFile:
os.remove(f)
-
-if __name__ == '__main__':
- unittest2.main()
Test lldb-mi -symbol-xxx commands.
"""
+import lldb_shared
+
import lldbmi_testcase
from lldbtest import *
-import unittest2
class MiSymbolTestCase(lldbmi_testcase.MiTestCaseBase):
# Test that -symbol-list-lines fails when file doesn't exist
self.runCmd("-symbol-list-lines unknown_dir/main.cpp")
self.expect("\^error,message=\"warning: No source filenames matched 'unknown_dir/main\.cpp'\. error: no source filenames matched any command arguments \"")
-
-if __name__ == '__main__':
- unittest2.main()
Test that the lldb-mi driver understands MI command syntax.
"""
+import lldb_shared
+
import lldbmi_testcase
from lldbtest import *
-import unittest2
class MiSyntaxTestCase(lldbmi_testcase.MiTestCaseBase):
# Test that a process output is wrapped correctly
self.expect("\@\"'\\\\r\\\\n\"")
self.expect("\@\"` - it's \\\\\\\\n\\\\x12\\\\\"\\\\\\\\\\\\\"")
-
-if __name__ == '__main__':
- unittest2.main()
Test lldb-mi -target-xxx commands.
"""
+import lldb_shared
+
import lldbmi_testcase
from lldbtest import *
-import unittest2
class MiTargetTestCase(lldbmi_testcase.MiTestCaseBase):
Test lldb-mi -gdb-set and -gdb-show commands for 'print option-name'.
"""
+import lldb_shared
+
import lldbmi_testcase
from lldbtest import *
-import unittest2
class MiGdbSetShowTestCase(lldbmi_testcase.MiTestCaseBase):
# Test that -gdb-set print aggregate-field-names fails when option is unknown
self.runCmd("-gdb-set print aggregate-field-names unknown")
self.expect("\^error,msg=\"The request ''print' expects option-name and \"on\" or \"off\"' failed.\"")
-
-if __name__ == '__main__':
- unittest2.main()
Test lldb-mi -var-xxx commands.
"""
+import lldb_shared
+
import lldbmi_testcase
from lldbtest import *
-import unittest2
class MiVarTestCase(lldbmi_testcase.MiTestCaseBase):
# Test for std::string
self.runCmd("-var-create - * std_string")
self.expect('\^done,name="var\d+",numchild="[0-9]+",value="\\\\"hello\\\\"",type="std::[\S]*?string",thread-id="1",has_more="0"')
-
-if __name__ == '__main__':
- unittest2.main()
Tests the binary ($x) and hex ($m) memory read packets of the remote stub
"""
+import lldb_shared
+
import os
-import unittest2
import lldb
from lldbtest import *
import lldbutil
process.Continue()
self.assertEqual(process.GetState(), lldb.eStateExited, "Process exited")
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
+import lldb_shared
+
import gdbremote_testcase
import lldbgdbserverutils
-import unittest2
from lldbtest import *
self.build()
self.set_inferior_startup_attach_manually()
self.attach_with_vAttach()
-
-
-if __name__ == '__main__':
- unittest2.main()
-import unittest2
+import lldb_shared
import gdbremote_testcase
from lldbtest import *
self.build()
self.set_inferior_startup_launch()
self.auxv_chunked_reads_work()
-
-
-if __name__ == '__main__':
- unittest2.main()
-import unittest2
+import lldb_shared
import gdbremote_testcase
from lldbtest import *
self.build()
self.set_inferior_startup_launch()
self.stop_notification_contains_sp_register()
-
-
-if __name__ == '__main__':
- unittest2.main()
-import unittest2
+import lldb_shared
import gdbremote_testcase
import lldbgdbserverutils
+import lldb_shared
+
import gdbremote_testcase
import lldbgdbserverutils
import sys
-import unittest2
from lldbtest import *
self.init_llgs_test()
self.build()
self.qProcessInfo_does_not_contain_keys(set(['cputype', 'cpusubtype']))
-
-
-if __name__ == '__main__':
- unittest2.main()
-import unittest2
+import lldb_shared
import gdbremote_testcase
from lldbtest import *
self.build()
self.set_inferior_startup_launch()
self.grp_register_save_restore_works(USE_THREAD_SUFFIX)
-
-
-if __name__ == '__main__':
- unittest2.main()
-import unittest2
+import lldb_shared
import gdbremote_testcase
from lldbtest import *
self.build()
self.set_inferior_startup_launch()
self.single_step_only_steps_one_instruction(use_Hc_packet=True, step_instruction="s")
-
-if __name__ == '__main__':
- unittest2.main()
-import unittest2
+import lldb_shared
import gdbremote_testcase
from lldbtest import *
self.build()
self.set_inferior_startup_launch()
self.stop_reply_reports_correct_threads(5)
-
-
-if __name__ == '__main__':
- unittest2.main()
+import lldb_shared
+
import sys
-import unittest2
+import unittest2
import gdbremote_testcase
from lldbtest import *
self.build()
self.set_inferior_startup_launch()
self.qThreadStopInfo_has_valid_thread_names(self.THREAD_COUNT, "a.out")
-
-
-if __name__ == '__main__':
- unittest2.main()
-import unittest2
+import lldb_shared
import gdbremote_testcase
from lldbtest import *
self.build()
self.set_inferior_startup_launch()
self.single_step_only_steps_one_instruction(use_Hc_packet=False, step_instruction="vCont;s:{thread}")
-
-
-if __name__ == '__main__':
- unittest2.main()
the initial set of tests implemented.
"""
+import lldb_shared
+
+import unittest2
import gdbremote_testcase
import lldbgdbserverutils
import platform
import signal
-import unittest2
from lldbtest import *
class LldbGdbServerTestCase(gdbremote_testcase.GdbRemoteTestCaseBase):
self.build()
self.set_inferior_startup_launch()
self.P_and_p_thread_suffix_work()
-
-
-if __name__ == '__main__':
- unittest2.main()
self.init_llgs_test(use_named_pipe=False)
self.set_inferior_startup_launch()
self.reverse_connect_works()
-
-
-if __name__ == '__main__':
- unittest2.main()
-import unittest2
+import lldb_shared
import gdbremote_testcase
import lldbgdbserverutils
Base class for gdb-remote test cases.
"""
+import lldb_shared
+
import errno
import os
import os.path
import sys
import tempfile
import time
-import unittest2
from lldbtest import *
from lldbgdbserverutils import *
import logging
-import unittest2
+import lldb_shared
import gdbremote_testcase
import signal
-import unittest2
+import lldb_shared
import gdbremote_testcase
import signal
+import lldb_shared
+
+import unittest2
import os.path
import re
import sys
-import unittest2
-
from lldbgdbserverutils import *
except AssertionError:
# okay
return None
-
-if __name__ == '__main__':
- unittest2.main()
Test that variables of integer basic types are displayed correctly.
"""
+import lldb_shared
+
import AbstractBase
-import unittest2
import sys
import lldb
from lldbtest import *
self.build(dictionary=d)
self.setTearDownCleanup(dictionary=d)
self.generic_type_tester(set(['long long']))
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test that variables of floating point types are displayed correctly.
"""
+import lldb_shared
+
import AbstractBase
-import unittest2
import lldb
import sys
from lldbtest import *
def test_double_type_from_block(self):
"""Test that double-type variables are displayed correctly from a block."""
self.build_and_run('double.cpp', set(['double']), bc=True)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test that variable expressions of floating point types are evaluated correctly.
"""
+import lldb_shared
+
import AbstractBase
-import unittest2
import lldb
import sys
from lldbtest import *
def test_double_type_from_block(self):
"""Test that double-type variables are displayed correctly from a block."""
self.build_and_run_expr('double.cpp', set(['double']), bc=True)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test that variables of integer basic types are displayed correctly.
"""
+import lldb_shared
+
import AbstractBase
-import unittest2
import lldb
import sys
from lldbtest import *
def test_unsigned_long_long_type_from_block(self):
"""Test that 'unsigned_long_long'-type variables are displayed correctly from a block."""
self.build_and_run('unsigned_long_long.cpp', set(['unsigned', 'long long']), bc=True)
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test that variable expressions of integer basic types are evaluated correctly.
"""
+import lldb_shared
+
import AbstractBase
-import unittest2
import lldb
import sys
from lldbtest import *
def test_unsigned_long_long_type_from_block(self):
"""Test that 'unsigned_long_long'-type variables are displayed correctly from a block."""
self.build_and_run_expr('unsigned_long_long.cpp', set(['unsigned', 'long long']), bc=True)
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
Test that recursive types are handled correctly.
"""
+import lldb_shared
+
import lldb
import lldbutil
import sys
-import unittest2
from lldbtest import *
class RecursiveTypesTestCase(TestBase):
self.expect("print tpi", RUN_SUCCEEDED)
self.expect("print *tpi", RUN_SUCCEEDED)
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
"""Test that the 'add-dsym', aka 'target symbols add', command informs the user about success or failure."""
+import lldb_shared
+
import os, time
-import unittest2
import lldb
from lldbtest import *
right_path = "%s.dSYM" % exe_name
self.expect("add-dsym " + right_path,
substrs = ['symbol file', 'has been added to'])
-
-
-if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
- unittest2.main()
projects / platform / upstream / llvm.git / commitdiff