[Test Suite] Pull generateSource into lldbtest

[beanz]

Summary

Convert tests using LLDB headers to use generateSource to put the right include paths in place regardless of whether or not you're building a framework.

This also abstracted generateSource out of TestPublicAPIHeaders.py into lldbtest.py.

[tfiala]

LGTM.

lldb/trunk/packages/Python/lldbsuite/test/api/check_public_api_headers/TestPublicAPIHeaders.py

 
 
 class SBDirCheckerCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
     def setUp(self):
         TestBase.setUp(self)
-        self.template = 'main.cpp.template'
         self.source = 'main.cpp'
         self.exe_name = 'a.out'
+        self.generateSource(self.source)
 
     @skipIfNoSBHeaders
     def test_sb_api_directory(self):
         """Test the SB API directory and make sure there's no unwanted stuff."""
 
         # Only proceed if this is an Apple OS, "x86_64", and local platform.
         if not (self.platformIsDarwin() and self.getArchitecture() == "x86_64"):
             self.skipTest("This test is only for LLDB.framework built 64-bit")
         if self.getArchitecture() == "i386":
             self.skipTest(
                 "LLDB is 64-bit and cannot be linked to 32-bit test program.")
 
-        # Generate main.cpp, build it, and execute.
-        self.generate_main_cpp()
         self.buildDriver(self.source, self.exe_name)
         self.sanity_check_executable(self.exe_name)
 
-    def generate_main_cpp(self):
-        """Generate main.cpp from main.cpp.template."""
-        temp = os.path.join(os.getcwd(), self.template)
-        with open(temp, 'r') as f:
-            content = f.read()
-
-        public_api_dir = os.path.join(
-            os.environ["LLDB_SRC"], "include", "lldb", "API")
-
-        # Look under the include/lldb/API directory and add #include statements
-        # for all the SB API headers.
-        public_headers = os.listdir(public_api_dir)
-        # For different platforms, the include statement can vary.
-        if self.platformIsDarwin():
-            include_stmt = "'#include <%s>' % os.path.join('LLDB', header)"
-        if self.getPlatform() == "freebsd" or self.getPlatform(
-        ) == "linux" or os.environ.get('LLDB_BUILD_TYPE') == 'Makefile':
-            include_stmt = "'#include <%s>' % os.path.join(public_api_dir, header)"
-        list = [eval(include_stmt) for header in public_headers if (
-            header.startswith("SB") and header.endswith(".h"))]
-        includes = '\n'.join(list)
-        new_content = content.replace('%include_SB_APIs%', includes)
-        src = os.path.join(os.getcwd(), self.source)
-        with open(src, 'w') as f:
-            f.write(new_content)
-
-        # The main.cpp has been generated, add a teardown hook to remove it.
-        self.addTearDownHook(lambda: os.remove(src))
-
     def sanity_check_executable(self, exe_name):
         """Sanity check executable compiled from the auto-generated program."""
         exe = os.path.join(os.getcwd(), exe_name)
         self.runCmd("file %s" % exe, CURRENT_EXECUTABLE_SET)
 
         self.line_to_break = line_number(
             self.source, '// Set breakpoint here.')
 

lldb/trunk/packages/Python/lldbsuite/test/api/multithreaded/TestMultithreaded.py

 from lldbsuite.test.decorators import *
 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 import subprocess
 
 
 class SBBreakpointCallbackCase(TestBase):
 
+    def setUp(self):
+        TestBase.setUp(self)
+        self.generateSource('driver.cpp')
+        self.generateSource('listener_test.cpp')
+        self.generateSource('test_breakpoint_callback.cpp')
+        self.generateSource('test_listener_event_description.cpp')
+        self.generateSource('test_listener_event_process_state.cpp')
+        self.generateSource('test_listener_resume.cpp')
+
     mydir = TestBase.compute_mydir(__file__)
 
     @skipIfRemote
     @skipIfNoSBHeaders
     # clang-cl does not support throw or catch (llvm.org/pr24538)
     @skipIfWindows
     def test_breakpoint_callback(self):
         """Test the that SBBreakpoint callback is invoked when a breakpoint is hit. """

