Refactor lldb-mi tests

[ki.stfu]

Summary

This patch includes following changes:

• split lldb-mi tests into separate folders. It will make our life simpler because we can modify a test program of certain test and don't worry about other tests
• a bit refactoring
• fix comments
• improve some tests

[ki.stfu]

Refactor MiDataTestCase

[ki.stfu]

Rename "evaluate" folder to "variable"

[ki.stfu]

Update MiExitTestCase/MiSyntaxTestCase/MiLaunchTestCase; MiLaunchTestCase was renamed to MiFileTestCase

[ki.stfu]

Refactor MiStackTestCase

[ki.stfu]

Clean up test/tools/lldb-mi folder

TODO: I'll do the refactoring of these tests later:

• MiExecTestCase
• MiInterpreterExecTestCase
• MiInterruptTestCase
• MiNotificationTestCase

[ki.stfu]

Refactor MiExecTestCase; minor changes

[abidh]

Please dont commit it for now. With this revision applied, I see a lot of error in Linux. Let me have a look first.

[ki.stfu]

Ok, but I'm still working on it.

[abidh]

Please make the following 2 changes and commit.
Enable all tests on Linux.
Fix the main.c as suggested in inline comments.

If there are some failures then I will fix/skip the tests as necessary.

test/tools/lldb-mi/symbol/main.cpp

14

This variable is undeclared. Causes build error.

[ki.stfu]

Refactoring of all remaining tests. Remove all unnecessary files. Fix MiSymbolTestCase

[ki.stfu]

Enable all tests on Linux

[ki.stfu]

Add tests for -var-list-children

[ki.stfu]

All tests pass on OS X. I'll commit it right now.

test/tools/lldb-mi/Makefile

 LEVEL = ../../make
 
-C_SOURCES := main.c a.c b.c loop.c locals.c
+C_SOURCES := main.c a.c b.c loop.c
 
 include $(LEVEL)/Makefile.rules

test/tools/lldb-mi/TestMiExit.py

 """
-Test that the lldb-mi driver works properly with "-gdb-exit".
+Test that the lldb-mi driver exits properly.
 """
 
 import lldbmi_testcase
 from lldbtest import *
 import unittest2
 
 class MiExitTestCase(lldbmi_testcase.MiTestCaseBase):
 
+    mydir = TestBase.compute_mydir(__file__)
+
     @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfLinux # llvm.org/pr22411: Failure presumably due to known thread races
-    def test_lldbmi_gdbexit(self):
-        """Test that '-gdb-exit' terminates debug session and exits."""
+    def test_lldbmi_gdb_exit(self):
+        """Test that '-gdb-exit' terminates local debug session and exits."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")
 
         # Run to main

test/tools/lldb-mi/TestMiFile.py

 """
-Test various ways the lldb-mi driver can launch a program.
+Test lldb-mi -file-xxx commands.
 """
 
 import lldbmi_testcase
 from lldbtest import *
 import unittest2
 
-class MiLaunchTestCase(lldbmi_testcase.MiTestCaseBase):
+class MiFileTestCase(lldbmi_testcase.MiTestCaseBase):
+
+    mydir = TestBase.compute_mydir(__file__)
 
     @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfLinux # llvm.org/pr22411: Failure presumably due to known thread races
-    def test_lldbmi_exe(self):
+    def test_lldbmi_file_exec_and_symbols_file(self):
         """Test that 'lldb-mi --interpreter' works for -file-exec-and-symbols exe."""
 
         self.spawnLldbMi(args = None)
 
-        # Use no path
+        # Test that -file-exec-and-symbols works for filename
         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")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfLinux # llvm.org/pr22411: Failure presumably due to known thread races
-    def test_lldbmi_abspathexe(self):
+    def test_lldbmi_file_exec_and_symbols_absolute_path(self):
         """Test that 'lldb-mi --interpreter' works for -file-exec-and-symbols fullpath/exe."""
 
         self.spawnLldbMi(args = None)
 
-        # Use full path
+        # Test that -file-exec-and-symbols works for absolute path
         import os
-        exe = os.path.join(os.getcwd(), self.myexe)
-        self.runCmd("-file-exec-and-symbols %s" % exe)
+        path = os.path.join(os.getcwd(), self.myexe)
+        self.runCmd("-file-exec-and-symbols \"%s\"" % path)
         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")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfLinux # llvm.org/pr22411: Failure presumably due to known thread races
-    def test_lldbmi_relpathexe(self):
+    def test_lldbmi_file_exec_and_symbols_relative_path(self):
         """Test that 'lldb-mi --interpreter' works for -file-exec-and-symbols relpath/exe."""
 
         self.spawnLldbMi(args = None)
 
-        # Use relative path
-        exe = "../../" + self.mydir + "/" + self.myexe
-        self.runCmd("-file-exec-and-symbols %s" % exe)
+        # Test that -file-exec-and-symbols works for relative path
+        path = "./%s" % self.myexe
+        self.runCmd("-file-exec-and-symbols %s" % path)
         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")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfLinux # llvm.org/pr22411: Failure presumably due to known thread races
-    def test_lldbmi_badpathexe(self):
+    def test_lldbmi_file_exec_and_symbols_unknown_path(self):
         """Test that 'lldb-mi --interpreter' works for -file-exec-and-symbols badpath/exe."""
 
         self.spawnLldbMi(args = None)
 
-        # Use non-existant path
-        exe = "badpath/" + self.myexe
-        self.runCmd("-file-exec-and-symbols %s" % exe)
+        # Test that -file-exec-and-symbols fails on unknown path
+        path = "unknown_dir/%s" % self.myexe
+        self.runCmd("-file-exec-and-symbols %s" % path)
         self.expect("\^error")
 
 if __name__ == '__main__':
     unittest2.main()

test/tools/lldb-mi/TestMiSyntax.py

 """
 Test that the lldb-mi driver understands MI command syntax.
 """
 
 import lldbmi_testcase
 from lldbtest import *
 import unittest2
 
 class MiSyntaxTestCase(lldbmi_testcase.MiTestCaseBase):
 
+    mydir = TestBase.compute_mydir(__file__)
+
     @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfLinux # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_tokens(self):
-        """Test that 'lldb-mi --interpreter' echos command tokens."""
+        """Test that 'lldb-mi --interpreter' prints command tokens."""
 
         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 b_MyFunction")
+        self.runCmd("100000001-break-insert -f main")
         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")
def test_lldbmi_specialchars(self):
         os.symlink(self.myexe, complicated_myexe)
 
         try:
             # Try to load executable with complicated filename
             self.runCmd("-file-exec-and-symbols \"%s\"" % complicated_myexe)
             self.expect("\^done")
 
             # Check that it was loaded correctly
-            self.runCmd("-break-insert -f a_MyFunction")
+            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\"")
 
         finally:
             # Clean up
             os.unlink(complicated_myexe)
 
 if __name__ == '__main__':
     unittest2.main()

test/tools/lldb-mi/breakpoint/Makefile

+LEVEL = ../../../make
+
+CXX_SOURCES := main.cpp
+
+include $(LEVEL)/Makefile.rules

test/tools/lldb-mi/breakpoint/TestMiBreak.py

 """
