public:

watchdog() {

m_thread = thread([&] {

auto tp = chrono::high_resolution_clock::now() + chrono::seconds(10);

std::unique_lock<mutex> guard{m_mtx};

while (!m_canceled

&& m_cv.wait_until(guard, tp) != cv_status::timeout) {

// spin

}

if (!m_canceled) {

std::lock_guard<std::mutex> io_guard{s_stdout_mtx};

cerr << "WATCHDOG: unit test did finish within 10s, abort" << endl;

abort();

}

});

}

~watchdog() {

{ // lifetime scope of guard

std::lock_guard<std::mutex> guard{m_mtx};

m_canceled = true;

m_cv.notify_all();

}

m_thread.join();

}

volatile bool m_canceled = false;

std::mutex m_mtx;

std::condition_variable m_cv;

std::thread m_thread;

string result = to_string(value);

while (result.size() < 4) result.insert(result.begin(), '0');

return result;

using namespace std;

vector<string> result;

stringstream strs{str};

string tmp;

while (getline(strs, tmp, delim)) {

if (!tmp.empty() || keep_empties) result.push_back(move(tmp));

}

return result;

try {

throw;

}

catch (std::exception& e) {

CAF_PRINTERR("terminate called after throwing "

<< to_verbose_string(e));

}

catch (...) {

CAF_PRINTERR("terminate called after throwing an unknown exception");

}

abort();

string path = cpath;

replace_all(path, "'", "\\'");

ostringstream oss;

oss << "'" << path << "'";

for (auto& arg : args) {

oss << " " << arg;

}

oss << " 2>&1";

string cmdstr = oss.str();

return std::thread([cmdstr, rc] {

string output;

auto fp = popen(cmdstr.c_str(), "r");

if (!fp) {

CAF_PRINTERR("FATAL: command line failed: " << cmdstr);

abort();

}

char buf[512];

while (fgets(buf, sizeof(buf), fp)) {

output += buf;

}

pclose(fp);

anon_send(rc, output);

});