diff --git a/libuavcan/test/protocol/dynamic_node_id_server/event.cpp b/libuavcan/test/protocol/dynamic_node_id_server/event.cpp
index b6dd2697ec..e8f2c457e6 100644
--- a/libuavcan/test/protocol/dynamic_node_id_server/event.cpp
+++ b/libuavcan/test/protocol/dynamic_node_id_server/event.cpp
@@ -4,6 +4,7 @@
 
 #include <gtest/gtest.h>
 #include <uavcan/protocol/dynamic_node_id_server/event.hpp>
+#include "event_tracer.hpp"
 
 
 TEST(dynamic_node_id_server_EventTracer, EventCodeToString)
@@ -15,4 +16,31 @@ TEST(dynamic_node_id_server_EventTracer, EventCodeToString)
     ASSERT_STREQ("RaftActiveSwitch",             IEventTracer::getEventName(TraceRaftActiveSwitch));
     ASSERT_STREQ("RaftAppendEntriesCallFailure", IEventTracer::getEventName(TraceRaftAppendEntriesCallFailure));
     ASSERT_STREQ("RaftDiscoveryReceived",        IEventTracer::getEventName(TraceRaftDiscoveryReceived));
+    ASSERT_STREQ("DiscoveryNodeRestartDetected", IEventTracer::getEventName(TraceDiscoveryNodeRestartDetected));
+    ASSERT_STREQ("AllocationUnexpectedStage",    IEventTracer::getEventName(TraceAllocationUnexpectedStage));
+}
+
+
+TEST(dynamic_node_id_server_EventTracer, EnvironmentSelfTest)
+{
+    using namespace uavcan::dynamic_node_id_server;
+
+    EventTracer tracer;
+
+    ASSERT_EQ(0, tracer.getNumEvents());
+
+    tracer.onEvent(TraceRaftAppendEntriesCallFailure, 123);
+    ASSERT_EQ(1, tracer.getNumEvents());
+    tracer.onEvent(TraceRaftAppendEntriesCallFailure, -456);
+    ASSERT_EQ(2, tracer.getNumEvents());
+    tracer.onEvent(TraceError, -0xFFFFFFFFFFFFFFFLL);
+    ASSERT_EQ(3, tracer.getNumEvents());
+
+    ASSERT_EQ(0, tracer.countEvents(TraceAllocationActivity));
+    ASSERT_EQ(2, tracer.countEvents(TraceRaftAppendEntriesCallFailure));
+    ASSERT_EQ(1, tracer.countEvents(TraceError));
+
+    ASSERT_EQ(-456, tracer.getLastEventArgumentOrFail(TraceRaftAppendEntriesCallFailure));
+
+    ASSERT_EQ(-0xFFFFFFFFFFFFFFFLL, tracer.getLastEventArgumentOrFail(TraceError));
 }
diff --git a/libuavcan/test/protocol/dynamic_node_id_server/event_tracer.hpp b/libuavcan/test/protocol/dynamic_node_id_server/event_tracer.hpp
index 0b8f89c533..dc7ba09077 100644
--- a/libuavcan/test/protocol/dynamic_node_id_server/event_tracer.hpp
+++ b/libuavcan/test/protocol/dynamic_node_id_server/event_tracer.hpp
@@ -6,20 +6,62 @@
 
 #include <iostream>
 #include <string>
+#include <list>
 #include <uavcan/protocol/dynamic_node_id_server/event.hpp>
 
 
 class EventTracer : public uavcan::dynamic_node_id_server::IEventTracer
 {
-    const std::string id_;
-
-    virtual void onEvent(uavcan::dynamic_node_id_server::TraceCode code, uavcan::int64_t argument)
+    struct EventLogEntry
     {
-        std::cout << "EVENT [" << id_ << "]\t" << code << "\t" << getEventName(code) << "\t" << argument << std::endl;
-    }
+        const uavcan::dynamic_node_id_server::TraceCode code;
+        const uavcan::int64_t argument;
+
+        EventLogEntry(uavcan::dynamic_node_id_server::TraceCode arg_code, uavcan::int64_t arg_argument)
+            : code(arg_code)
+            , argument(arg_argument)
+        { }
+    };
+
+    const std::string id_;
+    std::list<EventLogEntry> event_log_;
 
 public:
     EventTracer() { }
 
     EventTracer(const std::string& id) : id_(id) { }
+
+    virtual void onEvent(uavcan::dynamic_node_id_server::TraceCode code, uavcan::int64_t argument)
+    {
+        std::cout << "EVENT [" << id_ << "]\t" << code << "\t" << getEventName(code) << "\t" << argument << std::endl;
+        event_log_.push_back(EventLogEntry(code, argument));
+    }
+
+    unsigned countEvents(const uavcan::dynamic_node_id_server::TraceCode code) const
+    {
+        unsigned count = 0;
+        for (std::list<EventLogEntry>::const_iterator it = event_log_.begin(); it != event_log_.end(); ++it)
+        {
+            count += (it->code == code) ? 1U : 0U;
+        }
+        return count;
+    }
+
+    uavcan::int64_t getLastEventArgumentOrFail(const uavcan::dynamic_node_id_server::TraceCode code) const
+    {
+        for (std::list<EventLogEntry>::const_reverse_iterator it = event_log_.rbegin(); it != event_log_.rend(); ++it)
+        {
+            if (it->code == code)
+            {
+                return it->argument;
+            }
+        }
+
+        std::cout << "No such event in the event log, code " << code << ", log length " << event_log_.size()
+            << std::endl;
+
+        throw std::runtime_error("EventTracer::getLastEventArgumentOrFail()");
+    }
+
+    unsigned getNumEvents() const { return static_cast<unsigned>(event_log_.size()); }
 };