diff --git a/src/tests/meson.build b/src/tests/meson.build
new file mode 100644
index 0000000..0415e96
--- /dev/null
+++ b/src/tests/meson.build
@@ -0,0 +1,58 @@
+gtest_dep = dependency('gtest', main: true, disabler: true, required: false)
+gmock_dep = dependency('gmock', disabler: true, required: false)
+if not gtest_dep.found() or not gmock_dep.found()
+    gtest_proj = import('cmake').subproject('googletest', required: false)
+    if gtest_proj.found()
+        gtest_dep = declare_dependency(
+            dependencies: [
+                dependency('threads'),
+                gtest_proj.dependency('gtest'),
+                gtest_proj.dependency('gtest_main'),
+            ],
+        )
+        gmock_dep = gtest_proj.dependency('gmock')
+    else
+        assert(
+            not get_option('tests').allowed(),
+            'Googletest is required if tests are enabled',
+        )
+    endif
+endif
+
+ut_deps_list = [
+    gtest_dep,
+]
+
+ut_deps_list += default_deps
+src_inc = include_directories('..')
+
+test(
+    'test_utils',
+    executable(
+        'test_utils',
+        'test_Utils.cpp',
+        '../Utils.cpp',
+        dependencies: ut_deps_list,
+        implicit_include_directories: false,
+        include_directories: src_inc,
+    ),
+)
+
+test(
+    'test_ipmb',
+    executable(
+        'test_ipmb',
+        '../ipmb/IpmbSensor.cpp',
+        '../Utils.cpp',
+        '../ipmb/IpmbSDRSensor.cpp',
+        'test_IpmbSensor.cpp',
+        dependencies: ut_deps_list,
+        link_with: [
+            utils_a,
+            thresholds_a,
+            devicemgmt_a
+        ],
+        implicit_include_directories: false,
+        include_directories: src_inc,
+    ),
+)
diff --git a/src/tests/test_IpmbSensor.cpp b/src/tests/test_IpmbSensor.cpp
new file mode 100644
index 0000000..e2b3a4e
--- /dev/null
+++ b/src/tests/test_IpmbSensor.cpp
@@ -0,0 +1,291 @@
+#include "ipmb/IpmbSensor.hpp"
+
+#include <cstddef>
+#include <cstdint>
+#include <vector>
+
+#include <gtest/gtest.h>
+
+namespace
+{
+
+TEST(IPMBSensor, Byte0)
+{
+    std::vector<uint8_t> data;
+    data.push_back(42);
+
+    double responseValue = 0.0;
+    size_t errCount = 0;
+    EXPECT_TRUE(IpmbSensor::processReading(ReadingFormat::byte0, 0, data,
+                                           responseValue, errCount));
+    EXPECT_EQ(responseValue, 42.0);
+}
+
+TEST(IPMBSensor, NineBitValidPositive)
+{
+    std::vector<uint8_t> data;
+    data.push_back(0x2a);
+    data.push_back(0x00);
+
+    double responseValue = 0.0;
+    size_t errCount = 0;
+    EXPECT_TRUE(IpmbSensor::processReading(ReadingFormat::nineBit, 0, data,
+                                           responseValue, errCount));
+    EXPECT_EQ(responseValue, 42.0);
+    EXPECT_EQ(errCount, 0);
+}
+
+TEST(IPMBSensor, NineBitValidNegative)
+{
+    std::vector<uint8_t> data;
+    data.push_back(0x9c);
+    data.push_back(0x01);
+
+    double responseValue = 0.0;
+    size_t errCount = 0;
+    EXPECT_TRUE(IpmbSensor::processReading(ReadingFormat::nineBit, 0, data,
+                                           responseValue, errCount));
+    EXPECT_EQ(responseValue, -100.0);
+    EXPECT_EQ(errCount, 0);
+}
+
+TEST(IPMBSensor, NineBitMin)
+{
+    std::vector<uint8_t> data;
+    data.push_back(0x01);
+    data.push_back(0x01);
+
+    double responseValue = 0.0;
+    size_t errCount = 0;
+    EXPECT_TRUE(IpmbSensor::processReading(ReadingFormat::nineBit, 0, data,
+                                           responseValue, errCount));
+    EXPECT_EQ(responseValue, -255.0);
+    EXPECT_EQ(errCount, 0);
+}
+
+// The Altra Family SoC BMC Interface Specification says the maximum 9-bit value
+// is 256, but that can't be represented in 9 bits, so test the max as 255.
+TEST(IPMBSensor, NineBitMax)
+{
+    std::vector<uint8_t> data;
+    data.push_back(0xff);
+    data.push_back(0x00);
+
+    double responseValue = 0.0;
+    size_t errCount = 0;
+    EXPECT_TRUE(IpmbSensor::processReading(ReadingFormat::nineBit, 0, data,
+                                           responseValue, errCount));
+    EXPECT_EQ(responseValue, 255.0);
+    EXPECT_EQ(errCount, 0);
+}
+
+TEST(IPMBSensor, NineBitTooShort)
+{
+    std::vector<uint8_t> data;
+    data.push_back(0x00);
+
+    double responseValue = 0.0;
+    size_t errCount = 0;
+    EXPECT_FALSE(IpmbSensor::processReading(ReadingFormat::nineBit, 0, data,
+                                            responseValue, errCount));
+}
+
+TEST(IPMBSensor, NineBitTooLong)
+{
+    std::vector<uint8_t> data;
+    data.push_back(0x00);
+    data.push_back(0x00);
+    data.push_back(0x00);
+
+    double responseValue = 0.0;
+    size_t errCount = 0;
+    EXPECT_FALSE(IpmbSensor::processReading(ReadingFormat::nineBit, 0, data,
+                                            responseValue, errCount));
+}
+
+TEST(IPMBSensor, NineBitInvalid)
+{
+    std::vector<uint8_t> data;
+    data.push_back(0xff);
+    data.push_back(0xff);
+
+    double responseValue = 0.0;
+    size_t errCount = 0;
+    EXPECT_FALSE(IpmbSensor::processReading(ReadingFormat::nineBit, 0, data,
+                                            responseValue, errCount));
+}
+
+TEST(IPMBSensor, TenBitValid1)
+{
+    std::vector<uint8_t> data;
+    data.push_back(0x08);
+    data.push_back(0x00);
+
+    double responseValue = 0.0;
+    size_t errCount = 0;
+    EXPECT_TRUE(IpmbSensor::processReading(ReadingFormat::tenBit, 0, data,
+                                           responseValue, errCount));
+    EXPECT_EQ(responseValue, 8.0);
+    EXPECT_EQ(errCount, 0);
+}
+
+TEST(IPMBSensor, TenBitValid2)
+{
+    std::vector<uint8_t> data;
+    data.push_back(0x30);
+    data.push_back(0x02);
+
+    double responseValue = 0.0;
+    size_t errCount = 0;
+    EXPECT_TRUE(IpmbSensor::processReading(ReadingFormat::tenBit, 0, data,
+                                           responseValue, errCount));
+
+    EXPECT_EQ(responseValue, 560.0);
+    EXPECT_EQ(errCount, 0);
+}
+
+TEST(IPMBSensor, TenBitMin)
+{
+    std::vector<uint8_t> data;
+    data.push_back(0x00);
+    data.push_back(0x00);
+
+    double responseValue = 0.0;
+    size_t errCount = 0;
+    EXPECT_TRUE(IpmbSensor::processReading(ReadingFormat::tenBit, 0, data,
+                                           responseValue, errCount));
+
+    EXPECT_EQ(responseValue, 0.0);
+    EXPECT_EQ(errCount, 0);
+}
+
+TEST(IPMBSensor, TenBitValidMax)
+{
+    std::vector<uint8_t> data;
+    data.push_back(0xff);
+    data.push_back(0x03);
+
+    double responseValue = 0.0;
+    size_t errCount = 0;
+    EXPECT_TRUE(IpmbSensor::processReading(ReadingFormat::tenBit, 0, data,
+                                           responseValue, errCount));
+
+    EXPECT_EQ(responseValue, 1023.0);
+    EXPECT_EQ(errCount, 0);
+}
+
+TEST(IPMBSensor, TenBitTooShort)
+{
+    std::vector<uint8_t> data;
+    data.push_back(0xff);
+
+    double responseValue = 0.0;
+    size_t errCount = 0;
+    EXPECT_FALSE(IpmbSensor::processReading(ReadingFormat::tenBit, 0, data,
+                                            responseValue, errCount));
+}
+
+TEST(IPMBSensor, TenBitTooLong)
+{
+    std::vector<uint8_t> data;
+    data.push_back(0x00);
+    data.push_back(0x00);
+    data.push_back(0x00);
+
+    double responseValue = 0.0;
+    size_t errCount = 0;
+    EXPECT_FALSE(IpmbSensor::processReading(ReadingFormat::tenBit, 0, data,
+                                            responseValue, errCount));
+}
+
+TEST(IPMBSensor, TenBitInvalid)
+{
+    std::vector<uint8_t> data;
+    data.push_back(0xff);
+    data.push_back(0xff);
+
+    double responseValue = 0.0;
+    size_t errCount = 0;
+    EXPECT_FALSE(IpmbSensor::processReading(ReadingFormat::tenBit, 0, data,
+                                            responseValue, errCount));
+}
+
+TEST(IPMBSensor, FifteenBitValid1)
+{
+    std::vector<uint8_t> data;
+    data.push_back(0xda);
+    data.push_back(0x02);
+
+    double responseValue = 0.0;
+    size_t errCount = 0;
+    EXPECT_TRUE(IpmbSensor::processReading(ReadingFormat::fifteenBit, 0, data,
+                                           responseValue, errCount));
+    EXPECT_EQ(responseValue, 0.730);
+    EXPECT_EQ(errCount, 0);
+}
+
+TEST(IPMBSensor, FifteenBitMin)
+{
+    std::vector<uint8_t> data;
+    data.push_back(0x00);
+    data.push_back(0x00);
+
+    double responseValue = 0.0;
+    size_t errCount = 0;
+    EXPECT_TRUE(IpmbSensor::processReading(ReadingFormat::fifteenBit, 0, data,
+                                           responseValue, errCount));
+    EXPECT_EQ(responseValue, 0.0);
+    EXPECT_EQ(errCount, 0);
+}
+
+TEST(IPMBSensor, FifteenBitMax)
+{
+    std::vector<uint8_t> data;
+    data.push_back(0xff);
+    data.push_back(0x7f);
+
+    double responseValue = 0.0;
+    size_t errCount = 0;
+    EXPECT_TRUE(IpmbSensor::processReading(ReadingFormat::fifteenBit, 0, data,
+                                           responseValue, errCount));
+    EXPECT_EQ(responseValue, 32.767);
+    EXPECT_EQ(errCount, 0);
+}
+
+TEST(IPMBSensor, FifteenBitTooShort)
+{
+    std::vector<uint8_t> data;
+    data.push_back(0xff);
+
+    double responseValue = 0.0;
+    size_t errCount = 0;
+    EXPECT_FALSE(IpmbSensor::processReading(ReadingFormat::fifteenBit, 0, data,
+                                            responseValue, errCount));
+}
+
+TEST(IPMBSensor, FifteenBitTooLong)
+{
+    std::vector<uint8_t> data;
+    data.push_back(0x00);
+    data.push_back(0x00);
+    data.push_back(0x00);
+
+    double responseValue = 0.0;
+    size_t errCount = 0;
+    EXPECT_FALSE(IpmbSensor::processReading(ReadingFormat::fifteenBit, 0, data,
+                                            responseValue, errCount));
+}
+
+TEST(IPMBSensor, FifteenBitInvalid)
+{
+    std::vector<uint8_t> data;
+    data.push_back(0xff);
+    data.push_back(0xff);
+
+    double responseValue = 0.0;
+    size_t errCount = 0;
+    EXPECT_FALSE(IpmbSensor::processReading(ReadingFormat::fifteenBit, 0, data,
+                                            responseValue, errCount));
+}
+
+} // namespace
diff --git a/src/tests/test_Utils.cpp b/src/tests/test_Utils.cpp
new file mode 100644
index 0000000..8192475
--- /dev/null
+++ b/src/tests/test_Utils.cpp
@@ -0,0 +1,244 @@
+#include "Utils.hpp"
+
+#include <array>
+#include <cstddef>
+#include <cstdint>
+#include <cstdlib>
+#include <filesystem>
+#include <fstream>
+#include <iostream>
+#include <new>
+#include <string>
+#include <vector>
+
+#include <gtest/gtest.h>
+
+namespace fs = std::filesystem;
+class TestUtils : public testing::Test
+{
+  public:
+    std::string testDir;
+    fs::path hwmonDir;
+    fs::path peciDir;
+    TestUtils()
+    {
+        // Create test environment
+        auto dir = std::to_array("./testDirXXXXXX");
+        testDir = mkdtemp(dir.data());
+
+        if (testDir.empty())
+        {
+            throw std::bad_alloc();
+        }
+        hwmonDir = fs::path(testDir) / "hwmon";
+        fs::create_directory(hwmonDir);
+        auto hwmon10 = hwmonDir / "hwmon10";
+        fs::create_directory(hwmonDir / "hwmon10");
+        {
+            std::ofstream temp1Input{hwmon10 / "temp1_input"};
+            std::ofstream temp1Min{hwmon10 / "temp1_min"};
+            std::ofstream temp1Max{hwmon10 / "temp1_max"};
+            std::ofstream temp2Input{hwmon10 / "temp2_input"};
+        }
+        createPECIDir();
+    }
+
+    ~TestUtils() override
+    {
+        fs::remove_all(testDir);
+    }
+
+    TestUtils(const TestUtils&) = delete;
+    TestUtils(TestUtils&&) = delete;
+    TestUtils& operator=(const TestUtils&) = delete;
+    TestUtils& operator=(TestUtils&&) = delete;
+
+    void createPECIDir()
+    {
+        peciDir = fs::path(testDir) / "peci";
+        auto peci0 = peciDir /
+                     "peci-0/device/0-30/peci-cputemp.0/hwmon/hwmon25";
+        fs::create_directories(peci0);
+        {
+            std::ofstream temp0Input{peci0 / "temp0_input"};
+            std::ofstream temp1Input{peci0 / "temp1_input"};
+            std::ofstream temp2Input{peci0 / "temp2_input"};
+            std::ofstream name{peci0 / "name"};
+        }
+        auto devDir = peciDir / "peci-0/peci_dev/peci-0";
+        fs::create_directories(devDir);
+        fs::create_directory_symlink("../../../peci-0", devDir / "device");
+        fs::create_directory_symlink("device/0-30", peciDir / "peci-0/0-30");
+
+        // Let's keep this for debugging purpose
+        for (auto p = fs::recursive_directory_iterator(
+                 peciDir, fs::directory_options::follow_directory_symlink);
+             p != fs::recursive_directory_iterator(); ++p)
+        {
+            std::string path = p->path().string();
+            std::cerr << path << "\n";
+            if (p.depth() >= 6)
+            {
+                p.disable_recursion_pending();
+            }
+        }
+    }
+};
+
+TEST_F(TestUtils, findFiles_non_exist)
+{
+    std::vector<fs::path> foundPaths;
+    auto ret = findFiles("non-exist", "", foundPaths);
+
+    EXPECT_FALSE(ret);
+    EXPECT_TRUE(foundPaths.empty());
+}
+
+TEST_F(TestUtils, findFiles_in_hwmon_no_match)
+{
+    std::vector<fs::path> foundPaths;
+    auto ret = findFiles(hwmonDir, R"(in\d+_input)", foundPaths);
+
+    EXPECT_TRUE(ret);
+    EXPECT_EQ(foundPaths.size(), 0U);
+}
+
+TEST_F(TestUtils, findFiles_in_hwmon_match)
+{
+    std::vector<fs::path> foundPaths;
+    auto ret = findFiles(hwmonDir, R"(temp\d+_input)", foundPaths);
+
+    EXPECT_TRUE(ret);
+    EXPECT_EQ(foundPaths.size(), 2U);
+}
+
+TEST_F(TestUtils, findFiles_in_peci_no_match)
+{
+    std::vector<fs::path> foundPaths;
+    auto ret =
+        findFiles(peciDir, R"(peci-\d+/\d+-.+/peci-.+/hwmon/hwmon\d+/aaa$)",
+                  foundPaths, 6);
+
+    EXPECT_TRUE(ret);
+    EXPECT_TRUE(foundPaths.empty());
+}
+
+TEST_F(TestUtils, findFiles_in_peci_match)
+{
+    std::vector<fs::path> foundPaths;
+    auto ret =
+        findFiles(peciDir, R"(peci-\d+/\d+-.+/peci-.+/hwmon/hwmon\d+/name$)",
+                  foundPaths, 6);
+    EXPECT_TRUE(ret);
+    EXPECT_EQ(foundPaths.size(), 1U);
+
+    foundPaths.clear();
+
+    ret = findFiles(peciDir,
+                    R"(peci-\d+/\d+-.+/peci-.+/hwmon/hwmon\d+/temp\d+_input)",
+                    foundPaths, 6);
+    EXPECT_TRUE(ret);
+    EXPECT_EQ(foundPaths.size(), 3U);
+}
+
+TEST_F(TestUtils, findFiles_hwmonPath_end_with_slash)
+{
+    std::string p = hwmonDir.string() + "/";
+    std::vector<fs::path> foundPaths;
+    auto ret = findFiles(p, R"(temp\d+_input)", foundPaths);
+
+    EXPECT_TRUE(ret);
+    EXPECT_EQ(foundPaths.size(), 2U);
+}
+
+TEST_F(TestUtils, findFiles_peciPath_end_with_slash)
+{
+    std::string p = peciDir.string() + "/";
+    std::vector<fs::path> foundPaths;
+    auto ret =
+        findFiles(p, R"(peci-\d+/\d+-.+/peci-.+/hwmon/hwmon\d+/temp\d+_input)",
+                  foundPaths, 6);
+
+    EXPECT_TRUE(ret);
+    EXPECT_EQ(foundPaths.size(), 3U);
+}
+
+TEST_F(TestUtils, findFiles_in_sub_peci_match)
+{
+    std::vector<fs::path> foundPaths;
+    auto ret =
+        findFiles(peciDir / "peci-0", R"(\d+-.+/peci-.+/hwmon/hwmon\d+/name$)",
+                  foundPaths, 5);
+    EXPECT_TRUE(ret);
+    EXPECT_EQ(foundPaths.size(), 1U);
+
+    foundPaths.clear();
+
+    ret = findFiles(peciDir / "peci-0",
+                    R"(\d+-.+/peci-.+/hwmon/hwmon\d+/temp\d+_input)",
+                    foundPaths, 5);
+    EXPECT_TRUE(ret);
+    EXPECT_EQ(foundPaths.size(), 3U);
+}
+
+TEST(GetDeviceBusAddrTest, DevNameInvalid)
+{
+    size_t bus = 0;
+    size_t addr = 0;
+    std::string devName;
+
+    auto ret = getDeviceBusAddr(devName, bus, addr);
+    EXPECT_FALSE(ret);
+
+    devName = "NoHyphen";
+    ret = getDeviceBusAddr(devName, bus, addr);
+    EXPECT_FALSE(ret);
+
+    devName = "pwm-fan";
+    ret = getDeviceBusAddr(devName, bus, addr);
+    EXPECT_FALSE(ret);
+}
+
+TEST(GetDeviceBusAddrTest, BusInvalid)
+{
+    size_t bus = 0;
+    size_t addr = 0;
+    std::string devName = "FF-00FF";
+
+    auto ret = getDeviceBusAddr(devName, bus, addr);
+    EXPECT_FALSE(ret);
+}
+
+TEST(GetDeviceBusAddrTest, AddrInvalid)
+{
+    size_t bus = 0;
+    size_t addr = 0;
+    std::string devName = "12-fan";
+
+    auto ret = getDeviceBusAddr(devName, bus, addr);
+    EXPECT_FALSE(ret);
+}
+
+TEST(GetDeviceBusAddrTest, I3CBusAddrValid)
+{
+    uint64_t bus = 0;
+    uint64_t provisionedId = 0;
+    std::string devName = "0-22400000001";
+
+    auto ret = getDeviceBusAddr(devName, bus, provisionedId);
+    EXPECT_TRUE(ret);
+    EXPECT_EQ(bus, 0);
+    EXPECT_EQ(provisionedId, 0x22400000001);
+}
+
+TEST(GetDeviceBusAddrTest, AllValid)
+{
+    size_t bus = 0;
+    size_t addr = 0;
+    std::string devName = "12-00af";
+
+    auto ret = getDeviceBusAddr(devName, bus, addr);
+    EXPECT_TRUE(ret);
+    EXPECT_EQ(bus, 12);
+    EXPECT_EQ(addr, 0xaf);
+}