This is an archive of the discontinued LLVM Phabricator instance.

Differential D7162

Clean lldb-mi tests using MiTestCaseBase class.
ClosedPublic

Authored by ki.stfu on Jan 24 2015, 4:42 PM.

Details

Reviewers
abidh
zturner
Summary

This patch removes copy-paste from lldb-mi tests and the code easy to read now.

Previously lldb-mi tests were inherited from lldbtest.TestBase class which was designed for lldb tests. At this patch the lldbmi_testcase.MiTestCaseBase class is added to make MI tests's life simpler:

  1. A lot of repetitive code has been removed.
  2. Import list has been cleaned.
  3. Minor changes of the code-style.

Diff Detail

Event Timeline

ki.stfu updated this revision to Diff 18725.Jan 24 2015, 4:42 PM
ki.stfu retitled this revision from to Clean lldb-mi tests using MiTestCaseBase class..
ki.stfu updated this object.
ki.stfu edited the test plan for this revision. (Show Details)
ki.stfu added a reviewer: abidh.
ki.stfu added a subscriber: Unknown Object (MLST).
ki.stfu updated this object.Jan 24 2015, 4:50 PM
ki.stfu added a subscriber: abidh.Jan 25 2015, 2:53 AM
abidh edited edge metadata.Jan 27 2015, 6:40 AM

Looks good to me.

ki.stfu added a comment.Jan 27 2015, 7:38 AM
In D7162#113924, @abidh wrote:

Looks good to me.

Cool! Could you accept this revision and commit it?

abidh added a comment.Jan 27 2015, 10:06 AM

Committed in 227218.

ki.stfu edited edge metadata.Jan 27 2015, 10:13 AM
ki.stfu set the repository for this revision to rL LLVM.
zturner added a subscriber: zturner.Jan 27 2015, 10:29 AM

If you want it to automatically close on commit, you need to put

Differential Revision: http://reviews.llvm.org/D7162

in the commit message. Too late for that now, so instead you can use the combo box right above the comment box that says "Action". The default Action is set to "Comment", but you can change this to "Close Revision".

If you can't find it let me know, and I can do it for you.

ki.stfu added a comment.Jan 27 2015, 10:34 AM

No "Close Revision" type in "Action" select box. Please do it by yourself.

Thanks,
Ilia

zturner accepted this revision.Jan 27 2015, 10:35 AM
zturner added a reviewer: zturner.
This revision is now accepted and ready to land.Jan 27 2015, 10:35 AM
zturner closed this revision.Jan 27 2015, 10:35 AM

Revision Contents

PathSize
test/
tools/
lldb-mi/
208 lines
167 lines
111 lines
181 lines
92 lines
131 lines
74 lines
41 lines

Diff 18725

test/tools/lldb-mi/TestMiBreakpoint.py

