diff --git a/.gitignore b/.gitignore
index 27ec686..c48a372 100644
--- a/.gitignore
+++ b/.gitignore
@@ -27,5 +27,6 @@
 *.sw*
 *.log
 *.trs
+*_test
 libtool
 
diff --git a/configure.ac b/configure.ac
index d9e02b3..3b16f84 100644
--- a/configure.ac
+++ b/configure.ac
@@ -211,5 +211,5 @@
 ])
 
 # Create configured output
-AC_CONFIG_FILES([Makefile test/Makefile presence/test/Makefile])
+AC_CONFIG_FILES([Makefile test/Makefile presence/test/Makefile monitor/test/Makefile])
 AC_OUTPUT
diff --git a/monitor/Makefile.am b/monitor/Makefile.am
index e1bfcc0..ecfab71 100644
--- a/monitor/Makefile.am
+++ b/monitor/Makefile.am
@@ -39,3 +39,5 @@
 fan_monitor_defs.cpp: ${srcdir}/gen-fan-monitor-defs.py
 	$(AM_V_GEN)$(GEN_FAN_MONITOR_DEFS) > ${builddir}/$@
 endif
+
+SUBDIRS = test
diff --git a/monitor/power_off_cause.hpp b/monitor/power_off_cause.hpp
new file mode 100644
index 0000000..f40e1fe
--- /dev/null
+++ b/monitor/power_off_cause.hpp
@@ -0,0 +1,169 @@
+#pragma once
+
+#include "types.hpp"
+
+#include <algorithm>
+#include <vector>
+
+namespace phosphor::fan::monitor
+{
+
+/**
+ * @class PowerOffCause
+ *
+ * This abstract class provides a satisfied() pure virtual method
+ * that is called to know if the system should be powered off due
+ * to fan health.  Each type of class that is derived from this
+ * one provides different behavior, for example one may count
+ * missing fans, and another may count nonfunctional fans.
+ */
+class PowerOffCause
+{
+  public:
+    PowerOffCause() = delete;
+    virtual ~PowerOffCause() = default;
+    PowerOffCause(const PowerOffCause&) = delete;
+    PowerOffCause& operator=(const PowerOffCause&) = delete;
+    PowerOffCause(PowerOffCause&&) = delete;
+    PowerOffCause& operator=(PowerOffCause&&) = delete;
+
+    /**
+     * @brief Constructor
+     *
+     * @param[in] count - The number of items that is compared
+     *                    against in the derived class.
+     * @param[in] name - The name of the cause. Used for tracing.
+     */
+    PowerOffCause(size_t count, const std::string& name) :
+        _count(count), _name(std::to_string(count) + " " + name)
+    {}
+
+    /**
+     * @brief Pure virtual that says if the system should be powered
+     *        off based on the fan health.
+     *
+     * @param[in] fanHealth - The FanHealth map
+     *
+     * @return bool - If system should be powered off
+     */
+    virtual bool satisfied(const FanHealth& fanHealth) = 0;
+
+    /**
+     * @brief Returns the name of the cause.
+     *
+     * For example:  "3 Missing Fans"
+     *
+     * @return std::string - The name
+     */
+    const std::string& name() const
+    {
+        return _name;
+    }
+
+  protected:
+    /**
+     * @brief The number of fan health items that the derived
+     *        class uses to compare to the fan health status.
+     *        For example, a 3 for 3 missing fans.
+     */
+    const size_t _count;
+
+    /**
+     * @brief The cause name
+     */
+    const std::string _name;
+};
+
+/**
+ * @class MissingFanFRUCause
+ *
+ * This class provides a satisfied() method that checks for
+ * missing fans in the fan health map.
+ *
+ */
+class MissingFanFRUCause : public PowerOffCause
+{
+  public:
+    MissingFanFRUCause() = delete;
+    ~MissingFanFRUCause() = default;
+    MissingFanFRUCause(const MissingFanFRUCause&) = delete;
+    MissingFanFRUCause& operator=(const MissingFanFRUCause&) = delete;
+    MissingFanFRUCause(MissingFanFRUCause&&) = delete;
+    MissingFanFRUCause& operator=(MissingFanFRUCause&&) = delete;
+
+    /**
+     * @brief Constructor
+     *
+     * @param[in] count - The minimum number of fans that must be
+     *                    missing to need a power off.
+     */
+    explicit MissingFanFRUCause(size_t count) :
+        PowerOffCause(count, "Missing Fan FRUs")
+    {}
+
+    /**
+     * @brief Returns true if 'count' or more fans are missing
+     *        to require a power off.
+     *
+     * @param[in] fanHealth - The FanHealth map
+     */
+    bool satisfied(const FanHealth& fanHealth) override
+    {
+        size_t count = std::count_if(
+            fanHealth.begin(), fanHealth.end(), [](const auto& fan) {
+                return !std::get<presentHealthPos>(fan.second);
+            });
+
+        return count >= _count;
+    }
+};
+
+/**
+ * @class NonfuncFanRotorCause
+ *
+ * This class provides a satisfied() method that checks for
+ * nonfunctional fan rotors in the fan health map.
+ */
+class NonfuncFanRotorCause : public PowerOffCause
+{
+  public:
+    NonfuncFanRotorCause() = delete;
+    ~NonfuncFanRotorCause() = default;
+    NonfuncFanRotorCause(const NonfuncFanRotorCause&) = delete;
+    NonfuncFanRotorCause& operator=(const NonfuncFanRotorCause&) = delete;
+    NonfuncFanRotorCause(NonfuncFanRotorCause&&) = delete;
+    NonfuncFanRotorCause& operator=(NonfuncFanRotorCause&&) = delete;
+
+    /**
+     * @brief Constructor
+     *
+     * @param[in] count - The minimum number of rotors that must be
+     *                    nonfunctional nonfunctional to need a power off.
+     */
+    explicit NonfuncFanRotorCause(size_t count) :
+        PowerOffCause(count, "Nonfunctional Fan Rotors")
+    {}
+
+    /**
+     * @brief Returns true if 'count' or more rotors are nonfunctional
+     *        to require a power off.
+     *
+     * @param[in] fanHealth - The FanHealth map
+     */
+    bool satisfied(const FanHealth& fanHealth) override
+    {
+        size_t count = std::accumulate(
+            fanHealth.begin(), fanHealth.end(), 0,
+            [](int sum, const auto& fan) {
+                const auto& tachs = std::get<sensorFuncHealthPos>(fan.second);
+                auto nonFuncTachs =
+                    std::count_if(tachs.begin(), tachs.end(),
+                                  [](bool tach) { return !tach; });
+                return sum + nonFuncTachs;
+            });
+
+        return count >= _count;
+    }
+};
+
+} // namespace phosphor::fan::monitor
diff --git a/monitor/test/Makefile.am b/monitor/test/Makefile.am
new file mode 100644
index 0000000..32b8c3b
--- /dev/null
+++ b/monitor/test/Makefile.am
@@ -0,0 +1,19 @@
+AM_CPPFLAGS = -iquote$(top_srcdir)
+gtest_cflags = $(PTHREAD_CFLAGS)
+gtest_ldadd = -lgtest -lgtest_main -lgmock $(PTHREAD_LIBS)
+
+check_PROGRAMS =
+
+TESTS = $(check_PROGRAMS)
+
+check_PROGRAMS += \
+	power_off_cause_test
+
+power_off_cause_test_SOURCES = \
+	power_off_cause_test.cpp
+power_off_cause_test_CXXFLAGS = \
+	$(gtest_cflags)
+power_off_cause_test_LDFLAGS = \
+	$(OESDK_TESTCASE_FLAGS)
+power_off_cause_test_LDADD = \
+	$(gtest_ldadd)
diff --git a/monitor/test/power_off_cause_test.cpp b/monitor/test/power_off_cause_test.cpp
new file mode 100644
index 0000000..1c057b2
--- /dev/null
+++ b/monitor/test/power_off_cause_test.cpp
@@ -0,0 +1,55 @@
+#include "../power_off_cause.hpp"
+
+#include <gtest/gtest.h>
+
+using namespace phosphor::fan::monitor;
+
+TEST(PowerOffCauseTest, MissingFanTest)
+{
+    FanHealth health{{"fan0", {true, {true, true}}},
+                     {"fan1", {true, {true, true}}},
+                     {"fan2", {true, {true, true}}},
+                     {"fan3", {true, {true, true}}}};
+
+    MissingFanFRUCause cause{2};
+    EXPECT_FALSE(cause.satisfied(health));
+
+    health["fan0"] = {false, {false, false}};
+    EXPECT_FALSE(cause.satisfied(health));
+
+    health["fan1"] = {false, {false, false}};
+    EXPECT_TRUE(cause.satisfied(health));
+
+    health["fan2"] = {false, {false, false}};
+    EXPECT_TRUE(cause.satisfied(health));
+
+    health["fan0"] = {false, {true, true}};
+    health["fan1"] = {false, {true, true}};
+    health["fan2"] = {false, {true, true}};
+    EXPECT_TRUE(cause.satisfied(health));
+}
+
+TEST(PowerOffCauseTest, NonfuncRotorTest)
+{
+    FanHealth health{{"fan0", {true, {true, true}}},
+                     {"fan1", {true, {true, true}}},
+                     {"fan2", {true, {true, true}}},
+                     {"fan3", {true, {true, true}}}};
+
+    NonfuncFanRotorCause cause{2};
+    EXPECT_FALSE(cause.satisfied(health));
+
+    health["fan0"] = {true, {true, false}};
+    EXPECT_FALSE(cause.satisfied(health));
+
+    health["fan1"] = {true, {false, true}};
+    EXPECT_TRUE(cause.satisfied(health));
+
+    health["fan2"] = {true, {true, false}};
+    EXPECT_TRUE(cause.satisfied(health));
+
+    health["fan0"] = {false, {true, true}};
+    health["fan1"] = {false, {true, true}};
+    health["fan2"] = {false, {true, true}};
+    EXPECT_FALSE(cause.satisfied(health));
+}