lldb/trunk/packages/Python/lldbsuite/test/api/multithreaded/driver.cpp

-
-/// LLDB C API Test Driver
-
-#include <algorithm>
-#include <iostream>
-#include <iterator>
-#include <string>
-#include <vector>
-
-#include "lldb-headers.h"
-
-#include "common.h"
-
-using namespace std;
-using namespace lldb;
-
-void test(SBDebugger &dbg, std::vector<string> args);
-
-int main(int argc, char** argv) {
-  int code = 0;
-
-  SBDebugger::Initialize();
-  SBDebugger dbg = SBDebugger::Create();
-
-  try {
-    if (!dbg.IsValid())
-      throw Exception("invalid debugger");
-    vector<string> args(argv + 1, argv + argc);
-
-    test(dbg, args);
-  } catch (Exception &e) {
-    cout << "ERROR: " << e.what() << endl;
-    code = 1;
-  }
-
-  SBDebugger::Destroy(dbg);
-  return code;
-}

lldb/trunk/packages/Python/lldbsuite/test/api/multithreaded/driver.cpp.template

+
+/// LLDB C API Test Driver
+
+#include <algorithm>
+#include <iostream>
+#include <iterator>
+#include <string>
+#include <vector>
+
+%include_SB_APIs%
+
+#include "common.h"
+
+using namespace std;
+using namespace lldb;
+
+void test(SBDebugger &dbg, std::vector<string> args);
+
+int main(int argc, char** argv) {
+  int code = 0;
+
+  SBDebugger::Initialize();
+  SBDebugger dbg = SBDebugger::Create();
+
+  try {
+    if (!dbg.IsValid())
+      throw Exception("invalid debugger");
+    vector<string> args(argv + 1, argv + argc);
+
+    test(dbg, args);
+  } catch (Exception &e) {
+    cout << "ERROR: " << e.what() << endl;
+    code = 1;
+  }
+
+  SBDebugger::Destroy(dbg);
+  return code;
+}

lldb/trunk/packages/Python/lldbsuite/test/api/multithreaded/listener_test.cpp

-// LLDB test snippet that registers a listener with a process that hits
-// a breakpoint.
-
-#include <atomic>
-#include <iostream>
-#include <string>
-#include <thread>
-#include <vector>
-
-#include "lldb-headers.h"
-#include "common.h"
-
-using namespace lldb;
-using namespace std;
-
-void listener_func();
-void check_listener(SBDebugger &dbg);
-
-// Listener thread and related variables
-atomic<bool> g_done; 
-SBListener g_listener("test-listener");
-thread g_listener_thread;
-
-void shutdown_listener() {
-  g_done.store(true);
-  if (g_listener_thread.joinable())
-    g_listener_thread.join();
-}
-
-void test(SBDebugger &dbg, std::vector<string> args) {
-  try {
-    g_done.store(false);
-    SBTarget target = dbg.CreateTarget(args.at(0).c_str());
-    if (!target.IsValid()) throw Exception("invalid target");
-
-    SBBreakpoint breakpoint = target.BreakpointCreateByName("next");
-    if (!breakpoint.IsValid()) throw Exception("invalid breakpoint");
-
-    std::unique_ptr<char> working_dir(get_working_dir());
-
-    SBError error;
-    SBProcess process = target.Launch(g_listener,
-                                      0, 0, 0, 0, 0,
-                                      working_dir.get(),
-                                      0,
-                                      false,
-                                      error);
-    if (!error.Success())
-      throw Exception("Error launching process.");
-
-    /* FIXME: the approach below deadlocks
-    SBProcess process = target.LaunchSimple (0, 0, working_dir.get());
-
-    // get debugger listener (which is attached to process by default)
-    g_listener = dbg.GetListener();
-    */
-
-    // FIXME: because a listener is attached to the process at launch-time,
-    // registering the listener below results in two listeners being attached,
-    // which is not supported by LLDB.
-    // register listener
-    // process.GetBroadcaster().AddListener(g_listener,
-    //                                   SBProcess::eBroadcastBitStateChanged);
-
-    // start listener thread
-    g_listener_thread = thread(listener_func);
-    check_listener(dbg);
-
-  } catch (Exception &e) {
-    shutdown_listener();
-    throw e;
-  }
-  shutdown_listener();
-}

