diff --git a/include/voltage_regulator/voltage_regulator_utility.hpp b/include/voltage_regulator/voltage_regulator_utility.hpp
index 6e9b15c..0860a80 100644
--- a/include/voltage_regulator/voltage_regulator_utility.hpp
+++ b/include/voltage_regulator/voltage_regulator_utility.hpp
@@ -42,7 +42,7 @@
 constexpr std::string_view kUnit = "Unit";
 constexpr std::string_view kPage = "Page";
 
-enum class CommandType
+enum class CommandType : uint8_t
 {
     STATUS_WORD,
     RENESAS_BLACK_BOX,
diff --git a/src/common_utility.cpp b/src/common_utility.cpp
index f7bbb94..d12847c 100644
--- a/src/common_utility.cpp
+++ b/src/common_utility.cpp
@@ -223,7 +223,7 @@
 
         ofs.close();
         ofs.open(logFilePath, std::ios::binary | std::ios::trunc);
-        ofs << now << "\n" << truncatedMsg << std::endl;
+        ofs << now << "\n" << truncatedMsg << '\n';
     }
     else
     {
@@ -239,16 +239,17 @@
             }
 
             std::ifstream ifs(logFilePath, std::ios::binary);
-            ifs.seekg(fileSize - bytesToKeep, std::ios::beg);
+            ifs.seekg(static_cast<int64_t>(fileSize - bytesToKeep),
+                      std::ios::beg);
             std::vector<char> buffer(bytesToKeep);
-            ifs.read(buffer.data(), buffer.size());
+            ifs.read(buffer.data(), static_cast<int64_t>(buffer.size()));
             ifs.close();
 
             ofs.open(logFilePath, std::ios::binary | std::ios::trunc);
-            ofs.write(buffer.data(), buffer.size());
+            ofs.write(buffer.data(), static_cast<int64_t>(buffer.size()));
         }
 
-        ofs << now << "\n" << msg << std::endl;
+        ofs << now << "\n" << msg << '\n';
     }
 
     ofs.close();
diff --git a/src/power_rail/max34451_status.cpp b/src/power_rail/max34451_status.cpp
index 93d79af..984dd49 100644
--- a/src/power_rail/max34451_status.cpp
+++ b/src/power_rail/max34451_status.cpp
@@ -14,17 +14,17 @@
 
     logFile << std::hex << std::setw(4) << std::setfill('0');
     logFile << "FAULT LOG INDEX: " << static_cast<int>(bbrArray[kFaultLogIndex])
-            << std::endl;
+            << '\n';
 
     getWordAndLog(logFile, bbrArray, 3, 2, "FAULT_LOG_COUNT: ");
     getWordAndLog(logFile, bbrArray, 5, 4, "MFR_TIME_COUNT(LSW): ");
     getWordAndLog(logFile, bbrArray, 7, 6, "MFR_TIME_COUNT(MSW): ");
     logFile << "STATUS_CML: " << static_cast<int>(bbrArray[kStatusCmlIndex])
-            << " " << parserStatusCml(bbrArray[kStatusCmlIndex]) << std::endl;
+            << " " << parserStatusCml(bbrArray[kStatusCmlIndex]) << '\n';
     logFile << parserStatusWord(
                    getWordAndLog(logFile, bbrArray, kStatusWordMsbIndex,
                                  kStatusWordLsbIndex, "STATUS_WORD: "))
-            << std::endl;
+            << '\n';
 
     constexpr uint8_t kVoutIoutStartIndex = 14;
     constexpr uint8_t kVoutIoutEndIndex = 29;
@@ -33,11 +33,9 @@
         const uint8_t page = i - kVoutIoutStartIndex;
         logFile << "Page " << static_cast<int>(page)
                 << " STATUS_VOUT/STATUS_IOUT: " << static_cast<int>(bbrArray[i])
-                << std::endl;
-        logFile << "STATUS_VOUT: " << parserStatusVout(bbrArray[i])
-                << std::endl;
-        logFile << "STATUS_IOUT: " << parserStatusIout(bbrArray[i])
-                << std::endl;
+                << '\n';
+        logFile << "STATUS_VOUT: " << parserStatusVout(bbrArray[i]) << '\n';
+        logFile << "STATUS_IOUT: " << parserStatusIout(bbrArray[i]) << '\n';
     }
 
     constexpr uint8_t kMfrSpecificStartIndex = 30;
@@ -61,7 +59,7 @@
         const uint8_t page = (i == 53) ? 0 : i - 32;
         logFile << "Page " << static_cast<int>(page)
                 << " STATUS_TEMPERATURE: " << static_cast<int>(bbrArray[i])
-                << " " << parserStatusTemperature(bbrArray[i]) << std::endl;
+                << " " << parserStatusTemperature(bbrArray[i]) << '\n';
     }
 
     getWordAndLog(logFile, bbrArray, 55, 54, "CURRENT_CHANNELS: ");
@@ -81,13 +79,13 @@
             logFile << "Page " << static_cast<int>(page) << " T "
                     << static_cast<int>(k / 2) << " READ_VOUT/READ_IOUT: 0x"
                     << std::setw(4) << std::setfill('0') << readOut << std::dec
-                    << std::endl;
+                    << '\n';
             logFile << "READ_VOUT: "
                     << transferDirectDataFormat(1, readOut, 0, 0) << " mV"
-                    << std::endl;
+                    << '\n';
             logFile << "READ_IOUT: "
                     << transferDirectDataFormat(1, readOut, 2, 0) << " A"
-                    << std::endl;
+                    << '\n';
         }
     }
 
@@ -112,7 +110,7 @@
                                      "Page " + std::to_string(page) +
                                          " MFR_VOUT_MIN: "),
                        0, 0)
-                << " mV" << std::endl;
+                << " mV" << '\n';
     }
 
     constexpr uint8_t kReadTempStartIndex = 232;
@@ -126,7 +124,7 @@
                                      "Page " + std::to_string(page) +
                                          " READ_TEMPERATURE_1: "),
                        2, 0)
-                << " C" << std::endl;
+                << " C" << '\n';
     }
 
     constexpr uint8_t kMfrTempPeakStartIndex = 242;
@@ -140,8 +138,7 @@
     }
 
     logFile << "LOG_VALID: 0x" << std::setw(2) << std::setfill('0')
-            << static_cast<int>(bbrArray[kLogValidIndex]) << std::dec
-            << std::endl;
+            << static_cast<int>(bbrArray[kLogValidIndex]) << std::dec << '\n';
     logFile << std::dec;
 }
 
@@ -248,7 +245,7 @@
     {
         logFile << "POWER_GOOD# ";
     }
-    logFile << std::endl;
+    logFile << '\n';
 }
 
 void getMax34451Status(const Max34451Logger& logger, std::ofstream& logFile)
@@ -320,7 +317,7 @@
             logRailStatus(railName.get<std::string>(), pageIndex);
         }
     }
-    logFile << getPage255Config(logger) << std::endl;
+    logFile << getPage255Config(logger) << '\n';
 }
 
 uint16_t getFaultStatus(const Max34451Logger& logger)