-Test that the lldb-mi driver understands an MI breakpoint command.
+Test lldb-mi -break-xxx commands.
 """
 
 import lldbmi_testcase
 from lldbtest import *
 import unittest2
 
-class MiBreakpointTestCase(lldbmi_testcase.MiTestCaseBase):
+class MiBreakTestCase(lldbmi_testcase.MiTestCaseBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    @lldbmi_test
+    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
+    @skipIfLinux # llvm.org/pr22411: Failure presumably due to known thread races
+    def test_lldbmi_break_insert_function_pending(self):
+        """Test that 'lldb-mi --interpreter' works for pending function breakpoints."""
+
+        self.spawnLldbMi(args = None)
+
+        self.runCmd("-file-exec-and-symbols %s" % self.myexe)
+        self.expect("\^done")
+
+        self.runCmd("-break-insert -f g_MyFunction")
+        self.expect("\^done,bkpt={number=\"1\"")
+
+        self.runCmd("-exec-run")
+        self.expect("\^running")
+        self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
     @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfLinux # llvm.org/pr22411: Failure presumably due to known thread races
-    def test_lldbmi_pendbreakonsym(self):
-        """Test that 'lldb-mi --interpreter' works for pending symbol breakpoints."""
+    def test_lldbmi_break_insert_function(self):
+        """Test that 'lldb-mi --interpreter' works for function breakpoints."""
 
         self.spawnLldbMi(args = None)
 
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")
 
-        self.runCmd("-break-insert -f b_MyFunction")
+        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\"")
 
+        self.runCmd("-break-insert g_MyFunction")
+        self.expect("\^done,bkpt={number=\"2\"")
+
         self.runCmd("-exec-continue")
         self.expect("\^running")
-        self.expect("\*stopped,reason=\"exited-normally\"")
+        self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
     @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfLinux # llvm.org/pr22411: Failure presumably due to known thread races
-    def test_lldbmi_pendbreakonsrc(self):
-        """Test that 'lldb-mi --interpreter' works for pending source breakpoints."""
+    def test_lldbmi_break_insert_file_line_pending(self):
+        """Test that 'lldb-mi --interpreter' works for pending file:line breakpoints."""
 
         self.spawnLldbMi(args = None)
 
         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)
+        line = line_number('main.cpp', '// BP_return')
+        self.runCmd("-break-insert -f main.cpp:%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")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfLinux # llvm.org/pr22411: Failure presumably due to known thread races
-    def test_lldbmi_breakpoints(self):
-        """Test that 'lldb-mi --interpreter' works for breakpoints."""
+    def test_lldbmi_break_insert_file_line(self):
+        """Test that 'lldb-mi --interpreter' works for file:line breakpoints."""
 
         self.spawnLldbMi(args = None)
 
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")
 
         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 b_MyFunction")
+        line = line_number('main.cpp', '// BP_return')
+        self.runCmd("-break-insert main.cpp:%d" % line)
         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\"")
-
-        # Check with full path. TODO, figure out why this commands fails
-        # if -f is not given
-        line = line_number('main.c', '// BP_doloop')
-        full_path = os.path.join(os.getcwd(), "main.c")
-        self.runCmd("-break-insert -f %s:%d" % (full_path, line))
-        self.expect("\^done,bkpt={number=\"4\"")
+    @lldbmi_test
+    @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
+    @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
+    @skipIfLinux # llvm.org/pr22411: Failure presumably due to known thread races
+    @unittest2.expectedFailure("-break-insert doesn't work for absolute path")
+    def test_lldbmi_break_insert_file_line_absolute_path(self):
+        """Test that 'lldb-mi --interpreter' works for file:line breakpoints."""
 
-        self.runCmd("-exec-continue")
-        self.expect("\^running")
-        self.expect("\*stopped,reason=\"breakpoint-hit\"")
+        self.spawnLldbMi(args = None)
 
-        self.runCmd("-exec-continue")
+        self.runCmd("-file-exec-and-symbols %s" % self.myexe)
+        self.expect("\^done")
+
+        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 exit
+        import os
+        path = os.path.join(os.getcwd(), "main.cpp")
+        line = line_number('main.cpp', '// BP_return')
+        self.runCmd("-break-insert %s:%d" % (path, line))
+        self.expect("\^done,bkpt={number=\"2\"")
+
         self.runCmd("-exec-continue")
         self.expect("\^running")
-        self.expect("\*stopped,reason=\"exited-normally\"")
+        self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
 if __name__ == '__main__':
     unittest2.main()

test/tools/lldb-mi/breakpoint/main.cpp

+//===-- main.cpp ------------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+void
+g_MyFunction(void)
+{
+}
+
+int
+main(int argc, char const *argv[])
+{
+    g_MyFunction();
+    return 0; // BP_return
+}

test/tools/lldb-mi/control/Makefile

+LEVEL = ../../../make
+
+CXX_SOURCES := main.cpp
+
+include $(LEVEL)/Makefile.rules

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

 """
