diff --git a/FlippR-Driver/src/input/ErrorEvent.hpp b/FlippR-Driver/src/input/ErrorEvent.hpp
new file mode 100644
index 0000000..0588c3c
--- /dev/null
+++ b/FlippR-Driver/src/input/ErrorEvent.hpp
@@ -0,0 +1,25 @@
+/*
+ * ErrorEvent.h
+ *
+ *  Created on: Aug 8, 2018
+ *      Author: johannes
+ */
+
+#ifndef SRC_INPUT_ERROREVENT_HPP_
+#define SRC_INPUT_ERROREVENT_HPP_
+
+#include "Event.h"
+
+namespace Input
+{
+
+class ErrorEvent : public Event
+{
+public:
+  ErrorEvent() :
+    Event(0, HIGHEST_INPUT_EVENT_PRIORITY, "ERROR")
+  {}
+};
+}
+
+#endif /* SRC_INPUT_ERROREVENT_HPP_ */
diff --git a/FlippR-Driver/src/input/InputDriver.cpp b/FlippR-Driver/src/input/InputDriver.cpp
index f6910eb..1e66546 100644
--- a/FlippR-Driver/src/input/InputDriver.cpp
+++ b/FlippR-Driver/src/input/InputDriver.cpp
@@ -4,6 +4,7 @@
  *  Created on: Jun 15, 2018
  *      Author: Andreas Schneider, Johannes Wendel, Jonas Zeunert, Rafael Vinci, Dr. Franca Rupprecht
  */
+#include <input/ErrorEvent.hpp>
 #include "InputDriver.h"
 
 namespace Input