lldb/trunk/packages/Python/lldbsuite/test/api/multithreaded/listener_test.cpp.template

+// LLDB test snippet that registers a listener with a process that hits
+// a breakpoint.
+
+#include <atomic>
+#include <iostream>
+#include <string>
+#include <thread>
+#include <vector>
+
+%include_SB_APIs%
+#include "common.h"
+
+using namespace lldb;
+using namespace std;
+
+void listener_func();
+void check_listener(SBDebugger &dbg);
+
+// Listener thread and related variables
+atomic<bool> g_done; 
+SBListener g_listener("test-listener");
+thread g_listener_thread;
+
+void shutdown_listener() {
+  g_done.store(true);
+  if (g_listener_thread.joinable())
+    g_listener_thread.join();
+}
+
+void test(SBDebugger &dbg, std::vector<string> args) {
+  try {
+    g_done.store(false);
+    SBTarget target = dbg.CreateTarget(args.at(0).c_str());
+    if (!target.IsValid()) throw Exception("invalid target");
+
+    SBBreakpoint breakpoint = target.BreakpointCreateByName("next");
+    if (!breakpoint.IsValid()) throw Exception("invalid breakpoint");
+
+    std::unique_ptr<char> working_dir(get_working_dir());
+
+    SBError error;
+    SBProcess process = target.Launch(g_listener,
+                                      0, 0, 0, 0, 0,
+                                      working_dir.get(),
+                                      0,
+                                      false,
+                                      error);
+    if (!error.Success())
+      throw Exception("Error launching process.");
+
+    /* FIXME: the approach below deadlocks
+    SBProcess process = target.LaunchSimple (0, 0, working_dir.get());
+
+    // get debugger listener (which is attached to process by default)
+    g_listener = dbg.GetListener();
+    */
+
+    // FIXME: because a listener is attached to the process at launch-time,
+    // registering the listener below results in two listeners being attached,
+    // which is not supported by LLDB.
+    // register listener
+    // process.GetBroadcaster().AddListener(g_listener,
+    //                                   SBProcess::eBroadcastBitStateChanged);
+
+    // start listener thread
+    g_listener_thread = thread(listener_func);
+    check_listener(dbg);
+
+  } catch (Exception &e) {
+    shutdown_listener();
+    throw e;
+  }
+  shutdown_listener();
+}

lldb/trunk/packages/Python/lldbsuite/test/api/multithreaded/lldb-headers.h

-
-#ifndef LLDB_HEADERS_H
-#define LLDB_HEADERS_H
-
-#ifdef __APPLE__
-#include <LLDB/LLDB.h>
-#else
-#include "lldb/API/LLDB.h"
-#endif
-
-#endif // LLDB_HEADERS_H

lldb/trunk/packages/Python/lldbsuite/test/api/multithreaded/test_breakpoint_callback.cpp

-
-// LLDB C++ API Test: verify that the function registered with
-// SBBreakpoint.SetCallback() is invoked when a breakpoint is hit.
-
-#include <mutex>
-#include <iostream>
-#include <vector>
-#include <string>
-
-#include "lldb-headers.h"
-
-#include "common.h"
-
-using namespace std;
-using namespace lldb;
-
-mutex g_mutex;
-condition_variable g_condition;
-int g_breakpoint_hit_count = 0;
-
-bool BPCallback (void *baton,
-                 SBProcess &process,
-                 SBThread &thread,
-                 SBBreakpointLocation &location) {
-  lock_guard<mutex> lock(g_mutex);
-  g_breakpoint_hit_count += 1;
-  g_condition.notify_all();
-  return true;
-}
-
-void test(SBDebugger &dbg, vector<string> args) {
-  dbg.SetAsync(false);  
-  SBTarget target = dbg.CreateTarget(args.at(0).c_str());
-  if (!target.IsValid()) throw Exception("invalid target");
-
-  SBBreakpoint breakpoint = target.BreakpointCreateByName("next");
-  if (!breakpoint.IsValid()) throw Exception("invalid breakpoint");
-  breakpoint.SetCallback(BPCallback, 0);
-
-  std::unique_ptr<char> working_dir(get_working_dir());
-  SBProcess process = target.LaunchSimple (0, 0, working_dir.get());
-
-  {
-    unique_lock<mutex> lock(g_mutex);
-    g_condition.wait_for(lock, chrono::seconds(5));
-    if (g_breakpoint_hit_count != 1)
-      throw Exception("Breakpoint hit count expected to be 1");
-  }
-}

