libept
tests.h
Go to the documentation of this file.
1#ifndef EPT_TESTS_H
2#define EPT_TESTS_H
3
12#include <string>
13#include <sstream>
14#include <exception>
15#include <functional>
16#include <vector>
17
18namespace ept {
19namespace tests {
20struct LocationInfo;
21}
22}
23
24/*
25 * These global arguments will be shadowed by local variables in functions that
26 * implement tests.
27 *
28 * They are here to act as default root nodes to fulfill method signatures when
29 * tests are called from outside other tests.
30 */
32
33namespace ept {
34namespace tests {
35
53struct LocationInfo : public std::stringstream
54{
56
61 std::ostream& operator()();
62};
63
66{
67 const char* file;
68 int line;
69 const char* call;
70 std::string local_info;
71
72 TestStackFrame(const char* file, int line, const char* call)
73 : file(file), line(line), call(call)
74 {
75 }
76
77 TestStackFrame(const char* file, int line, const char* call, const LocationInfo& local_info)
79 {
80 }
81
82 std::string format() const;
83
84 void format(std::ostream& out) const;
85};
86
87struct TestStack : public std::vector<TestStackFrame>
88{
89 using vector::vector;
90
92 std::string backtrace() const;
93
95 void backtrace(std::ostream& out) const;
96};
97
102struct TestFailed : public std::exception
103{
104 std::string message;
106
107 TestFailed(const std::exception& e);
108
109 template<typename ...Args>
110 TestFailed(const std::exception& e, Args&&... args)
111 : TestFailed(e)
112 {
113 add_stack_info(std::forward<Args>(args)...);
114 }
115
116 TestFailed(const std::string& message) : message(message) {}
117
118 template<typename ...Args>
119 TestFailed(const std::string& message, Args&&... args)
121 {
122 add_stack_info(std::forward<Args>(args)...);
123 }
124
125 const char* what() const noexcept override { return message.c_str(); }
126
127 template<typename ...Args>
128 void add_stack_info(Args&&... args) { stack.emplace_back(std::forward<Args>(args)...); }
129};
130
135#define EPT_TEST_INFO(name) \
136 ept::tests::LocationInfo ept_test_location_info; \
137 ept::tests::LocationInfo& name = ept_test_location_info
138
139
141template<typename A>
142void assert_true(const A& actual)
143{
144 if (actual) return;
145 std::stringstream ss;
146 ss << "actual value " << actual << " is not true";
147 throw TestFailed(ss.str());
148};
149
150void assert_true(std::nullptr_t actual);
151
153template<typename A>
154void assert_false(const A& actual)
155{
156 if (!actual) return;
157 std::stringstream ss;
158 ss << "actual value " << actual << " is not false";
159 throw TestFailed(ss.str());
160};
161
162void assert_false(std::nullptr_t actual);
163
168template<typename A, typename E>
169void assert_equal(const A& actual, const E& expected)
170{
171 if (actual == expected) return;
172 std::stringstream ss;
173 ss << "value '" << actual << "' is different than the expected '" << expected << "'";
174 throw TestFailed(ss.str());
175}
176
181template<typename A, typename E>
182void assert_not_equal(const A& actual, const E& expected)
183{
184 if (actual != expected) return;
185 std::stringstream ss;
186 ss << "value '" << actual << "' is not different than the expected '" << expected << "'";
187 throw TestFailed(ss.str());
188}
189
191template<typename A, typename E>
192void assert_less(const A& actual, const E& expected)
193{
194 if (actual < expected) return;
195 std::stringstream ss;
196 ss << "value '" << actual << "' is not less than the expected '" << expected << "'";
197 throw TestFailed(ss.str());
198}
199
201template<typename A, typename E>
202void assert_less_equal(const A& actual, const E& expected)
203{
204 if (actual <= expected) return;
205 std::stringstream ss;
206 ss << "value '" << actual << "' is not less than or equals to the expected '" << expected << "'";
207 throw TestFailed(ss.str());
208}
209
211template<typename A, typename E>
212void assert_greater(const A& actual, const E& expected)
213{
214 if (actual > expected) return;
215 std::stringstream ss;
216 ss << "value '" << actual << "' is not greater than the expected '" << expected << "'";
217 throw TestFailed(ss.str());
218}
219
221template<typename A, typename E>
222void assert_greater_equal(const A& actual, const E& expected)
223{
224 if (actual >= expected) return;
225 std::stringstream ss;
226 ss << "value '" << actual << "' is not greater than or equals to the expected '" << expected << "'";
227 throw TestFailed(ss.str());
228}
229
231void assert_startswith(const std::string& actual, const std::string& expected);
232
234void assert_endswith(const std::string& actual, const std::string& expected);
235
237void assert_contains(const std::string& actual, const std::string& expected);
238
240void assert_not_contains(const std::string& actual, const std::string& expected);
241
248void assert_re_matches(const std::string& actual, const std::string& expected);
249
256void assert_not_re_matches(const std::string& actual, const std::string& expected);
257
258
259template<class A>
260struct Actual
261{
263 Actual(const A& actual) : _actual(actual) {}
265
266 void istrue() const { assert_true(_actual); }
267 void isfalse() const { assert_false(_actual); }
268 template<typename E> void operator==(const E& expected) const { assert_equal(_actual, expected); }
269 template<typename E> void operator!=(const E& expected) const { assert_not_equal(_actual, expected); }
270 template<typename E> void operator<(const E& expected) const { return assert_less(_actual, expected); }
271 template<typename E> void operator<=(const E& expected) const { return assert_less_equal(_actual, expected); }
272 template<typename E> void operator>(const E& expected) const { return assert_greater(_actual, expected); }
273 template<typename E> void operator>=(const E& expected) const { return assert_greater_equal(_actual, expected); }
274};
275
277{
278 const char* _actual;
279 ActualCString(const char* s) : _actual(s) {}
280
281 void istrue() const { return assert_true(_actual); }
282 void isfalse() const { return assert_false(_actual); }
283 void operator==(const char* expected) const;
284 void operator==(const std::string& expected) const;
285 void operator!=(const char* expected) const;
286 void operator!=(const std::string& expected) const;
287 void operator<(const std::string& expected) const;
288 void operator<=(const std::string& expected) const;
289 void operator>(const std::string& expected) const;
290 void operator>=(const std::string& expected) const;
291 void startswith(const std::string& expected) const;
292 void endswith(const std::string& expected) const;
293 void contains(const std::string& expected) const;
294 void not_contains(const std::string& expected) const;
295 void matches(const std::string& re) const;
296 void not_matches(const std::string& re) const;
297};
298
299struct ActualStdString : public Actual<std::string>
300{
301 ActualStdString(const std::string& s) : Actual<std::string>(s) {}
302
303 void startswith(const std::string& expected) const;
304 void endswith(const std::string& expected) const;
305 void contains(const std::string& expected) const;
306 void not_contains(const std::string& expected) const;
307 void matches(const std::string& re) const;
308 void not_matches(const std::string& re) const;
309};
310
311struct ActualDouble : public Actual<double>
312{
313 using Actual::Actual;
314
315 void almost_equal(double expected, unsigned places) const;
316 void not_almost_equal(double expected, unsigned places) const;
317};
318
319template<typename A>
320inline Actual<A> actual(const A& actual) { return Actual<A>(actual); }
321inline ActualCString actual(const char* actual) { return ActualCString(actual); }
323inline ActualStdString actual(const std::string& actual) { return ActualStdString(actual); }
324inline ActualDouble actual(double actual) { return ActualDouble(actual); }
325
326struct ActualFunction : public Actual<std::function<void()>>
327{
328 using Actual::Actual;
329
330 void throws(const std::string& what_match) const;
331};
332
333inline ActualFunction actual_function(std::function<void()> actual) { return ActualFunction(actual); }
334
335
343#define wassert(...) \
344 do { try { \
345 __VA_ARGS__ ; \
346 } catch (TestFailed& e) { \
347 e.add_stack_info(__FILE__, __LINE__, #__VA_ARGS__, ept_test_location_info); \
348 throw; \
349 } catch (std::exception& e) { \
350 throw TestFailed(e, __FILE__, __LINE__, #__VA_ARGS__, ept_test_location_info); \
351 } } while(0)
352
354#define wassert_true(...) wassert(actual(__VA_ARGS__).istrue())
355
357#define wassert_false(...) wassert(actual(__VA_ARGS__).isfalse())
358
366#define wcallchecked(func) \
367 [&]() { try { \
368 return func; \
369 } catch (TestFailed& e) { \
370 e.add_stack_info(__FILE__, __LINE__, #func, ept_test_location_info); \
371 throw; \
372 } catch (std::exception& e) { \
373 throw TestFailed(e, __FILE__, __LINE__, #func, ept_test_location_info); \
374 } }()
375
376
377struct TestCase;
378
383{
385 std::string test_case;
386
388 std::string test_method;
389
391 std::string error_message;
392
395
397 std::string exception_typeid;
398
400 bool skipped = false;
401
402
403 TestMethodResult(const std::string& test_case, const std::string& test_method)
405
407 {
408 error_message = e.what();
409 error_stack = e.stack;
410 if (error_message.empty())
411 error_message = "test failed with an empty error message";
412 }
413
414 void set_exception(std::exception& e)
415 {
416 error_message = e.what();
417 if (error_message.empty())
418 error_message = "test threw an exception with an empty error message";
419 exception_typeid = typeid(e).name();
420 }
421
423 {
424 error_message = "unknown exception caught";
425 }
426
427 void set_setup_exception(std::exception& e)
428 {
429 error_message = "[setup failed: ";
430 error_message += e.what();
431 error_message += "]";
432 }
433
434 void set_teardown_exception(std::exception& e)
435 {
436 error_message = "[teardown failed: ";
437 error_message += e.what();
438 error_message += "]";
439 }
440
441 bool is_success() const
442 {
443 return error_message.empty();
444 }
445};
446
451{
453 std::string test_case;
455 std::vector<TestMethodResult> methods;
457 std::string fail_setup;
460 std::string fail_teardown;
462 bool skipped = false;
463
464 TestCaseResult(const std::string& test_case) : test_case(test_case) {}
465
467 {
468 fail_setup = "test case setup method threw an unknown exception";
469 }
470
471 void set_setup_failed(std::exception& e)
472 {
473 fail_setup = "test case setup method threw an exception: ";
474 fail_setup += e.what();
475 }
476
478 {
479 fail_teardown = "test case teardown method threw an unknown exception";
480 }
481
482 void set_teardown_failed(std::exception& e)
483 {
484 fail_teardown = "test case teardown method threw an exception: ";
485 fail_teardown += e.what();
486 }
487
489 {
490 methods.emplace_back(std::move(e));
491 }
492
493 bool is_success() const
494 {
495 if (!fail_setup.empty() || !fail_teardown.empty()) return false;
496 for (const auto& m: methods)
497 if (!m.is_success())
498 return false;
499 return true;
500 }
501};
502
503struct TestCase;
504struct TestCaseResult;
505struct TestMethod;
506struct TestMethodResult;
507
515{
516 virtual ~TestController() {}
517
523 virtual bool test_case_begin(const TestCase& test_case, const TestCaseResult& test_case_result) { return true; }
524
528 virtual void test_case_end(const TestCase& test_case, const TestCaseResult& test_case_result) {}
529
535 virtual bool test_method_begin(const TestMethod& test_method, const TestMethodResult& test_method_result) { return true; }
536
540 virtual void test_method_end(const TestMethod& test_method, const TestMethodResult& test_method_result) {}
541};
542
550{
552 std::string whitelist;
553
555 std::string blacklist;
556
557 bool test_case_begin(const TestCase& test_case, const TestCaseResult& test_case_result) override;
558 void test_case_end(const TestCase& test_case, const TestCaseResult& test_case_result) override;
559 bool test_method_begin(const TestMethod& test_method, const TestMethodResult& test_method_result) override;
560 void test_method_end(const TestMethod& test_method, const TestMethodResult& test_method_result) override;
561
562 bool test_method_should_run(const std::string& fullname) const;
563};
564
565
573{
575 std::vector<TestCase*> entries;
576
583 void register_test_case(TestCase& test_case);
584
588 std::vector<TestCaseResult> run_tests(TestController& controller);
589
591 static TestRegistry& get();
592};
593
598{
600 std::string name;
601
603 std::function<void()> test_function;
604
605 TestMethod(const std::string& name, std::function<void()> test_function)
607};
608
609
615{
617 std::string name;
618
620 std::vector<TestMethod> methods;
621
622 TestCase(const std::string& name)
623 : name(name)
624 {
626 }
627 virtual ~TestCase() {}
628
636 virtual void register_tests() = 0;
637
641 virtual void setup() {}
642
646 virtual void teardown() {}
647
652
657
665 virtual TestCaseResult run_tests(TestController& controller);
666
679 virtual TestMethodResult run_test(TestController& controller, TestMethod& method);
680
684 template<typename ...Args>
685 void add_method(const std::string& name, std::function<void()> test_function)
686 {
687 methods.emplace_back(name, test_function);
688 }
689
693 template<typename ...Args>
694 void add_method(const std::string& name, std::function<void()> test_function, Args&&... args)
695 {
696 methods.emplace_back(name, test_function, std::forward<Args>(args)...);
697 }
698
704 template<typename FUNC, typename ...Args>
705 void add_method(const std::string& name, FUNC test_function, Args&&... args)
706 {
707 methods.emplace_back(name, [test_function, args...]() { test_function(args...); });
708 }
709};
710
711
723{
724 virtual ~Fixture() {}
725
726 // Called before each test
727 virtual void test_setup() {}
728
729 // Called after each test
730 virtual void test_teardown() {}
731};
732
736template<typename FIXTURE>
738{
739 typedef FIXTURE Fixture;
740
742 std::function<Fixture*()> make_fixture;
743
744 template<typename... Args>
745 FixtureTestCase(const std::string& name, Args... args)
746 : TestCase(name)
747 {
748 make_fixture = [=]() { return new Fixture(args...); };
749 }
750
751 void setup() override
752 {
755 }
756
757 void teardown() override
758 {
759 delete fixture;
760 fixture = 0;
762 }
763
765 {
767 if (fixture) fixture->test_setup();
768 }
769
771 {
772 if (fixture) fixture->test_teardown();
774 }
775
782 template<typename FUNC, typename ...Args>
783 void add_method(const std::string& name, FUNC test_function, Args&&... args)
784 {
785 methods.emplace_back(name, [this, test_function, args...] { test_function(*fixture, args...); });
786 }
787};
788
789#if 0
790 struct Test
791 {
792 std::string name;
793 std::function<void()> test_func;
794 };
795
797 virtual void add_tests() {}
798#endif
799
800
801}
802}
803
804#endif
ActualFunction actual_function(std::function< void()> actual)
Definition: tests.h:333
void assert_re_matches(const std::string &actual, const std::string &expected)
Ensure that the string actual matches the extended regular expression expected.
Definition: tests.cc:176
Actual< A > actual(const A &actual)
Definition: tests.h:320
void assert_false(std::nullptr_t actual)
Definition: tests.cc:199
void assert_greater_equal(const A &actual, const E &expected)
Ensure that the actual value is greather or equal than the reference value.
Definition: tests.h:222
void assert_endswith(const std::string &actual, const std::string &expected)
Ensure that the string actual ends with expected.
Definition: tests.cc:116
void assert_not_re_matches(const std::string &actual, const std::string &expected)
Ensure that the string actual does not match the extended regular expression expected.
Definition: tests.cc:185
void assert_true(std::nullptr_t actual)
Definition: tests.cc:194
void assert_equal(const A &actual, const E &expected)
Test function that ensures that the actual value is the same as a reference one.
Definition: tests.h:169
void assert_not_equal(const A &actual, const E &expected)
Test function that ensures that the actual value is different than a reference one.
Definition: tests.h:182
void assert_less(const A &actual, const E &expected)
Ensure that the actual value is less than the reference value.
Definition: tests.h:192
void assert_less_equal(const A &actual, const E &expected)
Ensure that the actual value is less or equal than the reference value.
Definition: tests.h:202
void assert_not_contains(const std::string &actual, const std::string &expected)
Ensure that the string actual does not contain expected.
Definition: tests.cc:132
void assert_greater(const A &actual, const E &expected)
Ensure that the actual value is greater than the reference value.
Definition: tests.h:212
void assert_startswith(const std::string &actual, const std::string &expected)
Ensure that the string actual starts with expected.
Definition: tests.cc:108
void assert_contains(const std::string &actual, const std::string &expected)
Ensure that the string actual contains expected.
Definition: tests.cc:124
String functions.
Definition: apt.cc:40
Definition: packagerecord-test.cc:4
Definition: tests.h:277
void operator<(const std::string &expected) const
Definition: tests.cc:250
void operator==(const char *expected) const
Definition: tests.cc:210
void not_matches(const std::string &re) const
Definition: tests.cc:280
void endswith(const std::string &expected) const
Definition: tests.cc:292
void contains(const std::string &expected) const
Definition: tests.cc:298
void not_contains(const std::string &expected) const
Definition: tests.cc:304
const char * _actual
Definition: tests.h:278
void operator!=(const char *expected) const
Definition: tests.cc:236
void startswith(const std::string &expected) const
Definition: tests.cc:286
void istrue() const
Definition: tests.h:281
void operator>(const std::string &expected) const
Definition: tests.cc:262
void isfalse() const
Definition: tests.h:282
void operator>=(const std::string &expected) const
Definition: tests.cc:268
ActualCString(const char *s)
Definition: tests.h:279
void matches(const std::string &re) const
Definition: tests.cc:274
void operator<=(const std::string &expected) const
Definition: tests.cc:256
Definition: tests.h:312
void not_almost_equal(double expected, unsigned places) const
Definition: tests.cc:349
void almost_equal(double expected, unsigned places) const
Definition: tests.cc:340
Definition: tests.h:327
Definition: tests.h:300
void not_matches(const std::string &re) const
Definition: tests.cc:335
ActualStdString(const std::string &s)
Definition: tests.h:301
void endswith(const std::string &expected) const
Definition: tests.cc:315
void not_contains(const std::string &expected) const
Definition: tests.cc:325
void startswith(const std::string &expected) const
Definition: tests.cc:310
void matches(const std::string &re) const
Definition: tests.cc:330
void contains(const std::string &expected) const
Definition: tests.cc:320
Definition: tests.h:261
void operator==(const E &expected) const
Definition: tests.h:268
~Actual()
Definition: tests.h:264
void isfalse() const
Definition: tests.h:267
A _actual
Definition: tests.h:262
void operator!=(const E &expected) const
Definition: tests.h:269
void operator>(const E &expected) const
Definition: tests.h:272
Actual(const A &actual)
Definition: tests.h:263
void operator<=(const E &expected) const
Definition: tests.h:271
void istrue() const
Definition: tests.h:266
void operator<(const E &expected) const
Definition: tests.h:270
void operator>=(const E &expected) const
Definition: tests.h:273
Test case that includes a fixture.
Definition: tests.h:738
FixtureTestCase(const std::string &name, Args... args)
Definition: tests.h:745
void method_teardown(TestMethodResult &mr) override
Clean up after the test method is run.
Definition: tests.h:770
Fixture * fixture
Definition: tests.h:741
void setup() override
Set up the test case before it is run.
Definition: tests.h:751
void add_method(const std::string &name, FUNC test_function, Args &&... args)
Add a method that takes a reference to the fixture as argument.
Definition: tests.h:783
void method_setup(TestMethodResult &mr) override
Set up before the test method is run.
Definition: tests.h:764
FIXTURE Fixture
Definition: tests.h:739
void teardown() override
Clean up after the test case is run.
Definition: tests.h:757
std::function< Fixture *()> make_fixture
Definition: tests.h:742
Base class for test fixtures.
Definition: tests.h:723
virtual ~Fixture()
Definition: tests.h:724
virtual void test_teardown()
Definition: tests.h:730
virtual void test_setup()
Definition: tests.h:727
Add information to the test backtrace for the tests run in the current scope.
Definition: tests.h:54
std::ostream & operator()()
Clear the current information and return the output stream to which new information can be sent.
Definition: tests.cc:97
LocationInfo()
Definition: tests.h:55
Simple default implementation of TestController.
Definition: tests.h:550
std::string blacklist
Any method matching this glob expression will not be run.
Definition: tests.h:555
bool test_method_should_run(const std::string &fullname) const
Definition: tests.cc:525
bool test_case_begin(const TestCase &test_case, const TestCaseResult &test_case_result) override
Called before running a test case.
Definition: tests.cc:536
std::string whitelist
Any method not matching this glob expression will not be run.
Definition: tests.h:552
void test_method_end(const TestMethod &test_method, const TestMethodResult &test_method_result) override
Called after running a test method.
Definition: tests.cc:566
void test_case_end(const TestCase &test_case, const TestCaseResult &test_case_result) override
Called after running a test case.
Definition: tests.cc:549
bool test_method_begin(const TestMethod &test_method, const TestMethodResult &test_method_result) override
Called before running a test method.
Definition: tests.cc:560
Result of running a whole test case.
Definition: tests.h:451
TestCaseResult(const std::string &test_case)
Definition: tests.h:464
std::string test_case
Name of the test case.
Definition: tests.h:453
void set_setup_failed(std::exception &e)
Definition: tests.h:471
bool is_success() const
Definition: tests.h:493
std::string fail_setup
Set to a non-empty string if the setup method of the test case failed.
Definition: tests.h:457
void set_teardown_failed()
Definition: tests.h:477
std::vector< TestMethodResult > methods
Outcome of all the methods that have been run.
Definition: tests.h:455
void add_test_method(TestMethodResult &&e)
Definition: tests.h:488
void set_setup_failed()
Definition: tests.h:466
bool skipped
Set to true if this test case has been skipped.
Definition: tests.h:462
std::string fail_teardown
Set to a non-empty string if the teardown method of the test case failed.
Definition: tests.h:460
void set_teardown_failed(std::exception &e)
Definition: tests.h:482
Test case collecting several test methods, and self-registering with the singleton instance of TestRe...
Definition: tests.h:615
void add_method(const std::string &name, std::function< void()> test_function)
Register a new test method.
Definition: tests.h:685
virtual void setup()
Set up the test case before it is run.
Definition: tests.h:641
virtual void method_setup(TestMethodResult &)
Set up before the test method is run.
Definition: tests.h:651
virtual void register_tests()=0
This will be called before running the test case, to populate it with its test methods.
void add_method(const std::string &name, std::function< void()> test_function, Args &&... args)
Register a new test method.
Definition: tests.h:694
TestCase(const std::string &name)
Definition: tests.h:622
virtual void teardown()
Clean up after the test case is run.
Definition: tests.h:646
virtual TestMethodResult run_test(TestController &controller, TestMethod &method)
Run a test method.
Definition: tests.cc:480
virtual void method_teardown(TestMethodResult &)
Clean up after the test method is run.
Definition: tests.h:656
virtual TestCaseResult run_tests(TestController &controller)
Call setup(), run all the tests that have been registered, then call teardown().
Definition: tests.cc:445
virtual ~TestCase()
Definition: tests.h:627
std::vector< TestMethod > methods
All registered test methods.
Definition: tests.h:620
std::string name
Name of the test case.
Definition: tests.h:617
void add_method(const std::string &name, FUNC test_function, Args &&... args)
Register a new test metheod, with arguments.
Definition: tests.h:705
Abstract interface for the objects that supervise test execution.
Definition: tests.h:515
virtual void test_case_end(const TestCase &test_case, const TestCaseResult &test_case_result)
Called after running a test case.
Definition: tests.h:528
virtual bool test_method_begin(const TestMethod &test_method, const TestMethodResult &test_method_result)
Called before running a test method.
Definition: tests.h:535
virtual bool test_case_begin(const TestCase &test_case, const TestCaseResult &test_case_result)
Called before running a test case.
Definition: tests.h:523
virtual void test_method_end(const TestMethod &test_method, const TestMethodResult &test_method_result)
Called after running a test method.
Definition: tests.h:540
virtual ~TestController()
Definition: tests.h:516
Exception raised when a test assertion fails, normally by Location::fail_test.
Definition: tests.h:103
const char * what() const noexcept override
Definition: tests.h:125
TestFailed(const std::string &message, Args &&... args)
Definition: tests.h:119
TestFailed(const std::exception &e, Args &&... args)
Definition: tests.h:110
std::string message
Definition: tests.h:104
TestFailed(const std::string &message)
Definition: tests.h:116
void add_stack_info(Args &&... args)
Definition: tests.h:128
TestFailed(const std::exception &e)
Definition: tests.cc:67
TestStack stack
Definition: tests.h:105
Result of running a test method.
Definition: tests.h:383
TestMethodResult(const std::string &test_case, const std::string &test_method)
Definition: tests.h:403
void set_unknown_exception()
Definition: tests.h:422
std::string exception_typeid
If non-empty, the test raised an exception and this is its type ID.
Definition: tests.h:397
std::string test_case
Name of the test case.
Definition: tests.h:385
bool is_success() const
Definition: tests.h:441
void set_failed(TestFailed &e)
Definition: tests.h:406
TestStack error_stack
Stack frame of where the error happened.
Definition: tests.h:394
bool skipped
True if the test has been skipped.
Definition: tests.h:400
std::string error_message
If non-empty, the test failed with this error.
Definition: tests.h:391
void set_exception(std::exception &e)
Definition: tests.h:414
void set_teardown_exception(std::exception &e)
Definition: tests.h:434
void set_setup_exception(std::exception &e)
Definition: tests.h:427
std::string test_method
Name of the test method.
Definition: tests.h:388
Test method information.
Definition: tests.h:598
TestMethod(const std::string &name, std::function< void()> test_function)
Definition: tests.h:605
std::string name
Name of the test method.
Definition: tests.h:600
std::function< void()> test_function
Main body of the test method.
Definition: tests.h:603
Test registry.
Definition: tests.h:573
std::vector< TestCase * > entries
All known test cases.
Definition: tests.h:575
void register_test_case(TestCase &test_case)
Register a new test case.
Definition: tests.cc:428
static TestRegistry & get()
Get the singleton instance of TestRegistry.
Definition: tests.cc:420
std::vector< TestCaseResult > run_tests(TestController &controller)
Run all the registered tests using the given controller.
Definition: tests.cc:433
Information about one stack frame in the test execution stack.
Definition: tests.h:66
int line
Definition: tests.h:68
const char * call
Definition: tests.h:69
TestStackFrame(const char *file, int line, const char *call, const LocationInfo &local_info)
Definition: tests.h:77
const char * file
Definition: tests.h:67
std::string format() const
Definition: tests.cc:29
std::string local_info
Definition: tests.h:70
TestStackFrame(const char *file, int line, const char *call)
Definition: tests.h:72
Definition: tests.h:88
std::string backtrace() const
Return the formatted backtrace for this location.
Definition: tests.cc:55
const ept::tests::LocationInfo ept_test_location_info
Definition: tests.cc:20