Add TestProcessAPI.py which exercises some Python SBProcess API. In particular, this tests

the SBProcess.ReadMemory() API, which, due to SWIG typemap'ing, expects 3 arguments (the location
to read from, the size in bytes to read, and an SBError object), and returns the result as a
Python string object.

On SnowLeopard where this has been tested, the SWIG script needs to be pampered (use the exact
same parameter names as in SBProcess.h) in order for this to work.

llvm-svn: 126736

lldb/scripts/lldb.swig

@@ -56,7 +56,7 @@
 
 
 // typemap for an outgoing buffer
-%typemap(in) (const void *wbuffer, size_t len) {
+%typemap(in) (const void *buf, size_t size) {
    if (!PyString_Check($input)) {
        PyErr_SetString(PyExc_ValueError, "Expecting a string");
        return NULL;
@@ -66,7 +66,7 @@
 }
 
 // typemap for an incoming buffer
-%typemap(in) (void *rbuffer, size_t len) {
+%typemap(in) (void *buf, size_t size) {
    if (!PyInt_Check($input)) {
        PyErr_SetString(PyExc_ValueError, "Expecting an integer");
        return NULL;
@@ -80,14 +80,14 @@
 }
 
 // Return the buffer.  Discarding any previous return result
-%typemap(argout) (void *rbuffer, size_t len) {
+%typemap(argout) (void *buf, size_t size) {
    Py_XDECREF($result);   /* Blow away any previous result */
    if (result < 0) {      /* Check for I/O error */
        free($1);
        PyErr_SetFromErrno(PyExc_IOError);
        return NULL;
    }
-   $result = PyString_FromStringAndSize($1,result);
+   $result = PyString_FromStringAndSize(static_cast<const char*>($1),result);
    free($1);
 }
 

lldb/test/python_api/process/Makefile

@@ -0,0 +1,5 @@
+LEVEL = ../../make
+
+CXX_SOURCES := main.cpp
+
+include $(LEVEL)/Makefile.rules

lldb/test/python_api/process/TestProcessAPI.py

@@ -0,0 +1,102 @@
+"""
+Test symbol table access for main.m.
+"""
+
+import os, time
+import unittest2
+import lldb
+from lldbtest import *
+
+@unittest2.skipUnless(sys.platform.startswith("darwin"), "requires Darwin")
+class ProcessAPITestCase(TestBase):
+
+    mydir = os.path.join("python_api", "process")
+
+    symbols_list = ['main',
+                    'my_char'
+                    ]
+
+    @python_api_test
+    def test_with_dsym_and_python_api(self):
+        """Test Python process APIs."""
+        self.buildDsym()
+        self.process_api()
+
+    @python_api_test
+    def test_with_dwarf_and_python_api(self):
+        """Test Python process APIs."""
+        self.buildDwarf()
+        self.process_api()
+
+    def setUp(self):
+        # Call super's setUp().
+        TestBase.setUp(self)
+        # Find the line number to break inside main().
+        self.line = line_number("main.cpp", "// Set break point at this line and check variable 'my_char'.")
+
+    def process_api(self):
+        """Test Python process APIs."""
+        exe = os.path.join(os.getcwd(), "a.out")
+        self.runCmd("file " + exe, CURRENT_EXECUTABLE_SET)
+
+        target = self.dbg.CreateTarget(exe)
+        self.assertTrue(target.IsValid(), VALID_TARGET)
+
+        breakpoint = target.BreakpointCreateByLocation("main.cpp", self.line)
+        self.assertTrue(breakpoint.IsValid(), VALID_BREAKPOINT)
+
+        # Launch the process, and do not stop at the entry point.
+        error = lldb.SBError()
+        self.process = target.Launch (self.dbg.GetListener(), None, None, os.ctermid(), os.ctermid(), os.ctermid(), None, 0, False, error)
+
+        thread = self.process.GetThreadAtIndex(0);
+        frame = thread.GetFrameAtIndex(0);
+
+        # Get the SBValue for the global variable 'my_char'.
+        val = frame.FindValue("my_char", lldb.eValueTypeVariableGlobal)
+        location = int(val.GetLocation(frame), 16)
+        self.DebugSBValue(frame, val)
+
+        # Due to the typemap magic (see lldb.swig), we pass in 1 to ReadMemory and
+        # expect to get a Python string as the result object!
+        content = self.process.ReadMemory(location, 1, error)
+        print "content:", content
+
+        self.expect(content, "Result from SBProcess.ReadMemory() matches our expected output: 'x'",
+                    exe=False,
+            startstr = 'x')
+
+        #
+        # Exercise Python APIs to access the symbol table entries.
+        #
+
+        # Create the filespec by which to locate our a.out module.
+        filespec = lldb.SBFileSpec(exe, False)
+
+        module = target.FindModule(filespec)
+        self.assertTrue(module.IsValid(), VALID_MODULE)
+
+        # Create the set of known symbols.  As we iterate through the symbol
+        # table, remove the symbol from the set if it is a known symbol.
+        expected_symbols = set(self.symbols_list)
+        from lldbutil import lldb_iter
+        for symbol in lldb_iter(module, 'GetNumSymbols', 'GetSymbolAtIndex'):
+            self.assertTrue(symbol.IsValid(), VALID_SYMBOL)
+            #print "symbol:", symbol
+            name = symbol.GetName()
+            if name in expected_symbols:
+                #print "Removing %s from known_symbols %s" % (name, expected_symbols)
+                expected_symbols.remove(name)
+
+        # At this point, the known_symbols set should have become an empty set.
+        # If not, raise an error.
+        #print "symbols unaccounted for:", expected_symbols
+        self.assertTrue(len(expected_symbols) == 0,
+                        "All the known symbols are accounted for")
+
+
+if __name__ == '__main__':
+    import atexit
+    lldb.SBDebugger.Initialize()
+    atexit.register(lambda: lldb.SBDebugger.Terminate())
+    unittest2.main()

lldb/test/python_api/process/main.cpp

@@ -0,0 +1,25 @@
+//===-- 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>
+
+// This simple program is to test the lldb Python API related to process.
+
+char my_char = 'u';
+
+int main (int argc, char const *argv[])
+{
+    for (int i = 0; i < 3; ++i) {
+        printf("my_char='%c'\n", my_char);
+        ++my_char;
+    }
+
+    printf("after the loop: my_char='%c'\n", my_char); // 'my_char' should print out as 'x'.
+
+    return 0; // Set break point at this line and check variable 'my_char'.
+}