clang-tidy fixes

Author: fgerlits

extensions/azure/storage/AzureDataLakeStorageClient.cpp

@@ -89,7 +89,7 @@ std::unique_ptr<io::InputStream> AzureDataLakeStorageClient::fetchFile(const Fet
   if (params.range_start || params.range_length) {
     Azure::Core::Http::HttpRange range;
     if (params.range_start) {
-      range.Offset = *params.range_start;
+      range.Offset = gsl::narrow<int64_t>(*params.range_start);
     }
 
     if (params.range_length) {

extensions/libarchive/WriteArchiveStream.cpp

@@ -30,7 +30,7 @@ WriteArchiveStreamImpl::archive_ptr WriteArchiveStreamImpl::createWriteArchive()
     return nullptr;
   }
 
-  int result;
+  int result = 0;
 
   result = archive_write_set_format_ustar(arch.get());
   if (result != ARCHIVE_OK) {
@@ -94,7 +94,7 @@ bool WriteArchiveStreamImpl::newEntry(const EntryInfo& info) {
     return false;
   }
   archive_entry_set_pathname(arch_entry_.get(), info.filename.c_str());
-  archive_entry_set_size(arch_entry_.get(), info.size);
+  archive_entry_set_size(arch_entry_.get(), gsl::narrow<la_int64_t>(info.size));
   archive_entry_set_mode(arch_entry_.get(), S_IFREG | 0755);
 
   int result = archive_write_header(arch_.get(), arch_entry_.get());

extensions/librdkafka/ConsumeKafka.cpp

@@ -281,7 +281,7 @@ std::string ConsumeKafka::resolve_duplicate_headers(const std::vector<std::strin
 std::vector<std::string> ConsumeKafka::get_matching_headers(const rd_kafka_message_t& message, const std::string& header_name) const {
   // Headers fetched this way are freed when rd_kafka_message_destroy is called
   // Detaching them using rd_kafka_message_detach_headers does not seem to work
-  rd_kafka_headers_t* headers_raw;
+  rd_kafka_headers_t* headers_raw = nullptr;
   const rd_kafka_resp_err_t get_header_response = rd_kafka_message_headers(&message, &headers_raw);
   if (RD_KAFKA_RESP_ERR__NOENT == get_header_response) {
     return {};
@@ -291,8 +291,8 @@ std::vector<std::string> ConsumeKafka::get_matching_headers(const rd_kafka_messa
   }
   std::vector<std::string> matching_headers;
   for (std::size_t header_idx = 0;; ++header_idx) {
-    const char* value;  // Not to be freed
-    std::size_t size;
+    const char* value = nullptr;  // Not to be freed
+    std::size_t size = 0;
     if (RD_KAFKA_RESP_ERR_NO_ERROR != rd_kafka_header_get(headers_raw, header_idx, header_name.c_str(), (const void**)(&value), &size)) {
       break;
     }

libminifi/src/utils/BaseHTTPClient.cpp

@@ -41,7 +41,7 @@ std::optional<std::string> parseProtocol(const std::string& url_input) {
 
 std::optional<int> parsePortNumber(const std::string& port_string) {
   try {
-    size_t pos;
+    size_t pos = 0;
     int port = std::stoi(port_string, &pos);
     if (pos == port_string.size()) {
       return port;
@@ -94,7 +94,7 @@ URL::URL(const std::string& url_input) {
   std::string::const_iterator current_pos = url_input.begin();
   std::advance(current_pos, protocol_.size());
 
-  constexpr const char HOST_TERMINATORS[] = ":/?#";
+  static constexpr std::string_view HOST_TERMINATORS = ":/?#";
   std::string::const_iterator end_of_host = std::find_first_of(current_pos, url_input.end(), std::begin(HOST_TERMINATORS), std::end(HOST_TERMINATORS));
   host_ = std::string{current_pos, end_of_host};
   if (host_.empty()) {
@@ -104,7 +104,7 @@ URL::URL(const std::string& url_input) {
   current_pos = end_of_host;
 
   if (current_pos != url_input.end() && *current_pos == ':') {
-    constexpr const char PORT_TERMINATORS[] = "/?#";
+    static constexpr std::string_view PORT_TERMINATORS = "/?#";
     ++current_pos;
     std::string::const_iterator end_of_port = std::find_first_of(current_pos, url_input.end(), std::begin(PORT_TERMINATORS), std::end(PORT_TERMINATORS));
     const auto port_number = parsePortNumber(std::string{current_pos, end_of_port});

libminifi/src/utils/Cron.cpp

@@ -142,7 +142,7 @@ weekday parse<weekday>(const std::string& weekday_str) {
     if (!stream.fail() && parsed_weekday.ok() && stream.peek() == EOF)
       return parsed_weekday;
   } else {
-    unsigned weekday_num;
+    unsigned weekday_num = 0;
     stream >> weekday_num;
     if (!stream.fail() && weekday_num < 7 && stream.peek() == EOF)
       return weekday(weekday_num-1);

libminifi/src/utils/crypto/ciphers/Aes256Ecb.cpp

@@ -67,7 +67,7 @@ void Aes256EcbCipher::encrypt(std::span<unsigned char, BLOCK_SIZE> data) const {
   }
 
   int ciphertext_len = 0;
-  int len;
+  int len = 0;
 
   if (1 != EVP_EncryptUpdate(ctx.get(), data.data(), &len, data.data(), gsl::narrow<int>(data.size()))) {
     handleOpenSSLError("Could not update cipher content");
@@ -99,7 +99,7 @@ void Aes256EcbCipher::decrypt(std::span<unsigned char, BLOCK_SIZE> data) const {
   }
 
   int plaintext_len = 0;
-  int len;
+  int len = 0;
 
   if (1 != EVP_DecryptUpdate(ctx.get(), data.data(), &len, data.data(), gsl::narrow<int>(data.size()))) {
     handleOpenSSLError("Could not update cipher content");

libminifi/test/unit/StringUtilsTests.cpp

@@ -453,18 +453,20 @@ TEST_CASE("test string::testBase64EncodeDecode", "[test base64 encode decode]")
 
 TEST_CASE("test string::testJoinPack", "[test join_pack]") {
   std::string stdstr = "std::string";
+  std::string_view strview = "std::string_view";
   const char* cstr = "c string";
-  const char carr[] = "char array";
-  REQUIRE(string::join_pack("rvalue c string, ", cstr, std::string{", rval std::string, "}, stdstr, ", ", carr)
-      == "rvalue c string, c string, rval std::string, std::string, char array");
+  const char carr[] = "char array";  // NOLINT(cppcoreguidelines-avoid-c-arrays): testing const char[] on purpose
+  REQUIRE(string::join_pack("rvalue c string, ", cstr, std::string{", rval std::string, "}, stdstr, ", ", strview, ", ", carr)
+      == "rvalue c string, c string, rval std::string, std::string, std::stringview, char array");
 }
 
 TEST_CASE("test string::testJoinPackWstring", "[test join_pack wstring]") {
   std::wstring stdstr = L"std::string";
+  std::wstring_view strview = L"std::stringview";
   const wchar_t* cstr = L"c string";
-  const wchar_t carr[] = L"char array";
-  REQUIRE(string::join_pack(L"rvalue c string, ", cstr, std::wstring{L", rval std::string, "}, stdstr, L", ", carr)
-      == L"rvalue c string, c string, rval std::string, std::string, char array");
+  const wchar_t carr[] = L"char array";  // NOLINT(cppcoreguidelines-avoid-c-arrays): testing const wchar_t[] on purpose
+  REQUIRE(string::join_pack(L"rvalue c string, ", cstr, std::wstring{L", rval std::string, "}, stdstr, L", ", strview, L", ", carr)
+      == L"rvalue c string, c string, rval std::string, std::string, std::stringview, char array");
 }
 
 /* doesn't and shouldn't compile
@@ -529,7 +531,7 @@ TEST_CASE("string::removeFramingCharacters works correctly", "[removeFramingChar
 
 // ignore terminating \0 character
 template<size_t N>
-std::span<const std::byte> from_cstring(const char (& str)[N]) {
+std::span<const std::byte> from_cstring(const char (& str)[N]) {  // NOLINT(cppcoreguidelines-avoid-c-arrays)
   return as_bytes(std::span<const char>(str, N - 1));
 }
 
@@ -558,7 +560,7 @@ TEST_CASE("string::toLower and toUpper tests") {
 }
 
 TEST_CASE("string::splitToValueAndUnit tests") {
-  int64_t value;
+  int64_t value = 0;
   std::string unit_str;
   SECTION("Simple case") {
     CHECK(string::splitToValueAndUnit("1 horse", value, unit_str));