testsuite/json/jsontest.cpp

#define _CRT_SECURE_NO_WARNINGS 1 // Prevents deprecation warning with MSVC
#include "jsontest.h"
#include <stdio.h>
#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 ()
    : predicateId_ (1)
    , lastUsedPredicateId_ (0)
    , messageTarget_ (0)
  {
    /* The root predicate has id 0 */
    rootPredicateNode_.id_ = 0;
    rootPredicateNode_.next_ = 0;
    predicateStackTail_ = &rootPredicateNode_;
  }

  void
  TestResult::setTestName (const std::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 != 0; 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_ != 0 && lastNode->next_->next_ != 0)
      lastNode = lastNode->next_;
    /* Set message target to popped failure */
    PredicateContext *tail = lastNode->next_;
    if (tail != 0 && tail->failure_ != 0)
      messageTarget_ = tail->failure_;
    /* Remove tail from list */
    predicateStackTail_ = lastNode;
    lastNode->next_ = 0;
    return *this;
  }

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

  unsigned int
  TestResult::getAssertionNestingLevel () const
  {
    unsigned int level = 0;
    const PredicateContext *lastNode = &rootPredicateNode_;

    while (lastNode->next_ != 0)
      {
        lastNode = lastNode->next_;
        ++level;
      }
    return level;
  }

  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 */
    Failures::const_iterator itEnd = failures_.end ();
    for (Failures::const_iterator it = failures_.begin (); it != itEnd; ++it)
      {
        const Failure &failure = *it;
        std::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 ())
          {
            std::string reindented = indentText (failure.message_, indent + "  ");
            printf ("%s\n", reindented.c_str ());
          }
      }
  }

  std::string
  TestResult::indentText (const std::string &text, const std::string &indent)
  {
    std::string reindented;
    std::string::size_type lastIndex = 0;

    while (lastIndex < text.size ())
      {
        std::string::size_type nextIndex = text.find ('\n', lastIndex);
        if (nextIndex == std::string::npos)
          nextIndex = text.size () - 1;
        reindented += indent;
        reindented += text.substr (lastIndex, nextIndex - lastIndex + 1);
        lastIndex = nextIndex + 1;
      }
    return reindented;
  }

  TestResult &
  TestResult::addToLastFailure (const std::string &message)
  {
    if (messageTarget_ != 0)
      messageTarget_->message_ += message;
    return *this;
  }

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

  TestResult &
  TestResult::operator << (int value)
  {
    char buffer[32];

    sprintf (buffer, "%d", value);
    return addToLastFailure (buffer);
  }

  TestResult &
  TestResult::operator << (unsigned int value)
  {
    char buffer[32];

    sprintf (buffer, "%u", value);
    return addToLastFailure (buffer);
  }

  TestResult &
  TestResult::operator << (double value)
  {
    char buffer[32];

    sprintf (buffer, "%16g", value);
    return addToLastFailure (buffer);
  }

  TestResult &
  TestResult::operator << (const char *value)
  {
    return addToLastFailure (value ? value
                             : "<NULL>");
  }

  TestResult &
  TestResult::operator << (const std::string &value)
  {
    return addToLastFailure (value);
  }

  /*
   * class TestCase
   * //////////////////////////////////////////////////////////////////
   */

  TestCase::TestCase ()
    : result_ (0)
  {
  }

  TestCase::~TestCase ()
  {
  }

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

  /*
   * class Runner
   * //////////////////////////////////////////////////////////////////
   */

  Runner::Runner ()
  {
  }

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

  unsigned int
  Runner::testCount () const
  {
    return static_cast<unsigned int> (tests_.size ());
  }

  std::string
  Runner::testNameAt (unsigned int index) const
  {
    TestCase *test = tests_[index] ();
    std::string name = test->testName ();

    delete test;
    return name;
  }

  void
  Runner::runTestAt (unsigned int 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 caugth:") << 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
  {
    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;
      }
  }

  bool
  Runner::testIndex (const std::string &testName, 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;
  }

  void
  Runner::listTests () const
  {
    unsigned int count = testCount ();

    for (unsigned int index = 0; index < count; ++index)
      printf ("%s\n", testNameAt (index).c_str ());
  }

  int
  Runner::runCommandLine (int argc, const char *argv[]) const
  {
    typedef std::deque<std::string> TestNames;
    Runner subrunner;
    for (int index = 1; index < argc; ++index)
      {
        std::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;
  }

#if defined(_MSC_VER)
  /* 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)
    /*
     * Install a hook to prevent MSVCRT error and assertion from
     * popping a dialog.
     */
    _CrtSetReportHook (&msvcrtSilentReportHook);
#endif /* if defined(_MSC_VER) */

    /*
     * @todo investiguate 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
   * //////////////////////////////////////////////////////////////////
   */

  TestResult &
  checkStringEqual (TestResult &result, const std::string &expected, const std::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 */
Revision:	1.1
Committed:	Sun Oct 17 08:15:15 2010 UTC (16 years ago) by sf-pippijn
Branch:	MAIN
CVS Tags:	HEAD
Log Message:	initial import
#	Content
1	#define _CRT_SECURE_NO_WARNINGS 1 // Prevents deprecation warning with MSVC
2	#include "jsontest.h"
3	#include <stdio.h>
4	#include <string>
5
6	#if defined(_MSC_VER)
7	// Used to install a report hook that prevent dialog on assertion and error.
8	# include <crtdbg.h>
9	#endif // if defined(_MSC_VER)
10
11	#if defined(_WIN32)
12	// Used to prevent dialog on memory fault.
13	// Limits headers included by Windows.h
14	# define WIN32_LEAN_AND_MEAN
15	# define NOSERVICE
16	# define NOMCX
17	# define NOIME
18	# define NOSOUND
19	# define NOCOMM
20	# define NORPC
21	# define NOGDI
22	# define NOUSER
23	# define NODRIVERS
24	# define NOLOGERROR
25	# define NOPROFILER
26	# define NOMEMMGR
27	# define NOLFILEIO
28	# define NOOPENFILE
29	# define NORESOURCE
30	# define NOATOM
31	# define NOLANGUAGE
32	# define NOLSTRING
33	# define NODBCS
34	# define NOKEYBOARDINFO
35	# define NOGDICAPMASKS
36	# define NOCOLOR
37	# define NOGDIOBJ
38	# define NODRAWTEXT
39	# define NOTEXTMETRIC
40	# define NOSCALABLEFONT
41	# define NOBITMAP
42	# define NORASTEROPS
43	# define NOMETAFILE
44	# define NOSYSMETRICS
45	# define NOSYSTEMPARAMSINFO
46	# define NOMSG
47	# define NOWINSTYLES
48	# define NOWINOFFSETS
49	# define NOSHOWWINDOW
50	# define NODEFERWINDOWPOS
51	# define NOVIRTUALKEYCODES
52	# define NOKEYSTATES
53	# define NOWH
54	# define NOMENUS
55	# define NOSCROLL
56	# define NOCLIPBOARD
57	# define NOICONS
58	# define NOMB
59	# define NOSYSCOMMANDS
60	# define NOMDI
61	# define NOCTLMGR
62	# define NOWINMESSAGES
63	# include <windows.h>
64	#endif // if defined(_WIN32)
65
66	namespace JsonTest
67	{
68	/*
69	* class TestResult
70	* //////////////////////////////////////////////////////////////////
71	*/
72
73	TestResult::TestResult ()
74	: predicateId_ (1)
75	, lastUsedPredicateId_ (0)
76	, messageTarget_ (0)
77	{
78	/* The root predicate has id 0 */
79	rootPredicateNode_.id_ = 0;
80	rootPredicateNode_.next_ = 0;
81	predicateStackTail_ = &rootPredicateNode_;
82	}
83
84	void
85	TestResult::setTestName (const std::string &name)
86	{
87	name_ = name;
88	}
89
90	TestResult &
91	TestResult::addFailure (const char file, unsigned int line, const char expr)
92	{
93	/* / Walks the PredicateContext stack adding them to failures_ if not already added. */
94	unsigned int nestingLevel = 0;
95	PredicateContext *lastNode = rootPredicateNode_.next_;
96
97	for (; lastNode != 0; lastNode = lastNode->next_)
98	{
99	if (lastNode->id_ > lastUsedPredicateId_) /* new PredicateContext */
100	{
101	lastUsedPredicateId_ = lastNode->id_;
102	addFailureInfo (lastNode->file_, lastNode->line_, lastNode->expr_,
103	nestingLevel);
104	/*
105	* Link the PredicateContext to the failure for message target when
106	* popping the PredicateContext.
107	*/
108	lastNode->failure_ = &(failures_.back ());
109	}
110	++nestingLevel;
111	}
112
113	/* Adds the failed assertion */
114	addFailureInfo (file, line, expr, nestingLevel);
115	messageTarget_ = &(failures_.back ());
116	return *this;
117	}
118
119	void
120	TestResult::addFailureInfo (const char file, unsigned int line, const char expr, unsigned int nestingLevel)
121	{
122	Failure failure;
123
124	failure.file_ = file;
125	failure.line_ = line;
126	if (expr)
127	failure.expr_ = expr;
128	failure.nestingLevel_ = nestingLevel;
129	failures_.push_back (failure);
130	}
131
132	TestResult &
133	TestResult::popPredicateContext ()
134	{
135	PredicateContext *lastNode = &rootPredicateNode_;
136
137	while (lastNode->next_ != 0 && lastNode->next_->next_ != 0)
138	lastNode = lastNode->next_;
139	/* Set message target to popped failure */
140	PredicateContext *tail = lastNode->next_;
141	if (tail != 0 && tail->failure_ != 0)
142	messageTarget_ = tail->failure_;
143	/* Remove tail from list */
144	predicateStackTail_ = lastNode;
145	lastNode->next_ = 0;
146	return *this;
147	}
148
149	bool
150	TestResult::failed () const
151	{
152	return !failures_.empty ();
153	}
154
155	unsigned int
156	TestResult::getAssertionNestingLevel () const
157	{
158	unsigned int level = 0;
159	const PredicateContext *lastNode = &rootPredicateNode_;
160
161	while (lastNode->next_ != 0)
162	{
163	lastNode = lastNode->next_;
164	++level;
165	}
166	return level;
167	}
168
169	void
170	TestResult::printFailure (bool printTestName) const
171	{
172	if (failures_.empty ())
173	return;
174
175	if (printTestName)
176	printf ("* Detail of %s test failure:\n", name_.c_str ());
177
178	/* Print in reverse to display the callstack in the right order */
179	Failures::const_iterator itEnd = failures_.end ();
180	for (Failures::const_iterator it = failures_.begin (); it != itEnd; ++it)
181	{
182	const Failure &failure = *it;
183	std::string indent (failure.nestingLevel_ * 2, ' ');
184	if (failure.file_)
185	printf ("%s%s(%d): ", indent.c_str (), failure.file_, failure.line_);
186	if (!failure.expr_.empty ())
187	printf ("%s\n", failure.expr_.c_str ());
188	else if (failure.file_)
189	printf ("\n");
190	if (!failure.message_.empty ())
191	{
192	std::string reindented = indentText (failure.message_, indent + " ");
193	printf ("%s\n", reindented.c_str ());
194	}
195	}
196	}
197
198	std::string
199	TestResult::indentText (const std::string &text, const std::string &indent)
200	{
201	std::string reindented;
202	std::string::size_type lastIndex = 0;
203
204	while (lastIndex < text.size ())
205	{
206	std::string::size_type nextIndex = text.find ('\n', lastIndex);
207	if (nextIndex == std::string::npos)
208	nextIndex = text.size () - 1;
209	reindented += indent;
210	reindented += text.substr (lastIndex, nextIndex - lastIndex + 1);
211	lastIndex = nextIndex + 1;
212	}
213	return reindented;
214	}
215
216	TestResult &
217	TestResult::addToLastFailure (const std::string &message)
218	{
219	if (messageTarget_ != 0)
220	messageTarget_->message_ += message;
221	return *this;
222	}
223
224	TestResult &
225	TestResult::operator << (bool value)
226	{
227	return addToLastFailure (value ? "true" : "false");
228	}
229
230	TestResult &
231	TestResult::operator << (int value)
232	{
233	char buffer[32];
234
235	sprintf (buffer, "%d", value);
236	return addToLastFailure (buffer);
237	}
238
239	TestResult &
240	TestResult::operator << (unsigned int value)
241	{
242	char buffer[32];
243
244	sprintf (buffer, "%u", value);
245	return addToLastFailure (buffer);
246	}
247
248	TestResult &
249	TestResult::operator << (double value)
250	{
251	char buffer[32];
252
253	sprintf (buffer, "%16g", value);
254	return addToLastFailure (buffer);
255	}
256
257	TestResult &
258	TestResult::operator << (const char *value)
259	{
260	return addToLastFailure (value ? value
261	: "<NULL>");
262	}
263
264	TestResult &
265	TestResult::operator << (const std::string &value)
266	{
267	return addToLastFailure (value);
268	}
269
270	/*
271	* class TestCase
272	* //////////////////////////////////////////////////////////////////
273	*/
274
275	TestCase::TestCase ()
276	: result_ (0)
277	{
278	}
279
280	TestCase::~TestCase ()
281	{
282	}
283
284	void
285	TestCase::run (TestResult &result)
286	{
287	result_ = &result;
288	runTestCase ();
289	}
290
291	/*
292	* class Runner
293	* //////////////////////////////////////////////////////////////////
294	*/
295
296	Runner::Runner ()
297	{
298	}
299
300	Runner &
301	Runner::add (TestCaseFactory factory)
302	{
303	tests_.push_back (factory);
304	return *this;
305	}
306
307	unsigned int
308	Runner::testCount () const
309	{
310	return static_cast<unsigned int> (tests_.size ());
311	}
312
313	std::string
314	Runner::testNameAt (unsigned int index) const
315	{
316	TestCase *test = tests_[index] ();
317	std::string name = test->testName ();
318
319	delete test;
320	return name;
321	}
322
323	void
324	Runner::runTestAt (unsigned int index, TestResult &result) const
325	{
326	TestCase *test = tests_[index] ();
327
328	result.setTestName (test->testName ());
329	printf ("Testing %s: ", test->testName ());
330	fflush (stdout);
331	#if JSON_USE_EXCEPTION
332	try
333	{
334	#endif /* if JSON_USE_EXCEPTION */
335	test->run (result);
336	#if JSON_USE_EXCEPTION
337	}
338
339	catch (const std::exception &e)
340	{
341	result.addFailure (__FILE__, __LINE__,
342	"Unexpected exception caugth:") << e.what ();
343	}
344	#endif /* if JSON_USE_EXCEPTION */
345	delete test;
346	const char *status = result.failed () ? "FAILED"
347	: "OK";
348	printf ("%s\n", status);
349	fflush (stdout);
350	}
351
352
353	bool
354	Runner::runAllTest (bool printSummary) const
355	{
356	unsigned int count = testCount ();
357
358	std::deque<TestResult> failures;
359	for (unsigned int index = 0; index < count; ++index)
360	{
361	TestResult result;
362	runTestAt (index, result);
363	if (result.failed ())
364	failures.push_back (result);
365	}
366
367	if (failures.empty ())
368	{
369	if (printSummary)
370	printf ("All %d tests passed\n", count);
371	return true;
372	}
373	else
374	{
375	for (unsigned int index = 0; index < failures.size (); ++index)
376	{
377	TestResult &result = failures[index];
378	result.printFailure (count > 1);
379	}
380
381	if (printSummary)
382	{
383	unsigned int failedCount = static_cast<unsigned int> (failures.size ());
384	unsigned int passedCount = count - failedCount;
385	printf ("%d/%d tests passed (%d failure(s))\n", passedCount, count, failedCount);
386	}
387	return false;
388	}
389	}
390
391	bool
392	Runner::testIndex (const std::string &testName, unsigned int &indexOut) const
393	{
394	unsigned int count = testCount ();
395
396	for (unsigned int index = 0; index < count; ++index)
397	if (testNameAt (index) == testName)
398	{
399	indexOut = index;
400	return true;
401	}
402	return false;
403	}
404
405	void
406	Runner::listTests () const
407	{
408	unsigned int count = testCount ();
409
410	for (unsigned int index = 0; index < count; ++index)
411	printf ("%s\n", testNameAt (index).c_str ());
412	}
413
414	int
415	Runner::runCommandLine (int argc, const char *argv[]) const
416	{
417	typedef std::deque<std::string> TestNames;
418	Runner subrunner;
419	for (int index = 1; index < argc; ++index)
420	{
421	std::string opt = argv[index];
422	if (opt == "--list-tests")
423	{
424	listTests ();
425	return 0;
426	}
427	else if (opt == "--test-auto")
428	preventDialogOnCrash ();
429	else if (opt == "--test")
430	{
431	++index;
432	if (index < argc)
433	{
434	unsigned int testNameIndex;
435	if (testIndex (argv[index], testNameIndex))
436	subrunner.add (tests_[testNameIndex]);
437	else
438	{
439	fprintf (stderr, "Test '%s' does not exist!\n", argv[index]);
440	return 2;
441	}
442	}
443	else
444	{
445	printUsage (argv[0]);
446	return 2;
447	}
448	}
449	else
450	{
451	printUsage (argv[0]);
452	return 2;
453	}
454	}
455	bool succeeded;
456	if (subrunner.testCount () > 0)
457	succeeded = subrunner.runAllTest (subrunner.testCount () > 1);
458	else
459	succeeded = runAllTest (true);
460	return succeeded ? 0
461	: 1;
462	}
463
464	#if defined(_MSC_VER)
465	/* Hook MSVCRT assertions to prevent dialog from appearing */
466	static int
467	msvcrtSilentReportHook (int reportType, char message, int returnValue)
468	{
469	/*
470	* The default CRT handling of error and assertion is to display
471	* an error dialog to the user.
472	* Instead, when an error or an assertion occurs, we force the
473	* application to terminate using abort() after display
474	* the message on stderr.
475	*/
476	if (reportType == _CRT_ERROR \|\|
477	reportType == _CRT_ASSERT)
478	{
479	/*
480	* calling abort() cause the ReportHook to be called
481	* The following is used to detect this case and let's the
482	* error handler fallback on its default behaviour (
483	* display a warning message)
484	*/
485	static volatile bool isAborting = false;
486	if (isAborting)
487	return TRUE;
488	isAborting = true;
489
490	fprintf (stderr, "CRT Error/Assert:\n%s\n", message);
491	fflush (stderr);
492	abort ();
493	}
494	/* Let's other reportType (_CRT_WARNING) be handled as they would by default */
495	return FALSE;
496	}
497	#endif /* if defined(_MSC_VER) */
498
499
500
501	void
502	Runner::preventDialogOnCrash ()
503	{
504	#if defined(_MSC_VER)
505	/*
506	* Install a hook to prevent MSVCRT error and assertion from
507	* popping a dialog.
508	*/
509	_CrtSetReportHook (&msvcrtSilentReportHook);
510	#endif /* if defined(_MSC_VER) */
511
512	/*
513	* @todo investiguate this handler (for buffer overflow)
514	* _set_security_error_handler
515	*/
516
517	#if defined(_WIN32)
518	/*
519	* Prevents the system from popping a dialog for debugging if the
520	* application fails due to invalid memory access.
521	*/
522	SetErrorMode (SEM_FAILCRITICALERRORS
523	\| SEM_NOGPFAULTERRORBOX
524	\| SEM_NOOPENFILEERRORBOX);
525	#endif /* if defined(_WIN32) */
526	}
527
528	void
529	Runner::printUsage (const char *appName)
530	{
531	printf (
532	"Usage: %s [options]\n"
533	"\n"
534	"If --test is not specified, then all the test cases be run.\n"
535	"\n"
536	"Valid options:\n"
537	"--list-tests: print the name of all test cases on the standard\n"
538	" output and exit.\n"
539	"--test TESTNAME: executes the test case with the specified name.\n"
540	" May be repeated.\n"
541	"--test-auto: prevent dialog prompting for debugging on crash.\n"
542	, appName);
543	}
544
545	/*
546	* Assertion functions
547	* //////////////////////////////////////////////////////////////////
548	*/
549
550	TestResult &
551	checkStringEqual (TestResult &result, const std::string &expected, const std::string &actual, const char file, unsigned int line, const char expr)
552	{
553	if (expected != actual)
554	{
555	result.addFailure (file, line, expr);
556	result << "Expected: '" << expected << "'\n";
557	result << "Actual : '" << actual << "'";
558	}
559	return result;
560	}
561	} /* namespace JsonTest */