style: clang-tidy auto fixes (#2783)

github-actions[bot] · web-flow · commit 1ef7ec346477 · 2025-11-14T10:52:44.000Z
diff --git a/src/data/LedgerCache.cpp b/src/data/LedgerCache.cpp
@@ -265,8 +265,8 @@ LedgerCache::saveToFile(std::string const& path) const
     }
 
     impl::LedgerCacheFile file{path};
-    std::unique_lock lock{mtx_};
-    impl::LedgerCacheFile::DataView data{.latestSeq = latestSeq_, .map = map_, .deleted = deleted_};
+    std::unique_lock const lock{mtx_};
+    impl::LedgerCacheFile::DataView const data{.latestSeq = latestSeq_, .map = map_, .deleted = deleted_};
     return file.write(data);
 }
 
@@ -279,7 +279,7 @@ LedgerCache::loadFromFile(std::string const& path, uint32_t minLatestSequence)
         return std::unexpected(std::move(data).error());
     }
     auto [latestSeq, map, deleted] = std::move(data).value();
-    std::unique_lock lock{mtx_};
+    std::unique_lock const lock{mtx_};
     latestSeq_ = latestSeq;
     map_ = std::move(map);
     deleted_ = std::move(deleted);
diff --git a/tests/unit/data/impl/InputFileTests.cpp b/tests/unit/data/impl/InputFileTests.cpp
@@ -22,7 +22,6 @@
 #include "util/TmpFile.hpp"
 
 #include <gtest/gtest.h>
-#include <xrpl/basics/base_uint.h>
 
 #include <cstdint>
 #include <string>
@@ -35,7 +34,7 @@ struct InputFileTest : ::testing::Test {};
 TEST_F(InputFileTest, ConstructorWithValidFile)
 {
     auto const tmpFile = TmpFile{"Hello, World!"};
-    InputFile inputFile(tmpFile.path);
+    InputFile const inputFile(tmpFile.path);
 
     EXPECT_TRUE(inputFile.isOpen());
 }