@@ -396,11 +393,11 @@
         lg2::info("MAX34451: Fault detected! Status word: {FAULT}", "FAULT",
                   faultStatus);
         logFile << "MAX34451: Fault detected! Status word: " << std::hex
-                << faultStatus << std::endl;
+                << faultStatus << '\n';
 
         if (logDetails)
         {
-            logFile << "[MAX34451 VR log]" << std::endl;
+            logFile << "[MAX34451 VR log]" << '\n';
             getMax34451Status(logger, logFile);
         }
 
@@ -440,7 +437,7 @@
     std::filesystem::path logDirPath;
     bool logDetails = false;
 
-    std::cout << "max34451 status" << std::endl;
+    std::cout << "max34451 status" << '\n';
 
     app.add_option("-c,--config", configFilePath, "Config file path")
         ->required()
diff --git a/src/power_rail/max34451_utility.cpp b/src/power_rail/max34451_utility.cpp
index 8e347be..6f315e1 100644
--- a/src/power_rail/max34451_utility.cpp
+++ b/src/power_rail/max34451_utility.cpp
@@ -180,7 +180,7 @@
     uint16_t word = (data[highIndex] << 8) | data[lowIndex];
 
     logFile << label << "0x" << std::hex << std::setw(4) << std::setfill('0')
-            << word << std::endl;
+            << word << '\n';
     return word;
 }
 
diff --git a/src/power_rail/pmbus_lib.cpp b/src/power_rail/pmbus_lib.cpp
index db8889b..d95a6e5 100644
--- a/src/power_rail/pmbus_lib.cpp
+++ b/src/power_rail/pmbus_lib.cpp
@@ -320,11 +320,11 @@
 
 double transferLinear11(const uint16_t word)
 {
-    int16_t y = word & 0x07FF;
-    int8_t ns = word >> 11;
+    int16_t y = static_cast<int16_t>(word & 0x07FF);
+    int8_t ns = static_cast<int8_t>(word >> 11);
     if ((ns & (1 << 4)) != 0)
     {
-        ns = 32 - ns;
+        ns = static_cast<int8_t>(32 - ns);
     }
     return ns > 0 ? y / pow(2, ns) : y * pow(2, ns);
 }
diff --git a/src/power_rail/power_rail_utility.cpp b/src/power_rail/power_rail_utility.cpp
index 57fa4b4..0bc7882 100644
--- a/src/power_rail/power_rail_utility.cpp
+++ b/src/power_rail/power_rail_utility.cpp
@@ -332,7 +332,7 @@
     std::string regValueHex = util::byteArrayToHexString(&regValue, 1);
     boost::algorithm::trim(regValueHex);
     logFile << util::getCurrentTimestamp() << " " << railInfo.name + ": "