Context not available.
Test that the lldb-mi driver understands an MI breakpoint command. Test that the lldb-mi driver understands an MI breakpoint command.
""" """
import os import lldbmi_testcase
from lldbtest import *
import unittest2 import unittest2
import lldb
from lldbtest import *
class MiBreakpointTestCase(TestBase): class MiBreakpointTestCase(lldbmi_testcase.MiTestCaseBase):
mydir = TestBase.compute_mydir(__file__)
myexe = "a.out"
@classmethod
def classCleanup(cls):
"""Cleanup the test byproducts."""
try:
os.remove("child_send.txt")
os.remove("child_read.txt")
os.remove(cls.myexe)
except:
pass
@lldbmi_test @lldbmi_test
@expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows") @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
def test_lldbmi_pendbreakonsym(self): def test_lldbmi_pendbreakonsym(self):
"""Test that 'lldb-mi --interpreter' works for pending symbol breakpoints.""" """Test that 'lldb-mi --interpreter' works for pending symbol breakpoints."""
import pexpect
self.buildDefault()
# So that the child gets torn down after the test. self.spawnLldbMi(args = None)
self.child = pexpect.spawn('%s --interpreter' % (self.lldbMiExec))
child = self.child
child.setecho(True)
# Turn on logging for input/output to/from the child.
with open('child_send.txt', 'w') as f_send:
with open('child_read.txt', 'w') as f_read:
child.logfile_send = f_send
child.logfile_read = f_read
child.sendline("-file-exec-and-symbols " + self.myexe) self.runCmd("-file-exec-and-symbols %s" % self.myexe)
child.expect("\^done") self.expect("\^done")
child.sendline("-break-insert -f a_MyFunction") self.runCmd("-break-insert -f a_MyFunction")
child.expect("\^done,bkpt={number=\"1\"") self.expect("\^done,bkpt={number=\"1\"")
child.sendline("-exec-run") self.runCmd("-exec-run")
child.expect("\^running") self.expect("\^running")
child.expect("\*stopped,reason=\"breakpoint-hit\"") self.expect("\*stopped,reason=\"breakpoint-hit\"")
child.sendline("-exec-continue") self.runCmd("-exec-continue")
child.expect("\^running") self.expect("\^running")
child.expect("\*stopped,reason=\"exited-normally\"") self.expect("\*stopped,reason=\"exited-normally\"")
# Now that the necessary logging is done, restore logfile to None to
# stop further logging.
child.logfile_send = None
child.logfile_read = None
with open('child_send.txt', 'r') as fs:
if self.TraceOn():
print "\n\nContents of child_send.txt:"
print fs.read()
with open('child_read.txt', 'r') as fr:
from_child = fr.read()
if self.TraceOn():
print "\n\nContents of child_read.txt:"
print from_child
self.expect(from_child, exe=False,
substrs = ["breakpoint-hit"])
@lldbmi_test @lldbmi_test
@expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows") @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
def test_lldbmi_pendbreakonsrc(self): def test_lldbmi_pendbreakonsrc(self):
"""Test that 'lldb-mi --interpreter' works for pending source breakpoints.""" """Test that 'lldb-mi --interpreter' works for pending source breakpoints."""
import pexpect
self.buildDefault()
# So that the child gets torn down after the test. self.spawnLldbMi(args = None)
self.child = pexpect.spawn('%s --interpreter' % (self.lldbMiExec))
child = self.child
child.setecho(True)
# Turn on logging for input/output to/from the child.
with open('child_send.txt', 'w') as f_send:
with open('child_read.txt', 'w') as f_read:
child.logfile_send = f_send
child.logfile_read = f_read
child.sendline("-file-exec-and-symbols " + self.myexe) self.runCmd("-file-exec-and-symbols %s" % self.myexe)
child.expect("\^done") self.expect("\^done")
# Find the line number to break inside main() and set # Find the line number to break inside main() and set
# pending BP. # pending BP.
self.line = line_number('main.c', '//BP_source') line = line_number('main.c', '//BP_source')
child.sendline("-break-insert -f main.c:%d" % self.line) self.runCmd("-break-insert -f main.c:%d" % line)
child.expect("\^done,bkpt={number=\"1\"") self.expect("\^done,bkpt={number=\"1\"")
child.sendline("-exec-run") self.runCmd("-exec-run")
child.expect("\^running") self.expect("\^running")
child.expect("\*stopped,reason=\"breakpoint-hit\"") self.expect("\*stopped,reason=\"breakpoint-hit\"")
child.sendline("-exec-continue") self.runCmd("-exec-continue")
child.expect("\^running") self.expect("\^running")
child.expect("\*stopped,reason=\"exited-normally\"") self.expect("\*stopped,reason=\"exited-normally\"")
# Now that the necessary logging is done, restore logfile to None to
# stop further logging.
child.logfile_send = None
child.logfile_read = None
with open('child_send.txt', 'r') as fs:
if self.TraceOn():
print "\n\nContents of child_send.txt:"
print fs.read()
with open('child_read.txt', 'r') as fr:
from_child = fr.read()
if self.TraceOn():
print "\n\nContents of child_read.txt:"
print from_child
self.expect(from_child, exe=False,
substrs = ["breakpoint-hit"])
@lldbmi_test @lldbmi_test
@expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows") @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
def test_lldbmi_breakpoints(self): def test_lldbmi_breakpoints(self):
"""Test that 'lldb-mi --interpreter' works for breakpoints.""" """Test that 'lldb-mi --interpreter' works for breakpoints."""
import pexpect
self.buildDefault()
# So that the child gets torn down after the test. self.spawnLldbMi(args = None)
self.child = pexpect.spawn('%s --interpreter' % (self.lldbMiExec))
child = self.child
child.setecho(True)
# Turn on logging for input/output to/from the child.
with open('child_send.txt', 'w') as f_send:
with open('child_read.txt', 'w') as f_read:
child.logfile_send = f_send
child.logfile_read = f_read
child.sendline("-file-exec-and-symbols " + self.myexe) self.runCmd("-file-exec-and-symbols %s" % self.myexe)
child.expect("\^done") self.expect("\^done")
child.sendline("-break-insert -f main") self.runCmd("-break-insert -f main")
child.expect("\^done,bkpt={number=\"1\"") self.expect("\^done,bkpt={number=\"1\"")
child.sendline("-exec-run") self.runCmd("-exec-run")
child.expect("\^running") self.expect("\^running")
child.expect("\*stopped,reason=\"breakpoint-hit\"") self.expect("\*stopped,reason=\"breakpoint-hit\"")
#break on symbol #break on symbol
child.sendline("-break-insert a_MyFunction") self.runCmd("-break-insert a_MyFunction")
child.expect("\^done,bkpt={number=\"2\"") self.expect("\^done,bkpt={number=\"2\"")
child.sendline("-exec-continue") self.runCmd("-exec-continue")
child.expect("\^running") self.expect("\^running")
child.expect("\*stopped,reason=\"breakpoint-hit\"") self.expect("\*stopped,reason=\"breakpoint-hit\"")
#break on source #break on source
self.line = line_number('main.c', '//BP_source') line = line_number('main.c', '//BP_source')
child.sendline("-break-insert main.c:%d" % self.line) self.runCmd("-break-insert main.c:%d" % line)
child.expect("\^done,bkpt={number=\"3\"") self.expect("\^done,bkpt={number=\"3\"")
child.sendline("-exec-continue") self.runCmd("-exec-continue")
child.expect("\^running") self.expect("\^running")
child.expect("\*stopped,reason=\"breakpoint-hit\"") self.expect("\*stopped,reason=\"breakpoint-hit\"")
#run to exit #run to exit
child.sendline("-exec-continue") self.runCmd("-exec-continue")
child.expect("\^running") self.expect("\^running")
child.expect("\*stopped,reason=\"exited-normally\"") self.expect("\*stopped,reason=\"exited-normally\"")
# Now that the necessary logging is done, restore logfile to None to
# stop further logging.
child.logfile_send = None
child.logfile_read = None
with open('child_send.txt', 'r') as fs:
if self.TraceOn():
print "\n\nContents of child_send.txt:"
print fs.read()
with open('child_read.txt', 'r') as fr:
from_child = fr.read()
if self.TraceOn():
print "\n\nContents of child_read.txt:"
print from_child
self.expect(from_child, exe=False,
substrs = ["breakpoint-hit"])
if __name__ == '__main__': if __name__ == '__main__':
import atexit
lldb.SBDebugger.Initialize()
atexit.register(lambda: lldb.SBDebugger.Terminate())
unittest2.main() unittest2.main()
Context not available.

test/tools/lldb-mi/TestMiEvaluate.py

