Fix and enable some tests on Linux (MI)

[ki.stfu]

Summary

Fix and enable some lldb-mi tests on Linux:

Fixed:

1. MiExecInterpreterTestCase.test_lldbmi_thread_step_in
2. MiExecTestCase.test_lldbmi_exec_step
3. MiStackTestCase.test_lldbmi_stack_info_frame tests.

Also I enabled the following tests on Linux:

1. MiExecTestCase.test_lldbmi_exec_step_instruction
2. MiSignalTestCase.test_lldbmi_stopped_when_interrupted

All test pass on OS X and Linux.

[ki.stfu]

Need to check these changes on Darwin.

tools/lldb-mi/stack/TestMiStack.py

299 ↗

(On Diff #20967)

fixme

[ki.stfu]

tools/lldb-mi/control/TestMiExec.py

316 ↗

(On Diff #20967)

Remove this

[vharron]

I tried this out and didn't see any improvement with the patch on Linux. Can you try again against top-of-tree? Linux now does local and remote debugging via lldb-server.

[ki.stfu]

In D7987#132264, @vharron wrote:

I tried this out and didn't see any improvement with the patch on Linux.

This patch fixes the following tests on Linux:

1. MiExecInterpreterTestCase.test_lldbmi_thread_step_in
2. MiExecTestCase.test_lldbmi_exec_step
3. MiStackTestCase.test_lldbmi_stack_info_frame tests.

Also I enabled the following tests on Linux:

1. MiExecTestCase.test_lldbmi_exec_step_instruction
2. MiSignalTestCase.test_lldbmi_stopped_when_interrupted

As I said this patch was tested on Linux, specifically on Ubuntu 14.10.

[ki.stfu]

little improvements; remove unnecessary changes

[ki.stfu]

update some comments

lldb/trunk/test/tools/lldb-mi/TestMiInterpreterExec.py

def test_lldbmi_thread_step_in(self):
 
         # 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 that "thread step-in" steps in
-        #FIXME: is this supposed to step into printf?
+        # Test that "thread step-in" steps into (or not) printf depending on debug info
+        # Note that message is different in Darwin and Linux:
+        # Darwin: "*stopped,reason=\"end-stepping-range\",frame={addr=\"0x[0-9a-f]+\",func=\"main\",args=[{name=\"argc\",value=\"1\"},{name=\"argv\",value="0x[0-9a-f]+\"}],file=\"main.cpp\",fullname=\".+main.cpp\",line=\"\d\"},thread-id=\"1\",stopped-threads=\"all\"
+        # Linux:  "*stopped,reason=\"end-stepping-range\",frame={addr="0x[0-9a-f]+\",func=\"__printf\",args=[{name=\"format\",value=\"0x[0-9a-f]+\"}],file=\"printf.c\",fullname=\".+printf.c\",line="\d+"},thread-id=\"1\",stopped-threads=\"all\"
         self.runCmd("-interpreter-exec console \"thread step-in\"")
         self.expect("\^done")
-        self.expect("~\"argc=1\\\\r\\\\n\"")
-        self.expect("\*stopped,reason=\"end-stepping-range\"")
+        it = self.expect([ "~\"argc=1\\\\r\\\\n\"",
+                           "\*stopped,reason=\"end-stepping-range\".+func=\"((?!main).)+\"" ])
+        if it == 0:
+            self.expect("\*stopped,reason=\"end-stepping-range\".+func=\"main\"")
 
     @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_thread_step_over(self):
         """Test that 'lldb-mi --interpreter' can step over by "thread step-over" command."""
 
         self.spawnLldbMi(args = None)

lldb/trunk/test/tools/lldb-mi/control/TestMiExec.py

def test_lldbmi_exec_step(self):
         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\"")
 
         # Warning: the following is sensative to the lines in the source
 
-        # Test that -exec-step does not step into printf (which
-        # has no debug info)
-        #FIXME: is this supposed to step into printf?
+        # Test that -exec-step steps into (or not) printf depending on debug info
+        # Note that message is different in Darwin and Linux:
+        # Darwin: "*stopped,reason=\"end-stepping-range\",frame={addr=\"0x[0-9a-f]+\",func=\"main\",args=[{name=\"argc\",value=\"1\"},{name=\"argv\",value="0x[0-9a-f]+\"}],file=\"main.cpp\",fullname=\".+main.cpp\",line=\"\d\"},thread-id=\"1\",stopped-threads=\"all\"
+        # Linux:  "*stopped,reason=\"end-stepping-range\",frame={addr="0x[0-9a-f]+\",func=\"__printf\",args=[{name=\"format\",value=\"0x[0-9a-f]+\"}],file=\"printf.c\",fullname=\".+printf.c\",line="\d+"},thread-id=\"1\",stopped-threads=\"all\"
         self.runCmd("-exec-step --thread 1 --frame 0")
         self.expect("\^running")
-        self.expect("\*stopped,reason=\"end-stepping-range\".*main.cpp\",line=\"29\"")
+        it = self.expect([ "\*stopped,reason=\"end-stepping-range\".+func=\"main\"",
+                           "\*stopped,reason=\"end-stepping-range\".+func=\"((?!main).)+\"" ])
+        # Exit from printf if needed
+        if it == 1:
+            self.runCmd("-exec-finish")
+            self.expect("\^running")
+            self.expect("\*stopped,reason=\"end-stepping-range\".+func=\"main\"")
 
         # Test that -exec-step steps into g_MyFunction and back out
         # (and that --thread is optional)
         self.runCmd("-exec-step --frame 0")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"end-stepping-range\".*func=\"g_MyFunction\(\)\"")