-Test that the lldb-mi driver works with -exec-xxx commands
+Test lldb-mi -exec-xxx commands.
 """
 
 import lldbmi_testcase
 from lldbtest import *
 import unittest2
 
 class MiExecTestCase(lldbmi_testcase.MiTestCaseBase):
 
+    mydir = TestBase.compute_mydir(__file__)
+
     @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @unittest2.skip("-exec-abort isn't implemented")
     def test_lldbmi_exec_abort(self):
         """Test that 'lldb-mi --interpreter' works for -exec-abort."""
 
         self.spawnLldbMi(args = None)
 
def test_lldbmi_exec_arguments_reset(self):
 
         self.spawnLldbMi(args = None)
 
         # Load executable
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")
 
         # Set arguments
-        self.runCmd("-exec-arguments foo bar baz")
+        self.runCmd("-exec-arguments arg1")
         self.expect("\^done")
         self.runCmd("-exec-arguments")
         self.expect("\^done")
 
         # Run to main
         self.runCmd("-break-insert -f main")
         self.expect("\^done,bkpt={number=\"1\"")
         self.runCmd("-exec-run")
def test_lldbmi_exec_next(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\"")
 
-        # Warning: the following is sensative to the lines in the source.
+        # Warning: the following is sensative to the lines in the source
 
         # Test -exec-next
         self.runCmd("-exec-next --thread 1 --frame 0")
         self.expect("\^running")
-        self.expect("\*stopped,reason=\"end-stepping-range\".*main.c\",line=\"26\"")
+        self.expect("\*stopped,reason=\"end-stepping-range\".*main.cpp\",line=\"29\"")
 
         # Test that --thread is optional
         self.runCmd("-exec-next --frame 0")
         self.expect("\^running")
-        self.expect("\*stopped,reason=\"end-stepping-range\".*main.c\",line=\"27\"")
+        self.expect("\*stopped,reason=\"end-stepping-range\".*main.cpp\",line=\"30\"")
 
         # Test that --frame is optional
         self.runCmd("-exec-next --thread 1")
         self.expect("\^running")
-        self.expect("\*stopped,reason=\"end-stepping-range\".*main.c\",line=\"29\"")
+        self.expect("\*stopped,reason=\"end-stepping-range\".*main.cpp\",line=\"31\"")
 
         # Test that both --thread and --frame are optional
-        self.runCmd("-exec-next --thread 1")
+        self.runCmd("-exec-next")
         self.expect("\^running")
-        self.expect("\*stopped,reason=\"end-stepping-range\".*main.c\",line=\"31\"")
+        self.expect("\*stopped,reason=\"end-stepping-range\".*main.cpp\",line=\"32\"")
 
         # Test that an invalid --thread is handled
         self.runCmd("-exec-next --thread 0")
         self.expect("\^error,message=\"error: Thread index 0 is out of range")
         self.runCmd("-exec-next --thread 10")
         self.expect("\^error,message=\"error: Thread index 10 is out of range")
 
         # Test that an invalid --frame is handled
def test_lldbmi_exec_next_instruction(self):
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
         # Warning: the following is sensative to the lines in the
         # source and optimizations
 
         # Test -exec-next-instruction
         self.runCmd("-exec-next-instruction --thread 1 --frame 0")
         self.expect("\^running")
-        self.expect("\*stopped,reason=\"end-stepping-range\".*main.c\",line=\"24\"")
+        self.expect("\*stopped,reason=\"end-stepping-range\".*main.cpp\",line=\"28\"")
 
         # Test that --thread is optional
         self.runCmd("-exec-next-instruction --frame 0")
         self.expect("\^running")
-        self.expect("\*stopped,reason=\"end-stepping-range\".*main.c\",line=\"24\"")
+        self.expect("\*stopped,reason=\"end-stepping-range\".*main.cpp\",line=\"28\"")
 
         # Test that --frame is optional
         self.runCmd("-exec-next-instruction --thread 1")
         self.expect("\^running")
-        self.expect("\*stopped,reason=\"end-stepping-range\".*main.c\",line=\"24\"")
+        self.expect("\*stopped,reason=\"end-stepping-range\".*main.cpp\",line=\"29\"")
 
         # Test that both --thread and --frame are optional
-        self.runCmd("-exec-next-instruction --thread 1")
+        self.runCmd("-exec-next-instruction")
         self.expect("\^running")
-        # Depending on compiler, it can stop at different line.
-        self.expect("\*stopped,reason=\"end-stepping-range\".*main.c\",line=\"2[4-6]\"")
+        # Depending on compiler, it can stop at different line
+        self.expect("\*stopped,reason=\"end-stepping-range\".*main.cpp\",line=\"29\"")
 
         # Test that an invalid --thread is handled
         self.runCmd("-exec-next-instruction --thread 0")
         self.expect("\^error,message=\"error: Thread index 0 is out of range")
         self.runCmd("-exec-next-instruction --thread 10")
         self.expect("\^error,message=\"error: Thread index 10 is out of range")
 
         # Test that an invalid --frame is handled
def test_lldbmi_exec_step(self):
         """Test that 'lldb-mi --interpreter' works for stepping into."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")
 
-        # Run to printf call
-        line = line_number('main.c', '//BP_printf_call')
-        self.runCmd("-break-insert -f main.c:%d" % line)
+        # 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\"")
 
         # 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?
         self.runCmd("-exec-step --thread 1 --frame 0")
         self.expect("\^running")
-        self.expect("\*stopped,reason=\"end-stepping-range\".*main.c\",line=\"26\"")
+        self.expect("\*stopped,reason=\"end-stepping-range\".*main.cpp\",line=\"29\"")
 
-        # Test that -exec-step steps into a_MyFunction and back out
+        # 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=\"a_MyFunction\"")
+        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=\"a_MyFunction\"")
+        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 a_MyFunction for gcc
+        # -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.c\",line=\"26\"")
+        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\".*main.c\",line=\"27\"")
+        self.expect("\*stopped,reason=\"end-stepping-range\".*func=\"s_MyFunction\(\)\"")
 
-        # Test that -exec-step steps into b_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=\"b_MyFunction\"")
+        self.expect("\*stopped,reason=\"end-stepping-range\".*func=\"g_MyFunction\(\)\"")
 
-        # Test that -exec-step steps into a_MyFunction from inside
-        # b_MyFunction (and that both --thread and --frame are optional)
+        # 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=\"a_MyFunction\"")
+        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
def test_lldbmi_exec_step_instruction(self):
 
         # Load executable
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")
 
         # Warning: the following is sensative to the lines in the
         # source and optimizations
 
-        # Run to a_MyFunction call
-        line = line_number('main.c', '//BP_a_MyFunction_call')
-        self.runCmd("-break-insert -f main.c:%d" % line)
+        # 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 -exec-next steps over printf
+        self.runCmd("-exec-next --thread 1 --frame 0")
+        self.expect("\^running")
+        self.expect("\*stopped,reason=\"end-stepping-range\".*main.cpp\",line=\"29\"")
+
         # Test that -exec-step-instruction steps over non branching
         # instruction
         self.runCmd("-exec-step-instruction --thread 1 --frame 0")
         self.expect("\^running")
-        self.expect("\*stopped,reason=\"end-stepping-range\".*main.c\",line=\"2[4-6]\"")
+        self.expect("\*stopped,reason=\"end-stepping-range\".*main.cpp\",line=\"2[8-9]\"")
 
-        # Test that -exec-step-instruction steps over non branching
+        # Test that -exec-step-instruction steps into g_MyFunction
         # instruction (and that --thread is optional)
         self.runCmd("-exec-step-instruction --frame 0")
         self.expect("\^running")