Context not available.
Test that the lldb-mi driver can evaluate expressions. Test that the lldb-mi driver can evaluate expressions.
""" """
import os import lldbmi_testcase
from lldbtest import *
import unittest2 import unittest2
import lldb
from lldbtest import *
class MiEvaluateTestCase(TestBase): class MiEvaluateTestCase(lldbmi_testcase.MiTestCaseBase):
mydir = TestBase.compute_mydir(__file__)
myexe = "a.out"
@classmethod
def classCleanup(cls):
"""Cleanup the test byproducts."""
try:
os.remove("child_send.txt")
os.remove("child_read.txt")
os.remove(cls.myexe)
except:
pass
@lldbmi_test @lldbmi_test
@expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows") @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
def test_lldbmi_eval(self): def test_lldbmi_eval(self):
"""Test that 'lldb-mi --interpreter' works for evaluating.""" """Test that 'lldb-mi --interpreter' works for evaluating."""
import pexpect
self.buildDefault()
# So that the child gets torn down after the test. self.spawnLldbMi(args = None)
self.child = pexpect.spawn('%s --interpreter' % (self.lldbMiExec))
child = self.child
child.setecho(True)
# Turn on logging for input/output to/from the child.
with open('child_send.txt', 'w') as f_send:
with open('child_read.txt', 'w') as f_read:
child.logfile_send = f_send
child.logfile_read = f_read
child.sendline("-file-exec-and-symbols " + self.myexe) self.runCmd("-file-exec-and-symbols %s" % self.myexe)
child.expect("\^done") self.expect("\^done")
#run to main #run to main
child.sendline("-break-insert -f main") self.runCmd("-break-insert -f main")
child.expect("\^done,bkpt={number=\"1\"") self.expect("\^done,bkpt={number=\"1\"")
child.sendline("-exec-run") self.runCmd("-exec-run")
child.expect("\^running") self.expect("\^running")
child.expect("\*stopped,reason=\"breakpoint-hit\"") self.expect("\*stopped,reason=\"breakpoint-hit\"")
#run to program return (marked BP_source) #run to program return (marked BP_source)
self.line = line_number('main.c', '//BP_source') line = line_number('main.c', '//BP_source')
child.sendline("-break-insert main.c:%d" % self.line) self.runCmd("-break-insert main.c:%d" % line)
child.expect("\^done,bkpt={number=\"2\"") self.expect("\^done,bkpt={number=\"2\"")
child.sendline("-exec-continue") self.runCmd("-exec-continue")
child.expect("\^running") self.expect("\^running")
child.expect("\*stopped,reason=\"breakpoint-hit\"") self.expect("\*stopped,reason=\"breakpoint-hit\"")
#print non-existant variable #print non-existant variable
#child.sendline("-var-create var1 --thread 1 --frame 0 * undef") #FIXME: shows undef as {...} #self.runCmd("-var-create var1 --thread 1 --frame 0 * undef") #FIXME: shows undef as {...}
#child.expect("error") #self.expect("error")
#child.sendline("-data-evaluate-expression undef") #FIXME: gets value="undef" #self.runCmd("-data-evaluate-expression undef") #FIXME: gets value="undef"
#child.expect("error") #self.expect("error")
#print global "g_MyVar" #print global "g_MyVar"
child.sendline("-var-create var1 --thread 1 --frame 0 * g_MyVar") #FIXME: shows name=<unnamedvariable>" self.runCmd("-var-create var1 --thread 1 --frame 0 * g_MyVar") #FIXME: shows name=<unnamedvariable>"
child.expect("value=\"3\",type=\"int\"") self.expect("value=\"3\",type=\"int\"")
#child.sendline("-var-evaluate-expression var1") #FIXME: gets var1 does not exist #self.runCmd("-var-evaluate-expression var1") #FIXME: gets var1 does not exist
child.sendline("-var-show-attributes var1") self.runCmd("-var-show-attributes var1")
child.expect("status=\"editable\"") self.expect("status=\"editable\"")
child.sendline("-var-delete var1") self.runCmd("-var-delete var1")
child.expect("\^done") self.expect("\^done")
child.sendline("-var-create var1 --thread 1 --frame 0 * g_MyVar") self.runCmd("-var-create var1 --thread 1 --frame 0 * g_MyVar")
child.expect("value=\"3\",type=\"int\"") self.expect("value=\"3\",type=\"int\"")
#print static "s_MyVar" and modify #print static "s_MyVar" and modify
child.sendline("-data-evaluate-expression s_MyVar") self.runCmd("-data-evaluate-expression s_MyVar")
child.expect("value=\"30\"") self.expect("value=\"30\"")
child.sendline("-var-create var3 --thread 1 --frame 0 * \"s_MyVar=3\"") self.runCmd("-var-create var3 --thread 1 --frame 0 * \"s_MyVar=3\"")
child.expect("value=\"3\",type=\"int\"") self.expect("value=\"3\",type=\"int\"")
child.sendline("-data-evaluate-expression \"s_MyVar=30\"") self.runCmd("-data-evaluate-expression \"s_MyVar=30\"")
child.expect("value=\"30\"") self.expect("value=\"30\"")
#print local "b" and modify #print local "b" and modify
child.sendline("-data-evaluate-expression b") self.runCmd("-data-evaluate-expression b")
child.expect("value=\"20\"") self.expect("value=\"20\"")
child.sendline("-var-create var3 --thread 1 --frame 0 * \"b=3\"") self.runCmd("-var-create var3 --thread 1 --frame 0 * \"b=3\"")
child.expect("value=\"3\",type=\"int\"") self.expect("value=\"3\",type=\"int\"")
child.sendline("-data-evaluate-expression \"b=20\"") self.runCmd("-data-evaluate-expression \"b=20\"")
child.expect("value=\"20\"") self.expect("value=\"20\"")
#print "a + b" #print "a + b"
child.sendline("-data-evaluate-expression \"a + b\"") self.runCmd("-data-evaluate-expression \"a + b\"")
child.expect("value=\"30\"") self.expect("value=\"30\"")
child.sendline("-var-create var3 --thread 1 --frame 0 * \"a + b\"") self.runCmd("-var-create var3 --thread 1 --frame 0 * \"a + b\"")
child.expect("value=\"30\",type=\"int\"") self.expect("value=\"30\",type=\"int\"")
#print "argv[0]" #print "argv[0]"
child.sendline("-data-evaluate-expression \"argv[0]\"") self.runCmd("-data-evaluate-expression \"argv[0]\"")
child.expect("value=\"0x") self.expect("value=\"0x")
child.sendline("-var-create var3 --thread 1 --frame 0 * \"argv[0]\"") self.runCmd("-var-create var3 --thread 1 --frame 0 * \"argv[0]\"")
child.expect("numchild=\"1\",value=\"0x.*\",type=\"const char \*\"") self.expect("numchild=\"1\",value=\"0x.*\",type=\"const char \*\"")
#run to exit #run to exit
child.sendline("-exec-continue") self.runCmd("-exec-continue")
child.expect("\^running") self.expect("\^running")
child.expect("\*stopped,reason=\"exited-normally\"") self.expect("\*stopped,reason=\"exited-normally\"")
# Now that the necessary logging is done, restore logfile to None to
# stop further logging.
child.logfile_send = None
child.logfile_read = None
with open('child_send.txt', 'r') as fs:
if self.TraceOn():
print "\n\nContents of child_send.txt:"
print fs.read()
with open('child_read.txt', 'r') as fr:
from_child = fr.read()
if self.TraceOn():
print "\n\nContents of child_read.txt:"
print from_child
if __name__ == '__main__': if __name__ == '__main__':
import atexit
lldb.SBDebugger.Initialize()
atexit.register(lambda: lldb.SBDebugger.Terminate())
unittest2.main() unittest2.main()
Context not available.