-            << regValueHex << std::endl;
+            << regValueHex << '\n';
 
     if (railInfo.name == kCPLDRuntimeFlag)
     {
@@ -358,7 +358,7 @@
     result.hasErrorInZiggurat = false;
 
     std::string railResult = fromMax34451Mb(railInfo.page);
-    logFile << railInfo.name + ": " << railResult << std::endl;
+    logFile << railInfo.name + ": " << railResult << '\n';
 
     if (railResult == "Fault")
     {
diff --git a/src/voltage_regulator/voltage_regulator_parse_MFR_log.cpp b/src/voltage_regulator/voltage_regulator_parse_MFR_log.cpp
index 68281c0..00c603c 100644
--- a/src/voltage_regulator/voltage_regulator_parse_MFR_log.cpp
+++ b/src/voltage_regulator/voltage_regulator_parse_MFR_log.cpp
@@ -1,5 +1,7 @@
 #include "include/voltage_regulator/voltage_regulator_parse_MFR_log.hpp"
 
+#include "absl/strings/match.h"
+
 namespace vrlog
 {
 // parse MFR_NV_FAULT_LOG
@@ -201,35 +203,35 @@
             message += parseStatusByte(value, statusMFRByte);
             continue;
         }
-        else if (regName.find("ReadVin") != std::string::npos)
+        else if (absl::StrContains(regName, "ReadVin"))
         {
             int offset = (regName == "rail0ReadVin") ? 64 : 66;
             value = (intTokens[offset + 1] << 8) | intTokens[offset];
             unit = " V";
             result = std::to_string(util::convertFromDirect(value, 1, 0, 2));
         }
-        else if (regName.find("ReadVout") != std::string::npos)
+        else if (absl::StrContains(regName, "ReadVout"))
         {
             int offset = (regName == "rail0ReadVout") ? 68 : 70;
             value = (intTokens[offset + 1] << 8) | intTokens[offset];
             unit = " V";
             result = std::to_string(util::convertFromDirect(value, 1, 0, 3));
         }
-        else if (regName.find("ReadIin") != std::string::npos)
+        else if (absl::StrContains(regName, "ReadIin"))
         {
             int offset = (regName == "rail0ReadIin") ? 72 : 74;
             value = (intTokens[offset + 1] << 8) | intTokens[offset];
             unit = " A";
             result = std::to_string(util::convertFromDirect(value, 1, 0, 2));
         }
-        else if (regName.find("ReadIout") != std::string::npos)
+        else if (absl::StrContains(regName, "ReadIout"))
         {
             int offset = (regName == "rail0ReadIout") ? 76 : 78;
             value = (intTokens[offset + 1] << 8) | intTokens[offset];
             unit = " A";
             result = std::to_string(util::convertFromDirect(value, 1, 0, 1));
         }
-        else if (regName.find("Readtemp") != std::string::npos)
+        else if (absl::StrContains(regName, "Readtemp"))
         {
             int offset = (regName == "rail0Readtemp") ? 80 : 81;
             value = intTokens[offset];
@@ -403,7 +405,8 @@
         }
         else if (regName == "Vin")
         {
-            float vinValue = (intTokens[4] << 8) | intTokens[3];
+            float vinValue =
+                static_cast<float>((intTokens[4] << 8) | intTokens[3]);
             result = std::to_string(vinValue * 250 / 1000);
             message += regName;
             message += ": ";
@@ -412,7 +415,8 @@
         }
         else if (regName == "Vout")
         {
-            float voutValue = (intTokens[6] << 8) | intTokens[5];
+            float voutValue =
+                static_cast<float>((intTokens[6] << 8) | intTokens[5]);
             result = std::to_string(voutValue * 488.28125 / 1000000);
             message += regName;
             message += ": ";
@@ -421,7 +425,8 @@
         }
         else if (regName == "Iout")
         {
-            float ioutValue = (intTokens[8] << 8) | intTokens[7];
+            float ioutValue =
+                static_cast<float>((intTokens[8] << 8) | intTokens[7]);
             result = std::to_string(ioutValue * 500 / 1000);
             message += regName;
             message += ": ";
@@ -430,7 +435,8 @@
         }
         else if (regName == "Temperature")
         {
-            float tempValue = (intTokens[10] << 8) | intTokens[9];
+            float tempValue =
+                static_cast<float>((intTokens[10] << 8) | intTokens[9]);
             result = std::to_string(tempValue);
             message += regName;
             message += ": ";
@@ -439,7 +445,8 @@
         }
         else if (regName == "Duty")
         {
-            float dutyValue = (intTokens[12] << 8) | intTokens[11];
+            float dutyValue =
+                static_cast<float>((intTokens[12] << 8) | intTokens[11]);
             result = std::to_string(dutyValue);
             message += regName;
             message += ": ";
@@ -563,7 +570,7 @@
             userTime |= static_cast<uint64_t>(intTokens[6]) << 8;
             userTime |= static_cast<uint64_t>(intTokens[5]);
             double microseconds = static_cast<double>(userTime) * 232.2;
-            uint64_t seconds = microseconds / 1000000.0;
+            uint64_t seconds = static_cast<uint64_t>(microseconds / 1000000.0);
             result = std::to_string(seconds);
             messageLine += result;
             messageLine += " s";
diff --git a/src/voltage_regulator/voltage_regulator_query_MFR_log.cpp b/src/voltage_regulator/voltage_regulator_query_MFR_log.cpp
index be9ef78..3b10040 100644
--- a/src/voltage_regulator/voltage_regulator_query_MFR_log.cpp
+++ b/src/voltage_regulator/voltage_regulator_query_MFR_log.cpp
@@ -35,7 +35,7 @@
     {
         minusOne(lastEventOffset);
         ofs << "BLACK_BOX_INDEX: "
-            << (lastEventOffset[1] << 8 | lastEventOffset[0]) << std::endl;
+            << (lastEventOffset[1] << 8 | lastEventOffset[0]) << '\n';
     }
     // set MFR_BLACKBOX_OFFSET to get last event log
     std::vector<uint8_t> setBBOffset = {readBBOffset[0], lastEventOffset[0],
@@ -65,7 +65,7 @@
     {
         minusOne(lastEventIndex);
         ofs << "BLACK_BOX_INDEX: "
-            << (lastEventIndex[1] << 8 | lastEventIndex[0]) << std::endl;
+            << (lastEventIndex[1] << 8 | lastEventIndex[0]) << '\n';
     }
     // set MFR_BLACKBOX_OFFSET to get last event log
     std::vector<uint8_t> setEventIndex = {mfrEventIndex[0], lastEventIndex[0],
diff --git a/src/voltage_regulator/voltage_regulator_utility.cpp b/src/voltage_regulator/voltage_regulator_utility.cpp
index 7d44d81..b444328 100644
--- a/src/voltage_regulator/voltage_regulator_utility.cpp
+++ b/src/voltage_regulator/voltage_regulator_utility.cpp
@@ -101,10 +101,14 @@
         !pmbusJson[std::string(kCoefficients)].is_null())
     {
         const json& coefficients = pmbusJson[std::string(kCoefficients)];
-        pmbus.mElement = std::stoi(getOptionalElement(coefficients, kM, "1"));
-        pmbus.bElement = std::stoi(getOptionalElement(coefficients, kB, "0"));
-        pmbus.rElement = std::stoi(getOptionalElement(coefficients, kR, "0"));
-        pmbus.nElement = std::stoi(getOptionalElement(coefficients, kN, "0"));
+        pmbus.mElement = static_cast<int16_t>(
+            std::stoi(getOptionalElement(coefficients, kM, "1")));
+        pmbus.bElement = static_cast<int16_t>(
+            std::stoi(getOptionalElement(coefficients, kB, "0")));
+        pmbus.rElement = static_cast<int8_t>(
+            std::stoi(getOptionalElement(coefficients, kR, "0")));
+        pmbus.nElement = static_cast<int8_t>(
+            std::stoi(getOptionalElement(coefficients, kN, "0")));
     }
 
     return pmbus;
@@ -173,11 +177,11 @@
                     // transform from two’s complement to integer
                     if (rData.at(0) > 0xf)
                     {
-                        exponent = -1 * (32 - rData.at(0));
+                        exponent = static_cast<int8_t>(-1 * (32 - rData.at(0)));
                     }
                     else
                     {
-                        exponent = rData.at(0);
+                        exponent = static_cast<int8_t>(rData.at(0));
                     }
                 }
                 ofs << " " << util::convertFromVoutLinear(value, exponent)
@@ -187,7 +191,7 @@
             {
                 ofs << " " << util::convertFromLinear(value) << pmbus.unit;
             }
-            ofs << std::endl;
+            ofs << '\n';
         }
     }
     catch (const std::exception& e)
diff --git a/test/common_utility_unittest.cpp b/test/common_utility_unittest.cpp
index 67d8e11..8d2a1ff 100644
--- a/test/common_utility_unittest.cpp
+++ b/test/common_utility_unittest.cpp
@@ -4,8 +4,6 @@
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
-using namespace util;
-
 class CommonUtilityTest : public ::testing::Test
 {
   protected:
@@ -48,7 +46,7 @@
     std::ofstream(file2.string()).put('b');
     std::ofstream(file3.string()).put('c');
 
-    auto foundFiles = findFiles(tempDir, "testFile");
+    auto foundFiles = util::findFiles(tempDir, "testFile");
 
     ASSERT_EQ(foundFiles.size(), 2);
     EXPECT_THAT(foundFiles, ::testing::UnorderedElementsAre(file1, file2));
@@ -61,7 +59,7 @@
     std::ofstream(file1.string()).put('a');
     std::ofstream(file2.string()).put('b');
 
-    auto foundFiles = findFiles(tempDir, "nonexistentFile");
+    auto foundFiles = util::findFiles(tempDir, "nonexistentFile");
 
     EXPECT_TRUE(foundFiles.empty());
 }
@@ -91,7 +89,7 @@
                                     std::to_string(fileCount);
     std::string logMessage = "Test log message";
 
-    summarizeLog(getDbusUtil(), logMessage, tempDir, logFilePrefix);
+    util::summarizeLog(getDbusUtil(), logMessage, tempDir, logFilePrefix);
     std::cerr << logFileDir / logFilename << "<<LogFile\n";
 
     ASSERT_TRUE(isStringInFile(logFileDir / logFilename, "Test log message"));
@@ -99,34 +97,34 @@
 
 TEST_F(CommonUtilityTest, GetProperty_Success)
 {
-    auto [success, value] = getProperty("some.service", "/some/object",
-                                        "some.interface", "some.property");
+    auto [success, value] = util::getProperty(
+        "some.service", "/some/object", "some.interface", "some.property");
 
     EXPECT_FALSE(success);
 }
 
 TEST_F(CommonUtilityTest, I2cOpenDevice_Failure)
 {
-    int fd = i2cOpenDevice(1, 0x50);
+    int fd = util::i2cOpenDevice(1, 0x50);
     EXPECT_EQ(fd, -1);
 }
 
 TEST_F(CommonUtilityTest, I2cWriteRead_Failure)
 {
     std::vector<uint8_t> writeBuf = {0x00, 0x01};
-    auto result = i2cWriteRead(1, 0x50, writeBuf, writeBuf.size(), 2);
+    auto result = util::i2cWriteRead(1, 0x50, writeBuf, writeBuf.size(), 2);
     EXPECT_TRUE(result.empty());
 }
 
 TEST_F(CommonUtilityTest, I2cReadByte_Failure)
 {
-    uint8_t result = i2cReadByte(1, 0x50, 0x00);
+    uint8_t result = util::i2cReadByte(1, 0x50, 0x00);
     EXPECT_EQ(result, 0);
 }
 
 TEST_F(CommonUtilityTest, I2cReadBytes_Failure)
 {
-    auto result = i2cReadBytes(1, 0x50, 0x00, 2);
+    auto result = util::i2cReadBytes(1, 0x50, 0x00, 2);
     EXPECT_TRUE(result.empty());
 }
 
@@ -134,14 +132,14 @@
 {
     uint16_t value = 0x0200;
     int8_t exponent = 6;
-    double result = convertFromVoutLinear(value, exponent);
+    double result = util::convertFromVoutLinear(value, exponent);
     EXPECT_NEAR(result, 32768.0, 1e-5);
 }
 
 TEST_F(CommonUtilityTest, ConvertFromLinear)
 {
     uint16_t value = 0x0400;
-    double result = convertFromLinear(value);
+    double result = util::convertFromLinear(value);
     EXPECT_NEAR(result, 1024.0, 1e-5);
 }
 
@@ -151,28 +149,28 @@
     int16_t m = 1;
     int16_t b = 0;
     int8_t r = 0;
-    double result = convertFromDirect(value, m, b, r);
+    double result = util::convertFromDirect(value, m, b, r);
     EXPECT_NEAR(result, 2048.0, 1e-5);
 }
 
 TEST_F(CommonUtilityTest, ParseDec_Valid)
 {
     json element = "1234";
-    uint16_t result = parseDec(element);
+    uint16_t result = util::parseDec(element);
     EXPECT_EQ(result, 1234);
 }
 
 TEST_F(CommonUtilityTest, ParseDec_Invalid)
 {
     json element = "invalid";
-    uint16_t result = parseDec(element);
+    uint16_t result = util::parseDec(element);
     EXPECT_EQ(result, 0);
 }
 
 TEST_F(CommonUtilityTest, ParseHexByteArray_Valid)
 {
     json element = {"0x01", "0x02", "0x03"};
-    auto result = parseHexByteArray(element);
+    auto result = util::parseHexByteArray(element);
     EXPECT_EQ(result.size(), 3);
     EXPECT_EQ(result[0], 0x01);
     EXPECT_EQ(result[1], 0x02);
@@ -182,14 +180,14 @@
 TEST_F(CommonUtilityTest, ParseHexByte_Valid)
 {
     json element = "0x1A";
-    uint8_t result = parseHexByte(element);
+    uint8_t result = util::parseHexByte(element);
     EXPECT_EQ(result, 0x1A);
 }
 
 TEST_F(CommonUtilityTest, ParseHexByte_Invalid)
 {
     json element = "invalid";
-    uint8_t result = parseHexByte(element);
+    uint8_t result = util::parseHexByte(element);
     EXPECT_EQ(result, 0);
 }
 
@@ -197,7 +195,7 @@
 {
     std::string_view upperByte = "0x12";
     std::string_view lowerByte = "0x34";
-    uint16_t result = bytesIntoWord(upperByte, lowerByte);
+    uint16_t result = util::bytesIntoWord(upperByte, lowerByte);
     EXPECT_EQ(result, 0x1234);
 }
 
@@ -205,13 +203,14 @@
 {
     // NOLINTNEXTLINE(cppcoreguidelines-avoid-c-arrays)
     uint8_t buf[] = {0x12, 0x34, 0x56};
-    std::string result = byteArrayToHexString(static_cast<uint8_t*>(buf), 3);
+    std::string result = util::byteArrayToHexString(static_cast<uint8_t*>(buf),
+                                                    3);
     EXPECT_EQ(result, "0x12 0x34 0x56 ");
 }
 
 TEST_F(CommonUtilityTest, GetCurrentTimestamp)
 {
-    std::string result = getCurrentTimestamp();
+    std::string result = util::getCurrentTimestamp();
     EXPECT_FALSE(result.empty());
     EXPECT_EQ(result.size(),
               19); // Expected timestamp format "YYYY-MM-DD HH:MM:SS"
diff --git a/test/power_rail/max34451_utility_unittest.cpp b/test/power_rail/max34451_utility_unittest.cpp
index 75fcd20..f7e0100 100644
--- a/test/power_rail/max34451_utility_unittest.cpp
+++ b/test/power_rail/max34451_utility_unittest.cpp
@@ -2,16 +2,14 @@
 
 #include "gtest/gtest.h"
 
-using namespace max34451;
-
 TEST(Max34451Test, CheckPowerRailFault)
 {
-    EXPECT_TRUE(checkPowerRailFault(0x20, true));
-    EXPECT_FALSE(checkPowerRailFault(0x20, false));
-    EXPECT_TRUE(checkPowerRailFault(0x10, false));
-    EXPECT_TRUE(checkPowerRailFault(0x10, true));
-    EXPECT_FALSE(checkPowerRailFault(0x00, false));
-    EXPECT_FALSE(checkPowerRailFault(0x00, true));
+    EXPECT_TRUE(max34451::checkPowerRailFault(0x20, true));
+    EXPECT_FALSE(max34451::checkPowerRailFault(0x20, false));
+    EXPECT_TRUE(max34451::checkPowerRailFault(0x10, false));
+    EXPECT_TRUE(max34451::checkPowerRailFault(0x10, true));
+    EXPECT_FALSE(max34451::checkPowerRailFault(0x00, false));
+    EXPECT_FALSE(max34451::checkPowerRailFault(0x00, true));
 }
 
 TEST(Max34451Test, GetWordAndLog)
@@ -19,7 +17,8 @@
     std::vector<uint8_t> data = {0x12, 0x34};
     std::stringstream logStream;
 
-    uint16_t result = getWordAndLog(logStream, data, 0, 1, "TestLabel: ");
+    uint16_t result = max34451::getWordAndLog(logStream, data, 0, 1,
+                                              "TestLabel: ");
 
     EXPECT_EQ(result, 0x1234);
     EXPECT_EQ(logStream.str(), "TestLabel: 0x1234\n");
@@ -27,7 +26,7 @@
 
 TEST(Max34451Test, LoadConfig)
 {
-    Max34451Logger logger;
+    max34451::Max34451Logger logger;
 
     std::ofstream tempFile("test_config.json");
     tempFile << R"({
@@ -91,19 +90,19 @@
 
 TEST(Max34451Test, Max34451PowerRailParser)
 {
-    Max34451Logger logger;
+    max34451::Max34451Logger logger;
     logger.faultLogOffset = 0;
     logger.includeWarnings = true;
 
     json sequencerReg = {
-        {kPageToPowerRailMap, {{"0", "Rail1"}, {"1", "Rail2"}}}};
+        {max34451::kPageToPowerRailMap, {{"0", "Rail1"}, {"1", "Rail2"}}}};
     logger.sequencerRegisters.push_back(sequencerReg);
 
     std::vector<uint8_t> faultLog = {0x20, 0x10};
 
     std::stringstream logStream;
 
-    max34451PowerRailParser(logger, faultLog, logStream);
+    max34451::max34451PowerRailParser(logger, faultLog, logStream);
 
     std::string expectedOutput = "    \"Rail1\"\n    \"Rail2\"\n";
     EXPECT_EQ(logStream.str(), expectedOutput);
diff --git a/test/power_rail/pmbus_lib_unittest.cpp b/test/power_rail/pmbus_lib_unittest.cpp
index 171d604..512f169 100644
--- a/test/power_rail/pmbus_lib_unittest.cpp
+++ b/test/power_rail/pmbus_lib_unittest.cpp
@@ -2,105 +2,105 @@
 
 #include "gtest/gtest.h"
 
-using namespace max34451;
-
 TEST(ParserStatusTest, TestParserStatusByte)
 {
-    EXPECT_EQ(parserStatusByte(0xa0), "VOUT_OV_FAULT BUSY ");
-    EXPECT_EQ(parserStatusByte(0x01), "NONE_OF_THE_ABOVE ");
-    EXPECT_EQ(parserStatusByte(0xff), "INVALID");
+    EXPECT_EQ(max34451::parserStatusByte(0xa0), "VOUT_OV_FAULT BUSY ");
+    EXPECT_EQ(max34451::parserStatusByte(0x01), "NONE_OF_THE_ABOVE ");
+    EXPECT_EQ(max34451::parserStatusByte(0xff), "INVALID");
 }
 
 TEST(ParserStatusTest, TestParserStatusWord)
 {
-    EXPECT_EQ(parserStatusWord(0xa00f),
+    EXPECT_EQ(max34451::parserStatusWord(0xa00f),
               "NONE_OF_THE_ABOVE CML TEMPERATURE VIN_UV_FAULT INPUT VOUT ");
-    EXPECT_EQ(parserStatusWord(0x0001), "NONE_OF_THE_ABOVE ");
-    EXPECT_EQ(parserStatusWord(0xffff), "INVALID");
+    EXPECT_EQ(max34451::parserStatusWord(0x0001), "NONE_OF_THE_ABOVE ");
+    EXPECT_EQ(max34451::parserStatusWord(0xffff), "INVALID");
 }
 
 TEST(ParserStatusTest, TestParserStatusVout)
 {
-    EXPECT_EQ(parserStatusVout(0xF0),
+    EXPECT_EQ(max34451::parserStatusVout(0xF0),
               "VOUT_UV_FAULT VOUT_UV_WARNING VOUT_OV_WARNING VOUT_OV_FAULT ");
-    EXPECT_EQ(parserStatusVout(0x00), "");
-    EXPECT_EQ(parserStatusVout(0xFF), "INVALID");
+    EXPECT_EQ(max34451::parserStatusVout(0x00), "");
+    EXPECT_EQ(max34451::parserStatusVout(0xFF), "INVALID");
 }
 
 TEST(ParserStatusTest, TestParserStatusIout)
 {
-    EXPECT_EQ(parserStatusIout(0xC0), "IOUT_OC_LV_FAULT IOUT_OC_FAULT ");
-    EXPECT_EQ(parserStatusIout(0x00), "");
-    EXPECT_EQ(parserStatusIout(0xFF), "INVALID");
+    EXPECT_EQ(max34451::parserStatusIout(0xC0),
+              "IOUT_OC_LV_FAULT IOUT_OC_FAULT ");
+    EXPECT_EQ(max34451::parserStatusIout(0x00), "");
+    EXPECT_EQ(max34451::parserStatusIout(0xFF), "INVALID");
 }
 
 TEST(ParserStatusTest, TestParserStatusInput)
 {
-    EXPECT_EQ(parserStatusInput(0x80), "VIN_OV_FAULT ");
-    EXPECT_EQ(parserStatusInput(0x03), "PIN_OP_WARN IIN_OC_WARN ");
-    EXPECT_EQ(parserStatusInput(0xFF), "INVALID");
+    EXPECT_EQ(max34451::parserStatusInput(0x80), "VIN_OV_FAULT ");
+    EXPECT_EQ(max34451::parserStatusInput(0x03), "PIN_OP_WARN IIN_OC_WARN ");
+    EXPECT_EQ(max34451::parserStatusInput(0xFF), "INVALID");
 }
 
 TEST(ParserStatusTest, TestParserStatusTemperature)
 {
-    EXPECT_EQ(parserStatusTemperature(0xC0), "OT_WARN OT_FAULT ");
-    EXPECT_EQ(parserStatusTemperature(0x03), "");
-    EXPECT_EQ(parserStatusTemperature(0xFF), "INVALID");
+    EXPECT_EQ(max34451::parserStatusTemperature(0xC0), "OT_WARN OT_FAULT ");
+    EXPECT_EQ(max34451::parserStatusTemperature(0x03), "");
+    EXPECT_EQ(max34451::parserStatusTemperature(0xFF), "INVALID");
 }
 
 TEST(ParserStatusTest, TestParserStatusCml)
 {
-    EXPECT_EQ(parserStatusCml(0xE0), "PEC_FAULT DATA_FAULT CMD_FAULT ");
-    EXPECT_EQ(parserStatusCml(0x01), "OTHER_CML_FAULT ");
-    EXPECT_EQ(parserStatusCml(0xFF), "INVALID");
+    EXPECT_EQ(max34451::parserStatusCml(0xE0),
+              "PEC_FAULT DATA_FAULT CMD_FAULT ");
+    EXPECT_EQ(max34451::parserStatusCml(0x01), "OTHER_CML_FAULT ");
+    EXPECT_EQ(max34451::parserStatusCml(0xFF), "INVALID");
 }
 
 TEST(TransferTest, TestTransferLinear11)
 {
-    EXPECT_DOUBLE_EQ(transferLinear11(0x0400), 1024);
-    EXPECT_DOUBLE_EQ(transferLinear11(0x0800), 0);
-    EXPECT_DOUBLE_EQ(transferLinear11(0x8400), 0.015625);
-    EXPECT_DOUBLE_EQ(transferLinear11(0x0C00), 512);
-    EXPECT_DOUBLE_EQ(transferLinear11(0x0000), 0);
+    EXPECT_DOUBLE_EQ(max34451::transferLinear11(0x0400), 1024);
+    EXPECT_DOUBLE_EQ(max34451::transferLinear11(0x0800), 0);
+    EXPECT_DOUBLE_EQ(max34451::transferLinear11(0x8400), 0.015625);
+    EXPECT_DOUBLE_EQ(max34451::transferLinear11(0x0C00), 512);
+    EXPECT_DOUBLE_EQ(max34451::transferLinear11(0x0000), 0);
 }
 
 TEST(TransferTest, TestTransferLinear16)
 {
-    EXPECT_DOUBLE_EQ(transferLinear16(8192), 1.0);
-    EXPECT_DOUBLE_EQ(transferLinear16(16384), 2.0);
-    EXPECT_DOUBLE_EQ(transferLinear16(0), 0.0);
-    EXPECT_DOUBLE_EQ(transferLinear16(1), 1.0 / 8192.0);
+    EXPECT_DOUBLE_EQ(max34451::transferLinear16(8192), 1.0);
+    EXPECT_DOUBLE_EQ(max34451::transferLinear16(16384), 2.0);
+    EXPECT_DOUBLE_EQ(max34451::transferLinear16(0), 0.0);
+    EXPECT_DOUBLE_EQ(max34451::transferLinear16(1), 1.0 / 8192.0);
 }
 
 TEST(TransferTest, TestTransferDirectDataFormat)
 {
-    EXPECT_DOUBLE_EQ(transferDirectDataFormat(1, 100, 2, 0), 1.0);
-    EXPECT_DOUBLE_EQ(transferDirectDataFormat(2, 1000, 3, 10), -4.5);
-    EXPECT_DOUBLE_EQ(transferDirectDataFormat(-1, 500, 2, -5), -10.0);
-    EXPECT_DOUBLE_EQ(transferDirectDataFormat(2, 100, 0, 10), 45.0);
-    EXPECT_DOUBLE_EQ(transferDirectDataFormat(1, 0, 2, 0), 0.0);
+    EXPECT_DOUBLE_EQ(max34451::transferDirectDataFormat(1, 100, 2, 0), 1.0);
+    EXPECT_DOUBLE_EQ(max34451::transferDirectDataFormat(2, 1000, 3, 10), -4.5);
+    EXPECT_DOUBLE_EQ(max34451::transferDirectDataFormat(-1, 500, 2, -5), -10.0);
+    EXPECT_DOUBLE_EQ(max34451::transferDirectDataFormat(2, 100, 0, 10), 45.0);
+    EXPECT_DOUBLE_EQ(max34451::transferDirectDataFormat(1, 0, 2, 0), 0.0);
 }
 
 TEST(TransferTest, TestTransferDirectValue)
 {
-    EXPECT_DOUBLE_EQ(transferDirectValue(100, 2.0), 200.0);
-    EXPECT_DOUBLE_EQ(transferDirectValue(-50, 2.5), -125.0);
-    EXPECT_DOUBLE_EQ(transferDirectValue(0, 100.0), 0.0);
-    EXPECT_DOUBLE_EQ(transferDirectValue(100, 0.0), 0.0);
-    EXPECT_DOUBLE_EQ(transferDirectValue(1, 1.0), 1.0);
+    EXPECT_DOUBLE_EQ(max34451::transferDirectValue(100, 2.0), 200.0);
+    EXPECT_DOUBLE_EQ(max34451::transferDirectValue(-50, 2.5), -125.0);
+    EXPECT_DOUBLE_EQ(max34451::transferDirectValue(0, 100.0), 0.0);
+    EXPECT_DOUBLE_EQ(max34451::transferDirectValue(100, 0.0), 0.0);
+    EXPECT_DOUBLE_EQ(max34451::transferDirectValue(1, 1.0), 1.0);
 }
 
 TEST(TransferTest, TestTransferAscii)
 {
     std::vector<uint8_t> asciiArray = {'H', 'e', 'l', 'l', 'o'};
-    EXPECT_EQ(transferAscii(asciiArray), "Hello");
+    EXPECT_EQ(max34451::transferAscii(asciiArray), "Hello");
 
     asciiArray = {};
-    EXPECT_EQ(transferAscii(asciiArray), "");
+    EXPECT_EQ(max34451::transferAscii(asciiArray), "");
 
     asciiArray = {0xC3, 0xA9}; // é
-    EXPECT_EQ(transferAscii(asciiArray), "\xC3\xA9");
+    EXPECT_EQ(max34451::transferAscii(asciiArray), "\xC3\xA9");
 
     asciiArray = {0x20, 0x7E}; // ' ' to '~'
-    EXPECT_EQ(transferAscii(asciiArray), " ~");
+    EXPECT_EQ(max34451::transferAscii(asciiArray), " ~");
 }
diff --git a/test/power_rail/power_rail_utility_unittest.cpp b/test/power_rail/power_rail_utility_unittest.cpp
index 9d38025..4b8184c 100644
--- a/test/power_rail/power_rail_utility_unittest.cpp
+++ b/test/power_rail/power_rail_utility_unittest.cpp
@@ -3,7 +3,17 @@
 
 #include <gtest/gtest.h>
 
-using namespace powerfault;
+using powerfault::kAddress;
+using powerfault::kBit;
+using powerfault::kBus;
+using powerfault::kCPLDM;
+using powerfault::kName;
+using powerfault::kReg;
+using powerfault::kRegister;
+using powerfault::kSource;
+using powerfault::kType;
+
+using powerfault::RailInfo;
 
 // Test for processRail
 TEST(PowerRailUtilityTest, TestProcessRail_Success)
@@ -14,7 +24,7 @@
         {std::string(kAddress), "0x50"},  {std::string(kReg), "0x30"},
         {std::string(kBit), "3"}};
 
-    auto railInfo = processRail(railConfig);
+    auto railInfo = powerfault::processRail(railConfig);
     ASSERT_TRUE(railInfo.has_value());
     if (railInfo.has_value())
     {
@@ -37,7 +47,7 @@
         // Missing fields like kBus, kAddress, kReg, and kBit
     };
 
-    auto railInfo = processRail(railConfig);
+    auto railInfo = powerfault::processRail(railConfig);
     ASSERT_FALSE(railInfo.has_value());
 }
 
@@ -53,7 +63,8 @@
     std::ofstream(testPath / "ziggurat.json") << zigguratJson.dump();
     std::ofstream(testPath / "peripheral.json") << peripheralJson.dump();
 
-    auto [zigguratPriority, peripheralPriority] = readPriorityFiles(testPath);
+    auto [zigguratPriority,
+          peripheralPriority] = powerfault::readPriorityFiles(testPath);
 
     EXPECT_EQ(zigguratPriority.size(), 2);
     EXPECT_EQ(zigguratPriority[0], "Rail1");
@@ -71,7 +82,8 @@
     fs::path testPath = "/tmp/testPriorityDir";
     fs::create_directories(testPath);
 
-    auto [zigguratPriority, peripheralPriority] = readPriorityFiles(testPath);
+    auto [zigguratPriority,
+          peripheralPriority] = powerfault::readPriorityFiles(testPath);
 
     EXPECT_TRUE(zigguratPriority.empty());
     EXPECT_TRUE(peripheralPriority.empty());
@@ -92,7 +104,7 @@
     std::ofstream(testPath / "Sequencer.json") << sequencerJson.dump();
 
     auto [cpldRegisterMap,
-          sequencerRegisterMap] = readRegisterMapFiles(testPath);
+          sequencerRegisterMap] = powerfault::readRegisterMapFiles(testPath);
 
     EXPECT_EQ(cpldRegisterMap, cpldJson);
     EXPECT_EQ(sequencerRegisterMap, sequencerJson);
@@ -106,7 +118,7 @@
     fs::create_directories(testPath);
 
     auto [cpldRegisterMap,
-          sequencerRegisterMap] = readRegisterMapFiles(testPath);
+          sequencerRegisterMap] = powerfault::readRegisterMapFiles(testPath);
 
     EXPECT_TRUE(cpldRegisterMap.empty());
     EXPECT_TRUE(sequencerRegisterMap.empty());
@@ -117,38 +129,41 @@
 // Test for collectPowerRails
 TEST(PowerRailUtilityTest, TestCollectPowerRails_CPLD)
 {
-    json registerMap = {{{std::string(kSource), "CPLD-M"},
-                         {std::string(kBus), "1"},
-                         {std::string(kAddress), "0x50"},
-                         {std::string(kCPLDRegisters),
-                          {{{std::string(kRegister), "0x30"},
-                            {std::string(kBitToPowerRailMap), {{"3", "Rail1"}}},
-                            {std::string(kReverseFlag), {"3"}}}}}}};
+    json registerMap = {
+        {{std::string(kSource), "CPLD-M"},
+         {std::string(kBus), "1"},
+         {std::string(kAddress), "0x50"},
+         {std::string(powerfault::kCPLDRegisters),
+          {{{std::string(kRegister), "0x30"},
+            {std::string(powerfault::kBitToPowerRailMap), {{"3", "Rail1"}}},
+            {std::string(powerfault::kReverseFlag), {"3"}}}}}}};
 
-    auto railMap = collectPowerRails(registerMap, kCPLD);
+    auto railMap = powerfault::collectPowerRails(registerMap,
+                                                 powerfault::kCPLD);
 
     EXPECT_EQ(railMap.size(), 1);
     EXPECT_EQ(railMap["Rail1"][std::string(kName)], "Rail1");
     EXPECT_EQ(railMap["Rail1"][std::string(kReg)], "0x30");
     EXPECT_EQ(railMap["Rail1"][std::string(kBit)], "3");
-    EXPECT_EQ(railMap["Rail1"][std::string(kReverseFlag)], "1");
+    EXPECT_EQ(railMap["Rail1"][std::string(powerfault::kReverseFlag)], "1");
 }
 
 TEST(PowerRailUtilityTest, TestCollectPowerRails_Sequencer)
 {
-    json registerMap = {
-        {{std::string(kSource), "Sequencer"},
-         {std::string(kBus), "1"},
-         {std::string(kAddress), "0x50"},
-         {std::string(kSequencerRegisters),
-          {{{std::string(kRegister), "0x30"},
-            {std::string(kPageToPowerRailMap), {{"1", "Rail1"}}}}}}}};
+    json registerMap = {{{std::string(kSource), "Sequencer"},
+                         {std::string(kBus), "1"},
+                         {std::string(kAddress), "0x50"},
+                         {std::string(powerfault::kSequencerRegisters),
+                          {{{std::string(kRegister), "0x30"},
+                            {std::string(powerfault::kPageToPowerRailMap),
+                             {{"1", "Rail1"}}}}}}}};
 
-    auto railMap = collectPowerRails(registerMap, kSequencer);
+    auto railMap = powerfault::collectPowerRails(registerMap,
+                                                 powerfault::kSequencer);
 
     EXPECT_EQ(railMap.size(), 1);
     EXPECT_EQ(railMap["Rail1"][std::string(kName)], "Rail1");
-    EXPECT_EQ(railMap["Rail1"][std::string(kPage)], "1");
+    EXPECT_EQ(railMap["Rail1"][std::string(powerfault::kPage)], "1");
     EXPECT_EQ(railMap["Rail1"][std::string(kReg)], "0x30");
 }
 
@@ -165,8 +180,8 @@
     std::map<uint8_t, uint8_t> cpldRegValues = {{0x30, 0x08}};
     fs::path logDirPath = "/tmp";
 
-    auto result = processPriorityList(priorityList, railInfoMap, logDirPath,
-                                      cpldRegValues);
+    auto result = powerfault::processPriorityList(priorityList, railInfoMap,
+                                                  logDirPath, cpldRegValues);
 
     EXPECT_TRUE(result.success);
     EXPECT_FALSE(result.hasErrorInZiggurat);
@@ -182,7 +197,7 @@
     std::map<uint8_t, uint8_t> cpldRegValues = {{0x30, 0x00}};
     std::ofstream logFile("/dev/null");
 
-    auto result = handleCPLDRail(railInfo, cpldRegValues, logFile);
+    auto result = powerfault::handleCPLDRail(railInfo, cpldRegValues, logFile);
     EXPECT_TRUE(result.success);
     EXPECT_TRUE(result.powerFaultRails.empty());
 }
