23225340130

Committed 18 Mar 2026 01:53AM UTC coverage: 89.677% (-0.001%) from 89.678%

Build # 23225340130

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #5456 from randombit/jack/clang-tidy-22

Fix various warnings from clang-tidy 22

Run Details

104438 of 116460 relevant lines covered (89.68%)

11819947.55 hits per line

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

98.75

/src/tests/test_tests.cpp

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

#include "tests.h"

#include <botan/rng.h>

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

namespace Botan_Tests {

namespace {

/*
* 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_bin_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_bin_ne("test vectors not equal", vec1, vec2);
            verify_failure("test vectors equal", result, test_result);
         }

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

         {
            Test::Result test_result(testcase_name);
            const size_t x = 5;
            const size_t y = 5;
            test_result.test_sz_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_str_not_empty("empty", "");
            verify_failure("test_str_not_empty", result, test_result);
         }

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

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

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

         {
            Test::Result test_result(testcase_name);
            test_result.test_str_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_bn_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_bn_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(const 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.test_is_true("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

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

randombit / botan / 23225340130

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