test/tools/lldb-mi/TestMiInterrupt.py

Context not available.
Test that the lldb-mi driver can interrupt and resume a looping app. Test that the lldb-mi driver can interrupt and resume a looping app.
""" """
import os import lldbmi_testcase
from lldbtest import *
import unittest2 import unittest2
import lldb
from lldbtest import *
class MiInterruptTestCase(TestBase): class MiInterruptTestCase(lldbmi_testcase.MiTestCaseBase):
mydir = TestBase.compute_mydir(__file__) @lldbmi_test
myexe = "a.out"
@classmethod
def classCleanup(cls):
"""Cleanup the test byproducts."""
try:
os.remove("child_send.txt")
os.remove("child_read.txt")
os.remove(cls.myexe)
except:
pass
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin") @unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin")
@expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows") @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
@lldbmi_test
def test_lldbmi_interrupt(self): def test_lldbmi_interrupt(self):
"""Test that 'lldb-mi --interpreter' interrupt and resume a looping app.""" """Test that 'lldb-mi --interpreter' interrupt and resume a looping app."""
import pexpect
self.buildDefault()
# So that the child gets torn down after the test. self.spawnLldbMi(args = None)
self.child = pexpect.spawn('%s --interpreter' % (self.lldbMiExec))
child = self.child
child.setecho(True)
# Turn on logging for input/output to/from the child.
with open('child_send.txt', 'w') as f_send:
with open('child_read.txt', 'w') as f_read:
child.logfile_send = f_send
child.logfile_read = f_read
child.sendline("-file-exec-and-symbols " + self.myexe) self.runCmd("-file-exec-and-symbols %s" % self.myexe)
child.expect("\^done") self.expect("\^done")
#run to main #run to main
child.sendline("-break-insert -f main") self.runCmd("-break-insert -f main")
child.expect("\^done,bkpt={number=\"1\"") self.expect("\^done,bkpt={number=\"1\"")
child.sendline("-exec-run") self.runCmd("-exec-run")
child.expect("\^running") self.expect("\^running")
child.expect("\*stopped,reason=\"breakpoint-hit\"") self.expect("\*stopped,reason=\"breakpoint-hit\"")
#set doloop=1 and run (to loop forever) #set doloop=1 and run (to loop forever)
child.sendline("-data-evaluate-expression \"doloop=1\"") self.runCmd("-data-evaluate-expression \"doloop=1\"")
child.expect("value=\"1\"") self.expect("value=\"1\"")
child.sendline("-exec-continue") self.runCmd("-exec-continue")
child.expect("\^running") self.expect("\^running")
#issue interrupt, set BP in loop (marked BP_loop), and resume #issue interrupt, set BP in loop (marked BP_loop), and resume
child.sendline("-exec-interrupt") self.runCmd("-exec-interrupt")
child.expect("\*stopped,reason=\"signal-received\"") self.expect("\*stopped,reason=\"signal-received\"")
self.line = line_number('loop.c', '//BP_loop') line = line_number('loop.c', '//BP_loop')
child.sendline("-break-insert loop.c:%d" % self.line) self.runCmd("-break-insert loop.c:%d" % line)
child.expect("\^done,bkpt={number=\"2\"") self.expect("\^done,bkpt={number=\"2\"")
#child.sendline("-exec-resume") #FIXME: command not recognized #self.runCmd("-exec-resume") #FIXME: command not recognized
child.sendline("-exec-continue") self.runCmd("-exec-continue")
child.expect("\*stopped,reason=\"breakpoint-hit\"") self.expect("\*stopped,reason=\"breakpoint-hit\"")
#we should have hit BP #we should have hit BP
#set loop=-1 so we'll exit the loop #set loop=-1 so we'll exit the loop
child.sendline("-data-evaluate-expression \"loop=-1\"") self.runCmd("-data-evaluate-expression \"loop=-1\"")
child.expect("value=\"-1\"") self.expect("value=\"-1\"")
child.sendline("-exec-continue") self.runCmd("-exec-continue")
child.expect("\^running") self.expect("\^running")
child.expect("\*stopped,reason=\"exited-normally\"") self.expect("\*stopped,reason=\"exited-normally\"")
# Now that the necessary logging is done, restore logfile to None to
# stop further logging.
child.logfile_send = None
child.logfile_read = None
with open('child_send.txt', 'r') as fs:
if self.TraceOn():
print "\n\nContents of child_send.txt:"
print fs.read()
with open('child_read.txt', 'r') as fr:
from_child = fr.read()
if self.TraceOn():
print "\n\nContents of child_read.txt:"
print from_child
if __name__ == '__main__': if __name__ == '__main__':
import atexit
lldb.SBDebugger.Initialize()
atexit.register(lambda: lldb.SBDebugger.Terminate())
unittest2.main() unittest2.main()
Context not available.

