1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
/* GDB self-testing.
Copyright (C) 2016-2024 Free Software Foundation, Inc.
This file is part of GDB.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>. */
#include "common-defs.h"
#include "common-exceptions.h"
#include "common-debug.h"
#include "selftest.h"
#include <functional>
namespace selftests
{
/* All the tests that have been registered. Using an std::set allows keeping
the order of tests stable and easily looking up whether a test name
exists. */
static selftests_registry tests;
/* Set of callback functions used to register selftests after GDB is fully
initialized. */
static std::vector<selftests_generator> lazy_generators;
/* See selftest.h. */
void
register_test (const std::string &name,
std::function<void(void)> function)
{
/* Check that no test with this name already exist. */
auto status = tests.emplace (name, std::move (function));
if (!status.second)
gdb_assert_not_reached ("Test already registered");
}
/* See selftest.h. */
void
add_lazy_generator (selftests_generator generator)
{
lazy_generators.push_back (std::move (generator));
}
/* See selftest.h. */
static bool run_verbose_ = false;
/* See selftest.h. */
bool
run_verbose ()
{
return run_verbose_;
}
/* See selftest.h. */
void
run_tests (gdb::array_view<const char *const> filters, bool verbose)
{
int ran = 0;
run_verbose_ = verbose;
std::vector<const char *> failed;
for (const auto &test : all_selftests ())
{
bool run = false;
if (filters.empty ())
run = true;
else
{
for (const char *filter : filters)
{
if (test.name.find (filter) != std::string::npos)
run = true;
}
}
if (!run)
continue;
try
{
debug_printf (_("Running selftest %s.\n"), test.name.c_str ());
++ran;
test.test ();
}
catch (const gdb_exception_error &ex)
{
debug_printf ("Self test failed: %s\n", ex.what ());
failed.push_back (test.name.c_str ());
}
reset ();
}
if (!failed.empty ())
{
debug_printf ("\nFailures:\n");
for (const char *name : failed)
debug_printf (" %s\n", name);
debug_printf ("\n");
}
debug_printf (_("Ran %d unit tests, %zu failed\n"),
ran, failed.size ());
}
/* See selftest.h. */
selftests_range
all_selftests ()
{
/* Execute any function which might still want to register tests. Once each
function has been executed, clear lazy_generators to ensure that
callback functions are only executed once. */
for (const auto &generator : lazy_generators)
for (selftest &test : generator ())
register_test (std::move (test.name), std::move (test.test));
lazy_generators.clear ();
return selftests_range (tests.cbegin (), tests.cend ());
}
} // namespace selftests
|