-        self.expect("\*stopped,reason=\"end-stepping-range\".*main.c\",line=\"2[4-6]\"")
+        self.expect("\*stopped,reason=\"end-stepping-range\".*func=\"g_MyFunction\(\)\"")
 
-        # Test that -exec-step-instruction steps into a_MyFunction
+        # Test that -exec-step-instruction steps over non branching
         # (and that --frame is optional)
         self.runCmd("-exec-step-instruction --thread 1")
         self.expect("\^running")
-        self.expect("\*stopped,reason=\"end-stepping-range\".*func=\"a_MyFunction\"")
+        self.expect("\*stopped,reason=\"end-stepping-range\".*func=\"g_MyFunction\(\)\"")
 
-        # Test that -exec-step-instruction steps into a_MyFunction
+        # Test that -exec-step-instruction steps into g_MyFunction
         # (and that both --thread and --frame are optional)
-        self.runCmd("-exec-step-instruction --thread 1")
+        self.runCmd("-exec-step-instruction")
         self.expect("\^running")
-        self.expect("\*stopped,reason=\"end-stepping-range\".*func=\"a_MyFunction\"")
+        self.expect("\*stopped,reason=\"end-stepping-range\".*func=\"g_MyFunction\(\)\"")
 
         # Test that an invalid --thread is handled
         self.runCmd("-exec-step-instruction --thread 0")
         self.expect("\^error,message=\"error: Thread index 0 is out of range")
         self.runCmd("-exec-step-instruction --thread 10")
         self.expect("\^error,message=\"error: Thread index 10 is out of range")
 
         # Test that an invalid --frame is handled
def test_lldbmi_exec_finish(self):
         """Test that 'lldb-mi --interpreter' works for -exec-finish."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")
 
-        # Set argument 'l'
-        self.runCmd("-exec-arguments l")
-        self.expect("\^done")
-
-        # Set BP at a_MyFunction_call and run to BP
-        self.runCmd("-break-insert -f a_MyFunction")
+        # Set BP at g_MyFunction and run to BP
+        self.runCmd("-break-insert -f g_MyFunction")
         self.expect("\^done,bkpt={number=\"1\"")
         self.runCmd("-exec-run")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
-        # Test that -exec-finish returns from a_MyFunction
+        # Test that -exec-finish returns from g_MyFunction
         self.runCmd("-exec-finish --thread 1 --frame 0")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"end-stepping-range\".*func=\"main\"")
 
-        # Run to BP inside b_MyFunction call
-        line = line_number('b.c', '//BP_b_MyFunction')
-        self.runCmd("-break-insert -f b.c:%d" % line)
+        # Run to BP inside s_MyFunction call
+        self.runCmd("-break-insert s_MyFunction")
         self.expect("\^done,bkpt={number=\"2\"")
         self.runCmd("-exec-continue")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
-        # Test that -exec-finish hits BP at a_MyFunction call inside
-        # b_MyFunction (and that --thread is optional)
+        # Test that -exec-finish hits BP at g_MyFunction call inside
+        # s_MyFunction (and that --thread is optional)
         self.runCmd("-exec-finish --frame 0")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
-        # Test that -exec-finish returns from a_MyFunction call inside
-        # b_MyFunction (and that --frame is optional)
+        # Test that -exec-finish returns from g_MyFunction call inside
+        # s_MyFunction (and that --frame is optional)
         self.runCmd("-exec-finish --thread 1")
         self.expect("\^running")
-        self.expect("\*stopped,reason=\"end-stepping-range\".*func=\"b_MyFunction\"")
+        self.expect("\*stopped,reason=\"end-stepping-range\".*func=\"s_MyFunction\(\)\"")
 
-        # Test that -exec-finish returns from b_MyFunction
+        # Test that -exec-finish returns from s_MyFunction
         # (and that both --thread and --frame are optional)
         self.runCmd("-exec-finish")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"end-stepping-range\".*func=\"main\"")
 
         # Test that an invalid --thread is handled
         self.runCmd("-exec-finish --thread 0")
         self.expect("\^error,message=\"error: Thread index 0 is out of range")
         self.runCmd("-exec-finish --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-finish --frame 10")
         #self.expect("\^error: Frame index 10 is out of range")
 
         # Set BP at printf and run to BP
         # FIXME: BP at printf not resolved and never hit!
-        self.runCmd("-interpreter-exec command \"b printf\"") #FIXME: self.runCmd("-break-insert -f printf")
-        self.expect("\^done")                                 #FIXME: self.expect("\^done,bkpt={number=\"3\"")
+        self.runCmd("-interpreter-exec command \"breakpoint set --name printf\"") #FIXME: self.runCmd("-break-insert -f printf")
+        self.expect("\^done")                                                     #FIXME: self.expect("\^done,bkpt={number=\"3\"")
         self.runCmd("-exec-continue")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
         ## Test that -exec-finish returns from printf
         self.runCmd("-exec-finish --thread 1 --frame 0")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"end-stepping-range\".*func=\"main\"")
 
 if __name__ == '__main__':
     unittest2.main()

test/tools/lldb-mi/control/main.cpp

+//===-- main.cpp ------------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include <cstdio>
+
+void
+g_MyFunction(void)
+{
+    printf("g_MyFunction");
+}
+
+static void
+s_MyFunction(void)
+{
+    g_MyFunction();
+    printf("s_MyFunction");
+}
+
+int
+main(int argc, char const *argv[])
+{
+    printf("start");
+    g_MyFunction();
+    s_MyFunction();
+    printf("exit");
+    return 0;
+}

test/tools/lldb-mi/data/Makefile

+LEVEL = ../../../make
+
+CXX_SOURCES := main.cpp
+
+include $(LEVEL)/Makefile.rules

test/tools/lldb-mi/data/TestMiData.py

 """