test/tools/lldb-mi/TestMiLaunch.py

Context not available.
Test various ways the lldb-mi driver can launch a program. Test various ways the lldb-mi driver can launch a program.
""" """
import os import lldbmi_testcase
from lldbtest import *
import unittest2 import unittest2
import lldb
from lldbtest import *
class MiLaunchTestCase(TestBase): class MiLaunchTestCase(lldbmi_testcase.MiTestCaseBase):
mydir = TestBase.compute_mydir(__file__)
myexe = "a.out"
@classmethod
def classCleanup(cls):
"""Cleanup the test byproducts."""
try:
os.remove("child_send.txt")
os.remove("child_read.txt")
os.remove(cls.myexe)
except:
pass
@lldbmi_test @lldbmi_test
@expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows") @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
def test_lldbmi_exe(self): def test_lldbmi_exe(self):
"""Test that 'lldb-mi --interpreter' works for -file-exec-and-symbols exe.""" """Test that 'lldb-mi --interpreter' works for -file-exec-and-symbols exe."""
import pexpect
self.buildDefault()
# So that the child gets torn down after the test. self.spawnLldbMi(args = None)
self.child = pexpect.spawn('%s --interpreter' % (self.lldbMiExec))
child = self.child
child.setecho(True)
# Turn on logging for input/output to/from the child.
with open('child_send.txt', 'w') as f_send:
with open('child_read.txt', 'w') as f_read:
child.logfile_send = f_send
child.logfile_read = f_read
#use no path #use no path
child.sendline("-file-exec-and-symbols " + self.myexe) self.runCmd("-file-exec-and-symbols %s" % self.myexe)
child.expect("\^done") self.expect("\^done")
child.sendline("-exec-run") self.runCmd("-exec-run")
child.expect("\^running") self.expect("\^running")
child.expect("\*stopped,reason=\"exited-normally\"") self.expect("\*stopped,reason=\"exited-normally\"")
# Now that the necessary logging is done, restore logfile to None to
# stop further logging.
child.logfile_send = None
child.logfile_read = None
with open('child_send.txt', 'r') as fs:
if self.TraceOn():
print "\n\nContents of child_send.txt:"
print fs.read()
with open('child_read.txt', 'r') as fr:
from_child = fr.read()
if self.TraceOn():
print "\n\nContents of child_read.txt:"
print from_child
@lldbmi_test @lldbmi_test
@expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows") @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
def test_lldbmi_abspathexe(self): def test_lldbmi_abspathexe(self):
"""Test that 'lldb-mi --interpreter' works for -file-exec-and-symbols fullpath/exe.""" """Test that 'lldb-mi --interpreter' works for -file-exec-and-symbols fullpath/exe."""
import pexpect
self.buildDefault()
# So that the child gets torn down after the test. self.spawnLldbMi(args = None)
self.child = pexpect.spawn('%s --interpreter' % (self.lldbMiExec))
child = self.child
child.setecho(True)
# Turn on logging for input/output to/from the child.
with open('child_send.txt', 'w') as f_send:
with open('child_read.txt', 'w') as f_read:
child.logfile_send = f_send
child.logfile_read = f_read
#use full path #use full path
exe = os.path.join(os.getcwd(), "a.out") import os
child.sendline("-file-exec-and-symbols " + exe) exe = os.path.join(os.getcwd(), self.myexe)
child.expect("\^done") self.runCmd("-file-exec-and-symbols %s" % exe)
self.expect("\^done")
child.sendline("-exec-run") self.runCmd("-exec-run")
child.expect("\^running") self.expect("\^running")
child.expect("\*stopped,reason=\"exited-normally\"") self.expect("\*stopped,reason=\"exited-normally\"")
# Now that the necessary logging is done, restore logfile to None to
# stop further logging.
child.logfile_send = None
child.logfile_read = None
with open('child_send.txt', 'r') as fs:
if self.TraceOn():
print "\n\nContents of child_send.txt:"
print fs.read()
with open('child_read.txt', 'r') as fr:
from_child = fr.read()
if self.TraceOn():
print "\n\nContents of child_read.txt:"
print from_child
@lldbmi_test @lldbmi_test
@expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows") @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
def test_lldbmi_relpathexe(self): def test_lldbmi_relpathexe(self):
"""Test that 'lldb-mi --interpreter' works for -file-exec-and-symbols relpath/exe.""" """Test that 'lldb-mi --interpreter' works for -file-exec-and-symbols relpath/exe."""
import pexpect
self.buildDefault()
# So that the child gets torn down after the test. self.spawnLldbMi(args = None)
self.child = pexpect.spawn('%s --interpreter' % (self.lldbMiExec))
child = self.child
child.setecho(True)
# Turn on logging for input/output to/from the child.
with open('child_send.txt', 'w') as f_send:
with open('child_read.txt', 'w') as f_read:
child.logfile_send = f_send
child.logfile_read = f_read
#use relative path #use relative path
exe = "../../" + self.mydir + "/" + self.myexe exe = "../../" + self.mydir + "/" + self.myexe
child.sendline("-file-exec-and-symbols " + exe) self.runCmd("-file-exec-and-symbols %s" % exe)
child.expect("\^done") self.expect("\^done")
child.sendline("-exec-run") self.runCmd("-exec-run")
child.expect("\^running") self.expect("\^running")
child.expect("\*stopped,reason=\"exited-normally\"") self.expect("\*stopped,reason=\"exited-normally\"")
# Now that the necessary logging is done, restore logfile to None to
# stop further logging.
child.logfile_send = None
child.logfile_read = None
with open('child_send.txt', 'r') as fs:
if self.TraceOn():
print "\n\nContents of child_send.txt:"
print fs.read()
with open('child_read.txt', 'r') as fr:
from_child = fr.read()
if self.TraceOn():
print "\n\nContents of child_read.txt:"
print from_child
@lldbmi_test @lldbmi_test
@expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows") @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
def test_lldbmi_badpathexe(self): def test_lldbmi_badpathexe(self):
"""Test that 'lldb-mi --interpreter' works for -file-exec-and-symbols badpath/exe.""" """Test that 'lldb-mi --interpreter' works for -file-exec-and-symbols badpath/exe."""
import pexpect
self.buildDefault()
# So that the child gets torn down after the test. self.spawnLldbMi(args = None)
self.child = pexpect.spawn('%s --interpreter' % (self.lldbMiExec))
child = self.child
child.setecho(True)
# Turn on logging for input/output to/from the child.
with open('child_send.txt', 'w') as f_send:
with open('child_read.txt', 'w') as f_read:
child.logfile_send = f_send
child.logfile_read = f_read
#use non-existant path #use non-existant path
exe = "badpath/" + self.myexe exe = "badpath/" + self.myexe
child.sendline("-file-exec-and-symbols " + exe) self.runCmd("-file-exec-and-symbols %s" % exe)
child.expect("\^error") self.expect("\^error")
# Now that the necessary logging is done, restore logfile to None to
# stop further logging.
child.logfile_send = None
child.logfile_read = None
with open('child_send.txt', 'r') as fs:
if self.TraceOn():
print "\n\nContents of child_send.txt:"
print fs.read()
with open('child_read.txt', 'r') as fr:
from_child = fr.read()
if self.TraceOn():
print "\n\nContents of child_read.txt:"
print from_child
if __name__ == '__main__': if __name__ == '__main__':
import atexit
lldb.SBDebugger.Initialize()
atexit.register(lambda: lldb.SBDebugger.Terminate())
unittest2.main() unittest2.main()
Context not available.

