19012754211

Committed 02 Nov 2025 01:10PM UTC coverage: 90.677% (+0.006%) from 90.671%

Build # 19012754211

Build Type

push

github

Committed by

web-flow

Commit Message

Merge pull request #5137 from randombit/jack/clang-tidy-includes

Remove various unused includes flagged by clang-tidy misc-include-cleaner

Run Details

100457 of 110786 relevant lines covered (90.68%)

12189873.8 hits per line

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

77.63

/src/tests/test_certstor_system.cpp

/*
* (C) 1999-2021 Jack Lloyd
* (C) 2019,2021 René Meusel
*
* Botan is released under the Simplified BSD License (see license.txt)
*/

#include "tests.h"

#if defined(BOTAN_HAS_CERTSTOR_SYSTEM)

   #include "test_certstor_utils.h"
   #include <botan/certstor_system.h>
   #include <algorithm>
   #include <memory>

namespace Botan_Tests {

namespace {

Test::Result find_certificate_by_pubkey_sha1(Botan::Certificate_Store& certstore) {
   Test::Result result("System Certificate Store - Find Certificate by SHA1(pubkey)");

   try {
      result.start_timer();
      auto cert = certstore.find_cert_by_pubkey_sha1(get_key_id());
      result.end_timer();

      if(result.test_not_nullopt("found certificate", cert)) {
         auto cns = cert->subject_dn().get_attribute("CN");
         result.test_is_eq("exactly one CN", cns.size(), size_t(1));
         result.test_eq("CN", cns.front(), get_subject_cn());
      }
   } catch(std::exception& e) {
      result.test_failure(e.what());
   }

   result.test_throws("on invalid SHA1 hash data", [&] { certstore.find_cert_by_pubkey_sha1({}); });

   return result;
}

Test::Result find_certificate_by_pubkey_sha1_with_unmatching_key_id(Botan::Certificate_Store& certstore) {
   Test::Result result("System Certificate Store - Find Certificate by SHA1(pubkey) - regression test for GH #2779");

   if(!certstore.find_cert(get_dn_of_cert_with_different_key_id(), {}).has_value()) {
      result.note_missing("OS does not trust the certificate used for this regression test, skipping");
      return result;
   }

   try {
      result.start_timer();
      auto cert = certstore.find_cert_by_pubkey_sha1(get_pubkey_sha1_of_cert_with_different_key_id());
      result.end_timer();

      if(result.test_not_nullopt("found certificate", cert)) {
         auto cns = cert->subject_dn().get_attribute("CN");
         result.test_is_eq("exactly one CN", cns.size(), size_t(1));
         result.test_eq("CN", cns.front(), "SecureTrust CA");
      }
   } catch(std::exception& e) {
      result.test_failure(e.what());
   }

   return result;
}

Test::Result find_cert_by_subject_dn(Botan::Certificate_Store& certstore) {
   Test::Result result("System Certificate Store - Find Certificate by subject DN");

   try {
      auto dn = get_dn();

      result.start_timer();
      auto cert = certstore.find_cert(dn, std::vector<uint8_t>());
      result.end_timer();

      if(result.test_not_nullopt("found certificate", cert)) {
         auto cns = cert->subject_dn().get_attribute("CN");
         result.test_is_eq("exactly one CN", cns.size(), size_t(1));
         result.test_eq("CN", cns.front(), get_subject_cn());
      }
   } catch(std::exception& e) {
      result.test_failure(e.what());
   }

   return result;
}

Test::Result find_cert_by_utf8_subject_dn(Botan::Certificate_Store& certstore) {
   Test::Result result("System Certificate Store - Find Certificate by UTF8 subject DN");

   try {
      const auto DNs = get_utf8_dn_alternatives();

      unsigned int found = 0;

      result.start_timer();
      for(const auto& [cn, dn] : DNs) {
         if(auto cert = certstore.find_cert(dn, {})) {
            auto cns = cert->subject_dn().get_attribute("CN");
            result.test_is_eq("exactly one CN", cns.size(), size_t(1));
            result.test_eq("CN", cns.front(), cn);

            ++found;
         }
      }
      result.end_timer();

      if(found == 0) {
         std::string tried_cns;
         for(const auto& [cn, dn] : DNs) {
            tried_cns += cn + ", ";
         }

         result.test_note("Tried to find any of those CNs: " + tried_cns);
         result.test_failure("Did not find any certificate via an UTF-8 encoded DN");
      }

      result.test_gte("found at least one certificate", found, 1);
   } catch(std::exception& e) {
      result.test_failure(e.what());
   }

   return result;
}

Test::Result find_cert_by_subject_dn_and_key_id(Botan::Certificate_Store& certstore) {
   Test::Result result("System Certificate Store - Find Certificate by subject DN and key ID");

   try {
      auto dn = get_dn();

      result.start_timer();
      auto cert = certstore.find_cert(dn, get_key_id());
      result.end_timer();

      if(result.test_not_nullopt("found certificate", cert)) {
         auto cns = cert->subject_dn().get_attribute("CN");
         result.test_is_eq("exactly one CN", cns.size(), size_t(1));
         result.test_eq("CN", cns.front(), get_subject_cn());
      }
   } catch(std::exception& e) {
      result.test_failure(e.what());
   }

   return result;
}

Test::Result find_certs_by_subject_dn_and_key_id(Botan::Certificate_Store& certstore) {
   Test::Result result("System Certificate Store - Find Certificates by subject DN and key ID");

   try {
      auto dn = get_dn();

      result.start_timer();
      auto certs = certstore.find_all_certs(dn, get_key_id());
      result.end_timer();

      if(result.confirm("result not empty", !certs.empty()) &&
         result.test_eq("exactly one certificate", certs.size(), 1)) {
         auto cns = certs.front().subject_dn().get_attribute("CN");
         result.test_is_eq("exactly one CN", cns.size(), size_t(1));
         result.test_eq("CN", cns.front(), get_subject_cn());
      }
   } catch(std::exception& e) {
      result.test_failure(e.what());
   }

   return result;
}

Test::Result find_all_certs_by_subject_dn(Botan::Certificate_Store& certstore) {
   Test::Result result("System Certificate Store - Find all Certificates by subject DN");

   try {
      auto dn = get_dn();

      result.start_timer();
      auto certs = certstore.find_all_certs(dn, std::vector<uint8_t>());
      result.end_timer();

      // check for duplications
      sort(certs.begin(), certs.end());
      for(size_t i = 1; i < certs.size(); ++i) {
         if(certs[i - 1] == certs[i]) {
            result.test_failure("find_all_certs produced duplicated result");
         }
      }

      if(result.confirm("result not empty", !certs.empty())) {
         auto cns = certs.front().subject_dn().get_attribute("CN");
         result.test_gte("at least one CN", cns.size(), size_t(1));
         result.test_eq("CN", cns.front(), get_subject_cn());
      }
   } catch(std::exception& e) {
      result.test_failure(e.what());
   }

   return result;
}

Test::Result find_all_subjects(Botan::Certificate_Store& certstore) {
   Test::Result result("System Certificate Store - Find all Certificate Subjects");

   try {
      result.start_timer();
      auto subjects = certstore.all_subjects();
      result.end_timer();

      if(result.confirm("result not empty", !subjects.empty())) {
         auto dn = get_dn();
         auto needle = std::find_if(
            subjects.cbegin(), subjects.cend(), [=](const Botan::X509_DN& subject) { return subject == dn; });

         if(result.confirm("found expected certificate", needle != subjects.end())) {
            result.confirm("expected certificate", *needle == dn);
         }
      }
   } catch(std::exception& e) {
      result.test_failure(e.what());
   }

   return result;
}

Test::Result find_cert_by_issuer_dn_and_serial_number(Botan::Certificate_Store& certstore) {
   Test::Result result("System Certificate Store - Find Certificate by issuer DN and serial number");

   try {
      result.start_timer();
      auto cert = certstore.find_cert_by_issuer_dn_and_serial_number(get_dn(), get_serial_number());
      result.end_timer();

      if(result.test_not_nullopt("found certificate", cert)) {
         auto cns = cert->subject_dn().get_attribute("CN");
         result.test_is_eq("exactly one CN", cns.size(), size_t(1));
         result.test_eq("CN", cns.front(), get_subject_cn());
         result.test_eq("serial number", cert->serial_number(), get_serial_number());
      }
   } catch(std::exception& e) {
      result.test_failure(e.what());
   }

   return result;
}

Test::Result no_certificate_matches(Botan::Certificate_Store& certstore) {
   Test::Result result("System Certificate Store - can deal with no matches (regression test)");

   try {
      auto dn = get_unknown_dn();
      auto kid = get_unknown_key_id();

      result.start_timer();
      auto certs = certstore.find_all_certs(dn, kid);
      auto cert = certstore.find_cert(dn, kid);
      auto pubk_cert = certstore.find_cert_by_pubkey_sha1(kid);
      result.end_timer();

      result.confirm("find_all_certs did not find the dummy", certs.empty());
      result.confirm("find_cert did not find the dummy", !cert);
      result.confirm("find_cert_by_pubkey_sha1 did not find the dummy", !pubk_cert);
   } catch(std::exception& e) {
      result.test_failure(e.what());
   }

   return result;
}

