Fake Proxy

Author: FabioBatSilva

src/ArduinoFake.h

@@ -1,20 +1,24 @@
-#ifndef ARDUINO_FAKE_H
-#define ARDUINO_FAKE_H
+#pragma once
 
 #if !defined(UBRRH) && !defined(UBRR0H) && !defined(USBCON)
     #define USBCON
 #endif
 
-#include <HardwareSerialFake.h>
+#include <cstring>
+#include <fakeit/fakeit.hpp>
+
 #include <FunctionFake.h>
 #include <StreamFake.h>
 #include <SerialFake.h>
+#include <ClientFake.h>
 #include <PrintFake.h>
 
-#define ArduinoFakeGetHardwareSerial() ArduinoFakeGetter(HardwareSerial)
+#include <arduino/Arduino.h>
+
 #define ArduinoFakeGetFunction() ArduinoFakeGetter(Function)
 #define ArduinoFakeGetSerial() ArduinoFakeGetter(Serial)
 #define ArduinoFakeGetStream() ArduinoFakeGetter(Stream)
+#define ArduinoFakeGetClient() ArduinoFakeGetter(Client)
 #define ArduinoFakeGetPrint() ArduinoFakeGetter(Print)
 #define ArduinoFakeGet() ArduinoFakeGetter(Function)
 
@@ -29,6 +33,12 @@
 #define ArduinoFakeInstance(mock, ...) \
     getArduinoFakeContext()->mock(__VA_ARGS__)
 