test/tools/lldb-mi/TestMiProgramArgs.py

Context not available.
Test that the lldb-mi driver can pass arguments to the app. Test that the lldb-mi driver can pass arguments to the app.
""" """
import os import lldbmi_testcase
from lldbtest import *
import unittest2 import unittest2
import lldb
from lldbtest import *
class MiProgramArgsTestCase(TestBase): class MiProgramArgsTestCase(lldbmi_testcase.MiTestCaseBase):
mydir = TestBase.compute_mydir(__file__) @lldbmi_test
myexe = "a.out"
@classmethod
def classCleanup(cls):
"""Cleanup the test byproducts."""
try:
os.remove("child_send.txt")
os.remove("child_read.txt")
os.remove(cls.myexe)
except:
pass
@unittest2.skip("lldb-mi can't pass params to app.") @unittest2.skip("lldb-mi can't pass params to app.")
@lldbmi_test
@expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows") @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
def test_lldbmi_paramargs(self): def test_lldbmi_paramargs(self):
"""Test that 'lldb-mi --interpreter' can pass arguments to the app.""" """Test that 'lldb-mi --interpreter' can pass arguments to the app."""
import pexpect
self.buildDefault()
# So that the child gets torn down after the test. self.spawnLldbMi(args = None)
self.child = pexpect.spawn('%s --interpreter' % (self.lldbMiExec))
child = self.child
child.setecho(True)
# Turn on logging for input/output to/from the child.
with open('child_send.txt', 'w') as f_send:
with open('child_read.txt', 'w') as f_read:
child.logfile_send = f_send
child.logfile_read = f_read
child.sendline("-file-exec-and-symbols " + self.myexe) self.runCmd("-file-exec-and-symbols %s" % self.myexe)
child.expect("\^done") self.expect("\^done")
child.sendline("settings set target.run-args l") #FIXME: args not passed self.runCmd("settings set target.run-args l") #FIXME: args not passed
#child.sendline("-exec-arguments l") #FIXME: not recognized and hung lldb-mi #self.runCmd("-exec-arguments l") #FIXME: not recognized and hung lldb-mi
#run to main #run to main
child.sendline("-break-insert -f main") self.runCmd("-break-insert -f main")
child.expect("\^done,bkpt={number=\"1\"") self.expect("\^done,bkpt={number=\"1\"")
child.sendline("-exec-run") self.runCmd("-exec-run")
child.expect("\^running") self.expect("\^running")
child.expect("\*stopped,reason=\"breakpoint-hit\"") self.expect("\*stopped,reason=\"breakpoint-hit\"")
#check argc to see if arg passed #check argc to see if arg passed
child.sendline("-data-evaluate-expression argc") self.runCmd("-data-evaluate-expression argc")
child.expect("value=\"2\"") self.expect("value=\"2\"")
#set BP on code which is only executed if "l" was passed correctly (marked BP_argtest) #set BP on code which is only executed if "l" was passed correctly (marked BP_argtest)
self.line = line_number('main.c', '//BP_argtest') line = line_number('main.c', '//BP_argtest')
child.sendline("-break-insert main.c:%d" % self.line) self.runCmd("-break-insert main.c:%d" % line)
child.expect("\^done,bkpt={number=\"2\"") self.expect("\^done,bkpt={number=\"2\"")
child.sendline("-exec-continue") self.runCmd("-exec-continue")
child.expect("\^running") self.expect("\^running")
child.expect("\*stopped,reason=\"breakpoint-hit\"") self.expect("\*stopped,reason=\"breakpoint-hit\"")
# Now that the necessary logging is done, restore logfile to None to
# stop further logging.
child.logfile_send = None
child.logfile_read = None
with open('child_send.txt', 'r') as fs:
if self.TraceOn():
print "\n\nContents of child_send.txt:"
print fs.read()
with open('child_read.txt', 'r') as fr:
from_child = fr.read()
if self.TraceOn():
print "\n\nContents of child_read.txt:"
print from_child
if __name__ == '__main__': if __name__ == '__main__':
import atexit
lldb.SBDebugger.Initialize()
atexit.register(lambda: lldb.SBDebugger.Terminate())
unittest2.main() unittest2.main()
Context not available.

