Merge pull request #4967 from KaganCanSit/cppCheck-static-analysis-tests

Fix/reduce CppCheck warnings in 'tests' folder

Author: randombit

src/tests/runner/test_reporter.h

@@ -154,7 +154,7 @@ class Reporter {
        *
        * Note that this merges test results with the same name
        */
-      void record(const std::string& test_name, const std::vector<Botan_Tests::Test::Result>& results);
+      void record(const std::string& testsuite_name, const std::vector<Botan_Tests::Test::Result>& results);
 
       /**
        * Called once all test results have been reported for a single run.

src/tests/runner/test_runner.cpp

@@ -31,22 +31,22 @@ Test_Runner::Test_Runner(std::ostream& out) : m_output(out) {}
 
 Test_Runner::~Test_Runner() = default;
 
-bool Test_Runner::run(const Test_Options& opts) {
-   if(!opts.no_stdout()) {
-      m_reporters.emplace_back(std::make_unique<StdoutReporter>(opts, output()));
+bool Test_Runner::run(const Test_Options& options) {
+   if(!options.no_stdout()) {
+      m_reporters.emplace_back(std::make_unique<StdoutReporter>(options, output()));
    }
-   if(!opts.xml_results_dir().empty()) {
+   if(!options.xml_results_dir().empty()) {
 #if defined(BOTAN_TARGET_OS_HAS_FILESYSTEM)
-      m_reporters.emplace_back(std::make_unique<XmlReporter>(opts, opts.xml_results_dir()));
+      m_reporters.emplace_back(std::make_unique<XmlReporter>(options, options.xml_results_dir()));
 #else
       output() << "Generating test report files is not supported on this platform\n";
 #endif
    }
 
-   auto req = Botan_Tests::Test::filter_registered_tests(opts.requested_tests(), opts.skip_tests());
+   auto req = Botan_Tests::Test::filter_registered_tests(options.requested_tests(), options.skip_tests());
 
    // TODO: Test runner should not be aware of certain test's environmental requirements.
-   if(opts.pkcs11_lib().empty()) {
+   if(options.pkcs11_lib().empty()) {
       // do not run pkcs11 tests by default unless pkcs11-lib set
       for(auto iter = req.begin(); iter != req.end();) {
          if((*iter).find("pkcs11") != std::string::npos) {
@@ -61,7 +61,7 @@ bool Test_Runner::run(const Test_Options& opts) {
       throw Test_Error("No tests to run");
    }
 
-   std::vector<uint8_t> seed = Botan::hex_decode(opts.drbg_seed());
+   std::vector<uint8_t> seed = Botan::hex_decode(options.drbg_seed());
    if(seed.empty()) {
       const uint64_t ts = Botan_Tests::Test::timestamp();
       seed.resize(8);
@@ -76,28 +76,28 @@ bool Test_Runner::run(const Test_Options& opts) {
       }
 #endif
 
-      if(!opts.pkcs11_lib().empty()) {
-         reporter->set_property("pkcs11 library", opts.pkcs11_lib());
+      if(!options.pkcs11_lib().empty()) {
+         reporter->set_property("pkcs11 library", options.pkcs11_lib());
       }
 
-      if(!opts.provider().empty()) {
-         reporter->set_property("provider", opts.provider());
+      if(!options.provider().empty()) {
+         reporter->set_property("provider", options.provider());
       }
 
       reporter->set_property("drbg_seed", Botan::hex_encode(seed));
    }
 
-   Botan_Tests::Test::set_test_options(opts);
+   Botan_Tests::Test::set_test_options(options);
 
-   for(size_t i = 0; i != opts.test_runs(); ++i) {
+   for(size_t i = 0; i != options.test_runs(); ++i) {
       Botan_Tests::Test::set_test_rng_seed(seed, i);
 
       for(const auto& reporter : m_reporters) {
          reporter->next_test_run();
       }
 
       const bool passed =
-         (opts.test_threads() == 1) ? run_tests(req) : run_tests_multithreaded(req, opts.test_threads());
+         (options.test_threads() == 1) ? run_tests(req) : run_tests_multithreaded(req, options.test_threads());
 
       for(const auto& reporter : m_reporters) {
          reporter->render();

src/tests/test_ecdsa.cpp

@@ -331,15 +331,13 @@ class ECDSA_ExplicitCurveKey_Test : public Text_Based_Test {
             const auto* ecdsa = dynamic_cast<const Botan::ECDSA_PrivateKey*>(key.get());
             if(ecdsa != nullptr) {
                result.test_success("Returned key was ECDSA");
+
+               const auto& group = ecdsa->domain();
+               result.test_eq("Key is marked as explicit encoding", group.used_explicit_encoding(), true);
+               result.confirm("Group has expected OID", group.get_curve_oid() == expected_oid);
             } else {
                result.test_failure("Returned key was some other type");
             }
-
-            const auto& group = ecdsa->domain();
-            result.test_eq("Key is marked as explicit encoding", group.used_explicit_encoding(), true);
-
-            result.confirm("Group has expected OID", group.get_curve_oid() == expected_oid);
-
          } catch(Botan::Exception& e) {
             result.test_failure("Failed to parse key", e.what());
          }

src/tests/test_pubkey.cpp

@@ -337,9 +337,9 @@ std::vector<Test::Result> PK_Sign_Verify_DER_Test::run() {
    return {result};
 }
 
-std::vector<std::string> PK_Sign_Verify_DER_Test::possible_providers(const std::string& algo) {
+std::vector<std::string> PK_Sign_Verify_DER_Test::possible_providers(const std::string& algo_name) {
    std::vector<std::string> pk_provider =
-      Botan::probe_provider_private_key(algo, {"base", "commoncrypto", "openssl", "tpm"});
+      Botan::probe_provider_private_key(algo_name, {"base", "commoncrypto", "openssl", "tpm"});
    return Test::provider_filter(pk_provider);
 }
 
@@ -379,6 +379,7 @@ Test::Result PK_Encryption_Decryption_Test::run_one_test(const std::string& pad_
 
       result.test_eq(dec_provider, "decryption of KAT", decrypted, plaintext);
       check_invalid_ciphertexts(result, *decryptor, plaintext, ciphertext, this->rng());
+      decryptors.push_back(std::move(decryptor));
    }
 
    for(const auto& enc_provider : possible_providers(algo_name())) {
@@ -555,9 +556,9 @@ Test::Result PK_Key_Agreement_Test::run_one_test(const std::string& header, cons
    return result;
 }
 
-std::vector<std::string> PK_Key_Generation_Test::possible_providers(const std::string& algo) {
+std::vector<std::string> PK_Key_Generation_Test::possible_providers(const std::string& algo_name) {
    std::vector<std::string> pk_provider =
-      Botan::probe_provider_private_key(algo, {"base", "commoncrypto", "openssl", "tpm"});
+      Botan::probe_provider_private_key(algo_name, {"base", "commoncrypto", "openssl", "tpm"});
    return Test::provider_filter(pk_provider);
 }
 
@@ -607,20 +608,20 @@ std::vector<Test::Result> PK_Key_Generation_Test::run() {
    std::vector<Test::Result> results;
 
    for(const auto& param : keygen_params()) {
-      const auto algo = algo_name(param);
-      const std::string report_name = Botan::fmt("{}{}", algo, (param.empty() ? param : " " + param));
+      const auto algorithm_name = algo_name(param);
+      const std::string report_name = Botan::fmt("{}{}", algorithm_name, (param.empty() ? param : " " + param));
 
       Test::Result result(report_name + " keygen");
 
-      const std::vector<std::string> providers = possible_providers(algo);
+      const std::vector<std::string> providers = possible_providers(algorithm_name);
 
       if(providers.empty()) {
-         result.note_missing("provider key generation " + algo);
+         result.note_missing("provider key generation " + algorithm_name);
       }
 
       result.start_timer();
       for(auto&& prov : providers) {
-         auto key_p = Botan::create_private_key(algo, this->rng(), param, prov);
+         auto key_p = Botan::create_private_key(algorithm_name, this->rng(), param, prov);
 
          if(key_p == nullptr) {
             continue;

src/tests/test_pubkey.h

@@ -28,7 +28,7 @@ class PK_Test : public Text_Based_Test {
       std::string algo_name() const { return m_algo; }
 
    protected:
-      std::vector<std::string> possible_providers(const std::string& params) override;
+      std::vector<std::string> possible_providers(const std::string& algo_name) override;
 
       virtual std::string default_padding(const VarMap&) const {
          throw Test_Error("No default padding scheme set for " + algo_name());
@@ -73,7 +73,7 @@ class PK_Signature_Verification_Test : public PK_Test {
       virtual std::unique_ptr<Botan::Public_Key> load_public_key(const VarMap& vars) = 0;
 
    private:
-      Test::Result run_one_test(const std::string& header, const VarMap& vars) final;
+      Test::Result run_one_test(const std::string& pad_hdr, const VarMap& vars) final;
 };
 
 class PK_Signature_NonVerification_Test : public PK_Test {
@@ -89,7 +89,7 @@ class PK_Signature_NonVerification_Test : public PK_Test {
       virtual std::unique_ptr<Botan::Public_Key> load_public_key(const VarMap& vars) = 0;
 
    private:
-      Test::Result run_one_test(const std::string& header, const VarMap& vars) final;
+      Test::Result run_one_test(const std::string& pad_hdr, const VarMap& vars) final;
 };
 
 class PK_Sign_Verify_DER_Test : public Test {
@@ -105,7 +105,7 @@ class PK_Sign_Verify_DER_Test : public Test {
 
       virtual bool test_random_invalid_sigs() const { return true; }
 
-      std::vector<std::string> possible_providers(const std::string& params) override;
+      std::vector<std::string> possible_providers(const std::string& algo_name) override;
 
    private:
       std::string m_algo;
@@ -129,7 +129,7 @@ class PK_Encryption_Decryption_Test : public PK_Test {
       }
 
    private:
-      Test::Result run_one_test(const std::string& header, const VarMap& vars) final;
+      Test::Result run_one_test(const std::string& pad_hdr, const VarMap& vars) final;
 };
 
 class PK_Decryption_Test : public PK_Test {
@@ -145,7 +145,7 @@ class PK_Decryption_Test : public PK_Test {
       std::string default_padding(const VarMap&) const override { return "Raw"; }
 
    private:
-      Test::Result run_one_test(const std::string& header, const VarMap& vars) final;
+      Test::Result run_one_test(const std::string& pad_hdr, const VarMap& vars) final;
 };
 
 class PK_Key_Agreement_Test : public PK_Test {
@@ -207,7 +207,7 @@ class PK_Key_Generation_Test : public Test {
                                                                      std::string_view provider,
                                                                      std::span<const uint8_t> raw_key_bits) const = 0;
 
-      std::vector<std::string> possible_providers(const std::string& params) override;
+      std::vector<std::string> possible_providers(const std::string& algo_name) override;
 };
 
 class PK_Key_Generation_Stability_Test : public PK_Test {

src/tests/test_rng.h

@@ -181,9 +181,7 @@ class Request_Counting_RNG final : public Botan::RandomNumberGenerator {
          The HMAC_DRBG and ChaCha reseed KATs assume this RNG type
          outputs all 0x80
          */
-         for(auto& out : output) {
-            out = 0x80;
-         }
+         std::ranges::fill(output, 0x80);
          if(!output.empty()) {
             m_randomize_count++;
          }
@@ -217,7 +215,7 @@ class CTR_DRBG_AES256 final : public Botan::RandomNumberGenerator {
 
       void update(std::span<const uint8_t> provided_data);
 
-      uint64_t m_V0, m_V1;
+      uint64_t m_V0 = 0, m_V1 = 0;
       std::unique_ptr<Botan::BlockCipher> m_cipher;
 };
 

src/tests/test_rngs.cpp

@@ -54,8 +54,8 @@ void CTR_DRBG_AES256::fill_bytes_with_input(std::span<uint8_t> output, std::span
    }
 }
 