lldb/trunk/packages/Python/lldbsuite/test/api/multithreaded/test_breakpoint_callback.cpp.template

+
+// LLDB C++ API Test: verify that the function registered with
+// SBBreakpoint.SetCallback() is invoked when a breakpoint is hit.
+
+#include <mutex>
+#include <iostream>
+#include <vector>
+#include <string>
+
+%include_SB_APIs%
+
+#include "common.h"
+
+using namespace std;
+using namespace lldb;
+
+mutex g_mutex;
+condition_variable g_condition;
+int g_breakpoint_hit_count = 0;
+
+bool BPCallback (void *baton,
+                 SBProcess &process,
+                 SBThread &thread,
+                 SBBreakpointLocation &location) {
+  lock_guard<mutex> lock(g_mutex);
+  g_breakpoint_hit_count += 1;
+  g_condition.notify_all();
+  return true;
+}
+
+void test(SBDebugger &dbg, vector<string> args) {
+  dbg.SetAsync(false);  
+  SBTarget target = dbg.CreateTarget(args.at(0).c_str());
+  if (!target.IsValid()) throw Exception("invalid target");
+
+  SBBreakpoint breakpoint = target.BreakpointCreateByName("next");
+  if (!breakpoint.IsValid()) throw Exception("invalid breakpoint");
+  breakpoint.SetCallback(BPCallback, 0);
+
+  std::unique_ptr<char> working_dir(get_working_dir());
+  SBProcess process = target.LaunchSimple (0, 0, working_dir.get());
+
+  {
+    unique_lock<mutex> lock(g_mutex);
+    g_condition.wait_for(lock, chrono::seconds(5));
+    if (g_breakpoint_hit_count != 1)
+      throw Exception("Breakpoint hit count expected to be 1");
+  }
+}

lldb/trunk/packages/Python/lldbsuite/test/api/multithreaded/test_listener_event_description.cpp

-
-// LLDB C++ API Test: verify the event description that is received by an
-// SBListener object registered with a process with a breakpoint.
-
-#include <atomic>
-#include <array>
-#include <iostream>
-#include <string>
-#include <thread>
-
-#include "lldb-headers.h"
-
-#include "common.h"
-
-using namespace lldb;
-using namespace std;
-
-// listener thread control
-extern atomic<bool> g_done;
-extern SBListener g_listener;
-
-multithreaded_queue<string> g_event_descriptions;
-string g_error_desc;
-
-void listener_func() {
-  while (!g_done) {
-    SBEvent event;
-    bool got_event = g_listener.WaitForEvent(1, event);
-
-    if (got_event) {
-      if (!event.IsValid())
-        throw Exception("event is not valid in listener thread");
-
-      SBStream description;
-      event.GetDescription(description);
-      string str(description.GetData());
-      g_event_descriptions.push(str);
-    }
-  }
-}
-
-bool check_state(string &state, string &desc, bool got_description)
-{
-    g_error_desc.clear();
-
-    if(!got_description)
-    {
-        g_error_desc.append("Did not get expected event description");
-        return false;
-    }
-
-    if (desc.find("state-changed") == desc.npos)
-        g_error_desc.append("Event description incorrect: missing 'state-changed' ");
-
-    if (desc.find("pid = ") == desc.npos)
-        g_error_desc.append("Event description incorrect: missing process pid ");
-
-    string state_search_str = "state = " + state;
-    if (desc.find(state_search_str) == desc.npos)
-    {
-        string errString = ("Event description incorrect: expected state "
-                      + state
-                      + " but desc was "
-                      + desc);
-        g_error_desc.append(errString);
-    }
-
-    if (g_error_desc.length() > 0)
-        return false;
-
-    cout << "check_state: " << state << "  OK\n";
-    return true;
-}
-
-void check_listener(SBDebugger &dbg)
-{
-    bool got_description;
-    string state;
-
-    // check for "launching" state, this may or may not be present
-    string desc = g_event_descriptions.pop(5, got_description);
-    state = "launching";
-    if (check_state(state, desc, got_description))
-    {
-        // found a 'launching' state, pop next one from queue
-        desc = g_event_descriptions.pop(5, got_description);
-    }
-
-    state = "running";
-    if( !check_state(state, desc, got_description) )
-        throw Exception(g_error_desc);
-
-    desc = g_event_descriptions.pop(5, got_description);
-    state = "stopped";
-    if( !check_state(state, desc, got_description) )
-        throw Exception(g_error_desc);
-}