-        #FIXME: is this supposed to step into printf?
-        self.runCmd("-exec-step --frame 0")
-        self.expect("\^running")
-        self.expect("\*stopped,reason=\"end-stepping-range\".*func=\"g_MyFunction\(\)\"")
         # Use -exec-finish here to make sure that control reaches the caller.
         # -exec-step can keep us in the g_MyFunction for gcc
         self.runCmd("-exec-finish --frame 0")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"end-stepping-range\".*main.cpp\",line=\"30\"")
 
         # Test that -exec-step steps into s_MyFunction
-        self.runCmd("-exec-step --frame 0")
-        self.expect("\^running")
-        self.expect("\*stopped,reason=\"end-stepping-range\".*func=\"s_MyFunction\(\)\"")
-
-        # Test that -exec-step steps into g_MyFunction
         # (and that --frame is optional)
         self.runCmd("-exec-step --thread 1")
         self.expect("\^running")
-        self.expect("\*stopped,reason=\"end-stepping-range\".*func=\"g_MyFunction\(\)\"")
+        self.expect("\*stopped,reason=\"end-stepping-range\".*func=\"s_MyFunction\(\)\"")
 
         # Test that -exec-step steps into g_MyFunction from inside
         # s_MyFunction (and that both --thread and --frame are optional)
         self.runCmd("-exec-step")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"end-stepping-range\".*func=\"g_MyFunction\(\)\"")
 
         # Test that an invalid --thread is handled
         self.runCmd("-exec-step --thread 0")
         self.expect("\^error,message=\"error: Thread index 0 is out of range")
         self.runCmd("-exec-step --thread 10")
         self.expect("\^error,message=\"error: Thread index 10 is out of range")
 
         # Test that an invalid --frame is handled
         # FIXME: no error is returned
         self.runCmd("-exec-step --frame 10")
         #self.expect("\^error: Frame index 10 is out of range")
 
     @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
-    @unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin due to calling convention assumptions")
+    @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_exec_step_instruction(self):
         """Test that 'lldb-mi --interpreter' works for instruction stepping into."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")

lldb/trunk/test/tools/lldb-mi/signal/TestMiSignal.py

 import unittest2
 
 class MiSignalTestCase(lldbmi_testcase.MiTestCaseBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
-    @unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin")
+    @skipIfFreeBSD # llvm.org/pr22411: Fails on FreeBSD apparently due to thread race conditions
     def test_lldbmi_stopped_when_interrupt(self):
         """Test that 'lldb-mi --interpreter' interrupt and resume a looping app."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")
def test_lldbmi_stopped_when_stopatentry_local(self):
 
         # Run with stop-at-entry flag
         self.runCmd("-interpreter-exec command \"process launch -s\"")
         self.expect("\^done")
 
         # Test that *stopped is printed
         # Note that message is different in Darwin and Linux:
         # Darwin: "*stopped,reason=\"signal-received\",signal-name=\"SIGINT\",signal-meaning=\"Interrupt\",frame={level=\"0\",addr=\"0x[0-9a-f]+\",func=\"_dyld_start\",file=\"??\",fullname=\"??\",line=\"-1\"},thread-id=\"1\",stopped-threads=\"all\"