-Test that the lldb-mi driver works with -data-xxx commands
+Test lldb-mi -data-xxx commands.
 """
 
 import lldbmi_testcase
 from lldbtest import *
 import unittest2
 
 class MiDataTestCase(lldbmi_testcase.MiTestCaseBase):
 
+    mydir = TestBase.compute_mydir(__file__)
+
     @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfLinux # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_data_disassemble(self):
         """Test that 'lldb-mi --interpreter' works for -data-disassemble."""
 
         self.spawnLldbMi(args = None)
def test_lldbmi_data_disassemble(self):
         # Test -data-disassemble: try to disassemble some address
         self.runCmd("-data-disassemble -s %#x -e %#x -- 0" % (addr, addr + 0x10))
         self.expect("\^done,asm_insns=\[{address=\"0x%08x\",func-name=\"main\",offset=\"0\",size=\"[1-9]+\",inst=\".+\"}," % addr)
 
     @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfLinux # llvm.org/pr22411: Failure presumably due to known thread races
+    @unittest2.skip("-data-evaluate-expression doesn't work") #FIXME: the global case worked before refactoring
     def test_lldbmi_data_read_memory_bytes(self):
         """Test that 'lldb-mi --interpreter' works for -data-read-memory-bytes."""
 
         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\"")
 
-        # Get address of s_RawData
-        self.runCmd("-data-evaluate-expression &s_RawData")
-        self.expect("\^done,value=\"0x[0-9a-f]+\"",timeout=1)
+        # Get address of char[] (global)
+        self.runCmd("-data-evaluate-expression &g_CharArray")
+        self.expect("\^done,value=\"0x[0-9a-f]+\"")
+        addr = int(self.child.after.split("\"")[1], 16)
+        size = 5
+
+        # Test that -data-read-memory-bytes works for char[] type (global)
+        self.runCmd("-data-read-memory-bytes %#x %d" % (addr, size))
+        self.expect("\^done,memory=\[{begin=\"0x0*%x\",offset=\"0x0+\",end=\"0x0*%x\",contents=\"1112131400\"}\]" % (addr, addr + size))
+
+        # Get address of static char[]
+        self.runCmd("-data-evaluate-expression &s_CharArray")
+        self.expect("\^done,value=\"0x[0-9a-f]+\"")
         addr = int(self.child.after.split("\"")[1], 16)
         size = 5
 
-        # Test -data-read-memory-bytes: try to read data of s_RawData
+        # Test that -data-read-memory-bytes works for static char[] type
         self.runCmd("-data-read-memory-bytes %#x %d" % (addr, size))
-        self.expect("\^done,memory=\[{begin=\"0x0*%x\",offset=\"0x0+\",end=\"0x0*%x\",contents=\"1234567800\"}\]" % (addr, addr + size))
+        self.expect("\^done,memory=\[{begin=\"0x0*%x\",offset=\"0x0+\",end=\"0x0*%x\",contents=\"1112131400\"}\]" % (addr, addr + size))
 
     @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfLinux # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_data_list_register_names(self):
         """Test that 'lldb-mi --interpreter' works for -data-list-register-names."""
 

test/tools/lldb-mi/data/main.cpp

+//===-- main.cpp ------------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+const char g_CharArray[] = "\x10\x11\x12\x13";
+static const char s_CharArray[] = "\x20\x21\x22\x23";
+
+int
+main(int argc, char const *argv[])
+{
+    return 0;
+}

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__)
+    mydir = Base.compute_mydir(__file__) #TODO remove me
     myexe = "a.out"
     mylog = "child.log"
 
     @classmethod
     def classCleanup(cls):
         TestBase.RemoveTempFile(cls.myexe)
         TestBase.RemoveTempFile(cls.mylog)
 

test/tools/lldb-mi/locals.c

-struct inner
-{
-    int var_d;
-};
-
-struct my_type
-{
-    int var_a;
-    char var_b;
-    struct inner inner_;
-};
-
-int local_struct_test(void)
-{
-    struct my_type var_c;
-    var_c.var_a = 10;
-    var_c.var_b = 'a';
-    var_c.inner_.var_d = 30;
-    return 0; // BP_LOCAL_STRUCT
-}
-
-int local_array_test(void)
-{
-    int array[3];
-    array[0] = 100;
-    array[1] = 200;
-    array[2] = 300;
-    return 0; // BP_LOCAL_ARRAY
-}
-
-int local_pointer_test(void)
-{
-    const char* test_str = "Rakaposhi";
-    int var_e = 24;
-    int *ptr = &var_e;
-    return 0; // BP_LOCAL_PTR
-}
-
-int local_test()
-{
-    local_struct_test();
-    local_array_test();
-    local_pointer_test();
-    return 0;
-}
 

test/tools/lldb-mi/main.c

 //===-- main.c --------------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include <stdio.h>
 extern int a_MyFunction();
 extern int b_MyFunction();
 extern int infloop();
-extern int local_test();
+
 int doloop, dosegfault;
-int g_MyVar = 3;
-static int s_MyVar = 4;
-//FIXME -data-evaluate-expression/print can't evaluate value of type "static char[]"
-const char s_RawData[] = "\x12\x34\x56\x78"; //FIXME static const char s_RawData[] = "\x12\x34\x56\x78";
+
+
+
+
 
 int main (int argc, char const *argv[])
-{ //FUNC_main
+{
     int a, b;
     printf("argc=%d\n", argc);   //BP_printf_call
     //BP_argctest
     a = a_MyFunction();          //BP_a_MyFunction_call
     b = b_MyFunction();          //BP_b_MyFunction_call
-    //BP_localstest -- it must be at line #24 (or fix it in main*.micmds)
+
     if (doloop) // BP_doloop
         infloop();
     if (dosegfault)
         *(volatile int *)NULL = 1;
     if (argc > 1 && *argv[1] == 'l') {
         a++;
-        printf("a=%d, argv[1]=%s\n", a, argv[1]); //BP_argtest
+        printf("a=%d, argv[1]=%s\n", a, argv[1]);
     }
-    s_MyVar = a + b;
-    local_test();
-    return a + b - s_MyVar; //BP_source
+
+
+    return a + b;
 }

test/tools/lldb-mi/stack/Makefile

+LEVEL = ../../../make
+
+CXX_SOURCES := main.cpp
+
+include $(LEVEL)/Makefile.rules

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

 """