test/tools/lldb-mi/TestMiStack.py

Context not available.
Test that the lldb-mi driver works with -stack-xxx commands Test that the lldb-mi driver works with -stack-xxx commands
""" """
import os import lldbmi_testcase
from lldbtest import *
import unittest2 import unittest2
import lldb
from lldbtest import *
class MiStackTestCase(TestBase): class MiStackTestCase(lldbmi_testcase.MiTestCaseBase):
mydir = TestBase.compute_mydir(__file__)
myexe = "a.out"
@classmethod
def classCleanup(cls):
"""Cleanup the test byproducts."""
try:
os.remove("child_send.txt")
os.remove("child_read.txt")
os.remove(cls.myexe)
except:
pass
@lldbmi_test @lldbmi_test
@expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows") @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
def test_lldbmi_stackargs(self): def test_lldbmi_stackargs(self):
"""Test that 'lldb-mi --interpreter' can shows arguments.""" """Test that 'lldb-mi --interpreter' can shows arguments."""
import pexpect
self.buildDefault()
# So that the child gets torn down after the test. self.spawnLldbMi(args = None)
self.child = pexpect.spawn('%s --interpreter' % (self.lldbMiExec))
child = self.child
child.setecho(True)
# Turn on logging for input/output to/from the child.
with open('child_send.txt', 'w') as f_send:
with open('child_read.txt', 'w') as f_read:
child.logfile_send = f_send
child.logfile_read = f_read
# Load executable # Load executable
child.sendline("-file-exec-and-symbols %s" % (self.myexe)) self.runCmd("-file-exec-and-symbols %s" % self.myexe)
child.expect("\^done") self.expect("\^done")
# Run to main # Run to main
child.sendline("-break-insert -f main") self.runCmd("-break-insert -f main")
child.expect("\^done,bkpt={number=\"1\"") self.expect("\^done,bkpt={number=\"1\"")
child.sendline("-exec-run") self.runCmd("-exec-run")
child.expect("\^running") self.expect("\^running")
child.expect("\*stopped,reason=\"breakpoint-hit\"") self.expect("\*stopped,reason=\"breakpoint-hit\"")
# Test arguments # Test arguments
child.sendline("-stack-list-arguments 0") #self.runCmd("-stack-list-arguments 0") #FIXME: --no-values doesn't work
child.expect("\^done,stack-args=\[frame={level=\"0\",args=\[{name=\"argc\",value=\"1\"},{name=\"argv\",value=\".*\"}\]}") #self.expect("\^done,stack-args=\[frame={level=\"0\",args=\[name=\"argc\",name=\"argv\"\]}")
self.runCmd("-stack-list-arguments 1")
self.expect("\^done,stack-args=\[frame={level=\"0\",args=\[{name=\"argc\",value=\"1\"},{name=\"argv\",value=\".*\"}\]}")
# Now that the necessary logging is done, restore logfile to None to
# stop further logging.
child.logfile_send = None
child.logfile_read = None
with open('child_send.txt', 'r') as fs:
if self.TraceOn():
print "\n\nContents of child_send.txt:"
print fs.read()
with open('child_read.txt', 'r') as fr:
from_child = fr.read()
if self.TraceOn():
print "\n\nContents of child_read.txt:"
print from_child
@lldbmi_test @lldbmi_test
@expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows") @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
def test_lldbmi_locals(self): def test_lldbmi_locals(self):
"""Test that 'lldb-mi --interpreter' can shows local variables.""" """Test that 'lldb-mi --interpreter' can shows local variables."""
import pexpect
self.buildDefault()
# So that the child gets torn down after the test. self.spawnLldbMi(args = None)
self.child = pexpect.spawn('%s --interpreter' % (self.lldbMiExec))
child = self.child
child.setecho(True)
# Turn on logging for input/output to/from the child.
with open('child_send.txt', 'w') as f_send:
with open('child_read.txt', 'w') as f_read:
child.logfile_send = f_send
child.logfile_read = f_read
# Load executable # Load executable
child.sendline("-file-exec-and-symbols %s" % (self.myexe)) self.runCmd("-file-exec-and-symbols %s" % (self.myexe))
child.expect("\^done") self.expect("\^done")
# Run to main # Run to main
self.line = line_number('main.c', '//BP_localstest') line = line_number('main.c', '//BP_localstest')
child.sendline("-break-insert --file main.c:%d" % (self.line)) self.runCmd("-break-insert --file main.c:%d" % line)
child.expect("\^done,bkpt={number=\"1\"") self.expect("\^done,bkpt={number=\"1\"")
child.sendline("-exec-run") self.runCmd("-exec-run")
child.expect("\^running") self.expect("\^running")
child.expect("\*stopped,reason=\"breakpoint-hit\"") self.expect("\*stopped,reason=\"breakpoint-hit\"")
# Test locals # Test locals
child.sendline("-stack-list-locals 0") #self.runCmd("-stack-list-locals 0") #FIXME: --no-values doesn't work
child.expect("\^done,locals=\[{name=\"a\",value=\"10\"},{name=\"b\",value=\"20\"}\]") #self.expect("\^done,locals=\[name=\"a\",name=\"b\"\]")
self.runCmd("-stack-list-locals 1")
self.expect("\^done,locals=\[{name=\"a\",value=\"10\"},{name=\"b\",value=\"20\"}\]")
# Now that the necessary logging is done, restore logfile to None to
# stop further logging.
child.logfile_send = None
child.logfile_read = None
with open('child_send.txt', 'r') as fs:
if self.TraceOn():
print "\n\nContents of child_send.txt:"
print fs.read()
with open('child_read.txt', 'r') as fr:
from_child = fr.read()
if self.TraceOn():
print "\n\nContents of child_read.txt:"
print from_child
if __name__ == '__main__': if __name__ == '__main__':
import atexit
lldb.SBDebugger.Initialize()
atexit.register(lambda: lldb.SBDebugger.Terminate())
unittest2.main() unittest2.main()
Context not available.

