diff --git a/test/impl/fsm.cpp b/test/impl/fsm.cpp
new file mode 100644
index 0000000..d819bff
--- /dev/null
+++ b/test/impl/fsm.cpp
@@ -0,0 +1,102 @@
+#include <obfs/fsm.hpp>
+#include <catch2/catch.hpp>
+
+#define STATE(Name) struct Name {};
+#define EVENT(Name) struct Name {};
+
+STATE(Final);
+EVENT(Trigger);
+
+STATE(state1); STATE(state2); STATE(state3); STATE(state4); STATE(state5);
+EVENT(event1); EVENT(event2); EVENT(event3); EVENT(event4); EVENT(event5);
+
+struct Action {
+    static bool trigged;
+    static void action() {
+        trigged = true;
+    }
+};
+bool Action::trigged = true;
+
+struct Dummy {
+    static int dummy;
+    static void dummy1() {
+        dummy += 10;
+    }
+    static void dummy2() {
+        dummy *= 20;
+    }
+};
+int Dummy::dummy = 0;
+
+TEST_CASE("Next", "[obfs::StateMachine]") {
+    using next = obfs::Next<event1, state1>;
+    static_assert(std::is_same_v<event1, typename next::event>);
+    static_assert(std::is_same_v<state1, typename next::state>);
+    static_assert(next::action == obfs::FreeAction);
+
+    using next2 = obfs::Next<event2, state2, Action::action>;
+    static_assert(next2::action == Action::action);
+}
+
+TEST_CASE("Stage", "[obfs::StateMachine]") {
+    using stage = obfs::Stage<
+        state1,
+        obfs::Next<event5, state2, Dummy::dummy1>,
+        obfs::Next<event1, state3>>;
+    
+    static_assert(std::is_same_v<
+        obfs::Next<event5, state2, Dummy::dummy1>,
+        typename stage::template next<event5>>);
+
+    static_assert(std::is_same_v<
+        obfs::Next<event5, state2, Dummy::dummy1>,
+        typename obfs::next_stage<stage, event5>::type>);
+
+    static_assert(std::is_same_v<
+        obfs::Next<event1, state3>,
+        typename stage::template next<event1>>);
+
+    static_assert(std::is_same_v<
+        obfs::Next<event1, state3>,
+        typename obfs::next_stage<stage, event1>::type>);
+
+    static_assert(std::is_same_v<obfs::None, typename stage::template next<event3>>);
+
+    static_assert(std::is_same_v<obfs::None, typename obfs::next_stage<stage, event3>::type>);
+
+    static_assert(std::is_same_v<obfs::None, typename obfs::next_stage<obfs::None, event1>::type>);
+}
+
+TEST_CASE("StateMachine", "[obfs::StateMachine]") {
+    using namespace obfs;
+    using machine = StateMachine<
+        Stage<state1, Next<event5 , state2, Dummy::dummy1>,
+                      Next<event1 , state3>>,
+        Stage<state2, Next<event2 , state4>>,
+        Stage<state3, Next<None   , state3>>,
+        Stage<state4, Next<event4 , state1>,
+                      Next<event3 , state5, Dummy::dummy2>>,
+        Stage<state5, Next<Trigger, Final, Action::action>>>;
+
+    auto failure = machine::run(obfs::None{}, event5{});
+    static_assert(std::is_same_v<decltype(failure), obfs::None>);
+
+    auto next1 = machine::run(state1{}, event5{});
+    static_assert(std::is_same_v<decltype(next1), state2>);
+    REQUIRE(Dummy::dummy == 10);
+
+    auto next2 = machine::run(next1, event2{});
+    static_assert(std::is_same_v<decltype(next2), state4>);
+
+    auto failure2 = machine::run(next2, event1{});
+    static_assert(std::is_same_v<decltype(failure2), obfs::None>);
+    
+    auto next3 = machine::run(next2, event3{});
+    static_assert(std::is_same_v<decltype(next3), state5>);
+    REQUIRE(Dummy::dummy == 200);
+
+    auto next4 = machine::run(next3, Trigger{});
+    static_assert(std::is_same_v<decltype(next4), Final>);
+    REQUIRE(Action::trigged);
+}