-Test that the lldb-mi driver works with -stack-xxx commands
+Test lldb-mi -stack-xxx commands.
 """
 
 import lldbmi_testcase
 from lldbtest import *
 import unittest2
 
 class MiStackTestCase(lldbmi_testcase.MiTestCaseBase):
 
+    mydir = TestBase.compute_mydir(__file__)
+
     @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfLinux # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_stack_list_arguments(self):
         """Test that 'lldb-mi --interpreter' can shows arguments."""
 
         self.spawnLldbMi(args = None)
def test_lldbmi_stack_list_locals(self):
 
         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.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 int local variables:
+        # Run to BP_local_int_test
+        line = line_number('main.cpp', '// BP_local_int_test')
+        self.runCmd("-break-insert --file main.cpp:%d" % line)
+        self.expect("\^done,bkpt={number=\"2\"")
+        self.runCmd("-exec-continue")
+        self.expect("\^running")
+        self.expect("\*stopped,reason=\"breakpoint-hit\"")
+
         # Test -stack-list-locals: use 0 or --no-values
         self.runCmd("-stack-list-locals 0")
         self.expect("\^done,locals=\[name=\"a\",name=\"b\"\]")
         self.runCmd("-stack-list-locals --no-values")
         self.expect("\^done,locals=\[name=\"a\",name=\"b\"\]")
 
         # Test -stack-list-locals: use 1 or --all-values
         self.runCmd("-stack-list-locals 1")
         self.expect("\^done,locals=\[{name=\"a\",value=\"10\"},{name=\"b\",value=\"20\"}\]")
         self.runCmd("-stack-list-locals --all-values")
         self.expect("\^done,locals=\[{name=\"a\",value=\"10\"},{name=\"b\",value=\"20\"}\]")
 
         # Test -stack-list-locals: use 2 or --simple-values
         self.runCmd("-stack-list-locals 2")
         self.expect("\^done,locals=\[{name=\"a\",value=\"10\"},{name=\"b\",value=\"20\"}\]")
         self.runCmd("-stack-list-locals --simple-values")
         self.expect("\^done,locals=\[{name=\"a\",value=\"10\"},{name=\"b\",value=\"20\"}\]")
         
-        # Test struct local variable
-        line = line_number('locals.c', '// BP_LOCAL_STRUCT')
-        self.runCmd("-break-insert --file locals.c:%d" % line)
-        self.expect("\^done,bkpt={number=\"2\"")
-
+        # Test struct local variable:
+        # Run to BP_local_struct_test
+        line = line_number('main.cpp', '// BP_local_struct_test')
+        self.runCmd("-break-insert --file main.cpp:%d" % line)
+        self.expect("\^done,bkpt={number=\"3\"")
         self.runCmd("-exec-continue")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
         
         # Test -stack-list-locals: use 0 or --no-values
         self.runCmd("-stack-list-locals 0")
         self.expect("\^done,locals=\[name=\"var_c\"\]")
         self.runCmd("-stack-list-locals --no-values")
         self.expect("\^done,locals=\[name=\"var_c\"\]")
 
         # Test -stack-list-locals: use 1 or --all-values
         self.runCmd("-stack-list-locals 1")
         self.expect("\^done,locals=\[{name=\"var_c\",value=\"{var_a = 10,var_b = 97 'a',inner_ = { var_d = 30 }}\"}\]")
         self.runCmd("-stack-list-locals --all-values")
         self.expect("\^done,locals=\[{name=\"var_c\",value=\"{var_a = 10,var_b = 97 'a',inner_ = { var_d = 30 }}\"}\]")
 
         # Test -stack-list-locals: use 2 or --simple-values
         self.runCmd("-stack-list-locals 2")
         self.expect("\^done,locals=\[name=\"var_c\"\]")
         self.runCmd("-stack-list-locals --simple-values")
         self.expect("\^done,locals=\[name=\"var_c\"\]")
         
-        # Test array local variable
-        line = line_number('locals.c', '// BP_LOCAL_ARRAY')
-        self.runCmd("-break-insert --file locals.c:%d" % line)
-        self.expect("\^done,bkpt={number=\"3\"")
-
+        # Test array local variable:
+        # Run to BP_local_array_test
+        line = line_number('main.cpp', '// BP_local_array_test')
+        self.runCmd("-break-insert --file main.cpp:%d" % line)
+        self.expect("\^done,bkpt={number=\"4\"")
         self.runCmd("-exec-continue")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
         
         # Test -stack-list-locals: use 0 or --no-values
         self.runCmd("-stack-list-locals 0")
         self.expect("\^done,locals=\[name=\"array\"\]")
         self.runCmd("-stack-list-locals --no-values")
         self.expect("\^done,locals=\[name=\"array\"\]")
 
         # Test -stack-list-locals: use 1 or --all-values
         self.runCmd("-stack-list-locals 1")
         self.expect("\^done,locals=\[{name=\"array\",value=\"{\[0\] = 100,\[1\] = 200,\[2\] = 300}\"}\]")
         self.runCmd("-stack-list-locals --all-values")
         self.expect("\^done,locals=\[{name=\"array\",value=\"{\[0\] = 100,\[1\] = 200,\[2\] = 300}\"}\]")
 
         # Test -stack-list-locals: use 2 or --simple-values
         self.runCmd("-stack-list-locals 2")
         self.expect("\^done,locals=\[name=\"array\"\]")
         self.runCmd("-stack-list-locals --simple-values")
         self.expect("\^done,locals=\[name=\"array\"\]")
         
-        # Test pointers as local variable
-        line = line_number('locals.c', '// BP_LOCAL_PTR')
-        self.runCmd("-break-insert --file locals.c:%d" % line)
-        self.expect("\^done,bkpt={number=\"4\"")
-
+        # Test pointers as local variable:
+        # Run to BP_local_pointer_test
+        line = line_number('main.cpp', '// BP_local_pointer_test')
+        self.runCmd("-break-insert --file main.cpp:%d" % line)
+        self.expect("\^done,bkpt={number=\"5\"")
         self.runCmd("-exec-continue")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
         
         # Test -stack-list-locals: use 0 or --no-values
         self.runCmd("-stack-list-locals 0")
         self.expect("\^done,locals=\[name=\"test_str\",name=\"var_e\",name=\"ptr\"\]")
         self.runCmd("-stack-list-locals --no-values")
def test_lldbmi_stack_info_frame(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\"")
 
         # Test that -stack-info-frame works when program is running
         self.runCmd("-stack-info-frame")
-        self.expect("\^done,frame=\{level=\"0\",addr=\".+\",func=\"main\",file=\"main\.c\",fullname=\".*main\.c\",line=\"\d+\"\}")
+        self.expect("\^done,frame=\{level=\"0\",addr=\".+\",func=\"main\",file=\"main\.cpp\",fullname=\".*main\.cpp\",line=\"\d+\"\}")
 
     @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfLinux # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_stack_list_frames(self):
         """Test that 'lldb-mi --interpreter' can lists the frames on the stack."""
 
         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 stack frame: get frame #0 info
         self.runCmd("-stack-list-frames 0 0")
-        self.expect("\^done,stack=\[frame=\{level=\"0\",addr=\".+\",func=\"main\",file=\"main\.c\",fullname=\".*main\.c\",line=\".+\"\}\]")
+        self.expect("\^done,stack=\[frame=\{level=\"0\",addr=\".+\",func=\"main\",file=\"main\.cpp\",fullname=\".*main\.cpp\",line=\".+\"\}\]")
 
     @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfLinux # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_stack_select_frame(self):
         """Test that 'lldb-mi --interpreter' can choose current frame."""
 
def test_lldbmi_stack_select_frame(self):
         self.expect("\^error,msg=\"Command 'stack-select-frame'. Command Args. Missing options, 1 or more required\"")
 
         # Test that -stack-select-frame fails on invalid frame number
         self.runCmd("-stack-select-frame 99")
         self.expect("\^error,msg=\"Command 'stack-select-frame'. Frame ID invalid\"")
 
         # Test that current frame is #0
         self.runCmd("-stack-info-frame")
-        self.expect("\^done,frame=\{level=\"0\",addr=\".+\",func=\"main\",file=\"main\.c\",fullname=\".*main\.c\",line=\"\d+\"\}")
+        self.expect("\^done,frame=\{level=\"0\",addr=\".+\",func=\"main\",file=\"main\.cpp\",fullname=\".*main\.cpp\",line=\"\d+\"\}")
 
         # Test that -stack-select-frame can select the selected frame
         self.runCmd("-stack-select-frame 0")
         self.expect("\^done")
 
         # Test that current frame is still #0
         self.runCmd("-stack-info-frame")
-        self.expect("\^done,frame=\{level=\"0\",addr=\".+\",func=\"main\",file=\"main\.c\",fullname=\".*main\.c\",line=\"\d+\"\}")
+        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
         self.runCmd("-stack-info-frame")
         self.expect("\^done,frame=\{level=\"1\",addr=\".+\",func=\".+\",file=\"\?\?\",fullname=\"\?\?\",line=\"-1\"\}")
 
         # 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\.c\",fullname=\".*main\.c\",line=\"\d+\"\}")
+        self.expect("\^done,frame=\{level=\"0\",addr=\".+\",func=\"main\",file=\"main\.cpp\",fullname=\".*main\.cpp\",line=\"\d+\"\}")
 
 if __name__ == '__main__':
     unittest2.main()

test/tools/lldb-mi/stack/main.cpp

+//===-- main.cpp ------------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+struct inner
+{
+    int var_d;
+};
+
+struct my_type
+{
+    int var_a;
+    char var_b;
+    struct inner inner_;
+};
+
+int
+local_int_test(void)
+{
+    int a = 10, b = 20;
+    return 0; // BP_local_int_test
+}
+
+int
+local_struct_test(void)
+{
+    struct my_type var_c;
+    var_c.var_a = 10;
+    var_c.var_b = 'a';
+    var_c.inner_.var_d = 30;
+    return 0; // BP_local_struct_test
+}
+
+int
+local_array_test(void)
+{
+    int array[3];
+    array[0] = 100;
+    array[1] = 200;
+    array[2] = 300;
+    return 0; // BP_local_array_test
+}
+
+int
+local_pointer_test(void)
+{
+    const char *test_str = "Rakaposhi";
+    int var_e = 24;
+    int *ptr = &var_e;
+    return 0; // BP_local_pointer_test
+}
+
+int
+main(int argc, char const *argv[])
+{
+    local_int_test();
+    local_struct_test();
+    local_array_test();
+    local_pointer_test();
+    return 0;
+}

test/tools/lldb-mi/symbol/Makefile

+LEVEL = ../../../make
+
+CXX_SOURCES := main.cpp
+
+include $(LEVEL)/Makefile.rules

test/tools/lldb-mi/symbol/TestMiSymbol.py

 """