@@ -196,7 +211,7 @@
     std::map<uint8_t, uint8_t> cpldRegValues = {{0x30, 0x08}};
     std::ofstream logFile("/dev/null");
 
-    auto result = handleCPLDRail(railInfo, cpldRegValues, logFile);
+    auto result = powerfault::handleCPLDRail(railInfo, cpldRegValues, logFile);
     EXPECT_TRUE(result.success);
     EXPECT_FALSE(result.powerFaultRails.empty());
     EXPECT_EQ(result.powerFaultRails[0], "Rail1");
@@ -211,7 +226,8 @@
     railInfoMap["Rail1"].reg = 0x20;
     railInfoMap["Rail2"].reg = 0x30;
 
-    auto [minReg, maxReg] = getCPLDRegisterRange(railInfoMap, kCPLDM);
+    auto [minReg, maxReg] = powerfault::getCPLDRegisterRange(railInfoMap,
+                                                             kCPLDM);
     EXPECT_EQ(minReg, 0x20);
     EXPECT_EQ(maxReg, 0x30);
 }
@@ -221,7 +237,8 @@
     std::map<std::string, RailInfo> railInfoMap = {
         {"Rail1", RailInfo("Rail1", "Sequencer", "Sequencer", 1, 0x51)}};
 
-    auto [minReg, maxReg] = getCPLDRegisterRange(railInfoMap, kCPLDM);
+    auto [minReg, maxReg] = powerfault::getCPLDRegisterRange(railInfoMap,
+                                                             kCPLDM);
     EXPECT_EQ(minReg, 0);
     EXPECT_EQ(maxReg, 0);
 }
