10821679119

Committed 12 Sep 2024 12:14AM CUT coverage: 95.295%. Remained the same

Build # 10821679119

Build Type

push

github

Committed by

web-flow

Commit Message

Merge fa99e2078 into 871f0cc43

Run Details

5306 of 5568 relevant lines covered (95.29%)

11935.1 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

40.14

/src/test_lib_json/jsontest.cpp

// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
// Distributed under MIT license, or public domain if desired and
// recognized in your jurisdiction.
// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE

#define _CRT_SECURE_NO_WARNINGS 1 // Prevents deprecation warning with MSVC
#include "jsontest.h"
#include <cstdio>
#include <string>

#if defined(_MSC_VER)
// Used to install a report hook that prevent dialog on assertion and error.
#include <crtdbg.h>
#endif // if defined(_MSC_VER)

#if defined(_WIN32)
// Used to prevent dialog on memory fault.
// Limits headers included by Windows.h
#define WIN32_LEAN_AND_MEAN
#define NOSERVICE
#define NOMCX
#define NOIME
#define NOSOUND
#define NOCOMM
#define NORPC
#define NOGDI
#define NOUSER
#define NODRIVERS
#define NOLOGERROR
#define NOPROFILER
#define NOMEMMGR
#define NOLFILEIO
#define NOOPENFILE
#define NORESOURCE
#define NOATOM
#define NOLANGUAGE
#define NOLSTRING
#define NODBCS
#define NOKEYBOARDINFO
#define NOGDICAPMASKS
#define NOCOLOR
#define NOGDIOBJ
#define NODRAWTEXT
#define NOTEXTMETRIC
#define NOSCALABLEFONT
#define NOBITMAP
#define NORASTEROPS
#define NOMETAFILE
#define NOSYSMETRICS
#define NOSYSTEMPARAMSINFO
#define NOMSG
#define NOWINSTYLES
#define NOWINOFFSETS
#define NOSHOWWINDOW
#define NODEFERWINDOWPOS
#define NOVIRTUALKEYCODES
#define NOKEYSTATES
#define NOWH
#define NOMENUS
#define NOSCROLL
#define NOCLIPBOARD
#define NOICONS
#define NOMB
#define NOSYSCOMMANDS
#define NOMDI
#define NOCTLMGR
#define NOWINMESSAGES
#include <windows.h>
#endif // if defined(_WIN32)

namespace JsonTest {

// class TestResult
// //////////////////////////////////////////////////////////////////

TestResult::TestResult() {
  // The root predicate has id 0
  rootPredicateNode_.id_ = 0;
  rootPredicateNode_.next_ = nullptr;
  predicateStackTail_ = &rootPredicateNode_;
}

void TestResult::setTestName(const Json::String& name) { name_ = name; }

TestResult& TestResult::addFailure(const char* file, unsigned int line,
                                   const char* expr) {
  /// Walks the PredicateContext stack adding them to failures_ if not already
  /// added.
  unsigned int nestingLevel = 0;
  PredicateContext* lastNode = rootPredicateNode_.next_;
  for (; lastNode != nullptr; lastNode = lastNode->next_) {
    if (lastNode->id_ > lastUsedPredicateId_) // new PredicateContext
    {
      lastUsedPredicateId_ = lastNode->id_;
      addFailureInfo(lastNode->file_, lastNode->line_, lastNode->expr_,
                     nestingLevel);
      // Link the PredicateContext to the failure for message target when
      // popping the PredicateContext.
      lastNode->failure_ = &(failures_.back());
    }
    ++nestingLevel;
  }

  // Adds the failed assertion
  addFailureInfo(file, line, expr, nestingLevel);
  messageTarget_ = &(failures_.back());
  return *this;
}

void TestResult::addFailureInfo(const char* file, 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);
}

TestResult& TestResult::popPredicateContext() {
  PredicateContext* lastNode = &rootPredicateNode_;
  while (lastNode->next_ != nullptr && lastNode->next_->next_ != nullptr) {
    lastNode = lastNode->next_;
  }
  // Set message target to popped failure
  PredicateContext* tail = lastNode->next_;
  if (tail != nullptr && tail->failure_ != nullptr) {
    messageTarget_ = tail->failure_;
  }
  // Remove tail from list
  predicateStackTail_ = lastNode;
  lastNode->next_ = nullptr;
  return *this;
}