@@ -29,7 +30,7 @@ void InputDriver::unregister_event_handler(IEventHandler* handler)
 
 std::shared_ptr<Event> InputDriver::get_event(std::string name)
 {
-  std::shared_ptr<Event> event;
+  std::shared_ptr<Event> event(new ErrorEvent());
   try
   {
     event = this->events.at(name);
diff --git a/FlippR-Driver/src/utilities/config.h b/FlippR-Driver/src/utilities/config.h
index 9277ba9..324fa47 100644
--- a/FlippR-Driver/src/utilities/config.h
+++ b/FlippR-Driver/src/utilities/config.h
@@ -22,3 +22,5 @@
 #define INPUT_SLEEP_DURATION_NANO 800
 
 #define NUMBER_OF_DISPLAYS 5
+
+#define HIGHEST_INPUT_EVENT_PRIORITY 0
diff --git a/FlippR-Driver/tests/input/TestDetector.cpp b/FlippR-Driver/tests/input/TestDetector.cpp
index f43f3e9..e137ad2 100644
--- a/FlippR-Driver/tests/input/TestDetector.cpp
+++ b/FlippR-Driver/tests/input/TestDetector.cpp
@@ -41,7 +41,7 @@ SCENARIO("Creating a Detector object", "")
     Fake(Dtor(event_notifier_mock));
     When(Method(event_notifier_mock, distribute_event)).AlwaysReturn();
 
-    std::map<char, Event> events;
+    std::map<char, std::shared_ptr<Event>> events;
 
     WHEN("Detector is created")
     {
@@ -71,13 +71,14 @@ SCENARIO("There are events at the input", "")
 
     Event event1(1, '1', "event 1");
     Event event2(2, '2', "event 2");
+    auto event2ptr = std::make_shared<Event>(event2);
     Event event3(3, '3', "event 3");
 
-    std::map<char, Event> events;
+    std::map<char, std::shared_ptr<Event>> events;
 
-    events.insert(std::make_pair(1, event1));
-    events.insert(std::make_pair(2, event2));
-    events.insert(std::make_pair(3, event3));
+    events.insert(std::make_pair(1, std::make_shared<Event>(event1)));
+    events.insert(std::make_pair(2, event2ptr));
+    events.insert(std::make_pair(3, std::make_shared<Event>(event3)));
 
     WHEN("an event can be found at gpio interface")
     {
@@ -87,7 +88,7 @@ SCENARIO("There are events at the input", "")
       {
         detector.is_running = false;
         std::this_thread::sleep_for(std::chrono::milliseconds(5));
-        REQUIRE((bool)Verify(Method(event_notifier_mock, distribute_event).Using(event2)));
+        REQUIRE((bool)Verify(Method(event_notifier_mock, distribute_event).Using(event2ptr)));
       }
     }
   }
@@ -112,11 +113,11 @@ SCENARIO("There are events at the input but no suitable event in map", "")
     Event event2(2, '2', "event 2");
     Event event3(3, '3', "event 3");
 
-    std::map<char, Event> events;
+    std::map<char, std::shared_ptr<Event>> events;
 
-    events.insert(std::make_pair(1, event1));
-    events.insert(std::make_pair(2, event2));
-    events.insert(std::make_pair(3, event3));
+    events.insert(std::make_pair(1, std::make_shared<Event>(event1)));
+    events.insert(std::make_pair(2, std::make_shared<Event>(event2)));
+    events.insert(std::make_pair(3, std::make_shared<Event>(event3)));
 
     WHEN("an event can be found at gpio interface")
     {
diff --git a/FlippR-Driver/tests/input/TestEventNotifier.cpp b/FlippR-Driver/tests/input/TestEventNotifier.cpp
index 9551463..3d80c64 100644
--- a/FlippR-Driver/tests/input/TestEventNotifier.cpp
+++ b/FlippR-Driver/tests/input/TestEventNotifier.cpp
@@ -97,6 +97,7 @@ SCENARIO("An event should be distributed", "[distribute]")
   GIVEN("An event")
   {
     Event event(0, 0, "test");
+    auto event_ptr = std::make_shared<Event>(event);
 
     Mock<IBlockingQueue<Event>> queue_mock;
     Fake(Method(queue_mock, push));
@@ -107,7 +108,7 @@ SCENARIO("An event should be distributed", "[distribute]")
 
     WHEN("The event comes in")
     {
-      notifier.distribute_event(event);
+      notifier.distribute_event(event_ptr);
       THEN("The event gets queued")
       {
         notifier.is_running = false;
diff --git a/FlippR-Driver/tests/input/TestInputDriver.cpp b/FlippR-Driver/tests/input/TestInputDriver.cpp
index 4d51482..8240d66 100644
--- a/FlippR-Driver/tests/input/TestInputDriver.cpp
+++ b/FlippR-Driver/tests/input/TestInputDriver.cpp
@@ -37,7 +37,9 @@ SCENARIO("An InputDriver gets created", "[construction}")
     WHEN("The InputDriver gets created")
     {
       std::shared_ptr<IEventNotifier> event_notifier_ptr(&event_notifier_mock.get());
-      InputDriver input_driver(event_notifier_ptr, std::unique_ptr<IDetector>(&detector_mock.get()));
+      std::map<std::string, std::shared_ptr<Event>> events;
+
+      InputDriver input_driver(event_notifier_ptr, std::unique_ptr<IDetector>(&detector_mock.get()), events);
 
       THEN("It saves the EventNotifier and the Detector")
       {
@@ -67,7 +69,10 @@ SCENARIO("An EventHandler [un]registers at the driver", "[un-register]")
     Fake(Dtor(event_notifier_mock));
 
     std::shared_ptr<IEventNotifier> event_notifier_ptr(&event_notifier_mock.get());
-    InputDriver input_driver(event_notifier_ptr, std::unique_ptr<IDetector>(&detector_mock.get()));
+
+    std::map<std::string, std::shared_ptr<Event>> events;
+
+    InputDriver input_driver(event_notifier_ptr, std::unique_ptr<IDetector>(&detector_mock.get()), events);
 
     WHEN("The EventHandler registers at the driver")
     {
@@ -92,3 +97,58 @@ SCENARIO("An EventHandler [un]registers at the driver", "[un-register]")
 }
 
 
+SCENARIO("An Input Driver is created normally", "")
+{
+  GIVEN("An InputDriver, EventHandler and an EventNotifier and some events")
+  {
+    LoggerFactory::CreateInputTestLogger();
+
+    Mock<Input::IDetector> detector_mock;
+    Fake(Dtor(detector_mock));
+
+    Mock<IEventHandler> event_handler_mock;
+    Fake(Dtor(event_handler_mock));
+
+    Mock<Input::IEventNotifier> event_notifier_mock;
+    Fake(Dtor(event_notifier_mock));
+
+    std::shared_ptr<IEventNotifier> event_notifier_ptr(&event_notifier_mock.get());
+
+    Event event1('a', 2, "e1");
+    auto event1_ptr = std::make_shared<Event>(event1  );
+    Event event2('b', 1, "e2");
+    Event event3('c', 2, "e3");
+    Event event4('d', 1, "e4");
+
+    std::map<std::string, std::shared_ptr<Event>> events;
+    events.emplace("e1", event1_ptr);
+    events.emplace("e2", std::make_shared<Event>(event2));
+    events.emplace("e3", std::make_shared<Event>(event3));
+    events.emplace("e4", std::make_shared<Event>(event4));
+
+
+    InputDriver input_driver(event_notifier_ptr, std::unique_ptr<IDetector>(&detector_mock.get()), events);
+
+    WHEN("Someone asks for an event that is registered")
+    {
+      auto event = input_driver.get_event("e1");
+
+      THEN("The obtained event should be the same as emplaced before")
+      {
+        REQUIRE(event==event1_ptr);
+      }
+    }
+
+    WHEN("someone asks for an event that is not registered")
+    {
+      auto event = input_driver.get_event("no event");
+
+      THEN("the obtained event should be null")
+      {
+        REQUIRE(event->name == "ERROR");
+      }
+    }
+  }
+}
+
+