diff --git a/test/Makefile.am b/test/Makefile.am
index ed9fefe..7a711a6 100755
--- a/test/Makefile.am
+++ b/test/Makefile.am
@@ -1,7 +1,7 @@
 AM_CPPFLAGS = -I$(top_srcdir)
 
 # gtest unit tests which run during a 'make check'
-check_PROGRAMS = utest
+check_PROGRAMS = utest test_functions
 
 # Run all 'check' test programs
 TESTS = $(check_PROGRAMS)
@@ -44,3 +44,23 @@
 	test_version.cpp \
 	test_item_updater_static.cpp \
 	msl_verify.cpp
+
+test_functions_CPPFLAGS = \
+	-Igtest \
+	$(GTEST_CPPFLAGS) \
+	$(AM_CPPFLAGS)
+
+test_functions_CXXFLAGS = \
+	$(PTHREAD_CFLAGS) \
+	$(SDBUSPLUS_CFLAGS) \
+	$(SDEVENTPLUS_CFLAGS)
+
+test_functions_LDFLAGS = \
+	-lgtest_main \
+	-lgtest \
+	$(SDBUSPLUS_LIBS) \
+	$(SDEVENTPLUS_LIBS)
+
+test_functions_SOURCES = \
+	test_functions.cpp \
+	../functions.cpp
diff --git a/test/test_functions.cpp b/test/test_functions.cpp
new file mode 100644
index 0000000..3b7d366
--- /dev/null
+++ b/test/test_functions.cpp
@@ -0,0 +1,466 @@
+// SPDX-License-Identifier: Apache-2.0
+
+#include "../functions.hpp"
+
+#include <stdlib.h>
+
+#include <array>
+#include <cerrno>
+#include <filesystem>
+#include <fstream>
+#include <map>
+#include <string>
+#include <vector>
+
+#include <gtest/gtest.h>
+
+using namespace std::string_literals;
+
+TEST(GetExtensionsForIbmCompatibleSystem, testSingleMatch)
+{
+    std::map<std::string, std::vector<std::string>> extensionMap{{
+        {"system-foo"s, {".EXT"s}},
+    }};
+    std::vector<std::string> compatibleSystem{"system-foo"s}, extensions;
+    auto found =
+        functions::process_hostfirmware::getExtensionsForIbmCompatibleSystem(
+            extensionMap, compatibleSystem, extensions);
+    EXPECT_TRUE(found);
+    EXPECT_EQ(extensions, std::vector<std::string>{".EXT"s});
+}
+
+TEST(GetExtensionsForIbmCompatibleSystem, testSingleNoMatchNoModify)
+{
+    std::map<std::string, std::vector<std::string>> extensionMap{{
+        {"system-bar"s, {".EXT"s}},
+    }};
+    std::vector<std::string> compatibleSystem{"system-foo"s},
+        extensions{"foo"s};
+    auto found =
+        functions::process_hostfirmware::getExtensionsForIbmCompatibleSystem(
+            extensionMap, compatibleSystem, extensions);
+    EXPECT_FALSE(found);
+    EXPECT_EQ(extensions, std::vector<std::string>{"foo"s});
+}
+
+TEST(GetExtensionsForIbmCompatibleSystem, testMatchModify)
+{
+    std::map<std::string, std::vector<std::string>> extensionMap{{
+        {"system-bar"s, {".BAR"s}},
+        {"system-foo"s, {".FOO"s}},
+    }};
+    std::vector<std::string> compatibleSystem{"system-foo"s},
+        extensions{"foo"s};
+    auto found =
+        functions::process_hostfirmware::getExtensionsForIbmCompatibleSystem(
+            extensionMap, compatibleSystem, extensions);
+    EXPECT_TRUE(found);
+    EXPECT_EQ(extensions, std::vector<std::string>{".FOO"s});
+}
+
+TEST(GetExtensionsForIbmCompatibleSystem, testEmpty)
+{
+    std::map<std::string, std::vector<std::string>> extensionMap;
+    std::vector<std::string> compatibleSystem{"system-foo"s},
+        extensions{"foo"s};
+    auto found =
+        functions::process_hostfirmware::getExtensionsForIbmCompatibleSystem(
+            extensionMap, compatibleSystem, extensions);
+    EXPECT_FALSE(found);
+    EXPECT_EQ(extensions, std::vector<std::string>{"foo"s});
+}
+
+TEST(GetExtensionsForIbmCompatibleSystem, testEmptyEmpty)
+{
+    std::map<std::string, std::vector<std::string>> extensionMap;
+    std::vector<std::string> compatibleSystem, extensions{"foo"s};
+    auto found =
+        functions::process_hostfirmware::getExtensionsForIbmCompatibleSystem(
+            extensionMap, compatibleSystem, extensions);
+    EXPECT_FALSE(found);
+    EXPECT_EQ(extensions, std::vector<std::string>{"foo"s});
+}
+
+TEST(GetExtensionsForIbmCompatibleSystem, testMatchMultiCompat)
+{
+    std::map<std::string, std::vector<std::string>> extensionMap{{
+        {"system-bar"s, {".BAR"s}},
+        {"system-foo"s, {".FOO"s}},
+    }};
+    std::vector<std::string> compatibleSystem{"system-foo"s, "system"},
+        extensions;
+    auto found =
+        functions::process_hostfirmware::getExtensionsForIbmCompatibleSystem(
+            extensionMap, compatibleSystem, extensions);
+    EXPECT_TRUE(found);
+    EXPECT_EQ(extensions, std::vector<std::string>{".FOO"s});
+}
+
+TEST(GetExtensionsForIbmCompatibleSystem, testMultiMatchMultiCompat)
+{
+    std::map<std::string, std::vector<std::string>> extensionMap{{
+        {"system-bar"s, {".BAR"s}},
+        {"system-foo"s, {".FOO"s}},
+    }};
+    std::vector<std::string> compatibleSystem{"system-foo"s, "system-bar"},
+        extensions;
+    auto found =
+        functions::process_hostfirmware::getExtensionsForIbmCompatibleSystem(
+            extensionMap, compatibleSystem, extensions);
+    EXPECT_TRUE(found);
+    EXPECT_EQ(extensions, std::vector<std::string>{".FOO"s});
+}
+
+TEST(GetExtensionsForIbmCompatibleSystem, testMultiMatchMultiCompat2)
+{
+    std::map<std::string, std::vector<std::string>> extensionMap{{
+        {"system-foo"s, {".FOO"s}},
+        {"system-bar"s, {".BAR"s}},
+    }};
+    std::vector<std::string> compatibleSystem{"system-foo"s, "system-bar"},
+        extensions;
+    auto found =
+        functions::process_hostfirmware::getExtensionsForIbmCompatibleSystem(
+            extensionMap, compatibleSystem, extensions);
+    EXPECT_TRUE(found);
+    EXPECT_EQ(extensions, std::vector<std::string>{".FOO"s});
+}
+
+TEST(GetExtensionsForIbmCompatibleSystem, testMultiMatchMultiCompat3)
+{
+    std::map<std::string, std::vector<std::string>> extensionMap{{
+        {"system-bar"s, {".BAR"s}},
+        {"system-foo"s, {".FOO"s}},
+    }};
+    std::vector<std::string> compatibleSystem{"system-bar", "system-foo"s},
+        extensions;
+    auto found =
+        functions::process_hostfirmware::getExtensionsForIbmCompatibleSystem(
+            extensionMap, compatibleSystem, extensions);
+    EXPECT_TRUE(found);
+    EXPECT_EQ(extensions, std::vector<std::string>{".BAR"s});
+}
+
+TEST(GetExtensionsForIbmCompatibleSystem, testMultiMatchMultiCompat4)
+{
+    std::map<std::string, std::vector<std::string>> extensionMap{{
+        {"system-foo"s, {".FOO"s}},
+        {"system-bar"s, {".BAR"s}},
+    }};
+    std::vector<std::string> compatibleSystem{"system-bar", "system-foo"s},
+        extensions;
+    auto found =
+        functions::process_hostfirmware::getExtensionsForIbmCompatibleSystem(
+            extensionMap, compatibleSystem, extensions);
+    EXPECT_TRUE(found);
+    EXPECT_EQ(extensions, std::vector<std::string>{".BAR"s});
+}
+
+TEST(MaybeCall, noMatch)
+{
+    bool called = false;
+    auto callback = [&called](const auto&) { called = true; };
+    std::map<std::string,
+             std::map<std::string, std::variant<std::vector<std::string>>>>
+        interfaces{{
+            {"foo"s, {{"bar"s, std::vector<std::string>{"foo"s}}}},
+        }};
+    auto found = functions::process_hostfirmware::maybeCall(
+        interfaces, std::move(callback));
+    EXPECT_FALSE(found);
+    EXPECT_FALSE(called);
+}
+
+TEST(MaybeCall, match)
+{
+    bool called = false;
+    std::vector<std::string> sys;
+    auto callback = [&called, &sys](const auto& system) {
+        sys = system;
+        called = true;
+    };
+    std::map<std::string,
+             std::map<std::string, std::variant<std::vector<std::string>>>>
+        interfaces{{
+            {"xyz.openbmc_project.Configuration.IBMCompatibleSystem"s,
+             {{"Names"s, std::vector<std::string>{"foo"s}}}},
+        }};
+    auto found = functions::process_hostfirmware::maybeCall(
+        interfaces, std::move(callback));
+    EXPECT_TRUE(found);
+    EXPECT_TRUE(called);
+    EXPECT_EQ(sys, std::vector<std::string>{"foo"s});
+}
+
+TEST(MaybeCall, missingNames)
+{
+    bool called = false;
+    auto callback = [&called](const auto&) { called = true; };
+    std::map<std::string,
+             std::map<std::string, std::variant<std::vector<std::string>>>>
+        interfaces{{
+            {"xyz.openbmc_project.Configuration.IBMCompatibleSystem"s, {}},
+        }};
+    auto found = functions::process_hostfirmware::maybeCall(
+        interfaces, std::move(callback));
+    EXPECT_TRUE(found);
+    EXPECT_FALSE(called);
+}
+
+TEST(MaybeCall, emptyCallbackFound)
+{
+    std::map<std::string,
+             std::map<std::string, std::variant<std::vector<std::string>>>>
+        interfaces{{
+            {"xyz.openbmc_project.Configuration.IBMCompatibleSystem"s,
+             {{"Names"s, std::vector<std::string>{"foo"s}}}},
+        }};
+    auto found = functions::process_hostfirmware::maybeCall(
+        interfaces, std::function<void(std::vector<std::string>)>());
+    EXPECT_TRUE(found);
+}
+
+TEST(MaybeCall, emptyCallbackNotFound)
+{
+    std::map<std::string,
+             std::map<std::string, std::variant<std::vector<std::string>>>>
+        interfaces{{
+            {"foo"s, {{"Names"s, std::vector<std::string>{"foo"s}}}},
+        }};
+    auto found = functions::process_hostfirmware::maybeCall(
+        interfaces, std::function<void(std::vector<std::string>)>());
+    EXPECT_FALSE(found);
+}
+
+TEST(MaybeCall, emptyInterfaces)
+{
+    bool called = false;
+    auto callback = [&called](const auto&) { called = true; };
+    std::map<std::string,
+             std::map<std::string, std::variant<std::vector<std::string>>>>
+        interfaces;
+    auto found = functions::process_hostfirmware::maybeCall(
+        interfaces, std::move(callback));
+    EXPECT_FALSE(found);
+    EXPECT_FALSE(called);
+}
+
+TEST(MaybeCall, emptyInterfacesEmptyCallback)
+{
+    std::map<std::string,
+             std::map<std::string, std::variant<std::vector<std::string>>>>
+        interfaces;
+    auto found = functions::process_hostfirmware::maybeCall(
+        interfaces, std::function<void(std::vector<std::string>)>());
+    EXPECT_FALSE(found);
+}
+
+TEST(WriteLink, testLinkNoDelete)
+{
+    std::array<char, 15> tmpl{"/tmp/tmpXXXXXX"};
+    std::filesystem::path workdir = mkdtemp(&tmpl[0]);
+    bool called = false;
+    auto callback = [&called](const auto&, auto&) { called = true; };
+    std::filesystem::path linkPath = workdir / "link";
+    std::filesystem::path targetPath = workdir / "target";
+    std::ofstream link{linkPath};
+    functions::process_hostfirmware::writeLink(linkPath.filename(), targetPath,
+                                               callback);
+    std::filesystem::remove_all(workdir);
+    EXPECT_FALSE(called);
+}
+
+TEST(WriteLink, testLinkDelete)
+{
+    std::array<char, 15> tmpl{"/tmp/tmpXXXXXX"};
+    std::filesystem::path workdir = mkdtemp(&tmpl[0]);
+    bool called = false;
+    auto callback = [&called](const auto&, auto&) { called = true; };
+    auto linkPath = workdir / "link";
+    auto targetPath = workdir / "target";
+    std::ofstream link{linkPath}, target{targetPath};
+    functions::process_hostfirmware::writeLink(linkPath.filename(), targetPath,
+                                               callback);
+    std::filesystem::remove_all(workdir);
+    EXPECT_FALSE(called);
+}
+
+TEST(WriteLink, testLinkFailDeleteDir)
+{
+    std::array<char, 15> tmpl{"/tmp/tmpXXXXXX"};
+    std::filesystem::path workdir = mkdtemp(&tmpl[0]);
+    std::error_code ec;
+    std::filesystem::path callbackPath;
+    auto callback = [&ec, &callbackPath](const auto& p, auto& _ec) {
+        ec = _ec;
+        callbackPath = p;
+    };
+    auto targetPath = workdir / "target";
+    std::filesystem::create_directory(targetPath);
+    auto linkPath = workdir / "link";
+    auto filePath = targetPath / "file";
+    std::ofstream link{linkPath}, file{filePath};
+    functions::process_hostfirmware::writeLink(linkPath.filename(), targetPath,
+                                               callback);
+    std::filesystem::remove_all(workdir);
+    EXPECT_EQ(ec.value(), ENOTEMPTY);
+    EXPECT_EQ(callbackPath, targetPath);
+}
+
+TEST(WriteLink, testLinkPathNotExist)
+{
+    std::array<char, 15> tmpl{"/tmp/tmpXXXXXX"};
+    std::filesystem::path workdir = mkdtemp(&tmpl[0]);
+    std::error_code ec;
+    std::filesystem::path callbackPath;
+    auto callback = [&ec, &callbackPath](const auto& p, auto& _ec) {
+        ec = _ec;
+        callbackPath = p;
+    };
+    auto linkPath = workdir / "baz";
+    auto targetPath = workdir / "foo/bar/foo";
+    functions::process_hostfirmware::writeLink(linkPath.filename(), targetPath,
+                                               callback);
+    std::filesystem::remove_all(workdir);
+    EXPECT_EQ(ec.value(), ENOENT);
+    EXPECT_EQ(callbackPath, targetPath);
+}
+
+TEST(FindLinks, testNoLinks)
+{
+    std::array<char, 15> tmpl{"/tmp/tmpXXXXXX"};
+    std::filesystem::path workdir = mkdtemp(&tmpl[0]);
+
+    bool callbackCalled = false, errorCallbackCalled = false;
+    auto callback = [&callbackCalled](const auto&, const auto&, const auto&) {
+        callbackCalled = true;
+    };
+    auto errorCallback = [&errorCallbackCalled](const auto&, auto&) {
+        errorCallbackCalled = true;
+    };
+
+    std::vector<std::string> extensions;
+    functions::process_hostfirmware::findLinks(workdir, extensions,
+                                               errorCallback, callback);
+    std::filesystem::remove_all(workdir);
+    EXPECT_FALSE(errorCallbackCalled);
+    EXPECT_FALSE(callbackCalled);
+}
+
+TEST(FindLinks, testOneFound)
+{
+    std::array<char, 15> tmpl{"/tmp/tmpXXXXXX"};
+    std::filesystem::path workdir = mkdtemp(&tmpl[0]);
+    std::filesystem::path callbackPath, callbackLink;
+
+    bool errorCallbackCalled = false;
+    auto callback = [&callbackPath, &callbackLink](
+                        const auto& p1, const auto& p2, const auto&) {
+        callbackPath = p1;
+        callbackLink = p2;
+    };
+    auto errorCallback = [&errorCallbackCalled](const auto&, auto&) {
+        errorCallbackCalled = true;
+    };
+
+    auto filePath = workdir / "foo.foo";
+    std::ofstream file{filePath};
+    std::vector<std::string> extensions{".foo"s};
+    functions::process_hostfirmware::findLinks(workdir, extensions,
+                                               errorCallback, callback);
+    std::filesystem::remove_all(workdir);
+    EXPECT_FALSE(errorCallbackCalled);
+    EXPECT_EQ(callbackLink, workdir / "foo");
+    EXPECT_EQ(callbackPath, filePath.filename());
+}
+
+TEST(FindLinks, testNoExtensions)
+{
+    std::array<char, 15> tmpl{"/tmp/tmpXXXXXX"};
+    std::filesystem::path workdir = mkdtemp(&tmpl[0]);
+    std::filesystem::path callbackPath, callbackLink;
+
+    bool errorCallbackCalled = false, callbackCalled = false;
+    auto callback = [&callbackCalled](const auto&, const auto&, const auto&) {
+        callbackCalled = true;
+    };
+    auto errorCallback = [&errorCallbackCalled](const auto&, auto&) {
+        errorCallbackCalled = true;
+    };
+
+    auto filePath = workdir / "foo.foo";
+    std::ofstream file{filePath};
+    std::vector<std::string> extensions;
+    functions::process_hostfirmware::findLinks(workdir, extensions,
+                                               errorCallback, callback);
+    std::filesystem::remove_all(workdir);
+    EXPECT_FALSE(errorCallbackCalled);
+    EXPECT_FALSE(callbackCalled);
+}
+
+TEST(FindLinks, testEnoent)
+{
+    std::array<char, 15> tmpl{"/tmp/tmpXXXXXX"};
+    std::filesystem::path workdir = mkdtemp(&tmpl[0]);
+
+    std::error_code ec;
+    bool called = false;
+    std::filesystem::path callbackPath;
+    auto callback = [&called](const auto&, const auto&, const auto&) {
+        called = true;
+    };
+    auto errorCallback = [&ec, &callbackPath](const auto& p, auto& _ec) {
+        ec = _ec;
+        callbackPath = p;
+    };
+
+    std::vector<std::string> extensions;
+    auto dir = workdir / "baz";
+    functions::process_hostfirmware::findLinks(dir, extensions, errorCallback,
+                                               callback);
+    std::filesystem::remove_all(workdir);
+    EXPECT_EQ(ec.value(), ENOENT);
+    EXPECT_EQ(callbackPath, dir);
+    EXPECT_FALSE(called);
+}
+
+TEST(FindLinks, testEmptyCallback)
+{
+    std::array<char, 15> tmpl{"/tmp/tmpXXXXXX"};
+    std::filesystem::path workdir = mkdtemp(&tmpl[0]);
+
+    bool called = false;
+    std::filesystem::path callbackPath;
+    auto errorCallback = [&called](const auto&, auto&) { called = true; };
+
+    auto filePath = workdir / "foo.foo";
+    std::ofstream file{filePath};
+
+    std::vector<std::string> extensions{".foo"s};
+    functions::process_hostfirmware::findLinks(
+        workdir, extensions, errorCallback,
+        functions::process_hostfirmware::LinkCallbackType());
+    std::filesystem::remove_all(workdir);
+    EXPECT_FALSE(called);
+    EXPECT_NO_THROW();
+}
+
+TEST(FindLinks, testEmptyErrorCallback)
+{
+    std::array<char, 15> tmpl{"/tmp/tmpXXXXXX"};
+    std::filesystem::path workdir = mkdtemp(&tmpl[0]);
+
+    bool called = false;
+    auto callback = [&called](const auto&, const auto&, const auto&) {
+        called = true;
+    };
+
+    std::vector<std::string> extensions;
+    auto dir = workdir / "baz";
+    functions::process_hostfirmware::findLinks(
+        dir, extensions, functions::process_hostfirmware::ErrorCallbackType(),
+        callback);
+    std::filesystem::remove_all(workdir);
+    EXPECT_FALSE(called);
+    EXPECT_NO_THROW();
+}