bool TestResult::failed() const { return !failures_.empty(); }

void TestResult::printFailure(bool printTestName) const {
  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
  for (const auto& failure : failures_) {
    Json::String indent(failure.nestingLevel_ * 2, ' ');
    if (failure.file_) {
      printf("%s%s(%u): ", 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()) {
      Json::String reindented = indentText(failure.message_, indent + "  ");
      printf("%s\n", reindented.c_str());
    }
  }
}

Json::String TestResult::indentText(const Json::String& text,
                                    const Json::String& indent) {
  Json::String reindented;
  Json::String::size_type lastIndex = 0;
  while (lastIndex < text.size()) {
    Json::String::size_type nextIndex = text.find('\n', lastIndex);
    if (nextIndex == Json::String::npos) {
      nextIndex = text.size() - 1;
    }
    reindented += indent;
    reindented += text.substr(lastIndex, nextIndex - lastIndex + 1);
    lastIndex = nextIndex + 1;
  }
  return reindented;
}

TestResult& TestResult::addToLastFailure(const Json::String& message) {
  if (messageTarget_ != nullptr) {
    messageTarget_->message_ += message;
  }
  return *this;
}

TestResult& TestResult::operator<<(Json::Int64 value) {
  return addToLastFailure(Json::valueToString(value));
}

TestResult& TestResult::operator<<(Json::UInt64 value) {
  return addToLastFailure(Json::valueToString(value));
}

TestResult& TestResult::operator<<(bool value) {
  return addToLastFailure(value ? "true" : "false");
}

// class TestCase
// //////////////////////////////////////////////////////////////////

TestCase::TestCase() = default;

TestCase::~TestCase() = default;

void TestCase::run(TestResult& result) {
  result_ = &result;
  runTestCase();
}

// class Runner
// //////////////////////////////////////////////////////////////////

Runner::Runner() = default;

Runner& Runner::add(TestCaseFactory factory) {
  tests_.push_back(factory);
  return *this;
}

size_t Runner::testCount() const { return tests_.size(); }

Json::String Runner::testNameAt(size_t index) const {
  TestCase* test = tests_[index]();
  Json::String name = test->testName();
  delete test;
  return name;
}

void Runner::runTestAt(size_t index, TestResult& result) const {
  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);
}

bool Runner::runAllTest(bool printSummary) const {
  size_t const count = testCount();
  std::deque<TestResult> failures;
  for (size_t index = 0; index < count; ++index) {
    TestResult result;
    runTestAt(index, result);
    if (result.failed()) {
      failures.push_back(result);
    }
  }

  if (failures.empty()) {
    if (printSummary) {
      printf("All %zu tests passed\n", count);
    }
    return true;
  }
  for (auto& result : failures) {
    result.printFailure(count > 1);
  }

  if (printSummary) {
    size_t const failedCount = failures.size();
    size_t const passedCount = count - failedCount;
    printf("%zu/%zu tests passed (%zu failure(s))\n", passedCount, count,
           failedCount);
  }
  return false;
}

bool Runner::testIndex(const Json::String& testName, size_t& indexOut) const {
  const size_t count = testCount();
  for (size_t index = 0; index < count; ++index) {
    if (testNameAt(index) == testName) {
      indexOut = index;
      return true;
    }
  }
  return false;
}

void Runner::listTests() const {
  const size_t count = testCount();
  for (size_t index = 0; index < count; ++index) {
    printf("%s\n", testNameAt(index).c_str());
  }
}

