Merge pull request #119 from joto/clang-tidy-fixes

joto · web-flow · commit a216428b0ab1 · 2024-12-20T17:47:28.000+01:00
Clang tidy fixes
diff --git a/include/protozero/basic_pbf_builder.hpp b/include/protozero/basic_pbf_builder.hpp
@@ -67,7 +67,7 @@ class basic_pbf_builder : public basic_pbf_writer<TBuffer> {
      * @param tag Tag of the field that will be written
      */
     template <typename P>
-    basic_pbf_builder(basic_pbf_writer<TBuffer>& parent_writer, P tag) noexcept :
+    basic_pbf_builder(basic_pbf_writer<TBuffer>& parent_writer, P tag) :
         basic_pbf_writer<TBuffer>{parent_writer, pbf_tag_type(tag)} {
     }
 
diff --git a/test/include/packed_access.hpp b/test/include/packed_access.hpp
@@ -153,7 +153,7 @@ TEST_CASE("write repeated packed field using packed field: " PBF_TYPE_NAME) {
 
     SECTION("empty - should do rollback") {
         {
-            packed_field_type field{pw, 1};
+            const packed_field_type field{pw, 1};
         }
 
         REQUIRE(buffer == load_data("repeated_packed_" PBF_TYPE_NAME "/data-empty"));
@@ -264,7 +264,7 @@ TEST_CASE("write from different types of iterators: " PBF_TYPE_NAME) {
     }
 
     SECTION("from string") {
-        std::string data{"1 4 9 16 25"};
+        const std::string data{"1 4 9 16 25"};
         std::stringstream sdata{data};
 
 #if PBF_TYPE_IS_SIGNED
@@ -273,8 +273,8 @@ TEST_CASE("write from different types of iterators: " PBF_TYPE_NAME) {
         using test_type = uint32_t;
 #endif
 
-        std::istream_iterator<test_type> eod;
-        std::istream_iterator<test_type> it(sdata);
+        const std::istream_iterator<test_type> eod;
+        const std::istream_iterator<test_type> it(sdata);
 
         pw.ADD_TYPE(1, it, eod);
     }
diff --git a/test/include/test.hpp b/test/include/test.hpp
@@ -13,7 +13,7 @@ struct assert_error : public std::runtime_error {
     explicit assert_error(const char* what_arg) : std::runtime_error(what_arg) {
     }
 };
-#define protozero_assert(x) if (!(x)) { throw assert_error{#x}; }
+#define protozero_assert(x) if (!(x)) { throw assert_error{#x}; } // NOLINT(readability-simplify-boolean-expr)
 
 #include <protozero/pbf_builder.hpp>
 #include <protozero/pbf_message.hpp>
diff --git a/test/t/bytes/reader_test_cases.cpp b/test/t/bytes/reader_test_cases.cpp
@@ -91,32 +91,32 @@ TEST_CASE("write bytes field using vectored approach") {
     protozero::pbf_writer pw{buffer};
 
     SECTION("using two strings") {
-        std::string d1{"foo"};
-        std::string d2{"bar"};
+        const std::string d1{"foo"};
+        const std::string d2{"bar"};
 
         pw.add_bytes_vectored(1, d1, d2);
     }
 
     SECTION("using a string and a dataview") {
-        std::string d1{"foo"};
-        std::string d2{"bar"};
-        protozero::data_view dv{d2};
+        const std::string d1{"foo"};
+        const std::string d2{"bar"};
+        const protozero::data_view dv{d2};
 
         pw.add_bytes_vectored(1, d1, dv);
     }
 
     SECTION("using three strings") {
-        std::string d1{"foo"};
-        std::string d2{"ba"};
-        std::string d3{"r"};
+        const std::string d1{"foo"};
+        const std::string d2{"ba"};
+        const std::string d3{"r"};
 
         pw.add_bytes_vectored(1, d1, d2, d3);
     }
 
     SECTION("with empty string") {
-        std::string d1{"foo"};
-        std::string d2{};
-        std::string d3{"bar"};
+        const std::string d1{"foo"};
+        const std::string d2{};
+        const std::string d3{"bar"};
 
         pw.add_bytes_vectored(1, d1, d2, d3);
     }
diff --git a/test/t/message/reader_test_cases.cpp b/test/t/message/reader_test_cases.cpp
@@ -67,7 +67,7 @@ TEST_CASE("write message field") {
     }
 
     SECTION("string with subwriter with reserved size") {
-        std::string str{"foobar"};
+        const std::string str{"foobar"};
         const auto size = 1 /* tag */ + 1 /* length field */ + str.size();
         protozero::pbf_writer pbf_submessage{pbf_test, 1, size};
         pbf_submessage.add_string(1, "foobar");
diff --git a/test/t/nested/reader_test_cases.cpp b/test/t/nested/reader_test_cases.cpp
@@ -80,14 +80,14 @@ inline void check_empty(protozero::pbf_reader message) {
 TEST_CASE("read nested message fields: string") {
     const std::string buffer = load_data("nested/data-message");
 
-    protozero::pbf_reader message{buffer};
+    const protozero::pbf_reader message{buffer};
     check(message);
 }
 
 TEST_CASE("read nested message fields: no submessage") {
     const std::string buffer = load_data("nested/data-no-message");
 
-    protozero::pbf_reader message{buffer};
+    const protozero::pbf_reader message{buffer};
     check_empty(message);
 }
 
@@ -121,7 +121,7 @@ TEST_CASE("write nested message fields") {
 
     pbf_test.add_int32(2, 77);
 
-    protozero::pbf_reader message{buffer_test};
+    const protozero::pbf_reader message{buffer_test};
     check(message);
 }
 
@@ -133,25 +133,25 @@ TEST_CASE("write nested message fields - no message") {
     }
 
     SECTION("empty string") {
-        std::string buffer_sub;
+        const std::string buffer_sub;
 
         pbf_test.add_message(1, buffer_sub);
     }
 
     SECTION("string with pbf_writer") {
         std::string buffer_sub;
-        protozero::pbf_writer pbf_sub{buffer_sub};
+        const protozero::pbf_writer pbf_sub{buffer_sub};
 
         pbf_test.add_message(1, buffer_sub);
     }
 
     SECTION("string with subwriter") {
-        protozero::pbf_writer pbf_sub{pbf_test, 1};
+        const protozero::pbf_writer pbf_sub{pbf_test, 1};
     }
 
     pbf_test.add_int32(2, 77);
 
-    protozero::pbf_reader message{buffer_test};
+    const protozero::pbf_reader message{buffer_test};
     check_empty(message);
 }
 
diff --git a/test/t/repeated_packed_bool/reader_test_cases.cpp b/test/t/repeated_packed_bool/reader_test_cases.cpp
@@ -90,7 +90,7 @@ TEST_CASE("write repeated packed bool field using packed_field_bool") {
 
     SECTION("empty - should do rollback") {
         {
-            protozero::packed_field_bool field{pw, 1};
+            const protozero::packed_field_bool field{pw, 1};
         }
 
         REQUIRE(buffer == load_data("repeated_packed_bool/data-empty"));
@@ -128,7 +128,7 @@ TEST_CASE("write repeated packed bool field using packed_field_bool with pbf_bui
 
     SECTION("empty - should do rollback") {
         {
-            protozero::packed_field_bool field{pw, msg::f};
+            const protozero::packed_field_bool field{pw, msg::f};
         }
 
         REQUIRE(buffer == load_data("repeated_packed_bool/data-empty"));
diff --git a/test/t/repeated_packed_fixed32/writer_test_cases.cpp b/test/t/repeated_packed_fixed32/writer_test_cases.cpp
@@ -58,11 +58,11 @@ TEMPLATE_TEST_CASE("write from different types of iterators and check with libpr
     }
 
     SECTION("from string") {
-        std::string data = "1 4 9 16 25";
+        const std::string data = "1 4 9 16 25";
         std::stringstream sdata(data);
 
-        std::istream_iterator<uint32_t> eod;
-        std::istream_iterator<uint32_t> it(sdata);
+        const std::istream_iterator<uint32_t> eod;
+        const std::istream_iterator<uint32_t> it(sdata);
 
         pw.template add_packed_fixed<uint32_t>(1, it, eod);
     }
diff --git a/test/t/rollback/reader_test_cases.cpp b/test/t/rollback/reader_test_cases.cpp
@@ -10,7 +10,7 @@ TEST_CASE("rollback when using packed_field functions") {
 
     SECTION("empty - should do rollback") {
         {
-            protozero::packed_field_sint64 field{pw, 1};
+            const protozero::packed_field_sint64 field{pw, 1};
         }
 
         pw.add_int32(4, 123);
@@ -197,7 +197,7 @@ TEST_CASE("rollback on message is not allowed if there is a nested submessage")
     {
         protozero::pbf_writer pws{pw, 1};
         pws.add_string(1, "foobar");
-        protozero::pbf_writer pws2{pws, 1};
+        const protozero::pbf_writer pws2{pws, 1};
         REQUIRE_THROWS_AS(pws.rollback(), assert_error);
     }
 }
diff --git a/test/t/vector_tile/reader_test_cases.cpp b/test/t/vector_tile/reader_test_cases.cpp
@@ -78,7 +78,7 @@ TEST_CASE("reading vector tiles") {
         int n_geomtype = 0;
         while (item.next(3)) { // repeated message Layer
             protozero::pbf_reader layer{item.get_message()};
-            std::string name = get_name(layer);
+            const std::string name = get_name(layer);
             if (name == "road") {
                 while (layer.next(2)) { // repeated Feature
                     ++n;
@@ -118,7 +118,7 @@ TEST_CASE("reading vector tiles") {
         int n_geomtype = 0;
         while (item.next(3)) { // repeated message Layer
             protozero::pbf_reader layer{item.get_message()};
-            std::string name = get_name(layer);
+            const std::string name = get_name(layer);
             if (name == "road") {
                 while (layer.next(2)) { // repeated Feature
                     ++n;
diff --git a/test/unit/test_exceptions.cpp b/test/unit/test_exceptions.cpp
@@ -2,32 +2,32 @@
 #include <test.hpp>
 
 TEST_CASE("exceptions messages for pbf exception") {
-    protozero::exception e;
+    const protozero::exception e;
     REQUIRE(std::string{e.what()} == std::string{"pbf exception"});
 }
 
 TEST_CASE("exceptions messages for varint too long") {
-    protozero::varint_too_long_exception e;
+    const protozero::varint_too_long_exception e;
     REQUIRE(std::string{e.what()} == std::string{"varint too long exception"});
 }
 
 TEST_CASE("exceptions messages for unknown pbf field type") {
-    protozero::unknown_pbf_wire_type_exception e;
+    const protozero::unknown_pbf_wire_type_exception e;
     REQUIRE(std::string{e.what()} == std::string{"unknown pbf field type exception"});
 }
 
 TEST_CASE("exceptions messages for end of buffer") {
-    protozero::end_of_buffer_exception e;
+    const protozero::end_of_buffer_exception e;
     REQUIRE(std::string{e.what()} == std::string{"end of buffer exception"});
 }
 
 TEST_CASE("exceptions messages for invalid tag") {
-    protozero::invalid_tag_exception e;
+    const protozero::invalid_tag_exception e;
     REQUIRE(std::string{e.what()} == std::string{"invalid tag exception"});
 }
 
 TEST_CASE("exceptions messages for invalid length") {
-    protozero::invalid_length_exception e;
+    const protozero::invalid_length_exception e;
     REQUIRE(std::string{e.what()} == std::string{"invalid length exception"});
 }
 
diff --git a/test/unit/test_iterators.cpp b/test/unit/test_iterators.cpp
@@ -2,10 +2,10 @@
 #include <test.hpp>
 
 TEST_CASE("default constructed varint_iterators are equal") {
-    protozero::const_varint_iterator<uint32_t> a{};
-    protozero::const_varint_iterator<uint32_t> b{};
+    const protozero::const_varint_iterator<uint32_t> a{};
+    const protozero::const_varint_iterator<uint32_t> b{};
 
-    protozero::iterator_range<protozero::const_varint_iterator<uint32_t>> r{};
+    const protozero::iterator_range<protozero::const_varint_iterator<uint32_t>> r{};
 
     REQUIRE(a == a);
     REQUIRE(a == b);
diff --git a/tools/pbf-decoder.cpp b/tools/pbf-decoder.cpp
@@ -67,7 +67,7 @@ bool decode_printable_string(std::stringstream& out, const protozero::data_view
 bool decode_string(std::stringstream& out, const protozero::data_view view) {
     static constexpr const std::size_t max_string_length = 60;
 
-    std::string str{view.data(), std::min(view.size(), max_string_length)};
+    const std::string str{view.data(), std::min(view.size(), max_string_length)};
     out << '"';
 
     for (const auto c : str) {
@@ -193,7 +193,7 @@ void print_help() {
 }
 
 std::string read_from_file(const char* filename) {
-    std::ifstream file{filename, std::ios::binary};
+    const std::ifstream file{filename, std::ios::binary};
     return std::string{std::istreambuf_iterator<char>(file.rdbuf()),
                        std::istreambuf_iterator<char>()};
 }

Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ class basic_pbf_builder : public basic_pbf_writer<TBuffer> {`
`67`	`67`	`* @param tag Tag of the field that will be written`
`68`	`68`	`*/`
`69`	`69`	`template <typename P>`
`70`		`- basic_pbf_builder(basic_pbf_writer<TBuffer>& parent_writer, P tag) noexcept :`
	`70`	`+ basic_pbf_builder(basic_pbf_writer<TBuffer>& parent_writer, P tag) :`
`71`	`71`	`basic_pbf_writer<TBuffer>{parent_writer, pbf_tag_type(tag)} {`
`72`	`72`	`}`
`73`	`73`
Original file line number	Diff line number	Diff line change
`@@ -153,7 +153,7 @@ TEST_CASE("write repeated packed field using packed field: " PBF_TYPE_NAME) {`
`153`	`153`
`154`	`154`	`SECTION("empty - should do rollback") {`
`155`	`155`	`{`
`156`		`- packed_field_type field{pw, 1};`
	`156`	`+ const packed_field_type field{pw, 1};`
`157`	`157`	`}`
`158`	`158`
`159`	`159`	`REQUIRE(buffer == load_data("repeated_packed_" PBF_TYPE_NAME "/data-empty"));`
`@@ -264,7 +264,7 @@ TEST_CASE("write from different types of iterators: " PBF_TYPE_NAME) {`
`264`	`264`	`}`
`265`	`265`
`266`	`266`	`SECTION("from string") {`
`267`		`- std::string data{"1 4 9 16 25"};`
	`267`	`+ const std::string data{"1 4 9 16 25"};`
`268`	`268`	`std::stringstream sdata{data};`
`269`	`269`
`270`	`270`	`#if PBF_TYPE_IS_SIGNED`
`@@ -273,8 +273,8 @@ TEST_CASE("write from different types of iterators: " PBF_TYPE_NAME) {`
`273`	`273`	`using test_type = uint32_t;`
`274`	`274`	`#endif`
`275`	`275`
`276`		`- std::istream_iterator<test_type> eod;`
`277`		`- std::istream_iterator<test_type> it(sdata);`
	`276`	`+ const std::istream_iterator<test_type> eod;`
	`277`	`+ const std::istream_iterator<test_type> it(sdata);`
`278`	`278`
`279`	`279`	`pw.ADD_TYPE(1, it, eod);`
`280`	`280`	`}`
Original file line number	Diff line number	Diff line change
`@@ -13,7 +13,7 @@ struct assert_error : public std::runtime_error {`
`13`	`13`	`explicit assert_error(const char* what_arg) : std::runtime_error(what_arg) {`
`14`	`14`	`}`
`15`	`15`	`};`
`16`		`-#define protozero_assert(x) if (!(x)) { throw assert_error{#x}; }`
	`16`	`+#define protozero_assert(x) if (!(x)) { throw assert_error{#x}; } // NOLINT(readability-simplify-boolean-expr)`
`17`	`17`
`18`	`18`	`#include <protozero/pbf_builder.hpp>`
`19`	`19`	`#include <protozero/pbf_message.hpp>`
Original file line number	Diff line number	Diff line change
`@@ -67,7 +67,7 @@ TEST_CASE("write message field") {`
`67`	`67`	`}`
`68`	`68`
`69`	`69`	`SECTION("string with subwriter with reserved size") {`
`70`		`- std::string str{"foobar"};`
	`70`	`+ const std::string str{"foobar"};`
`71`	`71`	`const auto size = 1 /* tag / + 1 / length field */ + str.size();`
`72`	`72`	`protozero::pbf_writer pbf_submessage{pbf_test, 1, size};`
`73`	`73`	`pbf_submessage.add_string(1, "foobar");`
Original file line number	Diff line number	Diff line change
`@@ -80,14 +80,14 @@ inline void check_empty(protozero::pbf_reader message) {`
`80`	`80`	`TEST_CASE("read nested message fields: string") {`
`81`	`81`	`const std::string buffer = load_data("nested/data-message");`
`82`	`82`
`83`		`- protozero::pbf_reader message{buffer};`
	`83`	`+ const protozero::pbf_reader message{buffer};`
`84`	`84`	`check(message);`
`85`	`85`	`}`
`86`	`86`
`87`	`87`	`TEST_CASE("read nested message fields: no submessage") {`
`88`	`88`	`const std::string buffer = load_data("nested/data-no-message");`
`89`	`89`
`90`		`- protozero::pbf_reader message{buffer};`
	`90`	`+ const protozero::pbf_reader message{buffer};`
`91`	`91`	`check_empty(message);`
`92`	`92`	`}`
`93`	`93`
`@@ -121,7 +121,7 @@ TEST_CASE("write nested message fields") {`
`121`	`121`
`122`	`122`	`pbf_test.add_int32(2, 77);`
`123`	`123`
`124`		`- protozero::pbf_reader message{buffer_test};`
	`124`	`+ const protozero::pbf_reader message{buffer_test};`
`125`	`125`	`check(message);`
`126`	`126`	`}`
`127`	`127`
`@@ -133,25 +133,25 @@ TEST_CASE("write nested message fields - no message") {`
`133`	`133`	`}`
`134`	`134`
`135`	`135`	`SECTION("empty string") {`
`136`		`- std::string buffer_sub;`
	`136`	`+ const std::string buffer_sub;`
`137`	`137`
`138`	`138`	`pbf_test.add_message(1, buffer_sub);`
`139`	`139`	`}`
`140`	`140`
`141`	`141`	`SECTION("string with pbf_writer") {`
`142`	`142`	`std::string buffer_sub;`
`143`		`- protozero::pbf_writer pbf_sub{buffer_sub};`
	`143`	`+ const protozero::pbf_writer pbf_sub{buffer_sub};`
`144`	`144`
`145`	`145`	`pbf_test.add_message(1, buffer_sub);`
`146`	`146`	`}`
`147`	`147`
`148`	`148`	`SECTION("string with subwriter") {`
`149`		`- protozero::pbf_writer pbf_sub{pbf_test, 1};`
	`149`	`+ const protozero::pbf_writer pbf_sub{pbf_test, 1};`
`150`	`150`	`}`
`151`	`151`
`152`	`152`	`pbf_test.add_int32(2, 77);`
`153`	`153`
`154`		`- protozero::pbf_reader message{buffer_test};`
	`154`	`+ const protozero::pbf_reader message{buffer_test};`
`155`	`155`	`check_empty(message);`
`156`	`156`	`}`
`157`	`157`
Original file line number	Diff line number	Diff line change
`@@ -90,7 +90,7 @@ TEST_CASE("write repeated packed bool field using packed_field_bool") {`
`90`	`90`
`91`	`91`	`SECTION("empty - should do rollback") {`
`92`	`92`	`{`
`93`		`- protozero::packed_field_bool field{pw, 1};`
	`93`	`+ const protozero::packed_field_bool field{pw, 1};`
`94`	`94`	`}`
`95`	`95`
`96`	`96`	`REQUIRE(buffer == load_data("repeated_packed_bool/data-empty"));`
`@@ -128,7 +128,7 @@ TEST_CASE("write repeated packed bool field using packed_field_bool with pbf_bui`
`128`	`128`
`129`	`129`	`SECTION("empty - should do rollback") {`
`130`	`130`	`{`
`131`		`- protozero::packed_field_bool field{pw, msg::f};`
	`131`	`+ const protozero::packed_field_bool field{pw, msg::f};`
`132`	`132`	`}`
`133`	`133`
`134`	`134`	`REQUIRE(buffer == load_data("repeated_packed_bool/data-empty"));`
Original file line number	Diff line number	Diff line change
`@@ -58,11 +58,11 @@ TEMPLATE_TEST_CASE("write from different types of iterators and check with libpr`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`SECTION("from string") {`
`61`		`- std::string data = "1 4 9 16 25";`
	`61`	`+ const std::string data = "1 4 9 16 25";`
`62`	`62`	`std::stringstream sdata(data);`
`63`	`63`
`64`		`- std::istream_iterator<uint32_t> eod;`
`65`		`- std::istream_iterator<uint32_t> it(sdata);`
	`64`	`+ const std::istream_iterator<uint32_t> eod;`
	`65`	`+ const std::istream_iterator<uint32_t> it(sdata);`
`66`	`66`
`67`	`67`	`pw.template add_packed_fixed<uint32_t>(1, it, eod);`
`68`	`68`	`}`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ TEST_CASE("rollback when using packed_field functions") {`
`10`	`10`
`11`	`11`	`SECTION("empty - should do rollback") {`
`12`	`12`	`{`
`13`		`- protozero::packed_field_sint64 field{pw, 1};`
	`13`	`+ const protozero::packed_field_sint64 field{pw, 1};`
`14`	`14`	`}`
`15`	`15`
`16`	`16`	`pw.add_int32(4, 123);`
`@@ -197,7 +197,7 @@ TEST_CASE("rollback on message is not allowed if there is a nested submessage")`
`197`	`197`	`{`
`198`	`198`	`protozero::pbf_writer pws{pw, 1};`
`199`	`199`	`pws.add_string(1, "foobar");`
`200`		`- protozero::pbf_writer pws2{pws, 1};`
	`200`	`+ const protozero::pbf_writer pws2{pws, 1};`
`201`	`201`	`REQUIRE_THROWS_AS(pws.rollback(), assert_error);`
`202`	`202`	`}`
`203`	`203`	`}`