@@ -233,7 +250,7 @@
         {"Rail1", RailInfo("Rail1", "CPLD", "CPLD-M", 1, 0x50)},
         {"Rail2", RailInfo("Rail2", "Sequencer", "Sequencer", 1, 0x51)}};
 
-    auto [bus, addr] = getCPLDBusAndAddress(railInfoMap, kCPLDM);
+    auto [bus, addr] = powerfault::getCPLDBusAndAddress(railInfoMap, kCPLDM);
     EXPECT_EQ(bus, 1);
     EXPECT_EQ(addr, 0x50);
 }
@@ -243,7 +260,7 @@
     std::map<std::string, RailInfo> railInfoMap = {
         {"Rail1", RailInfo("Rail1", "Sequencer", "Sequencer", 1, 0x51)}};
 
-    auto [bus, addr] = getCPLDBusAndAddress(railInfoMap, kCPLDM);
+    auto [bus, addr] = powerfault::getCPLDBusAndAddress(railInfoMap, kCPLDM);
     EXPECT_EQ(bus, 0);
     EXPECT_EQ(addr, 0);
 }
@@ -256,7 +273,7 @@
         {"Rail2", RailInfo("Rail2", "CPLD", "CPLD-M", 1, 0x50)}};
     bool setCPLDFlag = false;
 
-    auto regValues = getCPLDRegValues(railInfoMap, setCPLDFlag);
+    auto regValues = powerfault::getCPLDRegValues(railInfoMap, setCPLDFlag);
 
     EXPECT_FALSE(regValues.empty());
 }
@@ -283,8 +300,8 @@
     std::ofstream(priorityDirPath / "ziggurat.json") << priorityJson.dump();
     std::ofstream(registerMapDirPath / "CPLD.json") << cpldJson.dump();
 
-    bool result = logRailState(priorityDirPath, registerMapDirPath, logDirPath,
-                               "");
+    bool result = powerfault::logRailState(priorityDirPath, registerMapDirPath,
+                                           logDirPath, "");
 
     EXPECT_TRUE(result);
 
@@ -297,18 +314,18 @@
 TEST(PowerRailUtilityTest, TestShowPowerFault_NoFault)
 {
     bool runtime = false;
-    PowerFaultRail powerFaultRails;
+    powerfault::PowerFaultRail powerFaultRails;
     fs::path logDirPath = "/tmp";
 
-    showPowerFault(runtime, powerFaultRails, logDirPath);
+    powerfault::showPowerFault(runtime, powerFaultRails, logDirPath);
 }
 
 TEST(PowerRailUtilityTest, TestShowPowerFault_WithFault)
 {
     EXPECT_CALL(*getDbusUtil(), dbusAddStoredLog(::testing::_)).Times(1);
     bool runtime = true;
-    PowerFaultRail powerFaultRails = {"Rail1"};
+    powerfault::PowerFaultRail powerFaultRails = {"Rail1"};
     fs::path logDirPath = "/tmp";
 
-    showPowerFault(runtime, powerFaultRails, logDirPath);
+    powerfault::showPowerFault(runtime, powerFaultRails, logDirPath);
 }
diff --git a/test/voltage_regulator/voltage_regulator_utility_unittest.cpp b/test/voltage_regulator/voltage_regulator_utility_unittest.cpp
index 413229e..57118d8 100644
--- a/test/voltage_regulator/voltage_regulator_utility_unittest.cpp
+++ b/test/voltage_regulator/voltage_regulator_utility_unittest.cpp
@@ -3,20 +3,18 @@
 
 #include <gtest/gtest.h>
 
-using namespace vrlog;
-
 // Tests for getElement function
 TEST(VoltageRegulatorUtilityTest, GetElement_ValidKey_ReturnsValue)
 {
     json obj = {{"Key1", "Value1"}, {"Key2", "Value2"}};
-    std::string result = getElement(obj, "Key1");
+    std::string result = vrlog::getElement(obj, "Key1");
     EXPECT_EQ(result, "Value1");
 }
 
 TEST(VoltageRegulatorUtilityTest, GetElement_InvalidKey_ReturnsEmptyString)
 {
     json obj = {{"Key1", "Value1"}};
-    std::string result = getElement(obj, "NonExistingKey");
+    std::string result = vrlog::getElement(obj, "NonExistingKey");
     EXPECT_EQ(result, "");
 }
 
@@ -24,7 +22,7 @@
 TEST(VoltageRegulatorUtilityTest, GetOptionalElement_ValidKey_ReturnsValue)
 {
     json obj = {{"Key1", "Value1"}};
-    std::string result = getOptionalElement(obj, "Key1", "DefaultValue");
+    std::string result = vrlog::getOptionalElement(obj, "Key1", "DefaultValue");
     EXPECT_EQ(result, "Value1");
 }
 