int Runner::runCommandLine(int argc, const char* argv[]) const {
  // typedef std::deque<String> TestNames;
  Runner subrunner;
  for (int index = 1; index < argc; ++index) {
    Json::String opt = argv[index];
    if (opt == "--list-tests") {
      listTests();
      return 0;
    }
    if (opt == "--test-auto") {
      preventDialogOnCrash();
    } else if (opt == "--test") {
      ++index;
      if (index < argc) {
        size_t 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;
}

#if defined(_MSC_VER) && defined(_DEBUG)
// Hook MSVCRT assertions to prevent dialog from appearing
static int msvcrtSilentReportHook(int reportType, char* message,
                                  int* /*returnValue*/) {
  // 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;
}
#endif // if defined(_MSC_VER)

void Runner::preventDialogOnCrash() {
#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)

  // @todo investigate this handler (for buffer overflow)
  // _set_security_error_handler

#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)
}

void Runner::printUsage(const char* appName) {
  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);
}

// Assertion functions
// //////////////////////////////////////////////////////////////////

Json::String ToJsonString(const char* toConvert) {
  return Json::String(toConvert);
}

Json::String ToJsonString(Json::String in) { return in; }

#if JSONCPP_USING_SECURE_MEMORY
Json::String ToJsonString(std::string in) {
  return Json::String(in.data(), in.data() + in.length());
}
#endif

TestResult& checkStringEqual(TestResult& result, const Json::String& expected,
                             const Json::String& actual, const char* file,
                             unsigned int line, const char* expr) {
  if (expected != actual) {
    result.addFailure(file, line, expr);
    result << "Expected: '" << expected << "'\n";
    result << "Actual  : '" << actual << "'";
  }
  return result;
}

} // namespace JsonTest

1	// Copyright 2007-2010 Baptiste Lepilleur and The JsonCpp Authors
2	// Distributed under MIT license, or public domain if desired and
3	// recognized in your jurisdiction.
4	// See file LICENSE for detail or copy at http://jsoncpp.sourceforge.net/LICENSE
5
6	#define _CRT_SECURE_NO_WARNINGS 1 // Prevents deprecation warning with MSVC
7	#include "jsontest.h"
8	#include <cstdio>
9	#include <string>
10
11	#if defined(_MSC_VER)
12	// Used to install a report hook that prevent dialog on assertion and error.
13	#include <crtdbg.h>
14	#endif // if defined(_MSC_VER)
15
16	#if defined(_WIN32)
17	// Used to prevent dialog on memory fault.
18	// Limits headers included by Windows.h
19	#define WIN32_LEAN_AND_MEAN
20	#define NOSERVICE
21	#define NOMCX
22	#define NOIME
23	#define NOSOUND
24	#define NOCOMM
25	#define NORPC
26	#define NOGDI
27	#define NOUSER
28	#define NODRIVERS
29	#define NOLOGERROR
30	#define NOPROFILER
31	#define NOMEMMGR
32	#define NOLFILEIO
33	#define NOOPENFILE
34	#define NORESOURCE
35	#define NOATOM
36	#define NOLANGUAGE
37	#define NOLSTRING
38	#define NODBCS
39	#define NOKEYBOARDINFO
40	#define NOGDICAPMASKS
41	#define NOCOLOR
42	#define NOGDIOBJ
43	#define NODRAWTEXT
44	#define NOTEXTMETRIC
45	#define NOSCALABLEFONT
46	#define NOBITMAP
47	#define NORASTEROPS
48	#define NOMETAFILE
49	#define NOSYSMETRICS
50	#define NOSYSTEMPARAMSINFO
51	#define NOMSG
52	#define NOWINSTYLES
53	#define NOWINOFFSETS
54	#define NOSHOWWINDOW
55	#define NODEFERWINDOWPOS
56	#define NOVIRTUALKEYCODES
57	#define NOKEYSTATES
58	#define NOWH
59	#define NOMENUS
60	#define NOSCROLL
61	#define NOCLIPBOARD
62	#define NOICONS
63	#define NOMB
64	#define NOSYSCOMMANDS
65	#define NOMDI
66	#define NOCTLMGR
67	#define NOWINMESSAGES
68	#include <windows.h>
69	#endif // if defined(_WIN32)
70
71	namespace JsonTest {
72
73	// class TestResult
74	// //////////////////////////////////////////////////////////////////
75
76	TestResult::TestResult() {	121✔
77	// The root predicate has id 0
78	rootPredicateNode_.id_ = 0;	121✔
79	rootPredicateNode_.next_ = nullptr;	121✔
80	predicateStackTail_ = &rootPredicateNode_;	121✔
81	}	121✔
82
83	void TestResult::setTestName(const Json::String& name) { name_ = name; }	121✔
84
85	TestResult& TestResult::addFailure(const char* file, unsigned int line,	×
86	const char* expr) {
87	/// Walks the PredicateContext stack adding them to failures_ if not already
88	/// added.
89	unsigned int nestingLevel = 0;
90	PredicateContext* lastNode = rootPredicateNode_.next_;	×
91	for (; lastNode != nullptr; lastNode = lastNode->next_) {	×
92	if (lastNode->id_ > lastUsedPredicateId_) // new PredicateContext	×
93	{
94	lastUsedPredicateId_ = lastNode->id_;	×
95	addFailureInfo(lastNode->file_, lastNode->line_, lastNode->expr_,	×
96	nestingLevel);
97	// Link the PredicateContext to the failure for message target when
98	// popping the PredicateContext.
99	lastNode->failure_ = &(failures_.back());	×
100	}
101	++nestingLevel;	×
102	}
103
104	// Adds the failed assertion
105	addFailureInfo(file, line, expr, nestingLevel);	×
106	messageTarget_ = &(failures_.back());	×
107	return *this;	×
108	}
109
110	void TestResult::addFailureInfo(const char* file, unsigned int line,	×
111	const char* expr, unsigned int nestingLevel) {
112	Failure failure;
113	failure.file_ = file;	×
114	failure.line_ = line;	×
115	if (expr) {	×
116	failure.expr_ = expr;
117	}
118	failure.nestingLevel_ = nestingLevel;	×
119	failures_.push_back(failure);	×
120	}	×
121
122	TestResult& TestResult::popPredicateContext() {	130✔
123	PredicateContext* lastNode = &rootPredicateNode_;	130✔
124	while (lastNode->next_ != nullptr && lastNode->next_->next_ != nullptr) {	145✔
125	lastNode = lastNode->next_;
126	}
127	// Set message target to popped failure
128	PredicateContext* tail = lastNode->next_;
129	if (tail != nullptr && tail->failure_ != nullptr) {	130✔
130	messageTarget_ = tail->failure_;	×
131	}
132	// Remove tail from list
133	predicateStackTail_ = lastNode;	130✔
134	lastNode->next_ = nullptr;	130✔
135	return *this;	130✔
136	}
137
138	bool TestResult::failed() const { return !failures_.empty(); }	×
139
140	void TestResult::printFailure(bool printTestName) const {	×
141	if (failures_.empty()) {	×
142	return;
143	}
144
145	if (printTestName) {	×
146	printf("* Detail of %s test failure:\n", name_.c_str());
147	}
148
149	// Print in reverse to display the callstack in the right order
150	for (const auto& failure : failures_) {	×
151	Json::String indent(failure.nestingLevel_ * 2, ' ');	×
152	if (failure.file_) {	×
153	printf("%s%s(%u): ", indent.c_str(), failure.file_, failure.line_);	×
154	}
155	if (!failure.expr_.empty()) {	×
156	printf("%s\n", failure.expr_.c_str());
157	} else if (failure.file_) {	×
158	printf("\n");
159	}
160	if (!failure.message_.empty()) {	×
161	Json::String reindented = indentText(failure.message_, indent + " ");	×
162	printf("%s\n", reindented.c_str());
163	}
164	}
165	}
166
167	Json::String TestResult::indentText(const Json::String& text,	×
168	const Json::String& indent) {
169	Json::String reindented;
170	Json::String::size_type lastIndex = 0;
171	while (lastIndex < text.size()) {	×
172	Json::String::size_type nextIndex = text.find('\n', lastIndex);	×
173	if (nextIndex == Json::String::npos) {	×
174	nextIndex = text.size() - 1;	×
175	}
176	reindented += indent;
177	reindented += text.substr(lastIndex, nextIndex - lastIndex + 1);	×
178	lastIndex = nextIndex + 1;	×
179	}
180	return reindented;	×
181	}
182
183	TestResult& TestResult::addToLastFailure(const Json::String& message) {	3,486✔
184	if (messageTarget_ != nullptr) {	3,918✔
185	messageTarget_->message_ += message;	×
186	}
187	return *this;	3,486✔
188	}
189
190	TestResult& TestResult::operator<<(Json::Int64 value) {	×
191	return addToLastFailure(Json::valueToString(value));	×
192	}
193
194	TestResult& TestResult::operator<<(Json::UInt64 value) {	48✔
195	return addToLastFailure(Json::valueToString(value));	96✔
196	}
197
198	TestResult& TestResult::operator<<(bool value) {	384✔
199	return addToLastFailure(value ? "true" : "false");	896✔
200	}
201
202	// class TestCase
203	// //////////////////////////////////////////////////////////////////
204
205	TestCase::TestCase() = default;	121✔
206
207	TestCase::~TestCase() = default;	242✔
208
209	void TestCase::run(TestResult& result) {	×
210	result_ = &result;	121✔
211	runTestCase();	121✔
212	}	121✔
213
214	// class Runner
215	// //////////////////////////////////////////////////////////////////
216
217	Runner::Runner() = default;	2✔
218
219	Runner& Runner::add(TestCaseFactory factory) {	121✔
220	tests_.push_back(factory);	121✔
221	return *this;	121✔
222	}
223
224	size_t Runner::testCount() const { return tests_.size(); }	×
225
226	Json::String Runner::testNameAt(size_t index) const {	×
227	TestCase* test = tests_[index]();	×
228	Json::String name = test->testName();	×
229	delete test;	×
230	return name;	×
231	}
232
233	void Runner::runTestAt(size_t index, TestResult& result) const {	121✔
234	TestCase* test = tests_[index]();	121✔
235	result.setTestName(test->testName());	121✔
236	printf("Testing %s: ", test->testName());	121✔
237	fflush(stdout);	121✔
238	#if JSON_USE_EXCEPTION
239	try {
240	#endif // if JSON_USE_EXCEPTION
241	test->run(result);
242	#if JSON_USE_EXCEPTION
243	} catch (const std::exception& e) {	×
244	result.addFailure(__FILE__, __LINE__, "Unexpected exception caught:")	×
245	<< e.what();	×
246	}	×
247	#endif // if JSON_USE_EXCEPTION
248	delete test;	121✔
249	const char* status = result.failed() ? "FAILED" : "OK";	121✔
250	printf("%s\n", status);
251	fflush(stdout);	121✔
252	}	121✔
253
254	bool Runner::runAllTest(bool printSummary) const {	1✔
255	size_t const count = testCount();
256	std::deque<TestResult> failures;
257	for (size_t index = 0; index < count; ++index) {	122✔
258	TestResult result;	121✔
259	runTestAt(index, result);	121✔
260	if (result.failed()) {	121✔
261	failures.push_back(result);	×
262	}
263	}	121✔
264
265	if (failures.empty()) {	1✔
266	if (printSummary) {	1✔
267	printf("All %zu tests passed\n", count);
268	}
269	return true;	1✔
270	}
271	for (auto& result : failures) {	×
272	result.printFailure(count > 1);	×
273	}
274
275	if (printSummary) {	×
276	size_t const failedCount = failures.size();
277	size_t const passedCount = count - failedCount;	×
278	printf("%zu/%zu tests passed (%zu failure(s))\n", passedCount, count,
279	failedCount);
280	}
281	return false;
282	}	1✔
283
284	bool Runner::testIndex(const Json::String& testName, size_t& indexOut) const {	×
285	const size_t count = testCount();
286	for (size_t index = 0; index < count; ++index) {	×
287	if (testNameAt(index) == testName) {	×
288	indexOut = index;	×
289	return true;	×
290	}
291	}
292	return false;
293	}
294
295	void Runner::listTests() const {	×
296	const size_t count = testCount();
297	for (size_t index = 0; index < count; ++index) {	×
298	printf("%s\n", testNameAt(index).c_str());	×
299	}
300	}	×
301
302	int Runner::runCommandLine(int argc, const char* argv[]) const {	1✔
303	// typedef std::deque<String> TestNames;
304	Runner subrunner;
305	for (int index = 1; index < argc; ++index) {	1✔
306	Json::String opt = argv[index];	×
307	if (opt == "--list-tests") {	×
308	listTests();	×
309	return 0;
310	}
311	if (opt == "--test-auto") {	×
312	preventDialogOnCrash();
313	} else if (opt == "--test") {	×
314	++index;	×
315	if (index < argc) {	×
316	size_t testNameIndex;
317	if (testIndex(argv[index], testNameIndex)) {	×
318	subrunner.add(tests_[testNameIndex]);	×
319	} else {
320	fprintf(stderr, "Test '%s' does not exist!\n", argv[index]);	×
321	return 2;	×
322	}
323	} else {
324	printUsage(argv[0]);	×
325	return 2;
326	}
327	} else {
328	printUsage(argv[0]);	×
329	return 2;
330	}
331	}
332	bool succeeded;
333	if (subrunner.testCount() > 0) {	1✔
334	succeeded = subrunner.runAllTest(subrunner.testCount() > 1);	×
335	} else {
336	succeeded = runAllTest(true);	1✔
337	}
338	return succeeded ? 0 : 1;	1✔
339	}
340
341	#if defined(_MSC_VER) && defined(_DEBUG)
342	// Hook MSVCRT assertions to prevent dialog from appearing
343	static int msvcrtSilentReportHook(int reportType, char* message,
344	int* /returnValue/) {
345	// The default CRT handling of error and assertion is to display
346	// an error dialog to the user.
347	// Instead, when an error or an assertion occurs, we force the
348	// application to terminate using abort() after display
349	// the message on stderr.
350	if (reportType == _CRT_ERROR \|\| reportType == _CRT_ASSERT) {
351	// calling abort() cause the ReportHook to be called
352	// The following is used to detect this case and let's the
353	// error handler fallback on its default behaviour (
354	// display a warning message)
355	static volatile bool isAborting = false;
356	if (isAborting) {
357	return TRUE;
358	}
359	isAborting = true;
360
361	fprintf(stderr, "CRT Error/Assert:\n%s\n", message);
362	fflush(stderr);
363	abort();
364	}
365	// Let's other reportType (_CRT_WARNING) be handled as they would by default
366	return FALSE;
367	}
368	#endif // if defined(_MSC_VER)
369
370	void Runner::preventDialogOnCrash() {	×
371	#if defined(_MSC_VER) && defined(_DEBUG)
372	// Install a hook to prevent MSVCRT error and assertion from
373	// popping a dialog
374	// This function a NO-OP in release configuration
375	// (which cause warning since msvcrtSilentReportHook is not referenced)
376	_CrtSetReportHook(&msvcrtSilentReportHook);
377	#endif // if defined(_MSC_VER)
378
379	// @todo investigate this handler (for buffer overflow)
380	// _set_security_error_handler
381
382	#if defined(_WIN32)
383	// Prevents the system from popping a dialog for debugging if the
384	// application fails due to invalid memory access.
385	SetErrorMode(SEM_FAILCRITICALERRORS \| SEM_NOGPFAULTERRORBOX \|
386	SEM_NOOPENFILEERRORBOX);
387	#endif // if defined(_WIN32)
388	}	×
389
390	void Runner::printUsage(const char* appName) {	×
391	printf("Usage: %s [options]\n"
392	"\n"
393	"If --test is not specified, then all the test cases be run.\n"
394	"\n"
395	"Valid options:\n"
396	"--list-tests: print the name of all test cases on the standard\n"
397	" output and exit.\n"
398	"--test TESTNAME: executes the test case with the specified name.\n"
399	" May be repeated.\n"
400	"--test-auto: prevent dialog prompting for debugging on crash.\n",
401	appName);
402	}	×
403
404	// Assertion functions
405	// //////////////////////////////////////////////////////////////////
406
407	Json::String ToJsonString(const char* toConvert) {	106✔
408	return Json::String(toConvert);	106✔
409	}
410
411	Json::String ToJsonString(Json::String in) { return in; }	1,025✔
412
413	#if JSONCPP_USING_SECURE_MEMORY
414	Json::String ToJsonString(std::string in) {
415	return Json::String(in.data(), in.data() + in.length());
416	}
417	#endif
418
419	TestResult& checkStringEqual(TestResult& result, const Json::String& expected,	559✔
420	const Json::String& actual, const char* file,
421	unsigned int line, const char* expr) {
422	if (expected != actual) {	559✔
423	result.addFailure(file, line, expr);	×
424	result << "Expected: '" << expected << "'\n";	×
425	result << "Actual : '" << actual << "'";	×
426	}
427	return result;	559✔
428	}
429
430	} // namespace JsonTest

open-source-parsers / jsoncpp / 10821679119

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous