16393801904

Committed 19 Jul 2025 11:30PM UTC coverage: 90.637% (-0.07%) from 90.708%

Build # 16393801904

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #4998 from randombit/jack/fix-clang-tidy-readability-isolate-declaration

Enable and fix clang-tidy warning readability-isolate-declaration

Run Details

99942 of 110266 relevant lines covered (90.64%)

12231283.62 hits per line

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

98.2

/src/tests/test_tests.cpp

/*
* (C) 2017,2018 Jack Lloyd
*
* Botan is released under the Simplified BSD License (see license.txt)
*/

#include "tests.h"

#if defined(BOTAN_HAS_BIGINT)
   #include <botan/bigint.h>
#endif

namespace Botan_Tests {

/*
* Test the test framework :)
*/

class Test_Tests final : public Test {
   public:
      std::vector<Test::Result> run() override {
         /*
         Notation here is confusing. Idea is the result is the actual
         result of the test. The test_result is the result that is the
         testcase, and should typically be in a failure mode.
         */

         Test::Result result("Test Framework");

         // Test a few success corner cases first
         const std::string testcase_name = "Failing Test";

         // NOLINTNEXTLINE(hicpp-exception-baseclass)
         result.test_throws("throws pi(-ish)", []() { throw 22.0 / 7; });

         // Test expected failure cases
         {
            Test::Result test_result(testcase_name);
            test_result.test_throws("doesn't throw", []() {});
            verify_failure("test_throws 1", result, test_result);
         }

         {
            Test::Result test_result(testcase_name);
            test_result.test_failure("explicitly reported failure", std::vector<uint8_t>());
            verify_failure("explicit failure", result, test_result);
         }

         {
            Test::Result test_result(testcase_name);
            test_result.test_failure("explicitly reported failure", "test error");
            verify_failure("explicit failure", result, test_result);
         }

         { verify_failure("explicit failure", result, Test::Result::Failure(testcase_name, "failure")); }

         {
            Test::Result test_result(testcase_name);
            std::vector<uint8_t> vec1(5);
            std::vector<uint8_t> vec2(3, 9);
            test_result.test_eq("test vectors equal", vec1, vec2);
            verify_failure("test vectors equal", result, test_result);
         }

         {
            Test::Result test_result(testcase_name);
            std::vector<uint8_t> vec1(5);
            std::vector<uint8_t> vec2(5);
            test_result.test_ne("test vectors not equal", vec1, vec2);
            verify_failure("test vectors equal", result, test_result);
         }

         {
            Test::Result test_result(testcase_name);
            std::vector<uint8_t> vec1(5);
            std::vector<uint8_t> vec2(5);
            test_result.test_ne("test arrays not equal", vec1.data(), vec1.size(), vec2.data(), vec2.size());
            verify_failure("test vectors equal", result, test_result);
         }

         {
            Test::Result test_result(testcase_name);
            size_t x = 5;
            size_t y = 6;
            test_result.test_eq("test ints equal", x, y);
            verify_failure("test ints equal", result, test_result);
         }

         {
            Test::Result test_result(testcase_name);
            size_t x = 5;
            size_t y = 5;
            test_result.test_ne("test ints not equal", x, y);
            verify_failure("test ints not equal", result, test_result);
         }

         {
            Test::Result test_result(testcase_name);
            test_result.test_is_nonempty("empty", "");
            verify_failure("test_is_nonempty", result, test_result);
         }

         {
            Test::Result test_result(testcase_name);
            test_result.test_lt("not less", 5, 5);
            verify_failure("test_lt", result, test_result);
         }

         {
            Test::Result test_result(testcase_name);
            test_result.test_lte("not lte", 6, 5);
            verify_failure("test_lte", result, test_result);
         }

         {
            Test::Result test_result(testcase_name);
            test_result.test_gte("not gte", 5, 6);
            verify_failure("test_gte", result, test_result);
         }

         {
            Test::Result test_result(testcase_name);
            test_result.test_ne("string ne", "foo", "foo");
            verify_failure("test_ne", result, test_result);
         }

         {
            Test::Result test_result(testcase_name);
            test_result.test_rc_ok("test_func", -1);
            verify_failure("test_rc_ok", result, test_result);
         }

         {
            Test::Result test_result(testcase_name);
            test_result.test_rc("test_func", 0, 5);
            verify_failure("test_rc", result, test_result);
         }

         {
            Test::Result test_result(testcase_name);
            test_result.test_rc_fail("test_func", "testing", 0);
            verify_failure("test_rc_fail", result, test_result);
         }

         {
            Test::Result test_result(testcase_name);
            test_result.test_throws(
               "test_throws", "expected msg", []() { throw std::runtime_error("not the message"); });
            verify_failure("test_throws 2", result, test_result);
         }

         {
            Test::Result test_result(testcase_name);
            test_result.test_throws("test_throws", "expected msg", []() {
               // NOLINTNEXTLINE(hicpp-exception-baseclass)
               throw std::string("not even a std::exception");
            });
            verify_failure("test_throws 3", result, test_result);
         }

         {
            Test::Result test_result(testcase_name);
            test_result.test_throws("test_throws", "expected msg", []() { ; });
            verify_failure("test_throws 4", result, test_result);
         }

         {
            Test::Result test_result(testcase_name);
            test_result.test_throws<std::invalid_argument>(
               "test_throws", "expected msg", []() { throw std::runtime_error("expected msg"); });
            verify_failure("test_throws 5", result, test_result);
         }

         {
            Test::Result test_result(testcase_name);
            test_result.test_throws<std::invalid_argument>("test_throws",
                                                           []() { throw std::runtime_error("expected msg"); });
            verify_failure("test_throws 6", result, test_result);
         }

         {
            Test::Result test_result(testcase_name);
            test_result.test_no_throw("test_no_throw", []() { throw std::runtime_error("boom!"); });
            verify_failure("test_throws 7", result, test_result);
         }

#if defined(BOTAN_HAS_BIGINT)
         {
            Test::Result test_result(testcase_name);
            const auto x = Botan::BigInt::from_word(5);
            const auto y = Botan::BigInt::from_word(6);
            test_result.test_eq("test ints equal", x, y);
            verify_failure("test ints equal", result, test_result);
         }

         {
            Test::Result test_result(testcase_name);
            const auto x = Botan::BigInt::from_word(5);
            const auto y = Botan::BigInt::from_word(5);
            test_result.test_ne("test ints not equal", x, y);
            verify_failure("test ints not equal", result, test_result);
         }
#endif

         return {result, test_testsuite_rng()};
      }

   private:
      static Test::Result test_testsuite_rng() {
         Test::Result result("Testsuite_RNG");

         size_t histogram[256] = {0};

         const size_t RUNS = 1000;

         auto rng = Test::new_rng(__func__);

         for(size_t i = 0; i != 256 * RUNS; ++i) {
            histogram[rng->next_byte()] += 1;
         }

         for(size_t count : histogram) {
            if(count < RUNS / 2 || count > RUNS * 2) {
               result.test_failure("Testsuite_RNG produced non-uniform output");
            } else {
               result.test_success("Testsuite_RNG seemed roughly uniform");
            }
         }

         return result;
      }

      static void verify_failure(const std::string& what, Test::Result& result, const Test::Result& test_result) {
         if(test_result.tests_failed() > 0) {
            result.test_success("Got expected failure for " + what);
            const std::string result_str = test_result.result_string();

            result.confirm("result string contains FAIL", result_str.find("FAIL") != std::string::npos);
         } else {
            result.test_failure("Expected test to fail for " + what);
         }
      }
};

BOTAN_REGISTER_TEST("utils", "testcode", Test_Tests);

}  // namespace Botan_Tests

1	/*
2	* (C) 2017,2018 Jack Lloyd
3	*
4	* Botan is released under the Simplified BSD License (see license.txt)
5	*/
6
7	#include "tests.h"
8
9	#if defined(BOTAN_HAS_BIGINT)
10	#include <botan/bigint.h>
11	#endif
12
13	namespace Botan_Tests {
14
15	/*
16	* Test the test framework :)
17	*/
18
19	class Test_Tests final : public Test {	×
20	public:
21	std::vector<Test::Result> run() override {	1✔
22	/*
23	Notation here is confusing. Idea is the result is the actual
24	result of the test. The test_result is the result that is the
25	testcase, and should typically be in a failure mode.
26	*/
27
28	Test::Result result("Test Framework");	1✔
29
30	// Test a few success corner cases first
31	const std::string testcase_name = "Failing Test";	1✔
32
33	// NOLINTNEXTLINE(hicpp-exception-baseclass)
34	result.test_throws("throws pi(-ish)", []() { throw 22.0 / 7; });	3✔
35
36	// Test expected failure cases
37	{	1✔
38	Test::Result test_result(testcase_name);	2✔
39	test_result.test_throws("doesn't throw", []() {});	2✔
40	verify_failure("test_throws 1", result, test_result);	1✔
41	}	1✔
42
43	{	1✔
44	Test::Result test_result(testcase_name);	2✔
45	test_result.test_failure("explicitly reported failure", std::vector<uint8_t>());	2✔
46	verify_failure("explicit failure", result, test_result);	1✔
47	}	1✔
48
49	{	1✔
50	Test::Result test_result(testcase_name);	2✔
51	test_result.test_failure("explicitly reported failure", "test error");	2✔
52	verify_failure("explicit failure", result, test_result);	1✔
53	}	1✔
54
55	{ verify_failure("explicit failure", result, Test::Result::Failure(testcase_name, "failure")); }	2✔
56
57	{	1✔
58	Test::Result test_result(testcase_name);	2✔
59	std::vector<uint8_t> vec1(5);	1✔
60	std::vector<uint8_t> vec2(3, 9);	1✔
61	test_result.test_eq("test vectors equal", vec1, vec2);	2✔
62	verify_failure("test vectors equal", result, test_result);	2✔
63	}	2✔
64
65	{	1✔
66	Test::Result test_result(testcase_name);	2✔
67	std::vector<uint8_t> vec1(5);	1✔
68	std::vector<uint8_t> vec2(5);	1✔
69	test_result.test_ne("test vectors not equal", vec1, vec2);	2✔
70	verify_failure("test vectors equal", result, test_result);	2✔
71	}	2✔
72
73	{	1✔
74	Test::Result test_result(testcase_name);	2✔
75	std::vector<uint8_t> vec1(5);	1✔
76	std::vector<uint8_t> vec2(5);	1✔
77	test_result.test_ne("test arrays not equal", vec1.data(), vec1.size(), vec2.data(), vec2.size());	1✔
78	verify_failure("test vectors equal", result, test_result);	2✔
79	}	2✔
80
81	{	1✔
82	Test::Result test_result(testcase_name);	2✔
83	size_t x = 5;	1✔
84	size_t y = 6;	1✔
85	test_result.test_eq("test ints equal", x, y);	1✔
86	verify_failure("test ints equal", result, test_result);	1✔
87	}	1✔
88
89	{	1✔
90	Test::Result test_result(testcase_name);	2✔
91	size_t x = 5;	1✔
92	size_t y = 5;	1✔
93	test_result.test_ne("test ints not equal", x, y);	1✔
94	verify_failure("test ints not equal", result, test_result);	1✔
95	}	1✔
96
97	{	1✔
98	Test::Result test_result(testcase_name);	2✔
99	test_result.test_is_nonempty("empty", "");	2✔
100	verify_failure("test_is_nonempty", result, test_result);	1✔
101	}	1✔
102
103	{	1✔
104	Test::Result test_result(testcase_name);	2✔
105	test_result.test_lt("not less", 5, 5);	1✔
106	verify_failure("test_lt", result, test_result);	1✔
107	}	1✔
108
109	{	1✔
110	Test::Result test_result(testcase_name);	2✔
111	test_result.test_lte("not lte", 6, 5);	1✔
112	verify_failure("test_lte", result, test_result);	1✔
113	}	1✔
114
115	{	1✔
116	Test::Result test_result(testcase_name);	2✔
117	test_result.test_gte("not gte", 5, 6);	1✔
118	verify_failure("test_gte", result, test_result);	1✔
119	}	1✔
120
121	{	1✔
122	Test::Result test_result(testcase_name);	2✔
123	test_result.test_ne("string ne", "foo", "foo");	2✔
124	verify_failure("test_ne", result, test_result);	1✔
125	}	1✔
126
127	{	1✔
128	Test::Result test_result(testcase_name);	2✔
129	test_result.test_rc_ok("test_func", -1);	1✔
130	verify_failure("test_rc_ok", result, test_result);	1✔
131	}	1✔
132
133	{	1✔
134	Test::Result test_result(testcase_name);	2✔
135	test_result.test_rc("test_func", 0, 5);	1✔
136	verify_failure("test_rc", result, test_result);	1✔
137	}	1✔
138
139	{	1✔
140	Test::Result test_result(testcase_name);	2✔
141	test_result.test_rc_fail("test_func", "testing", 0);	2✔
142	verify_failure("test_rc_fail", result, test_result);	1✔
143	}	1✔
144
145	{	1✔
146	Test::Result test_result(testcase_name);	2✔
147	test_result.test_throws(	2✔
148	"test_throws", "expected msg", []() { throw std::runtime_error("not the message"); });	1✔
149	verify_failure("test_throws 2", result, test_result);	1✔
150	}	1✔
151
152	{	1✔
153	Test::Result test_result(testcase_name);	2✔
154	test_result.test_throws("test_throws", "expected msg", []() {	2✔
155	// NOLINTNEXTLINE(hicpp-exception-baseclass)
156	throw std::string("not even a std::exception");	1✔
157	});
158	verify_failure("test_throws 3", result, test_result);	1✔
159	}	1✔
160
161	{	1✔
162	Test::Result test_result(testcase_name);	2✔
163	test_result.test_throws("test_throws", "expected msg", []() { ; });	2✔
164	verify_failure("test_throws 4", result, test_result);	1✔
165	}	1✔
166
167	{	1✔
168	Test::Result test_result(testcase_name);	2✔
169	test_result.test_throws<std::invalid_argument>(	2✔
170	"test_throws", "expected msg", []() { throw std::runtime_error("expected msg"); });	1✔
171	verify_failure("test_throws 5", result, test_result);	1✔
172	}	1✔
173
174	{	1✔
175	Test::Result test_result(testcase_name);	2✔
176	test_result.test_throws<std::invalid_argument>("test_throws",	2✔
177	[]() { throw std::runtime_error("expected msg"); });	1✔
178	verify_failure("test_throws 6", result, test_result);	1✔
179	}	1✔
180
181	{	1✔
182	Test::Result test_result(testcase_name);	2✔
183	test_result.test_no_throw("test_no_throw", []() { throw std::runtime_error("boom!"); });	3✔
184	verify_failure("test_throws 7", result, test_result);	1✔
185	}	1✔
186
187	#if defined(BOTAN_HAS_BIGINT)
188	{	1✔
189	Test::Result test_result(testcase_name);	2✔
190	const auto x = Botan::BigInt::from_word(5);	1✔
191	const auto y = Botan::BigInt::from_word(6);	1✔
192	test_result.test_eq("test ints equal", x, y);	1✔
193	verify_failure("test ints equal", result, test_result);	1✔
194	}	1✔
195
196	{	1✔
197	Test::Result test_result(testcase_name);	2✔
198	const auto x = Botan::BigInt::from_word(5);	1✔
199	const auto y = Botan::BigInt::from_word(5);	1✔
200	test_result.test_ne("test ints not equal", x, y);	1✔
201	verify_failure("test ints not equal", result, test_result);	1✔
202	}	1✔
203	#endif
204
205	return {result, test_testsuite_rng()};	4✔
206	}	2✔
207
208	private:
209	static Test::Result test_testsuite_rng() {	1✔
210	Test::Result result("Testsuite_RNG");	1✔
211
212	size_t histogram[256] = {0};	1✔
213
214	const size_t RUNS = 1000;	1✔
215
216	auto rng = Test::new_rng(__func__);	1✔
217
218	for(size_t i = 0; i != 256 * RUNS; ++i) {	256,001✔
219	histogram[rng->next_byte()] += 1;	256,000✔
220	}
221
222	for(size_t count : histogram) {	257✔
223	if(count < RUNS / 2 \|\| count > RUNS * 2) {	256✔
224	result.test_failure("Testsuite_RNG produced non-uniform output");	×
225	} else {
226	result.test_success("Testsuite_RNG seemed roughly uniform");	512✔
227	}
228	}
229
230	return result;	1✔
231	}	1✔
232
233	static void verify_failure(const std::string& what, Test::Result& result, const Test::Result& test_result) {	25✔
234	if(test_result.tests_failed() > 0) {	25✔
235	result.test_success("Got expected failure for " + what);	25✔
236	const std::string result_str = test_result.result_string();	25✔
237
238	result.confirm("result string contains FAIL", result_str.find("FAIL") != std::string::npos);	50✔
239	} else {	25✔
240	result.test_failure("Expected test to fail for " + what);	×
241	}
242	}	25✔
243	};
244
245	BOTAN_REGISTER_TEST("utils", "testcode", Test_Tests);
246
247	} // namespace Botan_Tests

randombit / botan / 16393801904

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