@@ -32,8 +30,8 @@
      GetOptionalElement_InvalidKey_ReturnsDefaultValue)
 {
     json obj = {{"Key1", "Value1"}};
-    std::string result = getOptionalElement(obj, "NonExistingKey",
-                                            "DefaultValue");
+    std::string result = vrlog::getOptionalElement(obj, "NonExistingKey",
+                                                   "DefaultValue");
     EXPECT_EQ(result, "DefaultValue");
 }
 
@@ -45,7 +43,7 @@
     ofs << R"({"Key1": "Value1"})";
     ofs.close();
 
-    auto [success, config] = loadJsonFile(tempFile);
+    auto [success, config] = vrlog::loadJsonFile(tempFile);
     EXPECT_TRUE(success);
     EXPECT_EQ(config["Key1"], "Value1");
 
@@ -55,7 +53,7 @@
 TEST(VoltageRegulatorUtilityTest, LoadJsonFile_InvalidFile_ReturnsFalse)
 {
     fs::path invalidFilePath = "test_data/non_existing_file.json";
-    auto [success, config] = loadJsonFile(invalidFilePath);
+    auto [success, config] = vrlog::loadJsonFile(invalidFilePath);
     EXPECT_FALSE(success);
     EXPECT_TRUE(config.empty());
 }
@@ -72,7 +70,8 @@
         {"Coefficients", {{"M", "2"}, {"B", "0"}, {"R", "1"}, {"N", "0"}}},
         {"Unit", "V"}};
 
-    PMbusCommand pmbusCommand = processPMBusConfiguration(pmbusJson);
+    vrlog::PMbusCommand pmbusCommand =
+        vrlog::processPMBusConfiguration(pmbusJson);
 
     EXPECT_EQ(pmbusCommand.commandName, "READ_VOUT");
     EXPECT_EQ(pmbusCommand.writeData.size(), 2);
@@ -89,7 +88,8 @@
                       {"ReadLen", "2"},
                       {"Format", "linear16"}};
 
-    PMbusCommand pmbusCommand = processPMBusConfiguration(pmbusJson);
+    vrlog::PMbusCommand pmbusCommand =
+        vrlog::processPMBusConfiguration(pmbusJson);
 
     EXPECT_TRUE(pmbusCommand.commandName.empty());
     EXPECT_TRUE(pmbusCommand.writeData.empty());
@@ -100,7 +100,7 @@
 TEST(VoltageRegulatorUtilityTest, ParseLogContent_ValidStatusWord_ReturnsTrue)
 {
     std::vector<std::string> tokens = {"STATUS_WORD:", "0x20", "0x00"};
-    auto [powerFault, message] = parseLogContent(tokens);
+    auto [powerFault, message] = vrlog::parseLogContent(tokens);
 
     EXPECT_TRUE(powerFault);
     EXPECT_EQ(message, "STATUS_WORD:VOUT_OV_FAULT\n");
@@ -109,7 +109,7 @@
 TEST(VoltageRegulatorUtilityTest, ParseLogContent_UnknownCommand_ReturnsFalse)
 {
     std::vector<std::string> tokens = {"UNKNOWN_COMMAND:", "0x20", "0x00"};
-    auto [powerFault, message] = parseLogContent(tokens);
+    auto [powerFault, message] = vrlog::parseLogContent(tokens);
 
     EXPECT_FALSE(powerFault);
     EXPECT_TRUE(message.empty());
@@ -124,7 +124,7 @@
     ofs << "STATUS_WORD: 0x00 0x80\n";
     ofs.close();
 
-    bool result = parseLog(logFilePath);
+    bool result = vrlog::parseLog(logFilePath);
 
     EXPECT_TRUE(result);
 
@@ -134,7 +134,7 @@
 TEST(VoltageRegulatorUtilityTest, ParseLog_InvalidLogFile_ReturnsFalse)
 {
     fs::path invalidLogFilePath = "test_data/non_existing_log.txt";
-    bool result = parseLog(invalidLogFilePath);
+    bool result = vrlog::parseLog(invalidLogFilePath);
 
     EXPECT_FALSE(result);
 }