lldb/trunk/packages/Python/lldbsuite/test/api/multithreaded/test_listener_event_description.cpp.template

+
+// LLDB C++ API Test: verify the event description that is received by an
+// SBListener object registered with a process with a breakpoint.
+
+#include <atomic>
+#include <array>
+#include <iostream>
+#include <string>
+#include <thread>
+
+%include_SB_APIs%
+
+#include "common.h"
+
+using namespace lldb;
+using namespace std;
+
+// listener thread control
+extern atomic<bool> g_done;
+extern SBListener g_listener;
+
+multithreaded_queue<string> g_event_descriptions;
+string g_error_desc;
+
+void listener_func() {
+  while (!g_done) {
+    SBEvent event;
+    bool got_event = g_listener.WaitForEvent(1, event);
+
+    if (got_event) {
+      if (!event.IsValid())
+        throw Exception("event is not valid in listener thread");
+
+      SBStream description;
+      event.GetDescription(description);
+      string str(description.GetData());
+      g_event_descriptions.push(str);
+    }
+  }
+}
+
+bool check_state(string &state, string &desc, bool got_description)
+{
+    g_error_desc.clear();
+
+    if(!got_description)
+    {
+        g_error_desc.append("Did not get expected event description");
+        return false;
+    }
+
+    if (desc.find("state-changed") == desc.npos)
+        g_error_desc.append("Event description incorrect: missing 'state-changed' ");
+
+    if (desc.find("pid = ") == desc.npos)
+        g_error_desc.append("Event description incorrect: missing process pid ");
+
+    string state_search_str = "state = " + state;
+    if (desc.find(state_search_str) == desc.npos)
+    {
+        string errString = ("Event description incorrect: expected state "
+                      + state
+                      + " but desc was "
+                      + desc);
+        g_error_desc.append(errString);
+    }
+
+    if (g_error_desc.length() > 0)
+        return false;
+
+    cout << "check_state: " << state << "  OK\n";
+    return true;
+}
+
+void check_listener(SBDebugger &dbg)
+{
+    bool got_description;
+    string state;
+
+    // check for "launching" state, this may or may not be present
+    string desc = g_event_descriptions.pop(5, got_description);
+    state = "launching";
+    if (check_state(state, desc, got_description))
+    {
+        // found a 'launching' state, pop next one from queue
+        desc = g_event_descriptions.pop(5, got_description);
+    }
+
+    state = "running";
+    if( !check_state(state, desc, got_description) )
+        throw Exception(g_error_desc);
+
+    desc = g_event_descriptions.pop(5, got_description);
+    state = "stopped";
+    if( !check_state(state, desc, got_description) )
+        throw Exception(g_error_desc);
+}

lldb/trunk/packages/Python/lldbsuite/test/api/multithreaded/test_listener_event_process_state.cpp

