rhetenor/flippr-code
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

made some stuff working 😠 @Jonas

Browse Source
This commit is contained in:
Johannes Wendel
2019-04-25 00:46:44 +02:00
parent 218cb65dd4
commit 878b5f52ce
32 changed files with 781 additions and 731 deletions
Download Patch File Download Diff File Expand all files Collapse all files

33
FlippR-Driver/tests/input/TestDetector.cpp
View File

@@ -11,14 +11,15 @@
#include <map>
#include <typeinfo>
#include <thread>
#define private public
#include "input/IEventNotifier.h"
#include "input/EventNotifier.h"
#include "input/DistributingEvent.h"
#include "input/Detector.h"
#include "input/IInputGPIOInterface.h"
#include "input/detail/Detector.h"
#include "input/detail/InputPinController.h"
#include "utility/LoggerFactory.h"
@@ -34,8 +35,8 @@ SCENARIO("Creating a Detector object", "")
{
LoggerFactory::CreateInputTestLogger();
Mock<IEventNotifier> event_notifier_mock;
Mock<IInputGPIOInterface> gpio_interface_mock;
Mock<EventNotifier> event_notifier_mock;
Mock<InputPinController> gpio_interface_mock;
Fake(Dtor(gpio_interface_mock));
When(Method(gpio_interface_mock, read_data)).AlwaysReturn(false);
@@ -47,7 +48,7 @@ SCENARIO("Creating a Detector object", "")
WHEN("Detector is created")
{
Detector detector(std::unique_ptr<IInputGPIOInterface>(&gpio_interface_mock.get()), events);
detail::Detector detector(std::unique_ptr<InputPinController>(&gpio_interface_mock.get()), events);
THEN("a thread should be created")
{
REQUIRE(typeid(detector.detect_thread).hash_code() == typeid(std::thread).hash_code());
@@ -58,12 +59,12 @@ SCENARIO("Creating a Detector object", "")
SCENARIO("There are events at the input", "")
{
GIVEN("An IEventNofifier, three Events and an IInputGPIOInterface")
GIVEN("An IEventNofifier, three Events and an InputPinController")
{
LoggerFactory::CreateInputTestLogger();
Mock<IEventNotifier> event_notifier_mock;
Mock<IInputGPIOInterface> gpio_interface_mock;
Mock<EventNotifier> event_notifier_mock;
Mock<InputPinController> gpio_interface_mock;
Fake(Dtor(gpio_interface_mock));
When(Method(gpio_interface_mock, read_data)).AlwaysDo([](char c){return c==2;});
@@ -71,7 +72,7 @@ SCENARIO("There are events at the input", "")
Fake(Dtor(event_notifier_mock));
When(Method(event_notifier_mock, distribute_event)).AlwaysReturn();
std::shared_ptr<IEventNotifier> event_notifier;
std::shared_ptr<EventNotifier> event_notifier;
DistributingEvent event1(1, '1', "event 1", std::chrono::milliseconds(0), event_notifier);
DistributingEvent event2(2, '2', "event 2", std::chrono::milliseconds(0), event_notifier);
DistributingEvent event3(3, '3', "event 3", std::chrono::milliseconds(0), event_notifier);
@@ -85,7 +86,7 @@ SCENARIO("There are events at the input", "")
WHEN("an event can be found at gpio interface")
{
Detector detector(std::unique_ptr<IInputGPIOInterface>(&gpio_interface_mock.get()), events);
detail::Detector detector(std::unique_ptr<InputPinController>(&gpio_interface_mock.get()), events);
std::this_thread::sleep_for(std::chrono::milliseconds(50));
THEN("the event should be distributed")
{
@@ -99,12 +100,12 @@ SCENARIO("There are events at the input", "")
SCENARIO("There are events at the input but no suitable event in map", "")
{
GIVEN("An IEventNofifier, three Events and an IInputGPIOInterface")
GIVEN("An IEventNofifier, three Events and an InputPinController")
{
LoggerFactory::CreateInputTestLogger();
Mock<IEventNotifier> event_notifier_mock;
Mock<IInputGPIOInterface> gpio_interface_mock;
Mock<EventNotifier> event_notifier_mock;
Mock<InputPinController> gpio_interface_mock;
Fake(Dtor(gpio_interface_mock));
When(Method(gpio_interface_mock, read_data)).AlwaysDo([](char c){return c==4;});
@@ -112,7 +113,7 @@ SCENARIO("There are events at the input but no suitable event in map", "")
Fake(Dtor(event_notifier_mock));
When(Method(event_notifier_mock, distribute_event)).AlwaysReturn();
std::shared_ptr<IEventNotifier> event_notifier;
std::shared_ptr<EventNotifier> event_notifier;
DistributingEvent event1(1, '1', "event 1", std::chrono::milliseconds(0), event_notifier);
DistributingEvent event2(2, '2', "event 2", std::chrono::milliseconds(0), event_notifier);
DistributingEvent event3(3, '3', "event 3", std::chrono::milliseconds(0), event_notifier);
@@ -125,7 +126,7 @@ SCENARIO("There are events at the input but no suitable event in map", "")
WHEN("an event can be found at gpio interface")
{
Detector detector(std::unique_ptr<IInputGPIOInterface>(&gpio_interface_mock.get()), events);
detail::Detector detector(std::unique_ptr<InputPinController>(&gpio_interface_mock.get()), events);
std::this_thread::sleep_for(std::chrono::milliseconds(10));
THEN("the event should be distributed")
{

15
FlippR-Driver/tests/input/TestEventHandler.cpp
View File

@@ -8,14 +8,13 @@
#include "catch.hpp"
#include "fakeit.hpp"
#include "utility/LoggerFactory.h"
#include "input/EventHandler.h"
#include "input/IInputDriver.h"
// testing purposes
#define private public
#include "utility/LoggerFactory.h"
#include "input/detail/EventHandler.h"
#include "input/InputDriver.h"
using namespace fakeit;
using namespace flippR_driver::utility;
@@ -26,15 +25,15 @@ SCENARIO("An EventHandler gets created", "[construction}")
{
LoggerFactory::CreateInputTestLogger();
Mock<flippR_driver::input::IInputDriver> input_driver_mock;
Mock<flippR_driver::input::InputDriver> input_driver_mock;
Fake(Dtor(input_driver_mock));
When(Method(input_driver_mock, register_event_handler)).AlwaysReturn();
When(Method(input_driver_mock, unregister_event_handler)).AlwaysReturn();
WHEN("the event handler gets created")
{
std::shared_ptr<flippR_driver::input::IInputDriver> driver_ptr(&input_driver_mock.get());
flippR_driver::input::EventHandler handler(driver_ptr);
std::shared_ptr<flippR_driver::input::InputDriver> driver_ptr(&input_driver_mock.get());
flippR_driver::input::detail::EventHandler handler(driver_ptr);
THEN("It should register itself at the input_driver")
{

24
FlippR-Driver/tests/input/TestEventNotifier.cpp
View File

@@ -9,17 +9,17 @@
#include "catch.hpp"
#include "fakeit.hpp"
#include "utility/LoggerFactory.h"
#include "input/IEventHandler.h"
#include "utility/IBlockingQueue.h"
// testing purposes
#define private public
#include "utility/LoggerFactory.h"
#include "input/EventHandler.h"
#include "utility/IBlockingQueue.h"
#include "input/detail/EventNotifier.h"
#include "input/EventNotifier.h"
using namespace flippR_driver;
using namespace input;
using namespace fakeit;
@@ -38,7 +38,7 @@ SCENARIO("An EventNotifier gets created", "[construction]")
When(Method(queue_mock, pop)).AlwaysDo([event](){return event;});
Fake(Dtor(queue_mock));
EventNotifier notifier(&(queue_mock.get()));
input::detail::EventNotifier notifier(&(queue_mock.get()));
THEN("It sets the running variable to true")
{
REQUIRE(notifier.is_running);
@@ -63,11 +63,11 @@ SCENARIO("An EventHandler gets [un]registered at the notifier", "[un-register no
When(Method(queue_mock, pop)).AlwaysDo([event](){return event;});
Fake(Dtor(queue_mock));
Mock<IEventHandler> event_handler_mock;
Mock<input::EventHandler> event_handler_mock;
Fake(Method(event_handler_mock, handle));
Fake(Dtor(event_handler_mock));
EventNotifier notifier(&(queue_mock.get()));
input::detail::EventNotifier notifier(&(queue_mock.get()));
WHEN("The EventHandler gets registered at the eventNotifier")
{
@@ -105,7 +105,7 @@ SCENARIO("An event should be distributed", "[distribute]")
When(Method(queue_mock, pop)).AlwaysDo([event](){return event;});
Fake(Dtor(queue_mock));
EventNotifier notifier(&(queue_mock.get()));
input::detail::EventNotifier notifier(&(queue_mock.get()));
WHEN("The event comes in")
{
@@ -126,7 +126,7 @@ SCENARIO("The EventHandler gets notified")
{
Event event(0, 0, "test");
Mock<IEventHandler> event_handler_mock;
Mock<input::EventHandler> event_handler_mock;
When(Method(event_handler_mock, handle)).AlwaysReturn();
Fake(Dtor(event_handler_mock));
@@ -137,7 +137,7 @@ SCENARIO("The EventHandler gets notified")
When(Method(queue_mock, pop)).AlwaysDo([test_event](void){return test_event;});
Fake(Dtor(queue_mock));
EventNotifier notifier(&(queue_mock.get()));
input::detail::EventNotifier notifier(&(queue_mock.get()));
notifier.event_handlers.insert(&(event_handler_mock.get()));

38
FlippR-Driver/tests/input/TestInputDriver.cpp
View File

@@ -12,10 +12,10 @@
// testing purposes
#define private public
#include "input/InputDriver.h"
#include "input/detail/InputDriver.h"
#include "input/IEventNotifier.h"
#include "input/IDetector.h"
#include "input/EventNotifier.h"
#include "input/Detector.h"
using namespace fakeit;
@@ -29,19 +29,17 @@ SCENARIO("An InputDriver gets created", "[construction}")
{
LoggerFactory::CreateInputTestLogger();
Mock<IDetector> detector_mock;
Mock<Detector> detector_mock;
Fake(Dtor(detector_mock));
Mock<IEventNotifier> event_notifier_mock;
Mock<EventNotifier> event_notifier_mock;
Fake(Dtor(event_notifier_mock));
Mock<IEventHandler> event_handler_mock;
Fake(Dtor(event_handler_mock));
WHEN("The InputDriver gets created")
{
std::shared_ptr<IEventNotifier> event_notifier_ptr(&event_notifier_mock.get());
std::shared_ptr<EventNotifier> event_notifier_ptr(&event_notifier_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);
input::detail::InputDriver input_driver(event_notifier_ptr, std::unique_ptr<Detector>(&detector_mock.get()), events);
THEN("It saves the EventNotifier and the Detector")
{
@@ -58,23 +56,23 @@ SCENARIO("An EventHandler [un]registers at the driver", "[un-register]")
{
LoggerFactory::CreateInputTestLogger();
Mock<flippR_driver::input::IDetector> detector_mock;
Mock<flippR_driver::input::Detector> detector_mock;
Fake(Dtor(detector_mock));
Mock<IEventHandler> event_handler_mock;
Mock<input::EventHandler> event_handler_mock;
Fake(Method(event_handler_mock, handle));
Fake(Dtor(event_handler_mock));
Mock<flippR_driver::input::IEventNotifier> event_notifier_mock;
Mock<flippR_driver::input::EventNotifier> event_notifier_mock;
Fake(Method(event_notifier_mock, register_event_handler));
Fake(Method(event_notifier_mock, unregister_event_handler));
Fake(Dtor(event_notifier_mock));
std::shared_ptr<IEventNotifier> event_notifier_ptr(&event_notifier_mock.get());
std::shared_ptr<EventNotifier> event_notifier_ptr(&event_notifier_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);
input::detail::InputDriver input_driver(event_notifier_ptr, std::unique_ptr<Detector>(&detector_mock.get()), events);
WHEN("The EventHandler registers at the driver")
{
@@ -105,16 +103,16 @@ SCENARIO("An Input Driver is created normally", "")
{
LoggerFactory::CreateInputTestLogger();
Mock<flippR_driver::input::IDetector> detector_mock;
Mock<flippR_driver::input::Detector> detector_mock;
Fake(Dtor(detector_mock));
Mock<IEventHandler> event_handler_mock;
Mock<input::EventHandler> event_handler_mock;
Fake(Dtor(event_handler_mock));
Mock<flippR_driver::input::IEventNotifier> event_notifier_mock;
Mock<flippR_driver::input::EventNotifier> event_notifier_mock;
Fake(Dtor(event_notifier_mock));
std::shared_ptr<IEventNotifier> event_notifier_ptr(&event_notifier_mock.get());
std::shared_ptr<EventNotifier> event_notifier_ptr(&event_notifier_mock.get());
Event event1('a', 2, "e1");
auto event1_ptr = std::make_shared<Event>(event1 );
@@ -129,7 +127,7 @@ SCENARIO("An Input Driver is created normally", "")
events.emplace("e4", std::make_shared<Event>(event4));
InputDriver input_driver(event_notifier_ptr, std::unique_ptr<IDetector>(&detector_mock.get()), events);
input::detail::InputDriver input_driver(event_notifier_ptr, std::unique_ptr<Detector>(&detector_mock.get()), events);
WHEN("Someone asks for an event that is registered")
{
@@ -147,7 +145,7 @@ SCENARIO("An Input Driver is created normally", "")
THEN("the obtained event should be null")
{
REQUIRE(event->name == "ERROR");
REQUIRE(event->get()->name == "ERROR");
}
}
}