@@ -66,7 +65,7 @@ TEST_F(InputFileTest, ReadRawFromFile)
 
 TEST_F(InputFileTest, ReadRawFromFilePartial)
 {
-    std::string content = "Hello, World!";
+    std::string const content = "Hello, World!";
     auto tmpFile = TmpFile{content};
     InputFile inputFile(tmpFile.path);
 
@@ -87,7 +86,7 @@ TEST_F(InputFileTest, ReadRawFromFilePartial)
 
 TEST_F(InputFileTest, ReadRawAfterEnd)
 {
-    std::string content = "Test";
+    std::string const content = "Test";
     auto tmpFile = TmpFile{content};
     InputFile inputFile(tmpFile.path);
 
@@ -119,7 +118,7 @@ TEST_F(InputFileTest, ReadTemplateMethod)
     ASSERT_TRUE(inputFile.isOpen());
 
     std::uint32_t value{0};
-    bool success = inputFile.read(value);
+    bool const success = inputFile.read(value);
 
     EXPECT_TRUE(success);
     // Note: The actual value depends on endianness
@@ -151,7 +150,7 @@ TEST_F(InputFileTest, ReadFromEmptyFile)
 TEST_F(InputFileTest, HashOfEmptyFile)
 {
     auto tmpFile = TmpFile::empty();
-    InputFile inputFile(tmpFile.path);
+    InputFile const inputFile(tmpFile.path);
 
     ASSERT_TRUE(inputFile.isOpen());
     EXPECT_EQ(inputFile.hash(), util::sha256sum(""));
diff --git a/tests/unit/data/impl/LedgerCacheFileTests.cpp b/tests/unit/data/impl/LedgerCacheFileTests.cpp
@@ -212,28 +212,28 @@ struct LedgerCacheFileTestBase : ::testing::Test {
             case CorruptionType::CorruptedSeparator1:
                 file.seekp(offsets.separator1Offset);
                 {
-                    char corruptByte = static_cast<char>(0xFF);
+                    char const corruptByte = static_cast<char>(0xFF);
                     file.write(&corruptByte, 1);
                 }
                 break;
             case CorruptionType::CorruptedSeparator2:
                 file.seekp(offsets.separator2Offset);
                 {
-                    char corruptByte = static_cast<char>(0xFF);
+                    char const corruptByte = static_cast<char>(0xFF);
                     file.write(&corruptByte, 1);
                 }
                 break;
             case CorruptionType::CorruptedSeparator3:
                 file.seekp(offsets.separator3Offset);
                 {
-                    char corruptByte = static_cast<char>(0xFF);
+                    char const corruptByte = static_cast<char>(0xFF);
                     file.write(&corruptByte, 1);
                 }
                 break;
             case CorruptionType::MapKeyCorrupted:
                 if (!offsets.mapEntries.empty()) {
                     file.seekp(offsets.mapEntries[0].keyOffset);
-                    char corruptByte = static_cast<char>(0xFF);
+                    char const corruptByte = static_cast<char>(0xFF);
                     file.write(&corruptByte, 1);
                 }
                 break;
@@ -254,14 +254,14 @@ struct LedgerCacheFileTestBase : ::testing::Test {
             case CorruptionType::MapBlobDataCorrupted:
                 if (!offsets.mapEntries.empty() && !dataView.map.begin()->second.blob.empty()) {
                     file.seekp(offsets.mapEntries[0].blobDataOffset);
-                    char corruptByte = static_cast<char>(0xFF);
+                    char const corruptByte = static_cast<char>(0xFF);
                     file.write(&corruptByte, 1);
                 }
                 break;
             case CorruptionType::DeletedKeyCorrupted:
                 if (!offsets.deletedEntries.empty()) {
                     file.seekp(offsets.deletedEntries[0].keyOffset);
-                    char corruptByte = static_cast<char>(0xFF);
+                    char const corruptByte = static_cast<char>(0xFF);
                     file.write(&corruptByte, 1);
                 }
                 break;
@@ -282,7 +282,7 @@ struct LedgerCacheFileTestBase : ::testing::Test {
             case CorruptionType::DeletedBlobDataCorrupted:
                 if (!offsets.deletedEntries.empty() && !dataView.deleted.begin()->second.blob.empty()) {
                     file.seekp(offsets.deletedEntries[0].blobDataOffset);
-                    char corruptByte = static_cast<char>(0xFF);
+                    char const corruptByte = static_cast<char>(0xFF);
                     file.write(&corruptByte, 1);
                 }
                 break;
diff --git a/tests/unit/data/impl/OutputFileTests.cpp b/tests/unit/data/impl/OutputFileTests.cpp
@@ -22,7 +22,6 @@
 #include "util/TmpFile.hpp"
 
 #include <gtest/gtest.h>
-#include <xrpl/basics/base_uint.h>
 
 #include <cstddef>
 #include <cstdint>
@@ -48,14 +47,14 @@ struct OutputFileTest : ::testing::Test {
 
 TEST_F(OutputFileTest, ConstructorOpensFile)
 {
-    OutputFile file(tmpFile.path);
+    OutputFile const file(tmpFile.path);
     EXPECT_TRUE(file.isOpen());
 }
 
 TEST_F(OutputFileTest, NonExistingFile)
 {
     std::string const invalidPath = "/invalid/nonexistent/directory/file.dat";
-    OutputFile file(invalidPath);
+    OutputFile const file(invalidPath);
     EXPECT_FALSE(file.isOpen());
 }
 
@@ -107,7 +106,7 @@ TEST_F(OutputFileTest, WriteRawData)
         file.writeRaw(testData.data(), testData.size());
     }
 
-    std::string contents = readFileContents();
+    std::string const contents = readFileContents();
     EXPECT_EQ(contents, testData);
 }
 
@@ -125,13 +124,13 @@ TEST_F(OutputFileTest, WriteMultipleChunks)
         file.writeRaw(chunk3.data(), chunk3.size());
     }
 
-    std::string contents = readFileContents();
+    std::string const contents = readFileContents();
     EXPECT_EQ(contents, chunk1 + chunk2 + chunk3);
 }
 
 TEST_F(OutputFileTest, HashOfEmptyFile)
 {
-    OutputFile file(tmpFile.path);
+    OutputFile const file(tmpFile.path);
     ASSERT_TRUE(file.isOpen());
 
     // Hash of empty file should match SHA256 of empty string

Original file line number	Diff line number	Diff line change
`@@ -265,8 +265,8 @@ LedgerCache::saveToFile(std::string const& path) const`
`265`	`265`	`}`
`266`	`266`
`267`	`267`	`impl::LedgerCacheFile file{path};`
`268`		`- std::unique_lock lock{mtx_};`
`269`		`- impl::LedgerCacheFile::DataView data{.latestSeq = latestSeq_, .map = map_, .deleted = deleted_};`
	`268`	`+ std::unique_lock const lock{mtx_};`
	`269`	`+ impl::LedgerCacheFile::DataView const data{.latestSeq = latestSeq_, .map = map_, .deleted = deleted_};`
`270`	`270`	`return file.write(data);`
`271`	`271`	`}`
`272`	`272`
`@@ -279,7 +279,7 @@ LedgerCache::loadFromFile(std::string const& path, uint32_t minLatestSequence)`
`279`	`279`	`return std::unexpected(std::move(data).error());`
`280`	`280`	`}`
`281`	`281`	`auto [latestSeq, map, deleted] = std::move(data).value();`
`282`		`- std::unique_lock lock{mtx_};`
	`282`	`+ std::unique_lock const lock{mtx_};`
`283`	`283`	`latestSeq_ = latestSeq;`
`284`	`284`	`map_ = std::move(map);`
`285`	`285`	`deleted_ = std::move(deleted);`
Original file line number	Diff line number	Diff line change
`@@ -22,7 +22,6 @@`
`22`	`22`	`#include "util/TmpFile.hpp"`
`23`	`23`
`24`	`24`	`#include <gtest/gtest.h>`
`25`		`-#include <xrpl/basics/base_uint.h>`
`26`	`25`
`27`	`26`	`#include <cstddef>`
`28`	`27`	`#include <cstdint>`
`@@ -48,14 +47,14 @@ struct OutputFileTest : ::testing::Test {`
`48`	`47`
`49`	`48`	`TEST_F(OutputFileTest, ConstructorOpensFile)`
`50`	`49`	`{`
`51`		`- OutputFile file(tmpFile.path);`
	`50`	`+ OutputFile const file(tmpFile.path);`
`52`	`51`	`EXPECT_TRUE(file.isOpen());`
`53`	`52`	`}`
`54`	`53`
`55`	`54`	`TEST_F(OutputFileTest, NonExistingFile)`
`56`	`55`	`{`
`57`	`56`	`std::string const invalidPath = "/invalid/nonexistent/directory/file.dat";`
`58`		`- OutputFile file(invalidPath);`
	`57`	`+ OutputFile const file(invalidPath);`
`59`	`58`	`EXPECT_FALSE(file.isOpen());`
`60`	`59`	`}`
`61`	`60`
`@@ -107,7 +106,7 @@ TEST_F(OutputFileTest, WriteRawData)`
`107`	`106`	`file.writeRaw(testData.data(), testData.size());`
`108`	`107`	`}`
`109`	`108`
`110`		`- std::string contents = readFileContents();`
	`109`	`+ std::string const contents = readFileContents();`
`111`	`110`	`EXPECT_EQ(contents, testData);`
`112`	`111`	`}`
`113`	`112`
`@@ -125,13 +124,13 @@ TEST_F(OutputFileTest, WriteMultipleChunks)`
`125`	`124`	`file.writeRaw(chunk3.data(), chunk3.size());`
`126`	`125`	`}`
`127`	`126`
`128`		`- std::string contents = readFileContents();`
	`127`	`+ std::string const contents = readFileContents();`
`129`	`128`	`EXPECT_EQ(contents, chunk1 + chunk2 + chunk3);`
`130`	`129`	`}`
`131`	`130`
`132`	`131`	`TEST_F(OutputFileTest, HashOfEmptyFile)`
`133`	`132`	`{`
`134`		`- OutputFile file(tmpFile.path);`
	`133`	`+ OutputFile const file(tmpFile.path);`
`135`	`134`	`ASSERT_TRUE(file.isOpen());`
`136`	`135`
`137`	`136`	`// Hash of empty file should match SHA256 of empty string`