-Test that the lldb-mi driver works with -symbol-xxx commands
+Test lldb-mi -symbol-xxx commands.
 """
 
 import lldbmi_testcase
 from lldbtest import *
 import unittest2
 
 class MiSymbolTestCase(lldbmi_testcase.MiTestCaseBase):
 
+    mydir = TestBase.compute_mydir(__file__)
+
     @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfLinux # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_symbol_list_lines_file(self):
         """Test that 'lldb-mi --interpreter' works for -symbol-list-lines when file exists."""
 
         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\"")
 
-        # Get address of main
+        # Get address of main and its line
         self.runCmd("-data-evaluate-expression main")
         self.expect("\^done,value=\"0x[0-9a-f]+\"")
-        main_addr = int(self.child.after.split("\"")[1], 16)
-        main_line = line_number('main.c', '//FUNC_main')
+        addr = int(self.child.after.split("\"")[1], 16)
+        line = line_number('main.c', '// BP_main')
 
         # Test that -symbol-list-lines works on valid data
-        self.runCmd("-symbol-list-lines main.c")
-        self.expect("\^done,lines=\[\{pc=\"0x0*%x\",line=\"%d\"\}(,\{pc=\"0x[0-9a-f]+\",line=\"\d+\"\})+\]" % (main_addr, main_line))
+        self.runCmd("-symbol-list-lines main.cpp")
+        self.expect("\^done,lines=\[\{pc=\"0x0*%x\",line=\"%d\"\}(,\{pc=\"0x[0-9a-f]+\",line=\"\d+\"\})+\]" % (addr, line))
 
         # Test that -symbol-list-lines fails when file doesn't exist
         self.runCmd("-symbol-list-lines unknown_file")
         self.expect("\^error,message=\"warning: No source filenames matched 'unknown_file'. error: no source filenames matched any command arguments \"")
 
         # Test that -symbol-list-lines fails when file is specified using relative path
-        self.runCmd("-symbol-list-lines ./main.c")
+        self.runCmd("-symbol-list-lines ./main.cpp")
         self.expect("\^error,message=\"warning: No source filenames matched './main.c'. error: no source filenames matched any command arguments \"")
 
         # Test that -symbol-list-lines works when file is specified using absolute path
         import os
-        main_file = os.path.join(os.getcwd(), "main.c")
-        self.runCmd("-symbol-list-lines \"%s\"" % main_file)
-        self.expect("\^done,lines=\[\{pc=\"0x0*%x\",line=\"%d\"\}(,\{pc=\"0x[0-9a-f]+\",line=\"\d+\"\})+\]" % (main_addr, main_line))
+        path = os.path.join(os.getcwd(), "main.cpp")
+        self.runCmd("-symbol-list-lines \"%s\"" % path)
+        self.expect("\^done,lines=\[\{pc=\"0x0*%x\",line=\"%d\"\}(,\{pc=\"0x[0-9a-f]+\",line=\"\d+\"\})+\]" % (addr, line))
 
         # Test that -symbol-list-lines fails when file doesn't exist
-        self.runCmd("-symbol-list-lines unknown_dir/main.c")
+        self.runCmd("-symbol-list-lines unknown_dir/main.cpp")
         self.expect("\^error,message=\"warning: No source filenames matched 'unknown_dir/main.c'. error: no source filenames matched any command arguments \"")
 
 if __name__ == '__main__':
     unittest2.main()

test/tools/lldb-mi/symbol/main.cpp

+//===-- main.cpp ------------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+int
+main(int argc, char const *argv[]) // BP_main
+{
+    int a = 10, b = 20;
+    s_MyVar = a + b;
+    return 0; // BP_return
+}

test/tools/lldb-mi/variable/Makefile

+LEVEL = ../../../make
+
+CXX_SOURCES := main.cpp
+
+include $(LEVEL)/Makefile.rules

test/tools/lldb-mi/variable/TestMiVar.py

 """
