diff --git a/Makefile.am b/Makefile.am
index 61c6782..e118816 100644
--- a/Makefile.am
+++ b/Makefile.am
@@ -10,7 +10,7 @@
 	utility.cpp \
 	timer.cpp
 
-SUBDIRS = .
+SUBDIRS = . test
 
 if WANT_PRESENCE
 SUBDIRS += presence
diff --git a/configure.ac b/configure.ac
index 4a1cecd..1b6df27 100644
--- a/configure.ac
+++ b/configure.ac
@@ -30,6 +30,27 @@
 # Checks for library functions.
 LT_INIT # Required for systemd linking
 
+# Check/set gtest specific functions.
+AX_PTHREAD([GTEST_CPPFLAGS="-DGTEST_HAS_PTHREAD=1"],[GTEST_CPPFLAGS="-DGTEST_HAS_PTHREAD=0"])
+AC_SUBST(GTEST_CPPFLAGS)
+AC_ARG_ENABLE([oe-sdk],
+    AS_HELP_STRING([--enable-oe-sdk], [Link testcases absolutely against OE SDK so they can be ran within it.])
+)
+AC_ARG_VAR(OECORE_TARGET_SYSROOT,
+    [Path to the OE SDK SYSROOT])
+AS_IF([test "x$enable_oe_sdk" == "xyes"],
+    AS_IF([test "x$OECORE_TARGET_SYSROOT" == "x"],
+          AC_MSG_ERROR([OECORE_TARGET_SYSROOT must be set with --enable-oe-sdk])
+    )
+    AC_MSG_NOTICE([Enabling OE-SDK at $OECORE_TARGET_SYSROOT])
+    [
+        testcase_flags="-Wl,-rpath,\${OECORE_TARGET_SYSROOT}/lib"
+        testcase_flags="${testcase_flags} -Wl,-rpath,\${OECORE_TARGET_SYSROOT}/usr/lib"
+        testcase_flags="${testcase_flags} -Wl,-dynamic-linker,`find \${OECORE_TARGET_SYSROOT}/lib/ld-*.so | sort -r -n | head -n1`"
+    ]
+    AC_SUBST([OESDK_TESTCASE_FLAGS], [$testcase_flags])
+)
+
 AC_ARG_ENABLE([presence],
     AS_HELP_STRING([--disable-presence], [Disable fan presence package.]))
 AC_ARG_ENABLE([control],
@@ -94,5 +115,5 @@
 ])
 
 # Create configured output
-AC_CONFIG_FILES([Makefile])
+AC_CONFIG_FILES([Makefile test/Makefile])
 AC_OUTPUT