+#define ArduinoFakeInstanceFake(mock, ...) \
+    getArduinoFakeContext()->mock(__VA_ARGS__)
+
+#define ArduinoFakeMock(mock, ...) \
+    new mock##FakeProxy(ArduinoFakeInstance(mock, __VA_ARGS__))
+
 #define ArduinoFakeReturnInstaceOf(var, mock) \
     if (std::strstr(typeid(*var).name(), #mock)) { \
         return this->mock(); \
@@ -45,19 +55,19 @@
 
 struct ArduinoFakeMocks
 {
-    fakeit::Mock<HardwareSerialFake> HardwareSerial;
     fakeit::Mock<FunctionFake> Function;
     fakeit::Mock<SerialFake> Serial;
     fakeit::Mock<StreamFake> Stream;
+    fakeit::Mock<ClientFake> Client;
     fakeit::Mock<PrintFake> Print;
 };
 
 struct ArduinoFakeInstances
 {
-    HardwareSerialFake* HardwareSerial;
     FunctionFake* Function;
     SerialFake* Serial;
     StreamFake* Stream;
+    ClientFake* Client;
     PrintFake* Print;
 };
 
@@ -70,12 +80,11 @@ class ArduinoFakeContext
         ArduinoFakeSingleInstanceGetter(Print)
         ArduinoFakeSingleInstanceGetter(Stream)
         ArduinoFakeSingleInstanceGetter(Serial)
+        ArduinoFakeSingleInstanceGetter(Client)
         ArduinoFakeSingleInstanceGetter(Function)
-        ArduinoFakeSingleInstanceGetter(HardwareSerial)
 
         PrintFake* Print(class Print* p)
         {
-            ArduinoFakeReturnInstaceOf(p, HardwareSerial)
             ArduinoFakeReturnInstaceOf(p, Serial)
             ArduinoFakeReturnInstaceOf(p, Stream)
 
@@ -84,24 +93,26 @@ class ArduinoFakeContext
 
         StreamFake* Stream(class Stream* s)
         {
-            ArduinoFakeReturnInstaceOf(s, HardwareSerial)
             ArduinoFakeReturnInstaceOf(s, Serial)
 
             return this->Stream();
         }
 
+        ClientFake* Client(class Client* c)
+        {
+            return this->Client();
+        }
+
         void reset(void)
         {
             this->Instances = new ArduinoFakeInstances();
 
-            this->Mocks->HardwareSerial.Reset();
             this->Mocks->Function.Reset();
             this->Mocks->Stream.Reset();
             this->Mocks->Serial.Reset();
+            this->Mocks->Client.Reset();
             this->Mocks->Print.Reset();
         }
 };
 
 ArduinoFakeContext* getArduinoFakeContext();
-
-#endif // ARDUINO_FAKE_H

src/ClientFake.cpp

@@ -0,0 +1,76 @@
+#include "ArduinoFake.h"
+#include "ClientFake.h"
+
+ClientFake* getClientFakeProxy(Client* client)
+{
+    if (ClientFakeProxy* p = dynamic_cast<ClientFakeProxy*>(client)) {
+        return p->clientFake;
+    }
+
+    return ArduinoFakeInstance(Client, client);
+}
+
+int Client::connect(IPAddress ip, uint16_t port)
+{
+    return getClientFakeProxy(this)->connect(ip, port);
+}
+
+int Client::connect(const char *host, uint16_t port)
+{
+    return getClientFakeProxy(this)->connect(host, port);
+}
+
+size_t Client::write(uint8_t value)
+{
+    return getClientFakeProxy(this)->write(value);
+}
+
+size_t Client::write(const uint8_t *buf, size_t size)
+{
+    return getClientFakeProxy(this)->write(buf, size);
+}
+
+int Client::available()
+{
+    return getClientFakeProxy(this)->available();
+}
+
+int Client::read()
+{
+    return getClientFakeProxy(this)->read();
+}
+
+int Client::read(uint8_t *buf, size_t size)
+{
+    return getClientFakeProxy(this)->read(buf, size);
+}
+
+int Client::peek()
+{
+    return getClientFakeProxy(this)->peek();
+}
+
+void Client::flush()
+{
+    return getClientFakeProxy(this)->flush();
+}
+
+void Client::stop()
+{
+    return getClientFakeProxy(this)->stop();
+}
+
+uint8_t Client::connected()
+{
+    return getClientFakeProxy(this)->connected();
+}
+
+Client::operator bool()
+{
+    return 1 == 1;
+}
+
+ClientFakeProxy::operator bool()
+{
+    return 1 == 1;
+}

src/ClientFake.h

@@ -0,0 +1,98 @@
+#pragma once
+
+#include "ArduinoFake.h"
+#include "StreamFake.h"
+#include "arduino/Client.h"
+
+struct ClientFake : public StreamFake
+{
+    virtual int connect(IPAddress ip, uint16_t port) = 0;
+
+    virtual int connect(const char *host, uint16_t port) = 0;
+
+    virtual size_t write(uint8_t) = 0;
+
+    virtual size_t write(const uint8_t *buf, size_t size) = 0;
+
+    virtual int available() = 0;
+
+    virtual int read() = 0;
+
+    virtual int read(uint8_t *buf, size_t size) = 0;
+
+    virtual int peek() = 0;
+
+    virtual void flush() = 0;
+
+    virtual void stop() = 0;
+
+    virtual uint8_t connected() = 0;
+};
+
+class ClientFakeProxy : public Client
+{
+    public:
+        ClientFake* clientFake;
+
+        ClientFakeProxy(ClientFake* clientFake)
+        {
+            clientFake = clientFake;
+        }
+
+        int connect(IPAddress ip, uint16_t port)
+        {
+            return clientFake->connect(ip, port);
+        }
+
+        int connect(const char *host, uint16_t port)
+        {
+            return clientFake->connect(host, port);
+        }
+
+        size_t write(uint8_t value)
+        {
+            return clientFake->write(value);
+        }
+
+        size_t write(const uint8_t *buf, size_t size)
+        {
+            return clientFake->write(buf, size);
+        }
+
+        int available()
+        {
+            return clientFake->available();
+        }
+
+        int read()
+        {
+            return clientFake->read();
+        }
+
+        int read(uint8_t *buf, size_t size)
+        {
+            return clientFake->read(buf, size);
+        }
+
+        int peek()
+        {
+            return clientFake->peek();
+        }
+
+        void flush()
+        {
+            clientFake->flush();
+        }
+
+        void stop()
+        {
+            clientFake->stop();
+        }
+
+        uint8_t connected()
+        {
+            return clientFake->connected();
+        }
+
+        virtual operator bool();
+};

src/FunctionFake.h

@@ -2,7 +2,6 @@
 #define FUNCTION_FAKE_H
 
 #include <fakeit/fakeit.hpp>
-#include <arduino/Arduino.h>
 
 struct FunctionFake
 {