test/tools/lldb-mi/TestMiSyntax.py

Context not available.
Test that the lldb-mi driver understands MI command syntax. Test that the lldb-mi driver understands MI command syntax.
""" """
import os import lldbmi_testcase
from lldbtest import *
import unittest2 import unittest2
import lldb
from lldbtest import *
class MiSyntaxTestCase(TestBase): class MiSyntaxTestCase(lldbmi_testcase.MiTestCaseBase):
mydir = TestBase.compute_mydir(__file__)
myexe = "a.out"
@classmethod
def classCleanup(cls):
"""Cleanup the test byproducts."""
try:
os.remove("child_send.txt")
os.remove("child_read.txt")
os.remove(cls.myexe)
except:
pass
@lldbmi_test @lldbmi_test
@expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows") @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
def test_lldbmi_tokens(self): def test_lldbmi_tokens(self):
"""Test that 'lldb-mi --interpreter' echos command tokens.""" """Test that 'lldb-mi --interpreter' echos command tokens."""
import pexpect
self.buildDefault()
# So that the child gets torn down after the test. self.spawnLldbMi(args = None)
self.child = pexpect.spawn('%s --interpreter' % (self.lldbMiExec))
child = self.child
child.setecho(True)
# Turn on logging for input/output to/from the child.
with open('child_send.txt', 'w') as f_send:
with open('child_read.txt', 'w') as f_read:
child.logfile_send = f_send
child.logfile_read = f_read
child.sendline("000-file-exec-and-symbols " + self.myexe) # Load executable
child.expect("000\^done") self.runCmd("000-file-exec-and-symbols %s" % self.myexe)
self.expect("000\^done")
child.sendline("100000001-break-insert -f a_MyFunction") # Run to main
child.expect("100000001\^done,bkpt={number=\"1\"") self.runCmd("100000001-break-insert -f a_MyFunction")
self.expect("100000001\^done,bkpt={number=\"1\"")
self.runCmd("2-exec-run")
self.expect("2\^running")
self.expect("\*stopped,reason=\"breakpoint-hit\"")
child.sendline("2-exec-run") # Exit
child.expect("2\^running") self.runCmd("0000000000000000000003-exec-continue")
child.expect("\*stopped,reason=\"breakpoint-hit\"") self.expect("0000000000000000000003\^running")
self.expect("\*stopped,reason=\"exited-normally\"")
child.sendline("0000000000000000000003-exec-continue")
child.expect("0000000000000000000003\^running")
child.expect("\*stopped,reason=\"exited-normally\"")
# Now that the necessary logging is done, restore logfile to None to
# stop further logging.
child.logfile_send = None
child.logfile_read = None
with open('child_send.txt', 'r') as fs:
if self.TraceOn():
print "\n\nContents of child_send.txt:"
print fs.read()
with open('child_read.txt', 'r') as fr:
from_child = fr.read()
if self.TraceOn():
print "\n\nContents of child_read.txt:"
print from_child
if __name__ == '__main__': if __name__ == '__main__':
import atexit
lldb.SBDebugger.Initialize()
atexit.register(lambda: lldb.SBDebugger.Terminate())
unittest2.main() unittest2.main()
Context not available.

test/tools/lldb-mi/lldbmi_testcase.py

"""
Base class for lldb-mi test cases.
"""
from lldbtest import *
import pexpect
import unittest2
class MiTestCaseBase(Base):
mydir = Base.compute_mydir(__file__)
myexe = "a.out"
mylog = "child.log"
@classmethod
def classCleanup(cls):
TestBase.RemoveTempFile(cls.myexe)
TestBase.RemoveTempFile(cls.mylog)
def setUp(self):
Base.setUp(self)
self.buildDefault()
self.child_prompt = "(gdb)"
def tearDown(self):
if self.TraceOn():
print "\n\nContents of %s:" % self.mylog
print open(self.mylog, "r").read()
Base.tearDown(self)
def spawnLldbMi(self, args=None):
self.child = pexpect.spawn("%s --interpreter %s" % (
self.lldbMiExec, args if args else ""))
self.child.setecho(True)
self.child.logfile_read = open(self.mylog, "w")
def runCmd(self, cmd):
self.child.sendline(cmd)
def expect(self, pattern, *args, **kwargs):
self.child.expect(pattern, *args, **kwargs)