   #if defined(BOTAN_HAS_CERTSTOR_MACOS)

Test::Result certificate_matching_with_dn_normalization(Botan::Certificate_Store& certstore) {
   Test::Result result("System Certificate Store - normalization of X.509 DN (regression test)");

   try {
      auto dn = get_skewed_dn();

      result.start_timer();
      auto certs = certstore.find_all_certs(dn, std::vector<uint8_t>());
      auto cert = certstore.find_cert(dn, std::vector<uint8_t>());
      result.end_timer();

      if(result.confirm("find_all_certs did find the skewed DN", !certs.empty()) &&
         result.confirm("find_cert did find the skewed DN", cert.has_value())) {
         result.test_eq(
            "it is the correct cert", certs.front().subject_dn().get_first_attribute("CN"), get_subject_cn());
         result.test_eq("it is the correct cert", cert->subject_dn().get_first_attribute("CN"), get_subject_cn());
      }
   } catch(std::exception& e) {
      result.test_failure(e.what());
   }

   return result;
}

   #endif

class Certstor_System_Tests final : public Test {
   public:
      std::vector<Test::Result> run() override {
         Test::Result open_result("System Certificate Store - Open Keychain");

         std::unique_ptr<Botan::Certificate_Store> system;

         try {
            open_result.start_timer();
            system = std::make_unique<Botan::System_Certificate_Store>();
            open_result.end_timer();
         } catch(Botan::Not_Implemented& e) {
            BOTAN_UNUSED(e);
            open_result.test_note("Skipping due to not available in current build");
            return {open_result};
         } catch(std::exception& e) {
            open_result.test_failure(e.what());
            return {open_result};
         }

         open_result.test_success();

         std::vector<Test::Result> results;
         results.push_back(open_result);

         results.push_back(find_certificate_by_pubkey_sha1(*system));
         results.push_back(find_certificate_by_pubkey_sha1_with_unmatching_key_id(*system));
         results.push_back(find_cert_by_subject_dn(*system));
         results.push_back(find_cert_by_subject_dn_and_key_id(*system));
         results.push_back(find_all_certs_by_subject_dn(*system));
         results.push_back(find_certs_by_subject_dn_and_key_id(*system));
         results.push_back(find_all_subjects(*system));
         results.push_back(no_certificate_matches(*system));
         results.push_back(find_cert_by_utf8_subject_dn(*system));
         results.push_back(find_cert_by_issuer_dn_and_serial_number(*system));
   #if defined(BOTAN_HAS_CERTSTOR_MACOS)
         results.push_back(certificate_matching_with_dn_normalization(*system));
   #endif

         return results;
      }
};

BOTAN_REGISTER_TEST("x509", "certstor_system", Certstor_System_Tests);

}  // namespace

}  // namespace Botan_Tests

