#include "TestCase.h"
#include "Results.h"
#include "Xcode.h"
using namespace lldb_perf;
TestCase::TestCase () :
m_debugger(),
m_target(),
m_process(),
m_thread(),
m_listener(),
m_verbose(false),
m_step(0)
{
SBDebugger::Initialize();
SBHostOS::ThreadCreated ("<lldb-tester.app.main>");
m_debugger = SBDebugger::Create(false);
m_listener = m_debugger.GetListener();
}
static std::string
GetShortOptionString (struct option *long_options)
{
std::string option_string;
for (int i = 0; long_options[i].name != NULL; ++i)
{
if (long_options[i].flag == NULL)
{
option_string.push_back ((char) long_options[i].val);
switch (long_options[i].has_arg)
{
default:
case no_argument:
break;
case required_argument:
option_string.push_back (':');
break;
case optional_argument:
option_string.append (2, ':');
break;
}
}
}
return option_string;
}
bool
TestCase::Setup (int& argc, const char**& argv)
{
bool done = false;
struct option* long_options = GetLongOptions();
if (long_options)
{
std::string short_option_string (GetShortOptionString(long_options));
#if __GLIBC__
optind = 0;
#else
optreset = 1;
optind = 1;
#endif
while (!done)
{
int long_options_index = -1;
const int short_option = ::getopt_long_only (argc,
const_cast<char **>(argv),
short_option_string.c_str(),
long_options,
&long_options_index);
switch (short_option)
{
case 0:
break;
case -1:
done = true;
break;
default:
done = !ParseOption(short_option, optarg);
break;
}
}
argc -= optind;
argv += optind;
}
return false;
}
bool
TestCase::Launch (lldb::SBLaunchInfo &launch_info)
{
lldb::SBError error;
m_process = m_target.Launch (launch_info, error);
if (!error.Success())
fprintf (stderr, "error: %s\n", error.GetCString());
if (m_process.IsValid())
{
m_process.GetBroadcaster().AddListener(m_listener, SBProcess::eBroadcastBitStateChanged | SBProcess::eBroadcastBitInterrupt);
return true;
}
return false;
}
bool
TestCase::Launch (std::initializer_list<const char*> args)
{
std::vector<const char*> args_vect(args);
args_vect.push_back(NULL);
lldb::SBLaunchInfo launch_info((const char**)&args_vect[0]);
return Launch(launch_info);
}
void
TestCase::SetVerbose (bool b)
{
m_verbose = b;
}
bool
TestCase::GetVerbose ()
{
return m_verbose;
}
void
TestCase::Loop ()
{
while (true)
{
bool call_test_step = false;
if (m_process.IsValid())
{
SBEvent evt;
m_listener.WaitForEvent (UINT32_MAX, evt);
StateType state = SBProcess::GetStateFromEvent (evt);
if (m_verbose)
printf("event = %s\n",SBDebugger::StateAsCString(state));
if (SBProcess::GetRestartedFromEvent(evt))
continue;
switch (state)
{
case eStateInvalid:
case eStateDetached:
case eStateCrashed:
case eStateUnloaded:
break;
case eStateExited:
return;
case eStateConnected:
case eStateAttaching:
case eStateLaunching:
case eStateRunning:
case eStateStepping:
continue;
case eStateStopped:
case eStateSuspended:
{
call_test_step = true;
bool fatal = false;
bool selected_thread = false;
for (auto thread_index = 0; thread_index < m_process.GetNumThreads(); thread_index++)
{
SBThread thread(m_process.GetThreadAtIndex(thread_index));
SBFrame frame(thread.GetFrameAtIndex(0));
bool select_thread = false;
StopReason stop_reason = thread.GetStopReason();
if (m_verbose) printf("tid = 0x%llx pc = 0x%llx ",thread.GetThreadID(),frame.GetPC());
switch (stop_reason)
{
case eStopReasonNone:
if (m_verbose)
printf("none\n");
break;
case eStopReasonTrace:
select_thread = true;
if (m_verbose)
printf("trace\n");
break;
case eStopReasonPlanComplete:
select_thread = true;
if (m_verbose)
printf("plan complete\n");
break;
case eStopReasonThreadExiting:
if (m_verbose)
printf("thread exiting\n");
break;
case eStopReasonExec:
if (m_verbose)
printf("exec\n");
break;
case eStopReasonInvalid:
if (m_verbose)
printf("invalid\n");
break;
case eStopReasonException:
select_thread = true;
if (m_verbose)
printf("exception\n");
fatal = true;
break;
case eStopReasonBreakpoint:
select_thread = true;
if (m_verbose)
printf("breakpoint id = %lld.%lld\n",thread.GetStopReasonDataAtIndex(0),thread.GetStopReasonDataAtIndex(1));
break;
case eStopReasonWatchpoint:
select_thread = true;
if (m_verbose)
printf("watchpoint id = %lld\n",thread.GetStopReasonDataAtIndex(0));
break;
case eStopReasonSignal:
select_thread = true;
if (m_verbose)
printf("signal %d\n",(int)thread.GetStopReasonDataAtIndex(0));
break;
}
if (select_thread && !selected_thread)
{
m_thread = thread;
selected_thread = m_process.SetSelectedThread(thread);
}
}
if (fatal)
{
if (m_verbose) Xcode::RunCommand(m_debugger,"bt all",true);
exit(1);
}
}
break;
}
}
else
{
call_test_step = true;
}
if (call_test_step)
{
do_the_call:
if (m_verbose)
printf("RUNNING STEP %d\n",m_step);
ActionWanted action;
TestStep(m_step, action);
m_step++;
SBError err;
switch (action.type)
{
case ActionWanted::Type::eContinue:
err = m_process.Continue();
break;
case ActionWanted::Type::eStepOut:
if (action.thread.IsValid() == false)
{
if (m_verbose)
{
Xcode::RunCommand(m_debugger,"bt all",true);
printf("error: invalid thread for step out on step %d\n", m_step);
}
exit(501);
}
m_process.SetSelectedThread(action.thread);
action.thread.StepOut();
break;
case ActionWanted::Type::eStepOver:
if (action.thread.IsValid() == false)
{
if (m_verbose)
{
Xcode::RunCommand(m_debugger,"bt all",true);
printf("error: invalid thread for step over %d\n",m_step);
}
exit(500);
}
m_process.SetSelectedThread(action.thread);
action.thread.StepOver();
break;
case ActionWanted::Type::eRelaunch:
if (m_process.IsValid())
{
m_process.Kill();
m_process.Clear();
}
Launch(action.launch_info);
break;
case ActionWanted::Type::eKill:
if (m_verbose)
printf("kill\n");
m_process.Kill();
return;
case ActionWanted::Type::eCallNext:
goto do_the_call;
break;
}
}
}
if (GetVerbose()) printf("I am gonna die at step %d\n",m_step);
}
int
TestCase::Run (TestCase& test, int argc, const char** argv)
{
if (test.Setup(argc, argv))
{
test.Loop();
Results results;
test.WriteResults(results);
return RUN_SUCCESS;
}
else
return RUN_SETUP_ERROR;
}