diff --git a/test/Makefile.am b/test/Makefile.am
new file mode 100644
index 0000000..16a3252
--- /dev/null
+++ b/test/Makefile.am
@@ -0,0 +1,13 @@
+AM_CPPFLAGS = -I$(top_srcdir)
+
+# Run all 'check' test programs
+TESTS = $(check_PROGRAMS)
+
+# # Build/add timertest to test suite
+check_PROGRAMS = timertest
+timertest_CPPFLAGS = -Igtest $(GTEST_CPPFLAGS) $(AM_CPPFLAGS)
+timertest_CXXFLAGS = $(PTHREAD_CFLAGS)
+timertest_LDFLAGS = -lgtest_main -lgtest $(PTHREAD_LIBS) $(OESDK_TESTCASE_FLAGS) \
+                    $(SYSTEMD_LIBS) ${SDBUSPLUS_LIBS}
+timertest_SOURCES = timertest.cpp
+timertest_LDADD = $(top_builddir)/timer.o
diff --git a/test/timertest.cpp b/test/timertest.cpp
new file mode 100644
index 0000000..40b2ddf
--- /dev/null
+++ b/test/timertest.cpp
@@ -0,0 +1,359 @@
+/**
+ * Copyright © 2017 IBM Corporation
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+#include <iostream>
+#include <chrono>
+#include <gtest/gtest.h>
+#include "timer.hpp"
+
+/**
+ * Testcases for the Timer class
+ */
+
+using namespace phosphor::fan::util;
+using namespace std::chrono;
+
+void EventDeleter(sd_event* events)
+{
+    sd_event_unref(events);
+}
+
+using EventPtr = std::shared_ptr<sd_event>;
+
+/**
+ * Class to ensure sd_events are correctly
+ * setup and destroyed.
+ */
+class TimerTest : public ::testing::Test
+{
+    public:
+        // systemd event handler
+        EventPtr events;
+
+        // Need this so that events can be initialized.
+        int rc;
+
+        // Gets called as part of each TEST_F construction
+        TimerTest()
+        {
+            sd_event* event = nullptr;
+            auto rc = sd_event_default(&event);
+            EXPECT_GE(rc, 0);
+
+            events.reset(event, EventDeleter);
+        }
+};
+
+/**
+ * Helper class to hande tracking timer expirations
+ * via callback functions.
+ */
+class CallbackTester
+{
+    public:
+
+        CallbackTester() {}
+
+        size_t getCount()
+        {
+            return _count;
+        }
+
+        void callbackFunction()
+        {
+            _count++;
+            _gotCallback = true;
+        }
+
+        bool gotCallback()
+        {
+            return _gotCallback;
+        }
+
+    private:
+        bool _gotCallback = false;
+        size_t _count = 0;
+};
+
+
+/**
+ * Helper class that more closely mimics real usage,
+ * which is another class containing a timer and using
+ * one of its member functions as the callback.
+ */
+class CallbackTesterWithTimer : public CallbackTester
+{
+    public:
+        CallbackTesterWithTimer(EventPtr events) :
+            _timer(events,
+                   std::bind(&CallbackTesterWithTimer::callbackFunction,
+                             this))
+        {
+        }
+
+        void callbackFunction()
+        {
+            //restart the timer once from the callback
+            if (!_restarted)
+            {
+                _restarted = true;
+                auto time = duration_cast<microseconds>(seconds(1));
+                _timer.start(time, Timer::TimerType::oneshot);
+            }
+
+            CallbackTester::callbackFunction();
+        }
+
+        Timer& getTimer()
+        {
+            return _timer;
+        }
+
+        inline bool restarted() const
+        {
+            return _restarted;
+        }
+
+    private:
+
+        Timer _timer;
+        bool _restarted = false;
+};
+
+
+/**
+ * Test that a callback will occur after 2 seconds.
+ */
+TEST_F(TimerTest, timerExpiresAfter2seconds)
+{
+    CallbackTester tester;
+
+    Timer timer(events,
+                std::bind(&CallbackTester::callbackFunction, &tester));
+
+
+    auto time = duration_cast<microseconds>(seconds(2));
+
+    EXPECT_EQ(false, timer.running());
+
+    timer.start(time, Timer::TimerType::oneshot);
+    EXPECT_EQ(false, tester.gotCallback());
+    EXPECT_EQ(true, timer.running());
+
+    int count = 0;
+    auto sleepTime = duration_cast<microseconds>(seconds(1));
+
+    //Wait for 2 1s timeouts
+    while (count < 2)
+    {
+        // Returns 0 on timeout and positive number on dispatch
+        if (sd_event_run(events.get(), sleepTime.count()) == 0)
+        {
+            count++;
+        }
+    }
+
+    EXPECT_EQ(true, tester.gotCallback());
+    EXPECT_EQ(1, tester.getCount());
+    EXPECT_EQ(false, timer.running());
+}
+
+/**
+ * Test that a timer can be restarted.
+ */
+TEST_F(TimerTest, timerRestart)
+{
+    CallbackTester tester;
+
+    Timer timer(events,
+                std::bind(&CallbackTester::callbackFunction, &tester));
+
+
+    auto time = duration_cast<microseconds>(seconds(2));
+    timer.start(time, Timer::TimerType::oneshot);
+
+    //wait for a second
+    auto sleepTime = duration_cast<microseconds>(seconds(1));
+    auto rc = sd_event_run(events.get(), sleepTime.count());
+
+    //expect the timeout, not the dispatch
+    //and the timer should still be running
+    EXPECT_EQ(0, rc);
+    EXPECT_EQ(true, timer.running());
+
+    //Restart it
+    timer.start(time, Timer::TimerType::oneshot);
+
+    //Wait just 1s, make sure not done
+    rc = sd_event_run(events.get(), sleepTime.count());
+    EXPECT_EQ(0, rc);
+    EXPECT_EQ(true, timer.running());
+    EXPECT_EQ(false, tester.gotCallback());
+
+    //Wait 1 more second, this time expecting a dispatch
+    int count = 0;
+    while (count < 1)
+    {
+        // Returns 0 on timeout and positive number on dispatch
+        if (sd_event_run(events.get(), sleepTime.count()) == 0)
+        {
+            count++;
+        }
+    }
+
+    EXPECT_EQ(true, tester.gotCallback());
+    EXPECT_EQ(1, tester.getCount());
+    EXPECT_EQ(false, timer.running());
+}
+
+
+/**
+ * Test that a timer can be stopped.
+ */
+TEST_F(TimerTest, timerStop)
+{
+    CallbackTester tester;
+
+    Timer timer(events,
+                std::bind(&CallbackTester::callbackFunction, &tester));
+
+
+    auto time = duration_cast<microseconds>(seconds(2));
+    timer.start(time, Timer::TimerType::oneshot);
+
+    auto sleepTime = duration_cast<microseconds>(seconds(1));
+
+    //wait 1s
+    auto rc = sd_event_run(events.get(), sleepTime.count());
+
+    //expect the timeout, not the dispatch
+    EXPECT_EQ(rc, 0);
+    EXPECT_EQ(true, timer.running());
+
+    timer.stop();
+
+    EXPECT_EQ(false, timer.running());
+    EXPECT_EQ(false, tester.gotCallback());
+
+    //Wait another 2s, make sure no callbacks happened
+    sleepTime = duration_cast<microseconds>(seconds(2));
+    rc = sd_event_run(events.get(), sleepTime.count());
+
+    EXPECT_EQ(rc, 0);
+    EXPECT_EQ(false, timer.running());
+    EXPECT_EQ(false, tester.gotCallback());
+}
+
+
+/**
+ * Test that the timer can be restarted from within
+ * a callback function.
+ */
+TEST_F(TimerTest, timerRestartFromCallback)
+{
+    CallbackTesterWithTimer tester(events);
+
+    auto& timer = tester.getTimer();
+
+    auto time = duration_cast<microseconds>(seconds(2));
+    timer.start(time, Timer::TimerType::oneshot);
+
+    //after running for 2 seconds, the timer will get restarted
+    //for another 1s
+
+    int count = 0;
+    auto sleepTime = duration_cast<microseconds>(seconds(1));
+    while (count < 3)
+    {
+        // Returns 0 on timeout and positive number on dispatch
+        if (sd_event_run(events.get(), sleepTime.count()) == 0)
+        {
+            count++;
+        }
+    }
+
+    EXPECT_EQ(false, timer.running());
+    EXPECT_EQ(true, tester.gotCallback());
+    EXPECT_EQ(2, tester.getCount()); //2 callbacks
+    EXPECT_EQ(true, tester.restarted());
+}
+
+/**
+ * This shows what happens when the timer expires but
+ * sd_event_run never got called.
+ */
+TEST_F(TimerTest, timerNoEventRun)
+{
+    CallbackTester tester;
+
+    Timer timer(events,
+                std::bind(&CallbackTester::callbackFunction, &tester));
+
+
+    auto time = duration_cast<microseconds>(milliseconds(500));
+
+    timer.start(time, Timer::TimerType::oneshot);
+
+    sleep(1);
+
+    //The timer should have expired, but with no event processing
+    //it will still think it's running.
+
+    EXPECT_EQ(true, timer.running());
+    EXPECT_EQ(false, tester.gotCallback());
+
+    //Now process an event
+    auto sleepTime = duration_cast<microseconds>(milliseconds(5));
+    auto rc = sd_event_run(events.get(), sleepTime.count());
+
+    EXPECT_GT(rc, 0);
+    EXPECT_EQ(false, timer.running());
+    EXPECT_EQ(true, tester.gotCallback());
+}
+
+
+/**
+ * Tests that a timer in repeating mode will keep calling
+ * the callback.
+ */
+TEST_F(TimerTest, RepeatingTimer)
+{
+    CallbackTester tester;
+
+    Timer timer(events,
+                std::bind(&CallbackTester::callbackFunction, &tester));
+
+    auto time = duration_cast<microseconds>(seconds(1));
+    timer.start(time, Timer::TimerType::repeating);
+
+    int count = 0;
+    auto sleepTime = duration_cast<microseconds>(milliseconds(500));
+
+    while (count < 5)
+    {
+        if (sd_event_run(events.get(), sleepTime.count()) == 0)
+        {
+            count++;
+        }
+    }
+
+    EXPECT_EQ(true, timer.running());
+    EXPECT_EQ(true, tester.gotCallback());
+    EXPECT_EQ(4, tester.getCount());
+
+    timer.stop();
+
+    EXPECT_EQ(false, timer.running());
+}