-CTR_DRBG_AES256::CTR_DRBG_AES256(std::span<const uint8_t> seed) {
-   m_cipher = Botan::BlockCipher::create_or_throw("AES-256");
+CTR_DRBG_AES256::CTR_DRBG_AES256(std::span<const uint8_t> seed) :
+      m_cipher(Botan::BlockCipher::create_or_throw("AES-256")) {
    add_entropy(seed);
 }
 

src/tests/test_tls_rfc8448.cpp

@@ -359,7 +359,7 @@ class Test_TLS_13_Callbacks : public Botan::TLS::Callbacks {
    private:
       std::vector<uint8_t> send_buffer;
       std::vector<uint8_t> receive_buffer;
-      uint64_t received_seq_no;
+      uint64_t received_seq_no = 0;
       Modify_Exts_Fn m_modify_exts;
       std::vector<MockSignature> m_mock_signatures;
       std::chrono::system_clock::time_point m_timestamp;

src/tests/test_tls_stream_integration.cpp

@@ -179,7 +179,7 @@ class Peer {
       net::system_timer m_timeout_timer;
       std::function<void(const std::string&)> m_on_timeout;
 
-      char m_data[MAX_MSG_LENGTH];
+      char m_data[MAX_MSG_LENGTH]{};
 };
 
 class Result_Wrapper {

src/tests/tests.cpp

@@ -412,13 +412,13 @@ std::vector<std::string> Test::possible_providers(const std::string& /*unused*/)
 }
 
 //static
-std::string Test::format_time(uint64_t ns) {
+std::string Test::format_time(uint64_t nanoseconds) {
    std::ostringstream o;
 
-   if(ns > 1000000000) {
-      o << std::setprecision(2) << std::fixed << ns / 1000000000.0 << " sec";
+   if(nanoseconds > 1000000000) {
+      o << std::setprecision(2) << std::fixed << nanoseconds / 1000000000.0 << " sec";
    } else {
-      o << std::setprecision(2) << std::fixed << ns / 1000000.0 << " msec";
+      o << std::setprecision(2) << std::fixed << nanoseconds / 1000000.0 << " msec";
    }
 
    return o.str();
@@ -830,11 +830,11 @@ std::string Test::data_file_as_temporary_copy(const std::string& what) {
 }
 
 //static
-std::vector<std::string> Test::provider_filter(const std::vector<std::string>& in) {
+std::vector<std::string> Test::provider_filter(const std::vector<std::string>& providers) {
    if(m_opts.provider().empty()) {
-      return in;
+      return providers;
    }
-   for(auto&& provider : in) {
+   for(auto&& provider : providers) {
       if(provider == m_opts.provider()) {
          return std::vector<std::string>{provider};
       }