: predicateId_(1), lastUsedPredicateId_(0), messageTarget_(0) {

// The root predicate has id 0

rootPredicateNode_.id_ = 0;

rootPredicateNode_.next_ = 0;

predicateStackTail_ = &rootPredicateNode_;

unsigned int line,

const char* expr,

unsigned int nestingLevel) {

Failure failure;

failure.file_ = file;

failure.line_ = line;

if (expr) {

failure.expr_ = expr;

}

failure.nestingLevel_ = nestingLevel;

failures_.push_back(failure);

unsigned int level = 0;

const PredicateContext* lastNode = &rootPredicateNode_;

while (lastNode->next_ != 0) {

lastNode = lastNode->next_;

++level;

}

return level;

if (failures_.empty()) {

return;

}

if (printTestName) {

printf("* Detail of %s test failure:\n", name_.c_str());

}

// Print in reverse to display the callstack in the right order

Failures::const_iterator itEnd = failures_.end();

for (Failures::const_iterator it = failures_.begin(); it != itEnd; ++it) {

const Failure& failure = *it;

JSONCPP_STRING indent(failure.nestingLevel_ * 2, ' ');

if (failure.file_) {

printf("%s%s(%d): ", indent.c_str(), failure.file_, failure.line_);

}

if (!failure.expr_.empty()) {

printf("%s\n", failure.expr_.c_str());

} else if (failure.file_) {

printf("\n");

}

if (!failure.message_.empty()) {

JSONCPP_STRING reindented = indentText(failure.message_, indent + " ");

printf("%s\n", reindented.c_str());

}

}

const JSONCPP_STRING& indent) {

JSONCPP_STRING reindented;

JSONCPP_STRING::size_type lastIndex = 0;

while (lastIndex < text.size()) {

JSONCPP_STRING::size_type nextIndex = text.find('\n', lastIndex);

if (nextIndex == JSONCPP_STRING::npos) {

nextIndex = text.size() - 1;

}

reindented += indent;

reindented += text.substr(lastIndex, nextIndex - lastIndex + 1);

lastIndex = nextIndex + 1;

}

return reindented;

TestCase* test = tests_[index]();

JSONCPP_STRING name = test->testName();

delete test;

return name;

TestCase* test = tests_[index]();

result.setTestName(test->testName());

printf("Testing %s: ", test->testName());

fflush(stdout);

#if JSON_USE_EXCEPTION

try {

#endif // if JSON_USE_EXCEPTION

test->run(result);

#if JSON_USE_EXCEPTION

}

catch (const std::exception& e) {

result.addFailure(__FILE__, __LINE__, "Unexpected exception caught:")

<< e.what();

}

#endif // if JSON_USE_EXCEPTION

delete test;

const char* status = result.failed() ? "FAILED" : "OK";

printf("%s\n", status);

fflush(stdout);

unsigned int count = testCount();

std::deque<TestResult> failures;

for (unsigned int index = 0; index < count; ++index) {

TestResult result;

runTestAt(index, result);

if (result.failed()) {

failures.push_back(result);

}

}

if (failures.empty()) {

if (printSummary) {

printf("All %d tests passed\n", count);

}

return true;

} else {

for (unsigned int index = 0; index < failures.size(); ++index) {

TestResult& result = failures[index];

result.printFailure(count > 1);

}

if (printSummary) {

unsigned int failedCount = static_cast<unsigned int>(failures.size());

unsigned int passedCount = count - failedCount;

printf("%d/%d tests passed (%d failure(s))\n",

passedCount,

count,

failedCount);

}

return false;

}

unsigned int& indexOut) const {

unsigned int count = testCount();

for (unsigned int index = 0; index < count; ++index) {

if (testNameAt(index) == testName) {

indexOut = index;

return true;

}

}

return false;

unsigned int count = testCount();

for (unsigned int index = 0; index < count; ++index) {

printf("%s\n", testNameAt(index).c_str());

}

// typedef std::deque<JSONCPP_STRING> TestNames;

Runner subrunner;

for (int index = 1; index < argc; ++index) {

JSONCPP_STRING opt = argv[index];

if (opt == "--list-tests") {

listTests();

return 0;

} else if (opt == "--test-auto") {

preventDialogOnCrash();

} else if (opt == "--test") {

++index;

if (index < argc) {

unsigned int testNameIndex;

if (testIndex(argv[index], testNameIndex)) {

subrunner.add(tests_[testNameIndex]);

} else {

fprintf(stderr, "Test '%s' does not exist!\n", argv[index]);

return 2;

}

} else {

printUsage(argv[0]);

return 2;

}

} else {

printUsage(argv[0]);

return 2;

}

}

bool succeeded;

if (subrunner.testCount() > 0) {

succeeded = subrunner.runAllTest(subrunner.testCount() > 1);

} else {

succeeded = runAllTest(true);

}

return succeeded ? 0 : 1;

// The default CRT handling of error and assertion is to display

// an error dialog to the user.

// Instead, when an error or an assertion occurs, we force the

// application to terminate using abort() after display

// the message on stderr.

if (reportType == _CRT_ERROR || reportType == _CRT_ASSERT) {

// calling abort() cause the ReportHook to be called

// The following is used to detect this case and let's the

// error handler fallback on its default behaviour (

// display a warning message)

static volatile bool isAborting = false;

if (isAborting) {

return TRUE;

}

isAborting = true;

fprintf(stderr, "CRT Error/Assert:\n%s\n", message);

fflush(stderr);

abort();

}

// Let's other reportType (_CRT_WARNING) be handled as they would by default

return FALSE;

#if defined(_MSC_VER) && defined(_DEBUG)

// Install a hook to prevent MSVCRT error and assertion from

// popping a dialog

// This function a NO-OP in release configuration

// (which cause warning since msvcrtSilentReportHook is not referenced)

_CrtSetReportHook(&msvcrtSilentReportHook);

#endif // if defined(_MSC_VER)

#if defined(_WIN32)

// Prevents the system from popping a dialog for debugging if the

// application fails due to invalid memory access.

SetErrorMode(SEM_FAILCRITICALERRORS | SEM_NOGPFAULTERRORBOX |

SEM_NOOPENFILEERRORBOX);

#endif // if defined(_WIN32)

printf("Usage: %s [options]\n"

"\n"

"If --test is not specified, then all the test cases be run.\n"

"\n"

"Valid options:\n"

"--list-tests: print the name of all test cases on the standard\n"

" output and exit.\n"

"--test TESTNAME: executes the test case with the specified name.\n"

" May be repeated.\n"

"--test-auto: prevent dialog prompting for debugging on crash.\n",

appName);