-
-// LLDB C++ API Test: verify the event description as obtained by calling
-// SBEvent::GetCStringFromEvent that is received by an
-// SBListener object registered with a process with a breakpoint.
-
-#include <atomic>
-#include <iostream>
-#include <string>
-#include <thread>
-
-#include "lldb-headers.h"
-
-#include "common.h"
-
-using namespace lldb;
-using namespace std;
-
-// listener thread control
-extern atomic<bool> g_done;
-
-multithreaded_queue<string> g_frame_functions;
-
-extern SBListener g_listener;
-
-void listener_func() {
-  while (!g_done) {
-    SBEvent event;
-    bool got_event = g_listener.WaitForEvent(1, event);
-    if (got_event) {
-      if (!event.IsValid())
-        throw Exception("event is not valid in listener thread");
-        // send process description
-        SBProcess process = SBProcess::GetProcessFromEvent(event);
-        if (!process.IsValid())
-            throw Exception("process is not valid");
-        if (SBProcess::GetStateFromEvent(event) != lldb::eStateStopped || SBProcess::GetRestartedFromEvent(event))
-            continue; // Only interested in "stopped" events.
-
-        SBStream description;
-
-        for (int i = 0; i < process.GetNumThreads(); ++i) {
-            // send each thread description
-            SBThread thread = process.GetThreadAtIndex(i);
-            // send each frame function name
-            uint32_t num_frames = thread.GetNumFrames();
-            for(int j = 0; j < num_frames; ++j) {
-                const char* function_name = thread.GetFrameAtIndex(j).GetSymbol().GetName();
-                if (function_name)
-                    g_frame_functions.push(string(function_name));
-            }
-        }
-    }
-  }
-}
-
-void check_listener(SBDebugger &dbg) {
-  // check thread description
-  bool got_description = false;
-  string func_name = g_frame_functions.pop(5, got_description);
-  
-  if(got_description == false)
-    throw Exception("Expected at least one frame function");
-}

lldb/trunk/packages/Python/lldbsuite/test/api/multithreaded/test_listener_event_process_state.cpp.template

+
+// LLDB C++ API Test: verify the event description as obtained by calling
+// SBEvent::GetCStringFromEvent that is received by an
+// SBListener object registered with a process with a breakpoint.
+
+#include <atomic>
+#include <iostream>
+#include <string>
+#include <thread>
+
+%include_SB_APIs%
+
+#include "common.h"
+
+using namespace lldb;
+using namespace std;
+
+// listener thread control
+extern atomic<bool> g_done;
+
+multithreaded_queue<string> g_frame_functions;
+
+extern SBListener g_listener;
+
+void listener_func() {
+  while (!g_done) {
+    SBEvent event;
+    bool got_event = g_listener.WaitForEvent(1, event);
+    if (got_event) {
+      if (!event.IsValid())
+        throw Exception("event is not valid in listener thread");
+        // send process description
+        SBProcess process = SBProcess::GetProcessFromEvent(event);
+        if (!process.IsValid())
+            throw Exception("process is not valid");
+        if (SBProcess::GetStateFromEvent(event) != lldb::eStateStopped || SBProcess::GetRestartedFromEvent(event))
+            continue; // Only interested in "stopped" events.
+
+        SBStream description;
+
+        for (int i = 0; i < process.GetNumThreads(); ++i) {
+            // send each thread description
+            SBThread thread = process.GetThreadAtIndex(i);
+            // send each frame function name
+            uint32_t num_frames = thread.GetNumFrames();
+            for(int j = 0; j < num_frames; ++j) {
+                const char* function_name = thread.GetFrameAtIndex(j).GetSymbol().GetName();
+                if (function_name)
+                    g_frame_functions.push(string(function_name));
+            }
+        }
+    }
+  }
+}
+
+void check_listener(SBDebugger &dbg) {
+  // check thread description
+  bool got_description = false;
+  string func_name = g_frame_functions.pop(5, got_description);
+  
+  if(got_description == false)
+    throw Exception("Expected at least one frame function");
+}

lldb/trunk/packages/Python/lldbsuite/test/api/multithreaded/test_listener_resume.cpp

