[Lldb-commits] [lldb] r227218 - Clean lldb-mi test cases.
Hafiz Abid Qadeer
hafiz_abid at mentor.com
Tue Jan 27 10:03:50 PST 2015
Author: abidh
Date: Tue Jan 27 12:03:50 2015
New Revision: 227218
URL: http://llvm.org/viewvc/llvm-project?rev=227218&view=rev
Log:
Clean lldb-mi test cases.
This patch adds lldbmi_testcase.MiTestCaseBase class and removes
a lot of repitition in the lldb-mi test cases. Also cleans import
list and code-style.
Presented for review in http://reviews.llvm.org/D7162.
Patch from Ilia K <ki.stfu at gmail.com>.
Added:
lldb/trunk/test/tools/lldb-mi/lldbmi_testcase.py
Modified:
lldb/trunk/test/tools/lldb-mi/TestMiBreakpoint.py
lldb/trunk/test/tools/lldb-mi/TestMiEvaluate.py
lldb/trunk/test/tools/lldb-mi/TestMiInterrupt.py
lldb/trunk/test/tools/lldb-mi/TestMiLaunch.py
lldb/trunk/test/tools/lldb-mi/TestMiProgramArgs.py
lldb/trunk/test/tools/lldb-mi/TestMiStack.py
lldb/trunk/test/tools/lldb-mi/TestMiSyntax.py
Modified: lldb/trunk/test/tools/lldb-mi/TestMiBreakpoint.py
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/test/tools/lldb-mi/TestMiBreakpoint.py?rev=227218&r1=227217&r2=227218&view=diff
==============================================================================
--- lldb/trunk/test/tools/lldb-mi/TestMiBreakpoint.py (original)
+++ lldb/trunk/test/tools/lldb-mi/TestMiBreakpoint.py Tue Jan 27 12:03:50 2015
@@ -2,197 +2,95 @@
Test that the lldb-mi driver understands an MI breakpoint command.
"""
-import os
-import unittest2
-import lldb
+import lldbmi_testcase
from lldbtest import *
+import unittest2
-class MiBreakpointTestCase(TestBase):
-
- 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
+class MiBreakpointTestCase(lldbmi_testcase.MiTestCaseBase):
@lldbmi_test
@expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
def test_lldbmi_pendbreakonsym(self):
"""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.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)
- child.expect("\^done")
-
- child.sendline("-break-insert -f a_MyFunction")
- child.expect("\^done,bkpt={number=\"1\"")
-
- child.sendline("-exec-run")
- child.expect("\^running")
- child.expect("\*stopped,reason=\"breakpoint-hit\"")
-
- child.sendline("-exec-continue")
- child.expect("\^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
+ self.spawnLldbMi(args = None)
+
+ self.runCmd("-file-exec-and-symbols %s" % self.myexe)
+ self.expect("\^done")
- self.expect(from_child, exe=False,
- substrs = ["breakpoint-hit"])
+ self.runCmd("-break-insert -f a_MyFunction")
+ self.expect("\^done,bkpt={number=\"1\"")
+
+ self.runCmd("-exec-run")
+ self.expect("\^running")
+ self.expect("\*stopped,reason=\"breakpoint-hit\"")
+
+ self.runCmd("-exec-continue")
+ self.expect("\^running")
+ self.expect("\*stopped,reason=\"exited-normally\"")
@lldbmi_test
@expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
def test_lldbmi_pendbreakonsrc(self):
"""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.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)
- child.expect("\^done")
-
- # Find the line number to break inside main() and set
- # pending BP.
- self.line = line_number('main.c', '//BP_source')
- child.sendline("-break-insert -f main.c:%d" % self.line)
- child.expect("\^done,bkpt={number=\"1\"")
-
- child.sendline("-exec-run")
- child.expect("\^running")
- child.expect("\*stopped,reason=\"breakpoint-hit\"")
-
- child.sendline("-exec-continue")
- child.expect("\^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
+ self.spawnLldbMi(args = None)
- self.expect(from_child, exe=False,
- substrs = ["breakpoint-hit"])
+ self.runCmd("-file-exec-and-symbols %s" % self.myexe)
+ self.expect("\^done")
+
+ # Find the line number to break inside main() and set
+ # pending BP.
+ line = line_number('main.c', '//BP_source')
+ self.runCmd("-break-insert -f main.c:%d" % line)
+ self.expect("\^done,bkpt={number=\"1\"")
+
+ self.runCmd("-exec-run")
+ self.expect("\^running")
+ self.expect("\*stopped,reason=\"breakpoint-hit\"")
+
+ self.runCmd("-exec-continue")
+ self.expect("\^running")
+ self.expect("\*stopped,reason=\"exited-normally\"")
@lldbmi_test
@expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
def test_lldbmi_breakpoints(self):
"""Test that 'lldb-mi --interpreter' works for breakpoints."""
- import pexpect
- self.buildDefault()
- # So that the child gets torn down after the test.
- 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)
- child.expect("\^done")
-
- child.sendline("-break-insert -f main")
- child.expect("\^done,bkpt={number=\"1\"")
-
- child.sendline("-exec-run")
- child.expect("\^running")
- child.expect("\*stopped,reason=\"breakpoint-hit\"")
-
- #break on symbol
- child.sendline("-break-insert a_MyFunction")
- child.expect("\^done,bkpt={number=\"2\"")
-
- child.sendline("-exec-continue")
- child.expect("\^running")
- child.expect("\*stopped,reason=\"breakpoint-hit\"")
-
- #break on source
- self.line = line_number('main.c', '//BP_source')
- child.sendline("-break-insert main.c:%d" % self.line)
- child.expect("\^done,bkpt={number=\"3\"")
-
- child.sendline("-exec-continue")
- child.expect("\^running")
- child.expect("\*stopped,reason=\"breakpoint-hit\"")
-
- #run to exit
- child.sendline("-exec-continue")
- child.expect("\^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
+ self.spawnLldbMi(args = None)
+
+ self.runCmd("-file-exec-and-symbols %s" % self.myexe)
+ self.expect("\^done")
- self.expect(from_child, exe=False,
- substrs = ["breakpoint-hit"])
+ self.runCmd("-break-insert -f main")
+ self.expect("\^done,bkpt={number=\"1\"")
+ self.runCmd("-exec-run")
+ self.expect("\^running")
+ self.expect("\*stopped,reason=\"breakpoint-hit\"")
+
+ #break on symbol
+ self.runCmd("-break-insert a_MyFunction")
+ self.expect("\^done,bkpt={number=\"2\"")
+
+ self.runCmd("-exec-continue")
+ self.expect("\^running")
+ self.expect("\*stopped,reason=\"breakpoint-hit\"")
+
+ #break on source
+ line = line_number('main.c', '//BP_source')
+ self.runCmd("-break-insert main.c:%d" % line)
+ self.expect("\^done,bkpt={number=\"3\"")
+
+ self.runCmd("-exec-continue")
+ self.expect("\^running")
+ self.expect("\*stopped,reason=\"breakpoint-hit\"")
+
+ #run to exit
+ self.runCmd("-exec-continue")
+ self.expect("\^running")
+ self.expect("\*stopped,reason=\"exited-normally\"")
if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
unittest2.main()
Modified: lldb/trunk/test/tools/lldb-mi/TestMiEvaluate.py
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/test/tools/lldb-mi/TestMiEvaluate.py?rev=227218&r1=227217&r2=227218&view=diff
==============================================================================
--- lldb/trunk/test/tools/lldb-mi/TestMiEvaluate.py (original)
+++ lldb/trunk/test/tools/lldb-mi/TestMiEvaluate.py Tue Jan 27 12:03:50 2015
@@ -2,131 +2,88 @@
Test that the lldb-mi driver can evaluate expressions.
"""
-import os
-import unittest2
-import lldb
+import lldbmi_testcase
from lldbtest import *
+import unittest2
-class MiEvaluateTestCase(TestBase):
-
- 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
+class MiEvaluateTestCase(lldbmi_testcase.MiTestCaseBase):
@lldbmi_test
@expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
def test_lldbmi_eval(self):
"""Test that 'lldb-mi --interpreter' works for evaluating."""
- import pexpect
- self.buildDefault()
- # So that the child gets torn down after the test.
- 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)
- child.expect("\^done")
-
- #run to main
- child.sendline("-break-insert -f main")
- child.expect("\^done,bkpt={number=\"1\"")
-
- child.sendline("-exec-run")
- child.expect("\^running")
- child.expect("\*stopped,reason=\"breakpoint-hit\"")
-
- #run to program return (marked BP_source)
- self.line = line_number('main.c', '//BP_source')
- child.sendline("-break-insert main.c:%d" % self.line)
- child.expect("\^done,bkpt={number=\"2\"")
-
- child.sendline("-exec-continue")
- child.expect("\^running")
- child.expect("\*stopped,reason=\"breakpoint-hit\"")
-
- #print non-existant variable
- #child.sendline("-var-create var1 --thread 1 --frame 0 * undef") #FIXME: shows undef as {...}
- #child.expect("error")
- #child.sendline("-data-evaluate-expression undef") #FIXME: gets value="undef"
- #child.expect("error")
-
- #print global "g_MyVar"
- child.sendline("-var-create var1 --thread 1 --frame 0 * g_MyVar") #FIXME: shows name=<unnamedvariable>"
- child.expect("value=\"3\",type=\"int\"")
- #child.sendline("-var-evaluate-expression var1") #FIXME: gets var1 does not exist
- child.sendline("-var-show-attributes var1")
- child.expect("status=\"editable\"")
- child.sendline("-var-delete var1")
- child.expect("\^done")
- child.sendline("-var-create var1 --thread 1 --frame 0 * g_MyVar")
- child.expect("value=\"3\",type=\"int\"")
-
- #print static "s_MyVar" and modify
- child.sendline("-data-evaluate-expression s_MyVar")
- child.expect("value=\"30\"")
- child.sendline("-var-create var3 --thread 1 --frame 0 * \"s_MyVar=3\"")
- child.expect("value=\"3\",type=\"int\"")
- child.sendline("-data-evaluate-expression \"s_MyVar=30\"")
- child.expect("value=\"30\"")
-
- #print local "b" and modify
- child.sendline("-data-evaluate-expression b")
- child.expect("value=\"20\"")
- child.sendline("-var-create var3 --thread 1 --frame 0 * \"b=3\"")
- child.expect("value=\"3\",type=\"int\"")
- child.sendline("-data-evaluate-expression \"b=20\"")
- child.expect("value=\"20\"")
-
- #print "a + b"
- child.sendline("-data-evaluate-expression \"a + b\"")
- child.expect("value=\"30\"")
- child.sendline("-var-create var3 --thread 1 --frame 0 * \"a + b\"")
- child.expect("value=\"30\",type=\"int\"")
-
- #print "argv[0]"
- child.sendline("-data-evaluate-expression \"argv[0]\"")
- child.expect("value=\"0x")
- child.sendline("-var-create var3 --thread 1 --frame 0 * \"argv[0]\"")
- child.expect("numchild=\"1\",value=\"0x.*\",type=\"const char \*\"")
-
- #run to exit
- child.sendline("-exec-continue")
- child.expect("\^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
+ self.spawnLldbMi(args = None)
+
+ self.runCmd("-file-exec-and-symbols %s" % self.myexe)
+ self.expect("\^done")
+ #run to main
+ self.runCmd("-break-insert -f main")
+ self.expect("\^done,bkpt={number=\"1\"")
+
+ self.runCmd("-exec-run")
+ self.expect("\^running")
+ self.expect("\*stopped,reason=\"breakpoint-hit\"")
+
+ #run to program return (marked BP_source)
+ line = line_number('main.c', '//BP_source')
+ self.runCmd("-break-insert main.c:%d" % line)
+ self.expect("\^done,bkpt={number=\"2\"")
+
+ self.runCmd("-exec-continue")
+ self.expect("\^running")
+ self.expect("\*stopped,reason=\"breakpoint-hit\"")
+
+ #print non-existant variable
+ #self.runCmd("-var-create var1 --thread 1 --frame 0 * undef") #FIXME: shows undef as {...}
+ #self.expect("error")
+ #self.runCmd("-data-evaluate-expression undef") #FIXME: gets value="undef"
+ #self.expect("error")
+
+ #print global "g_MyVar"
+ self.runCmd("-var-create var1 --thread 1 --frame 0 * g_MyVar") #FIXME: shows name=<unnamedvariable>"
+ self.expect("value=\"3\",type=\"int\"")
+ #self.runCmd("-var-evaluate-expression var1") #FIXME: gets var1 does not exist
+ self.runCmd("-var-show-attributes var1")
+ self.expect("status=\"editable\"")
+ self.runCmd("-var-delete var1")
+ self.expect("\^done")
+ self.runCmd("-var-create var1 --thread 1 --frame 0 * g_MyVar")
+ self.expect("value=\"3\",type=\"int\"")
+
+ #print static "s_MyVar" and modify
+ self.runCmd("-data-evaluate-expression s_MyVar")
+ self.expect("value=\"30\"")
+ self.runCmd("-var-create var3 --thread 1 --frame 0 * \"s_MyVar=3\"")
+ self.expect("value=\"3\",type=\"int\"")
+ self.runCmd("-data-evaluate-expression \"s_MyVar=30\"")
+ self.expect("value=\"30\"")
+
+ #print local "b" and modify
+ self.runCmd("-data-evaluate-expression b")
+ self.expect("value=\"20\"")
+ self.runCmd("-var-create var3 --thread 1 --frame 0 * \"b=3\"")
+ self.expect("value=\"3\",type=\"int\"")
+ self.runCmd("-data-evaluate-expression \"b=20\"")
+ self.expect("value=\"20\"")
+
+ #print "a + b"
+ self.runCmd("-data-evaluate-expression \"a + b\"")
+ self.expect("value=\"30\"")
+ self.runCmd("-var-create var3 --thread 1 --frame 0 * \"a + b\"")
+ self.expect("value=\"30\",type=\"int\"")
+
+ #print "argv[0]"
+ self.runCmd("-data-evaluate-expression \"argv[0]\"")
+ self.expect("value=\"0x")
+ self.runCmd("-var-create var3 --thread 1 --frame 0 * \"argv[0]\"")
+ self.expect("numchild=\"1\",value=\"0x.*\",type=\"const char \*\"")
+
+ #run to exit
+ self.runCmd("-exec-continue")
+ self.expect("\^running")
+ self.expect("\*stopped,reason=\"exited-normally\"")
if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
unittest2.main()
Modified: lldb/trunk/test/tools/lldb-mi/TestMiInterrupt.py
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/test/tools/lldb-mi/TestMiInterrupt.py?rev=227218&r1=227217&r2=227218&view=diff
==============================================================================
--- lldb/trunk/test/tools/lldb-mi/TestMiInterrupt.py (original)
+++ lldb/trunk/test/tools/lldb-mi/TestMiInterrupt.py Tue Jan 27 12:03:50 2015
@@ -2,96 +2,53 @@
Test that the lldb-mi driver can interrupt and resume a looping app.
"""
-import os
-import unittest2
-import lldb
+import lldbmi_testcase
from lldbtest import *
+import unittest2
-class MiInterruptTestCase(TestBase):
-
- 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
+class MiInterruptTestCase(lldbmi_testcase.MiTestCaseBase):
+ @lldbmi_test
@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin")
@expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
- @lldbmi_test
def test_lldbmi_interrupt(self):
"""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.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)
- child.expect("\^done")
-
- #run to main
- child.sendline("-break-insert -f main")
- child.expect("\^done,bkpt={number=\"1\"")
- child.sendline("-exec-run")
- child.expect("\^running")
- child.expect("\*stopped,reason=\"breakpoint-hit\"")
-
- #set doloop=1 and run (to loop forever)
- child.sendline("-data-evaluate-expression \"doloop=1\"")
- child.expect("value=\"1\"")
- child.sendline("-exec-continue")
- child.expect("\^running")
-
- #issue interrupt, set BP in loop (marked BP_loop), and resume
- child.sendline("-exec-interrupt")
- child.expect("\*stopped,reason=\"signal-received\"")
- self.line = line_number('loop.c', '//BP_loop')
- child.sendline("-break-insert loop.c:%d" % self.line)
- child.expect("\^done,bkpt={number=\"2\"")
- #child.sendline("-exec-resume") #FIXME: command not recognized
- child.sendline("-exec-continue")
- child.expect("\*stopped,reason=\"breakpoint-hit\"")
-
- #we should have hit BP
- #set loop=-1 so we'll exit the loop
- child.sendline("-data-evaluate-expression \"loop=-1\"")
- child.expect("value=\"-1\"")
- child.sendline("-exec-continue")
- child.expect("\^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
+ self.spawnLldbMi(args = None)
+
+ self.runCmd("-file-exec-and-symbols %s" % self.myexe)
+ self.expect("\^done")
+ #run to main
+ self.runCmd("-break-insert -f main")
+ self.expect("\^done,bkpt={number=\"1\"")
+ self.runCmd("-exec-run")
+ self.expect("\^running")
+ self.expect("\*stopped,reason=\"breakpoint-hit\"")
+
+ #set doloop=1 and run (to loop forever)
+ self.runCmd("-data-evaluate-expression \"doloop=1\"")
+ self.expect("value=\"1\"")
+ self.runCmd("-exec-continue")
+ self.expect("\^running")
+
+ #issue interrupt, set BP in loop (marked BP_loop), and resume
+ self.runCmd("-exec-interrupt")
+ self.expect("\*stopped,reason=\"signal-received\"")
+ line = line_number('loop.c', '//BP_loop')
+ self.runCmd("-break-insert loop.c:%d" % line)
+ self.expect("\^done,bkpt={number=\"2\"")
+ #self.runCmd("-exec-resume") #FIXME: command not recognized
+ self.runCmd("-exec-continue")
+ self.expect("\*stopped,reason=\"breakpoint-hit\"")
+
+ #we should have hit BP
+ #set loop=-1 so we'll exit the loop
+ self.runCmd("-data-evaluate-expression \"loop=-1\"")
+ self.expect("value=\"-1\"")
+ self.runCmd("-exec-continue")
+ self.expect("\^running")
+ self.expect("\*stopped,reason=\"exited-normally\"")
if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
unittest2.main()
Modified: lldb/trunk/test/tools/lldb-mi/TestMiLaunch.py
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/test/tools/lldb-mi/TestMiLaunch.py?rev=227218&r1=227217&r2=227218&view=diff
==============================================================================
--- lldb/trunk/test/tools/lldb-mi/TestMiLaunch.py (original)
+++ lldb/trunk/test/tools/lldb-mi/TestMiLaunch.py Tue Jan 27 12:03:50 2015
@@ -2,188 +2,71 @@
Test various ways the lldb-mi driver can launch a program.
"""
-import os
-import unittest2
-import lldb
+import lldbmi_testcase
from lldbtest import *
+import unittest2
-class MiLaunchTestCase(TestBase):
-
- 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
+class MiLaunchTestCase(lldbmi_testcase.MiTestCaseBase):
@lldbmi_test
@expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
def test_lldbmi_exe(self):
"""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.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
- child.sendline("-file-exec-and-symbols " + self.myexe)
- child.expect("\^done")
-
- child.sendline("-exec-run")
- child.expect("\^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
+ self.spawnLldbMi(args = None)
+
+ #use no path
+ self.runCmd("-file-exec-and-symbols %s" % self.myexe)
+ self.expect("\^done")
+
+ self.runCmd("-exec-run")
+ self.expect("\^running")
+ self.expect("\*stopped,reason=\"exited-normally\"")
@lldbmi_test
@expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
def test_lldbmi_abspathexe(self):
"""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.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
- exe = os.path.join(os.getcwd(), "a.out")
- child.sendline("-file-exec-and-symbols " + exe)
- child.expect("\^done")
-
- child.sendline("-exec-run")
- child.expect("\^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
+ self.spawnLldbMi(args = None)
+
+ #use full path
+ import os
+ exe = os.path.join(os.getcwd(), self.myexe)
+ self.runCmd("-file-exec-and-symbols %s" % exe)
+ self.expect("\^done")
+
+ self.runCmd("-exec-run")
+ self.expect("\^running")
+ self.expect("\*stopped,reason=\"exited-normally\"")
@lldbmi_test
@expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
def test_lldbmi_relpathexe(self):
"""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.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
- exe = "../../" + self.mydir + "/" + self.myexe
- child.sendline("-file-exec-and-symbols " + exe)
- child.expect("\^done")
-
- child.sendline("-exec-run")
- child.expect("\^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
+ self.spawnLldbMi(args = None)
+
+ #use relative path
+ exe = "../../" + self.mydir + "/" + self.myexe
+ self.runCmd("-file-exec-and-symbols %s" % exe)
+ self.expect("\^done")
+
+ self.runCmd("-exec-run")
+ self.expect("\^running")
+ self.expect("\*stopped,reason=\"exited-normally\"")
@lldbmi_test
@expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
def test_lldbmi_badpathexe(self):
"""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.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
- exe = "badpath/" + self.myexe
- child.sendline("-file-exec-and-symbols " + exe)
- child.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
+ self.spawnLldbMi(args = None)
+ #use non-existant path
+ exe = "badpath/" + self.myexe
+ self.runCmd("-file-exec-and-symbols %s" % exe)
+ self.expect("\^error")
if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
unittest2.main()
Modified: lldb/trunk/test/tools/lldb-mi/TestMiProgramArgs.py
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/test/tools/lldb-mi/TestMiProgramArgs.py?rev=227218&r1=227217&r2=227218&view=diff
==============================================================================
--- lldb/trunk/test/tools/lldb-mi/TestMiProgramArgs.py (original)
+++ lldb/trunk/test/tools/lldb-mi/TestMiProgramArgs.py Tue Jan 27 12:03:50 2015
@@ -2,86 +2,44 @@
Test that the lldb-mi driver can pass arguments to the app.
"""
-import os
-import unittest2
-import lldb
+import lldbmi_testcase
from lldbtest import *
+import unittest2
-class MiProgramArgsTestCase(TestBase):
-
- 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
+class MiProgramArgsTestCase(lldbmi_testcase.MiTestCaseBase):
- @unittest2.skip("lldb-mi can't pass params to app.")
@lldbmi_test
+ @unittest2.skip("lldb-mi can't pass params to app.")
@expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
def test_lldbmi_paramargs(self):
"""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.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)
- child.expect("\^done")
-
- child.sendline("settings set target.run-args l") #FIXME: args not passed
- #child.sendline("-exec-arguments l") #FIXME: not recognized and hung lldb-mi
-
- #run to main
- child.sendline("-break-insert -f main")
- child.expect("\^done,bkpt={number=\"1\"")
- child.sendline("-exec-run")
- child.expect("\^running")
- child.expect("\*stopped,reason=\"breakpoint-hit\"")
-
- #check argc to see if arg passed
- child.sendline("-data-evaluate-expression argc")
- child.expect("value=\"2\"")
-
- #set BP on code which is only executed if "l" was passed correctly (marked BP_argtest)
- self.line = line_number('main.c', '//BP_argtest')
- child.sendline("-break-insert main.c:%d" % self.line)
- child.expect("\^done,bkpt={number=\"2\"")
- child.sendline("-exec-continue")
- child.expect("\^running")
- child.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
+ self.spawnLldbMi(args = None)
+
+ self.runCmd("-file-exec-and-symbols %s" % self.myexe)
+ self.expect("\^done")
+
+ self.runCmd("settings set target.run-args l") #FIXME: args not passed
+ #self.runCmd("-exec-arguments l") #FIXME: not recognized and hung lldb-mi
+
+ #run to main
+ self.runCmd("-break-insert -f main")
+ self.expect("\^done,bkpt={number=\"1\"")
+ self.runCmd("-exec-run")
+ self.expect("\^running")
+ self.expect("\*stopped,reason=\"breakpoint-hit\"")
+
+ #check argc to see if arg passed
+ self.runCmd("-data-evaluate-expression argc")
+ self.expect("value=\"2\"")
+
+ #set BP on code which is only executed if "l" was passed correctly (marked BP_argtest)
+ line = line_number('main.c', '//BP_argtest')
+ self.runCmd("-break-insert main.c:%d" % line)
+ self.expect("\^done,bkpt={number=\"2\"")
+ self.runCmd("-exec-continue")
+ self.expect("\^running")
+ self.expect("\*stopped,reason=\"breakpoint-hit\"")
if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
unittest2.main()
Modified: lldb/trunk/test/tools/lldb-mi/TestMiStack.py
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/test/tools/lldb-mi/TestMiStack.py?rev=227218&r1=227217&r2=227218&view=diff
==============================================================================
--- lldb/trunk/test/tools/lldb-mi/TestMiStack.py (original)
+++ lldb/trunk/test/tools/lldb-mi/TestMiStack.py Tue Jan 27 12:03:50 2015
@@ -2,123 +2,60 @@
Test that the lldb-mi driver works with -stack-xxx commands
"""
-import os
-import unittest2
-import lldb
+import lldbmi_testcase
from lldbtest import *
+import unittest2
-class MiStackTestCase(TestBase):
-
- 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
+class MiStackTestCase(lldbmi_testcase.MiTestCaseBase):
@lldbmi_test
@expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
def test_lldbmi_stackargs(self):
"""Test that 'lldb-mi --interpreter' can shows arguments."""
- import pexpect
- self.buildDefault()
- # So that the child gets torn down after the test.
- 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
- child.sendline("-file-exec-and-symbols %s" % (self.myexe))
- child.expect("\^done")
-
- # Run to main
- child.sendline("-break-insert -f main")
- child.expect("\^done,bkpt={number=\"1\"")
- child.sendline("-exec-run")
- child.expect("\^running")
- child.expect("\*stopped,reason=\"breakpoint-hit\"")
-
- # Test arguments
- child.sendline("-stack-list-arguments 0")
- child.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
+ self.spawnLldbMi(args = None)
+
+ # Load executable
+ self.runCmd("-file-exec-and-symbols %s" % self.myexe)
+ self.expect("\^done")
+
+ # Run to main
+ self.runCmd("-break-insert -f main")
+ self.expect("\^done,bkpt={number=\"1\"")
+ self.runCmd("-exec-run")
+ self.expect("\^running")
+ self.expect("\*stopped,reason=\"breakpoint-hit\"")
+
+ # Test arguments
+ #self.runCmd("-stack-list-arguments 0") #FIXME: --no-values doesn't work
+ #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=\".*\"}\]}")
@lldbmi_test
@expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
def test_lldbmi_locals(self):
"""Test that 'lldb-mi --interpreter' can shows local variables."""
- import pexpect
- self.buildDefault()
- # So that the child gets torn down after the test.
- 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
- child.sendline("-file-exec-and-symbols %s" % (self.myexe))
- child.expect("\^done")
-
- # Run to main
- self.line = line_number('main.c', '//BP_localstest')
- child.sendline("-break-insert --file main.c:%d" % (self.line))
- child.expect("\^done,bkpt={number=\"1\"")
- child.sendline("-exec-run")
- child.expect("\^running")
- child.expect("\*stopped,reason=\"breakpoint-hit\"")
-
- # Test locals
- child.sendline("-stack-list-locals 0")
- child.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
+ self.spawnLldbMi(args = None)
+
+ # Load executable
+ self.runCmd("-file-exec-and-symbols %s" % (self.myexe))
+ self.expect("\^done")
+
+ # Run to main
+ line = line_number('main.c', '//BP_localstest')
+ self.runCmd("-break-insert --file main.c:%d" % line)
+ self.expect("\^done,bkpt={number=\"1\"")
+ self.runCmd("-exec-run")
+ self.expect("\^running")
+ self.expect("\*stopped,reason=\"breakpoint-hit\"")
+
+ # Test locals
+ #self.runCmd("-stack-list-locals 0") #FIXME: --no-values doesn't work
+ #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\"}\]")
if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
unittest2.main()
Modified: lldb/trunk/test/tools/lldb-mi/TestMiSyntax.py
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/test/tools/lldb-mi/TestMiSyntax.py?rev=227218&r1=227217&r2=227218&view=diff
==============================================================================
--- lldb/trunk/test/tools/lldb-mi/TestMiSyntax.py (original)
+++ lldb/trunk/test/tools/lldb-mi/TestMiSyntax.py Tue Jan 27 12:03:50 2015
@@ -2,74 +2,34 @@
Test that the lldb-mi driver understands MI command syntax.
"""
-import os
-import unittest2
-import lldb
+import lldbmi_testcase
from lldbtest import *
+import unittest2
-class MiSyntaxTestCase(TestBase):
-
- 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
+class MiSyntaxTestCase(lldbmi_testcase.MiTestCaseBase):
@lldbmi_test
@expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
def test_lldbmi_tokens(self):
"""Test that 'lldb-mi --interpreter' echos command tokens."""
- import pexpect
- self.buildDefault()
- # So that the child gets torn down after the test.
- 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)
- child.expect("000\^done")
-
- child.sendline("100000001-break-insert -f a_MyFunction")
- child.expect("100000001\^done,bkpt={number=\"1\"")
-
- child.sendline("2-exec-run")
- child.expect("2\^running")
- child.expect("\*stopped,reason=\"breakpoint-hit\"")
-
- 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
+ self.spawnLldbMi(args = None)
+
+ # Load executable
+ self.runCmd("000-file-exec-and-symbols %s" % self.myexe)
+ self.expect("000\^done")
+
+ # Run to main
+ 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\"")
+
+ # Exit
+ self.runCmd("0000000000000000000003-exec-continue")
+ self.expect("0000000000000000000003\^running")
+ self.expect("\*stopped,reason=\"exited-normally\"")
if __name__ == '__main__':
- import atexit
- lldb.SBDebugger.Initialize()
- atexit.register(lambda: lldb.SBDebugger.Terminate())
unittest2.main()
Added: lldb/trunk/test/tools/lldb-mi/lldbmi_testcase.py
URL: http://llvm.org/viewvc/llvm-project/lldb/trunk/test/tools/lldb-mi/lldbmi_testcase.py?rev=227218&view=auto
==============================================================================
--- lldb/trunk/test/tools/lldb-mi/lldbmi_testcase.py (added)
+++ lldb/trunk/test/tools/lldb-mi/lldbmi_testcase.py Tue Jan 27 12:03:50 2015
@@ -0,0 +1,41 @@
+"""
+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)
More information about the lldb-commits
mailing list