// This test will present lldb with two threads one of which the test will
// overlay with an OSPlugin thread.  Then we'll do a step out on the thread_1,
// but arrange to hit a breakpoint in main before the step out completes. At
// that point we will not report an OS plugin thread for thread_1. Then we'll
// run again and hit the step out breakpoint.  Make sure we haven't deleted
// that, and recognize it.

#include <condition_variable>
#include <mutex>
#include <stdio.h>
#include <thread>

static int g_value = 0; // I don't have access to the real threads in the
                        // OS Plugin, and I don't want to have to count
                        // StopID's. So I'm using this value to tell me which
                        // stop point the program has reached.
std::mutex g_mutex;
std::condition_variable g_cv;
static int g_condition = 0; // Using this as the variable backing g_cv
                            // to prevent spurious wakeups.

void step_out_of_here() {
  std::unique_lock<std::mutex> func_lock(g_mutex);
  // Set a breakpoint:first stop in thread - do a step out.
  g_condition = 1;
  g_cv.notify_one();
  g_cv.wait(func_lock, [&] { return g_condition == 2; });
}

void *thread_func() {
  // Do something
  step_out_of_here();

  // Return
  return NULL;
}

int main() {
  // Lock the mutex so we can block the thread:
  std::unique_lock<std::mutex> main_lock(g_mutex);
  // Create the thread
  std::thread thread_1(thread_func);
  g_cv.wait(main_lock, [&] { return g_condition == 1; });
  g_value = 1;
  g_condition = 2;
  // Stop here and do not make a memory thread for thread_1.
  g_cv.notify_one();
  g_value = 2;
  main_lock.unlock();

  // Wait for the threads to finish
  thread_1.join();

  return 0;
}