-
-// LLDB C++ API Test: verify the event description as obtained by calling
-// SBEvent::GetCStringFromEvent that is received by an
-// SBListener object registered with a process with a breakpoint.
-
-#include <atomic>
-#include <iostream>
-#include <string>
-#include <thread>
-
-#include "lldb-headers.h"
-
-#include "common.h"
-
-using namespace lldb;
-using namespace std;
-
-// listener thread control
-extern atomic<bool> g_done;
-
-// used by listener thread to communicate a successful process continue command
-// back to the checking thread.
-
-multithreaded_queue<bool> g_process_started;
-
-extern SBListener g_listener;
-
-void listener_func() {
-  while (!g_done) {
-    SBEvent event;
-    bool got_event = g_listener.WaitForEvent(1, event);
-    if (got_event) {
-      if (!event.IsValid())
-        throw Exception("event is not valid in listener thread");
-
-      SBProcess process = SBProcess::GetProcessFromEvent(event);
-      if (process.GetState() == eStateStopped) {
-        SBError error = process.Continue();
-        if (!error.Success())
-          throw Exception(string("Cannot continue process from listener thread: ")
-                          + error.GetCString());
-        g_process_started.push(true);
-      }
-    }
-  }
-}
-
-void check_listener(SBDebugger &dbg) {
-  bool got_message = false;
-  while (!got_message)
-    g_process_started.pop(5, got_message);
-  g_done = true;
-}

lldb/trunk/packages/Python/lldbsuite/test/api/multithreaded/test_listener_resume.cpp.template

+
+// LLDB C++ API Test: verify the event description as obtained by calling
+// SBEvent::GetCStringFromEvent that is received by an
+// SBListener object registered with a process with a breakpoint.
+
+#include <atomic>
+#include <iostream>
+#include <string>
+#include <thread>
+
+%include_SB_APIs%
+
+#include "common.h"
+
+using namespace lldb;
+using namespace std;
+
+// listener thread control
+extern atomic<bool> g_done;
+
+// used by listener thread to communicate a successful process continue command
+// back to the checking thread.
+
+multithreaded_queue<bool> g_process_started;
+
+extern SBListener g_listener;
+
+void listener_func() {
+  while (!g_done) {
+    SBEvent event;
+    bool got_event = g_listener.WaitForEvent(1, event);
+    if (got_event) {
+      if (!event.IsValid())
+        throw Exception("event is not valid in listener thread");
+
+      SBProcess process = SBProcess::GetProcessFromEvent(event);
+      if (process.GetState() == eStateStopped) {
+        SBError error = process.Continue();
+        if (!error.Success())
+          throw Exception(string("Cannot continue process from listener thread: ")
+                          + error.GetCString());
+        g_process_started.push(true);
+      }
+    }
+  }
+}
+
+void check_listener(SBDebugger &dbg) {
+  bool got_message = false;
+  while (!got_message)
+    g_process_started.pop(5, got_message);
+  g_done = true;
+}

lldb/trunk/packages/Python/lldbsuite/test/functionalities/plugins/commands/TestPluginCommands.py

 from lldbsuite.test.lldbtest import *
 from lldbsuite.test import lldbutil
 
 
 class PluginCommandTestCase(TestBase):
 
     mydir = TestBase.compute_mydir(__file__)
 
+    def setUp(self):
+        TestBase.setUp(self)
+        self.generateSource('plugin.cpp')
+
     @skipIfNoSBHeaders
     # Requires a compatible arch and platform to link against the host's built
     # lldb lib.
     @skipIfHostIncompatibleWithRemote
     @expectedFailureAll(oslist=["windows"], bugnumber="llvm.org/pr24778")
     @no_debug_info_test
     def test_load_plugin(self):
         """Test that plugins that load commands work correctly."""

lldb/trunk/packages/Python/lldbsuite/test/functionalities/plugins/commands/plugin.cpp