-Test that the lldb-mi driver can evaluate expressions.
+Test lldb-mi -var-xxx commands.
 """
 
 import lldbmi_testcase
 from lldbtest import *
 import unittest2
 
-class MiEvaluateTestCase(lldbmi_testcase.MiTestCaseBase):
+class MiVarTestCase(lldbmi_testcase.MiTestCaseBase):
+
+    mydir = TestBase.compute_mydir(__file__)
 
     @lldbmi_test
     @expectedFailureWindows("llvm.org/pr22274: need a pexpect replacement for windows")
     @skipIfFreeBSD # llvm.org/pr22411: Failure presumably due to known thread races
     @skipIfLinux # llvm.org/pr22411: Failure presumably due to known thread races
     def test_lldbmi_eval(self):
         """Test that 'lldb-mi --interpreter' works for evaluating."""
 
         self.spawnLldbMi(args = None)
 
         # Load executable
         self.runCmd("-file-exec-and-symbols %s" % self.myexe)
         self.expect("\^done")
 
-        # Run to program return (marked BP_source)
-        line = line_number('main.c', '//BP_source')
-        self.runCmd("-break-insert main.c:%d" % line)
+        # Run to program return
+        line = line_number('main.cpp', '// BP_return')
+        self.runCmd("-break-insert main.cpp:%d" % line)
         self.expect("\^done,bkpt={number=\"1\"")
         self.runCmd("-exec-run")
         self.expect("\^running")
         self.expect("\*stopped,reason=\"breakpoint-hit\"")
 
         # Print non-existant variable
         self.runCmd("-var-create var1 * undef")
         #self.expect("\^error") #FIXME: shows undef as {...}
         self.runCmd("-data-evaluate-expression undef")
         self.expect("\^error,msg=\"Could not evaluate expression\"")
 
         # Print global "g_MyVar", modify, delete and create again
         self.runCmd("-data-evaluate-expression g_MyVar")
         self.expect("\^done,value=\"3\"")
         self.runCmd("-var-create var2 * g_MyVar")
         self.expect("\^done,name=\"var2\",numchild=\"0\",value=\"3\",type=\"int\",thread-id=\"1\",has_more=\"0\"")
         self.runCmd("-var-evaluate-expression var2")
         self.expect("\^done,value=\"3\"")
         self.runCmd("-var-show-attributes var2")
         self.expect("\^done,status=\"editable\"")
         self.runCmd("-data-evaluate-expression \"g_MyVar=30\"")
         self.expect("\^done,value=\"30\"")
-        self.runCmd("-var-update var2")
-        #self.expect("name=\"var2\",value=\"30\"") #FIXME -var-update doesn't work
+        self.runCmd("-var-update --all-values var2")
+        #self.expect("\^done,changelist=\[\{name=\"var2\",value=\"30\",in_scope=\"true\",type_changed=\"false\",has_more=\"0\"\}\]") #FIXME -var-update doesn't work
         self.runCmd("-var-delete var2")
         self.expect("\^done")
         self.runCmd("-var-create var2 * g_MyVar")
         self.expect("\^done,name=\"var2\",numchild=\"0\",value=\"30\",type=\"int\",thread-id=\"1\",has_more=\"0\"")
 
         # Print static "s_MyVar", modify, delete and create again
         self.runCmd("-data-evaluate-expression s_MyVar")
         self.expect("\^done,value=\"30\"")
         self.runCmd("-var-create var3 * s_MyVar")
         self.expect("\^done,name=\"var3\",numchild=\"0\",value=\"30\",type=\"int\",thread-id=\"1\",has_more=\"0\"")
         self.runCmd("-var-evaluate-expression var3")
         self.expect("\^done,value=\"30\"")
         self.runCmd("-var-show-attributes var3")
         self.expect("\^done,status=\"editable\"")
         self.runCmd("-data-evaluate-expression \"s_MyVar=3\"")
         self.expect("\^done,value=\"3\"")
-        self.runCmd("-var-update var3")
-        #self.expect("name=\"var3\",value=\"3\"") #FIXME -var-update doesn't work
+        self.runCmd("-var-update --all-values var3")
+        #self.expect("\^done,changelist=\[\{name=\"var3\",value=\"3\",in_scope=\"true\",type_changed=\"false\",has_more=\"0\"\}\]") #FIXME -var-update doesn't work
         self.runCmd("-var-delete var3")
         self.expect("\^done")
         self.runCmd("-var-create var3 * s_MyVar")
         self.expect("\^done,name=\"var3\",numchild=\"0\",value=\"3\",type=\"int\",thread-id=\"1\",has_more=\"0\"")
 
         # Print local "b", modify, delete and create again
         self.runCmd("-data-evaluate-expression b")
         self.expect("\^done,value=\"20\"")
         self.runCmd("-var-create var4 * b")
         self.expect("\^done,name=\"var4\",numchild=\"0\",value=\"20\",type=\"int\",thread-id=\"1\",has_more=\"0\"")
         self.runCmd("-var-evaluate-expression var4")
         self.expect("\^done,value=\"20\"")
         self.runCmd("-var-show-attributes var4")
         self.expect("\^done,status=\"editable\"")
         self.runCmd("-data-evaluate-expression \"b=2\"")
         self.expect("\^done,value=\"2\"")
-        self.runCmd("-var-update var4")
-        #self.expect("name=\"var4\",value=\"2\"") #FIXME -var-update doesn't work
+        self.runCmd("-var-update --all-values var4")
+        #self.expect("\^done,changelist=\[\{name=\"var4\",value=\"2\",in_scope=\"true\",type_changed=\"false\",has_more=\"0\"\}\]") #FIXME -var-update doesn't work
         self.runCmd("-var-delete var4")
         self.expect("\^done")
         self.runCmd("-var-create var4 * b")
         self.expect("\^done,name=\"var4\",numchild=\"0\",value=\"2\",type=\"int\",thread-id=\"1\",has_more=\"0\"")
 
         # Print temp "a + b"
         self.runCmd("-data-evaluate-expression \"a + b\"")
         self.expect("\^done,value=\"12\"")

test/tools/lldb-mi/variable/main.cpp

+//===-- main.cpp ------------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+int g_MyVar = 3;
+static int s_MyVar = 4;
+
+int
+main(int argc, char const *argv[])
+{
+    int a = 10, b = 20;
+    s_MyVar = a + b;
+    return 0; // BP_return
+}