-        # Linux:  "*stopped,reason=\"end-stepping-range\",frame={addr=\"0x[0-9a-f]+\",func=\"??\",args=\[\],file=\"??\",fullname=\"??\",line=\"-1\"},thread-id=\"1\",stopped-threads=\"all\"
-        self.expect("\*stopped,reason=\"(signal-received|end-stepping-range)\",.+,thread-id=\"1\",stopped-threads=\"all\"")
+        # Linux:  "*stopped,reason=\"end-stepping-range\",frame={addr=\"0x[0-9a-f]+\",func=\"??\",args=[],file=\"??\",fullname=\"??\",line=\"-1\"},thread-id=\"1\",stopped-threads=\"all\"
+        self.expect([ "\*stopped,reason=\"signal-received\",signal-name=\"SIGINT\",signal-meaning=\"Interrupt\",frame=\{level=\"0\",addr=\"0x[0-9a-f]+\",func=\"_dyld_start\",file=\"\?\?\",fullname=\"\?\?\",line=\"-1\"\},thread-id=\"1\",stopped-threads=\"all\"",
+                      "\*stopped,reason=\"end-stepping-range\",frame={addr=\"0x[0-9a-f]+\",func=\"\?\?\",args=\[\],file=\"\?\?\",fullname=\"\?\?\",line=\"-1\"},thread-id=\"1\",stopped-threads=\"all\"" ])
 
         # Run to main to make sure we have not exited the application
         self.runCmd("-break-insert -f main")
         self.expect("\^done,bkpt={number=\"1\"")
         self.runCmd("-exec-continue")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
def test_lldbmi_stopped_when_segfault_local(self):
 
         # Set do_segfault=1 and run (to cause a segfault error)
         self.runCmd("-data-evaluate-expression \"do_segfault=1\"")
         self.expect("\^done,value=\"1\"")
         self.runCmd("-exec-continue")
         self.expect("\^running")
 
         # Test that *stopped is printed
-        self.expect("\*stopped,reason=\"exception-received\",exception=\"(EXC_BAD_ACCESS \(code=1, address=0x0\)|invalid address \(fault address: 0x0\))\",thread-id=\"1\",stopped-threads=\"all\"")
+        # Note that message is different in Darwin and Linux:
+        # Darwin: "*stopped,reason=\"exception-received\",exception=\"EXC_BAD_ACCESS (code=1, address=0x0)\",thread-id=\"1\",stopped-threads=\"all\""
+        # Linux:  "*stopped,reason=\"exception-received\",exception=\"invalid address (fault address: 0x0)\",thread-id=\"1\",stopped-threads=\"all\""
+        self.expect([ "\*stopped,reason=\"exception-received\",exception=\"EXC_BAD_ACCESS \(code=1, address=0x0\)\",thread-id=\"1\",stopped-threads=\"all\"",
+                      "\*stopped,reason=\"exception-received\",exception=\"invalid address \(fault address: 0x0\)\",thread-id=\"1\",stopped-threads=\"all\"" ])
 
     @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin")
     def test_lldbmi_stopped_when_segfault_remote(self):
         """Test that 'lldb-mi --interpreter' notifies after it was stopped when segfault occurred (remote)."""
 
         # Prepare debugserver

lldb/trunk/test/tools/lldb-mi/stack/TestMiStack.py

def test_lldbmi_stack_select_frame(self):
         self.runCmd("-stack-info-frame")
         self.expect("\^done,frame=\{level=\"0\",addr=\".+\",func=\"main\",file=\"main\.cpp\",fullname=\".*main\.cpp\",line=\"\d+\"\}")
 
         # Test that -stack-select-frame can select frame #1 (parent frame)
         self.runCmd("-stack-select-frame 1")
         self.expect("\^done")
 
         # Test that current frame is #1
+        # Note that message is different in Darwin and Linux:
+        # Darwin: "^done,frame={level=\"1\",addr=\"0x[0-9a-f]+\",func=\"start\",file=\"??\",fullname=\"??\",line=\"-1\"}"
+        # Linux:  "^done,frame={level=\"1\",addr=\"0x[0-9a-f]+\",func=\".+\",file=\".+\",fullname=\".+\",line=\"\d+\"}"
         self.runCmd("-stack-info-frame")
-        self.expect("\^done,frame=\{level=\"1\",addr=\".+\",func=\".+\",file=\"\?\?\",fullname=\"\?\?\",line=\"-1\"\}")
+        self.expect("\^done,frame=\{level=\"1\",addr=\".+\",func=\".+\",file=\".+\",fullname=\".+\",line=\"(-1|\d+)\"\}")
 
         # Test that -stack-select-frame can select frame #0 (child frame)
         self.runCmd("-stack-select-frame 0")
         self.expect("\^done")
 
         # Test that current frame is #0 and it has the same information
         self.runCmd("-stack-info-frame")
         self.expect("\^done,frame=\{level=\"0\",addr=\".+\",func=\"main\",file=\"main\.cpp\",fullname=\".*main\.cpp\",line=\"\d+\"\}")
 
 if __name__ == '__main__':
     unittest2.main()