-//===-- plugin.cpp -------------------------------------------*- C++ -*-===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is distributed under the University of Illinois Open Source
-// License. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-/*
-An example plugin for LLDB that provides a new foo command with a child subcommand
-Compile this into a dylib foo.dylib and load by placing in appropriate locations on disk or
-by typing plugin load foo.dylib at the LLDB command line
-*/
-
-#if defined (__APPLE__)
-#include <LLDB/SBCommandInterpreter.h>
-#include <LLDB/SBCommandReturnObject.h>
-#include <LLDB/SBDebugger.h>
-#else
-#include <lldb/API/SBCommandInterpreter.h>
-#include <lldb/API/SBCommandReturnObject.h>
-#include <lldb/API/SBDebugger.h>
-#endif
-
-namespace lldb {
-    bool
-    PluginInitialize (lldb::SBDebugger debugger);
-}
-
-class ChildCommand : public lldb::SBCommandPluginInterface
-{
-public:
-    virtual bool
-    DoExecute (lldb::SBDebugger debugger,
-               char** command,
-               lldb::SBCommandReturnObject &result)
-    {
-        if (command)
-        {
-            const char* arg = *command;
-            while (arg)
-            {
-                result.Printf("%s ",arg);
-                arg = *(++command);
-            }
-            result.Printf("\n");
-            return true;
-        }
-        return false;
-    }
-    
-};
-
-bool
-lldb::PluginInitialize (lldb::SBDebugger debugger)
-{
-    lldb::SBCommandInterpreter interpreter = debugger.GetCommandInterpreter();
-    lldb::SBCommand foo = interpreter.AddMultiwordCommand("plugin_loaded_command",NULL);
-    foo.AddCommand("child",new ChildCommand(),"a child of plugin_loaded_command");
-    return true;
-}

lldb/trunk/packages/Python/lldbsuite/test/functionalities/plugins/commands/plugin.cpp.template

+//===-- plugin.cpp -------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+/*
+An example plugin for LLDB that provides a new foo command with a child subcommand
+Compile this into a dylib foo.dylib and load by placing in appropriate locations on disk or
+by typing plugin load foo.dylib at the LLDB command line
+*/
+
+%include_SB_APIs%
+
+namespace lldb {
+    bool
+    PluginInitialize (lldb::SBDebugger debugger);
+}
+
+class ChildCommand : public lldb::SBCommandPluginInterface
+{
+public:
+    virtual bool
+    DoExecute (lldb::SBDebugger debugger,
+               char** command,
+               lldb::SBCommandReturnObject &result)
+    {
+        if (command)
+        {
+            const char* arg = *command;
+            while (arg)
+            {
+                result.Printf("%s ",arg);
+                arg = *(++command);
+            }
+            result.Printf("\n");
+            return true;
+        }
+        return false;
+    }
+    
+};
+
+bool
+lldb::PluginInitialize (lldb::SBDebugger debugger)
+{
+    lldb::SBCommandInterpreter interpreter = debugger.GetCommandInterpreter();
+    lldb::SBCommand foo = interpreter.AddMultiwordCommand("plugin_loaded_command",NULL);
+    foo.AddCommand("child",new ChildCommand(),"a child of plugin_loaded_command");
+    return true;
+}

lldb/trunk/packages/Python/lldbsuite/test/lldbtest.py

def getCategories(self):
                 categories_file.close()
                 categories = str.replace(categories, '\n', '')
                 categories = str.replace(categories, '\r', '')
                 return categories.split(',')
             else:
                 folder = os.path.dirname(folder)
                 continue
 
+    def generateSource(self, source):
+        template = source + '.template'
+        temp = os.path.join(os.getcwd(), template)
+        with open(temp, 'r') as f:
+            content = f.read()
+            
+        public_api_dir = os.path.join(
+            os.environ["LLDB_SRC"], "include", "lldb", "API")
+
+        # Look under the include/lldb/API directory and add #include statements
+        # for all the SB API headers.
+        public_headers = os.listdir(public_api_dir)
+        # For different platforms, the include statement can vary.
+        if self.hasDarwinFramework():
+            include_stmt = "'#include <%s>' % os.path.join('LLDB', header)"
+        else:
+            include_stmt = "'#include <%s>' % os.path.join(public_api_dir, header)"
+        list = [eval(include_stmt) for header in public_headers if (
+            header.startswith("SB") and header.endswith(".h"))]
+        includes = '\n'.join(list)
+        new_content = content.replace('%include_SB_APIs%', includes)
+        src = os.path.join(os.getcwd(), source)
+        with open(src, 'w') as f:
+            f.write(new_content)
+
+        self.addTearDownHook(lambda: os.remove(src))
+
     def setUp(self):
         #import traceback
         # traceback.print_stack()
 
         # Works with the test driver to conditionally skip tests via
         # decorators.
         Base.setUp(self)