add ForwardHandler

src/ForwardPacketHandler.cpp

@@ -0,0 +1,17 @@
+#include "ForwardPacketHandler.h"
+
+ForwardPacketHandler::ForwardPacketHandler(SPtrIPacketHandler forwardToHandler, SPtrIPacketHandler forwardToCallBackHandler)
+{
+    targetHandler = forwardToHandler;
+    targetCallBackHandler = forwardToCallBackHandler;
+}
+
+ForwardPacketHandler::~ForwardPacketHandler()
+{
+    //dtor
+}
+
+bool ForwardPacketHandler::handle(const Tins::PDU &pdu, IPacketHandler * /*callBackHandler */)
+{
+    return targetHandler->handle(pdu, targetCallBackHandler.get());
+}

src/ForwardPacketHandler.h

@@ -0,0 +1,19 @@
+#ifndef FORWARDPACKETHANDLER_H
+#define FORWARDPACKETHANDLER_H
+
+#include "AbstractPacketHandler.h"
+
+class ForwardPacketHandler : public AbstractPacketHandler
+{
+public:
+
+	ForwardPacketHandler(SPtrIPacketHandler forwardToHandler, SPtrIPacketHandler forwardToCallBackHandler);
+	virtual ~ForwardPacketHandler();
+
+	virtual bool handle(IN const Tins::PDU & pdu, IN IPacketHandler *  callBackHandler = nullptr) override;
+
+private:
+	SPtrIPacketHandler targetCallBackHandler;
+	SPtrIPacketHandler targetHandler;
+};
+#endif

test/src/TestForwardPacketHandler.cpp

@@ -0,0 +1,50 @@
+#include "fakeit.hpp"
+#include "IPacketHandler.h"
+#include "ForwardPacketHandler.h"
+#include "tins/ethernetII.h"
+
+using namespace fakeit;
+
+namespace TestForwardPacketHandler
+{
+    IPacketHandler * ptrTargetCallback = nullptr;
+    class MockForwardIPacketHandler : public IPacketHandler
+    {
+    public:
+        int callCount = 0;
+        virtual bool handle(IN const Tins::PDU & pdu, IN IPacketHandler *  callBackHandler) override
+        {
+            callCount++;
+            REQUIRE(ptrTargetCallback != nullptr);
+            REQUIRE(ptrTargetCallback == callBackHandler);
+            return callBackHandler->handle(pdu, nullptr);
+        }
+    };
+
+
+    class MockForwardCallBackIPacketHandler : public IPacketHandler
+    {
+    public:
+        int callCount = 0;
+        virtual bool handle(IN const Tins::PDU & pdu, IN IPacketHandler *  callBackHandler) override
+        {
+            callCount++;
+            return true;
+        }
+    };
+}
+
+TEST_CASE( "test ForwardPacketHandler", "[ForwardPacketHandler]" )
+{
+    SPtrIPacketHandler sptrTargetCallBackHandler = std::make_shared<TestForwardPacketHandler::MockForwardCallBackIPacketHandler>();
+    TestForwardPacketHandler::ptrTargetCallback = sptrTargetCallBackHandler.get();
+	SPtrIPacketHandler sptrTargetHandler = std::make_shared<TestForwardPacketHandler::MockForwardIPacketHandler>();
+    Mock<IPacketHandler> mockCallCallbackHandler;
+    Fake(Method(mockCallCallbackHandler, handle));
+    SPtrIPacketHandler sptrForwardHandler = std::make_shared<ForwardPacketHandler>(sptrTargetHandler, sptrTargetCallBackHandler);
+    Tins::EthernetII pkt = Tins::EthernetII("11:22:33:44:55:66", "66:55:44:33:22:11");
+    REQUIRE(sptrForwardHandler->handle(pkt, &mockCallCallbackHandler.get()) == true);
+    Verify(Method(mockCallCallbackHandler, handle)).Never();
+    REQUIRE(((TestForwardPacketHandler::MockForwardCallBackIPacketHandler *)sptrTargetCallBackHandler.get())->callCount == 1);
+    REQUIRE(((TestForwardPacketHandler::MockForwardIPacketHandler *)sptrTargetHandler.get())->callCount == 1);
+}