#endif

1	/*
2	* (C) 1999-2021 Jack Lloyd
3	* (C) 2019,2021 René Meusel
4	*
5	* Botan is released under the Simplified BSD License (see license.txt)
6	*/
7
8	#include "tests.h"
9
10	#if defined(BOTAN_HAS_CERTSTOR_SYSTEM)
11
12	#include "test_certstor_utils.h"
13	#include <botan/certstor_system.h>
14	#include <algorithm>
15	#include <memory>
16
17	namespace Botan_Tests {
18
19	namespace {
20
21	Test::Result find_certificate_by_pubkey_sha1(Botan::Certificate_Store& certstore) {	1✔
22	Test::Result result("System Certificate Store - Find Certificate by SHA1(pubkey)");	1✔
23
24	try {	1✔
25	result.start_timer();	1✔
26	auto cert = certstore.find_cert_by_pubkey_sha1(get_key_id());	1✔
27	result.end_timer();	1✔
28
29	if(result.test_not_nullopt("found certificate", cert)) {	1✔
30	auto cns = cert->subject_dn().get_attribute("CN");	1✔
31	result.test_is_eq("exactly one CN", cns.size(), size_t(1));	1✔
32	result.test_eq("CN", cns.front(), get_subject_cn());	2✔
33	}	1✔
34	} catch(std::exception& e) {	1✔
35	result.test_failure(e.what());	×
36	}	×
37
38	result.test_throws("on invalid SHA1 hash data", [&] { certstore.find_cert_by_pubkey_sha1({}); });	3✔
39
40	return result;	1✔
41	}	×
42
43	Test::Result find_certificate_by_pubkey_sha1_with_unmatching_key_id(Botan::Certificate_Store& certstore) {	1✔
44	Test::Result result("System Certificate Store - Find Certificate by SHA1(pubkey) - regression test for GH #2779");	1✔
45
46	if(!certstore.find_cert(get_dn_of_cert_with_different_key_id(), {}).has_value()) {	2✔
47	result.note_missing("OS does not trust the certificate used for this regression test, skipping");	×
48	return result;	×
49	}
50
51	try {	1✔
52	result.start_timer();	1✔
53	auto cert = certstore.find_cert_by_pubkey_sha1(get_pubkey_sha1_of_cert_with_different_key_id());	1✔
54	result.end_timer();	1✔
55
56	if(result.test_not_nullopt("found certificate", cert)) {	1✔
57	auto cns = cert->subject_dn().get_attribute("CN");	1✔
58	result.test_is_eq("exactly one CN", cns.size(), size_t(1));	1✔
59	result.test_eq("CN", cns.front(), "SecureTrust CA");	2✔
60	}	1✔
61	} catch(std::exception& e) {	1✔
62	result.test_failure(e.what());	×
63	}	×
64
65	return result;
66	}	×
67
68	Test::Result find_cert_by_subject_dn(Botan::Certificate_Store& certstore) {	1✔
69	Test::Result result("System Certificate Store - Find Certificate by subject DN");	1✔
70
71	try {	1✔
72	auto dn = get_dn();	1✔
73
74	result.start_timer();	1✔
75	auto cert = certstore.find_cert(dn, std::vector<uint8_t>());	1✔
76	result.end_timer();	1✔
77
78	if(result.test_not_nullopt("found certificate", cert)) {	1✔
79	auto cns = cert->subject_dn().get_attribute("CN");	1✔
80	result.test_is_eq("exactly one CN", cns.size(), size_t(1));	1✔
81	result.test_eq("CN", cns.front(), get_subject_cn());	2✔
82	}	1✔
83	} catch(std::exception& e) {	1✔
84	result.test_failure(e.what());	×
85	}	×
86
87	return result;	1✔
88	}	×
89
90	Test::Result find_cert_by_utf8_subject_dn(Botan::Certificate_Store& certstore) {	1✔
91	Test::Result result("System Certificate Store - Find Certificate by UTF8 subject DN");	1✔
92
93	try {	1✔
94	const auto DNs = get_utf8_dn_alternatives();	1✔
95
96	unsigned int found = 0;	1✔
97
98	result.start_timer();	1✔
99	for(const auto& [cn, dn] : DNs) {	6✔
100	if(auto cert = certstore.find_cert(dn, {})) {	10✔
101	auto cns = cert->subject_dn().get_attribute("CN");	5✔
102	result.test_is_eq("exactly one CN", cns.size(), size_t(1));	5✔
103	result.test_eq("CN", cns.front(), cn);	5✔
104
105	++found;	5✔
106	}	10✔
107	}
108	result.end_timer();	1✔
109
110	if(found == 0) {	1✔
111	std::string tried_cns;	×
112	for(const auto& [cn, dn] : DNs) {	×
113	tried_cns += cn + ", ";	×
114	}
115
116	result.test_note("Tried to find any of those CNs: " + tried_cns);	×
117	result.test_failure("Did not find any certificate via an UTF-8 encoded DN");	×
118	}	×
119
120	result.test_gte("found at least one certificate", found, 1);	1✔
121	} catch(std::exception& e) {	1✔
122	result.test_failure(e.what());	×
123	}	×
124
125	return result;	1✔
126	}	×
127
128	Test::Result find_cert_by_subject_dn_and_key_id(Botan::Certificate_Store& certstore) {	1✔
129	Test::Result result("System Certificate Store - Find Certificate by subject DN and key ID");	1✔
130
131	try {	1✔
132	auto dn = get_dn();	1✔
133
134	result.start_timer();	1✔
135	auto cert = certstore.find_cert(dn, get_key_id());	1✔
136	result.end_timer();	1✔
137
138	if(result.test_not_nullopt("found certificate", cert)) {	1✔
139	auto cns = cert->subject_dn().get_attribute("CN");	1✔
140	result.test_is_eq("exactly one CN", cns.size(), size_t(1));	1✔
141	result.test_eq("CN", cns.front(), get_subject_cn());	2✔
142	}	1✔
143	} catch(std::exception& e) {	1✔
144	result.test_failure(e.what());	×
145	}	×
146
147	return result;	1✔
148	}	×
149
150	Test::Result find_certs_by_subject_dn_and_key_id(Botan::Certificate_Store& certstore) {	1✔
151	Test::Result result("System Certificate Store - Find Certificates by subject DN and key ID");	1✔
152
153	try {	1✔
154	auto dn = get_dn();	1✔
155
156	result.start_timer();	1✔
157	auto certs = certstore.find_all_certs(dn, get_key_id());	1✔
158	result.end_timer();	1✔
159
160	if(result.confirm("result not empty", !certs.empty()) &&	2✔
161	result.test_eq("exactly one certificate", certs.size(), 1)) {	2✔
162	auto cns = certs.front().subject_dn().get_attribute("CN");	1✔
163	result.test_is_eq("exactly one CN", cns.size(), size_t(1));	1✔
164	result.test_eq("CN", cns.front(), get_subject_cn());	2✔
165	}	1✔
166	} catch(std::exception& e) {	1✔
167	result.test_failure(e.what());	×
168	}	×
169
170	return result;	1✔
171	}	×
172
173	Test::Result find_all_certs_by_subject_dn(Botan::Certificate_Store& certstore) {	1✔
174	Test::Result result("System Certificate Store - Find all Certificates by subject DN");	1✔
175
176	try {	1✔
177	auto dn = get_dn();	1✔
178
179	result.start_timer();	1✔
180	auto certs = certstore.find_all_certs(dn, std::vector<uint8_t>());	1✔
181	result.end_timer();	1✔
182
183	// check for duplications
184	sort(certs.begin(), certs.end());	1✔
185	for(size_t i = 1; i < certs.size(); ++i) {	1✔
186	if(certs[i - 1] == certs[i]) {	×
187	result.test_failure("find_all_certs produced duplicated result");	×
188	}
189	}
190
191	if(result.confirm("result not empty", !certs.empty())) {	2✔
192	auto cns = certs.front().subject_dn().get_attribute("CN");	1✔
193	result.test_gte("at least one CN", cns.size(), size_t(1));	1✔
194	result.test_eq("CN", cns.front(), get_subject_cn());	2✔
195	}	1✔
196	} catch(std::exception& e) {	1✔
197	result.test_failure(e.what());	×
198	}	×
199
200	return result;	1✔
201	}	×
202
203	Test::Result find_all_subjects(Botan::Certificate_Store& certstore) {	1✔
204	Test::Result result("System Certificate Store - Find all Certificate Subjects");	1✔
205
206	try {	1✔
207	result.start_timer();	1✔
208	auto subjects = certstore.all_subjects();	1✔
209	result.end_timer();	1✔
210
211	if(result.confirm("result not empty", !subjects.empty())) {	2✔
212	auto dn = get_dn();	1✔
213	auto needle = std::find_if(	1✔
214	subjects.cbegin(), subjects.cend(), [=](const Botan::X509_DN& subject) { return subject == dn; });	88✔
215
216	if(result.confirm("found expected certificate", needle != subjects.end())) {	2✔
217	result.confirm("expected certificate", *needle == dn);	2✔
218	}
219	}	1✔
220	} catch(std::exception& e) {	1✔
221	result.test_failure(e.what());	×
222	}	×
223
224	return result;	1✔
225	}	×
226
227	Test::Result find_cert_by_issuer_dn_and_serial_number(Botan::Certificate_Store& certstore) {	1✔
228	Test::Result result("System Certificate Store - Find Certificate by issuer DN and serial number");	1✔
229
230	try {	1✔
231	result.start_timer();	1✔
232	auto cert = certstore.find_cert_by_issuer_dn_and_serial_number(get_dn(), get_serial_number());	1✔
233	result.end_timer();	1✔
234
235	if(result.test_not_nullopt("found certificate", cert)) {	1✔
236	auto cns = cert->subject_dn().get_attribute("CN");	1✔
237	result.test_is_eq("exactly one CN", cns.size(), size_t(1));	1✔
238	result.test_eq("CN", cns.front(), get_subject_cn());	2✔
239	result.test_eq("serial number", cert->serial_number(), get_serial_number());	2✔
240	}	1✔
241	} catch(std::exception& e) {	1✔
242	result.test_failure(e.what());	×
243	}	×
244
245	return result;	1✔
246	}	×
247
248	Test::Result no_certificate_matches(Botan::Certificate_Store& certstore) {	1✔
249	Test::Result result("System Certificate Store - can deal with no matches (regression test)");	1✔
250
251	try {	1✔
252	auto dn = get_unknown_dn();	1✔
253	auto kid = get_unknown_key_id();	1✔
254
255	result.start_timer();	1✔
256	auto certs = certstore.find_all_certs(dn, kid);	1✔
257	auto cert = certstore.find_cert(dn, kid);	1✔
258	auto pubk_cert = certstore.find_cert_by_pubkey_sha1(kid);	1✔
259	result.end_timer();	1✔
260
261	result.confirm("find_all_certs did not find the dummy", certs.empty());	2✔
262	result.confirm("find_cert did not find the dummy", !cert);	2✔
263	result.confirm("find_cert_by_pubkey_sha1 did not find the dummy", !pubk_cert);	2✔
264	} catch(std::exception& e) {	2✔
265	result.test_failure(e.what());	×
266	}	×
267
268	return result;	1✔
269	}	×
270
271	#if defined(BOTAN_HAS_CERTSTOR_MACOS)
272
273	Test::Result certificate_matching_with_dn_normalization(Botan::Certificate_Store& certstore) {
274	Test::Result result("System Certificate Store - normalization of X.509 DN (regression test)");
275
276	try {
277	auto dn = get_skewed_dn();
278
279	result.start_timer();
280	auto certs = certstore.find_all_certs(dn, std::vector<uint8_t>());
281	auto cert = certstore.find_cert(dn, std::vector<uint8_t>());
282	result.end_timer();
283
284	if(result.confirm("find_all_certs did find the skewed DN", !certs.empty()) &&
285	result.confirm("find_cert did find the skewed DN", cert.has_value())) {
286	result.test_eq(
287	"it is the correct cert", certs.front().subject_dn().get_first_attribute("CN"), get_subject_cn());
288	result.test_eq("it is the correct cert", cert->subject_dn().get_first_attribute("CN"), get_subject_cn());
289	}
290	} catch(std::exception& e) {
291	result.test_failure(e.what());
292	}
293
294	return result;
295	}
296
297	#endif
298
299	class Certstor_System_Tests final : public Test {	×
300	public:
301	std::vector<Test::Result> run() override {	1✔
302	Test::Result open_result("System Certificate Store - Open Keychain");	1✔
303
304	std::unique_ptr<Botan::Certificate_Store> system;	1✔
305
306	try {	1✔
307	open_result.start_timer();	1✔
308	system = std::make_unique<Botan::System_Certificate_Store>();	1✔
309	open_result.end_timer();	1✔
310	} catch(Botan::Not_Implemented& e) {	×
311	BOTAN_UNUSED(e);	×
312	open_result.test_note("Skipping due to not available in current build");	×
313	return {open_result};	×
314	} catch(std::exception& e) {	×
315	open_result.test_failure(e.what());	×
316	return {open_result};	×
317	}	×
318
319	open_result.test_success();	1✔
320
321	std::vector<Test::Result> results;	1✔
322	results.push_back(open_result);	1✔
323
324	results.push_back(find_certificate_by_pubkey_sha1(*system));	2✔
325	results.push_back(find_certificate_by_pubkey_sha1_with_unmatching_key_id(*system));	2✔
326	results.push_back(find_cert_by_subject_dn(*system));	2✔
327	results.push_back(find_cert_by_subject_dn_and_key_id(*system));	2✔
328	results.push_back(find_all_certs_by_subject_dn(*system));	2✔
329	results.push_back(find_certs_by_subject_dn_and_key_id(*system));	2✔
330	results.push_back(find_all_subjects(*system));	2✔
331	results.push_back(no_certificate_matches(*system));	2✔
332	results.push_back(find_cert_by_utf8_subject_dn(*system));	2✔
333	results.push_back(find_cert_by_issuer_dn_and_serial_number(*system));	2✔
334	#if defined(BOTAN_HAS_CERTSTOR_MACOS)
335	results.push_back(certificate_matching_with_dn_normalization(*system));
336	#endif
337
338	return results;	1✔
339	}	2✔
340	};
341
342	BOTAN_REGISTER_TEST("x509", "certstor_system", Certstor_System_Tests);
343
344	} // namespace
345
346	} // namespace Botan_Tests
347
348	#endif

randombit / botan / 19012754211

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