Add support for faking (Two|)Wire

wrong-kendall · wrong-kendall · commit 896b242397f6 · 2021-12-07T16:08:41.000-08:00
diff --git a/src/ArduinoFake.h b/src/ArduinoFake.h
@@ -15,6 +15,7 @@
 #include "FunctionFake.h"
 #include "StreamFake.h"
 #include "SerialFake.h"
+#include "WireFake.h"
 #include "ClientFake.h"
 #include "PrintFake.h"
 
@@ -34,6 +35,7 @@
 
 #define _ArduinoFakeGetFunction() _ArduinoFakeGetMock(Function)
 #define _ArduinoFakeGetSerial() _ArduinoFakeGetMock(Serial)
+#define _ArduinoFakeGetWire() _ArduinoFakeGetMock(Wire)
 #define _ArduinoFakeGetStream() _ArduinoFakeGetMock(Stream)
 #define _ArduinoFakeGetClient() _ArduinoFakeGetMock(Client)
 #define _ArduinoFakeGetPrint() _ArduinoFakeGetMock(Print)
@@ -64,6 +66,7 @@ struct ArduinoFakeMocks
 {
     fakeit::Mock<FunctionFake> Function;
     fakeit::Mock<SerialFake> Serial;
+    fakeit::Mock<WireFake> Wire;
     fakeit::Mock<StreamFake> Stream;
     fakeit::Mock<ClientFake> Client;
     fakeit::Mock<PrintFake> Print;
@@ -73,6 +76,7 @@ struct ArduinoFakeInstances
 {
     FunctionFake* Function;
     SerialFake* Serial;
+    WireFake* Wire;
     StreamFake* Stream;
     ClientFake* Client;
     PrintFake* Print;
@@ -88,13 +92,15 @@ class ArduinoFakeContext
         _ArduinoFakeInstanceGetter1(Print)
         _ArduinoFakeInstanceGetter1(Stream)
         _ArduinoFakeInstanceGetter1(Serial)
+        _ArduinoFakeInstanceGetter1(Wire)
         _ArduinoFakeInstanceGetter1(Client)
         _ArduinoFakeInstanceGetter1(Function)
 
         _ArduinoFakeInstanceGetter2(Print, Print)
         _ArduinoFakeInstanceGetter2(Client, Client)
         _ArduinoFakeInstanceGetter2(Stream, Stream)
         _ArduinoFakeInstanceGetter2(Serial, Serial_)
+        _ArduinoFakeInstanceGetter2(Wire, TwoWire)
 
         ArduinoFakeContext()
         {
@@ -108,10 +114,12 @@ class ArduinoFakeContext
             this->Mocks->Function.Reset();
             this->Mocks->Stream.Reset();
             this->Mocks->Serial.Reset();
+            this->Mocks->Wire.Reset();
             this->Mocks->Client.Reset();
             this->Mocks->Print.Reset();
 
             Mapping[&::Serial] = this->Serial();
+            Mapping[&::Wire] = this->Wire();
         }
 };
 
diff --git a/src/WireFake.cpp b/src/WireFake.cpp
@@ -0,0 +1,93 @@
+#include "ArduinoFake.h"
+#include "WireFake.h"
+
+void TwoWire::begin(void) { ArduinoFakeInstance(Wire, this)->begin(); }
+
+void TwoWire::begin(uint8_t address) {
+
+  ArduinoFakeInstance(Wire, this)->begin(address);
+}
+
+void TwoWire::begin(int address) {
+  ArduinoFakeInstance(Wire, this)->begin(address);
+}
+
+void TwoWire::end(void) { ArduinoFakeInstance(Wire, this)->end(); }
+
+void TwoWire::setClock(uint32_t clock) {
+  ArduinoFakeInstance(Wire, this)->setClock(clock);
+}
+
+void TwoWire::setWireTimeout(uint32_t timeout, bool reset_with_timeout) {
+  ArduinoFakeInstance(Wire, this)->setWireTimeout(timeout, reset_with_timeout);
+}
+
+bool TwoWire::getWireTimeoutFlag(void) {
+  return ArduinoFakeInstance(Wire, this)->getWireTimeoutFlag();
+}
+
+void TwoWire::clearWireTimeoutFlag(void) {
+  ArduinoFakeInstance(Wire, this)->clearWireTimeoutFlag();
+}
+
+uint8_t TwoWire::requestFrom(uint8_t address, uint8_t quantity,
+                             uint32_t iaddress, uint8_t isize,
+                             uint8_t sendStop) {
+  return ArduinoFakeInstance(Wire, this)
+      ->requestFrom(address, quantity, iaddress, isize, sendStop);
+}
+
+uint8_t TwoWire::requestFrom(uint8_t address, uint8_t quantity,
+                             uint8_t sendStop) {
+  return ArduinoFakeInstance(Wire, this)
+      ->requestFrom(address, quantity, sendStop);
+}
+
+uint8_t TwoWire::requestFrom(uint8_t address, uint8_t quantity) {
+  return ArduinoFakeInstance(Wire, this)->requestFrom(address, quantity);
+}
+
+void TwoWire::beginTransmission(uint8_t address) {
+  ArduinoFakeInstance(Wire, this)->beginTransmission(address);
+}
+
+void TwoWire::beginTransmission(int address) {
+  ArduinoFakeInstance(Wire, this)->beginTransmission(address);
+}
+
+uint8_t TwoWire::endTransmission(bool sendStop) {
+
+  return ArduinoFakeInstance(Wire, this)->endTransmission(sendStop);
+}
+
+uint8_t TwoWire::endTransmission(void) {
+  return ArduinoFakeInstance(Wire, this)->endTransmission();
+}
+
+size_t TwoWire::write(uint8_t data) {
+  return ArduinoFakeInstance(Wire, this)->write(data);
+}
+
+size_t TwoWire::write(const uint8_t *data, size_t quantity) {
+  return ArduinoFakeInstance(Wire, this)->write(data, quantity);
+}
+
+int TwoWire::available(void) {
+  return ArduinoFakeInstance(Wire, this)->available();
+}
+
+int TwoWire::read(void) { return ArduinoFakeInstance(Wire, this)->read(); }
+
+int TwoWire::peek(void) { return ArduinoFakeInstance(Wire, this)->peek(); }
+
+void TwoWire::flush(void) { ArduinoFakeInstance(Wire, this)->flush(); }
+
+void TwoWire::onReceive(void (*function)(int)) {
+  ArduinoFakeInstance(Wire, this)->onReceive(function);
+}
+
+void TwoWire::onRequest(void (*function)(void)) {
+  ArduinoFakeInstance(Wire, this)->onRequest(function);
+}
+
+TwoWire Wire = WireFakeProxy(ArduinoFakeInstance(Wire));
diff --git a/src/WireFake.h b/src/WireFake.h
@@ -0,0 +1,41 @@
+#pragma once
+#include "ArduinoFake.h"
+#include "StreamFake.h"
+#include "arduino/Wire.h"
+
+struct WireFake : public StreamFake {
+  virtual void begin() = 0;
+  virtual void begin(uint8_t) = 0;
+  virtual void begin(int) = 0;
+  virtual void end() = 0;
+  virtual void setClock(uint32_t) = 0;
+  virtual void setWireTimeout(uint32_t timeout = 25000,
+                              bool reset_with_timeout = false) = 0;
+  virtual bool getWireTimeoutFlag(void) = 0;
+  virtual void clearWireTimeoutFlag(void) = 0;
+  virtual void beginTransmission(uint8_t) = 0;
+  virtual void beginTransmission(int) = 0;
+  virtual uint8_t endTransmission(void) = 0;
+  virtual uint8_t endTransmission(bool) = 0;
+  virtual uint8_t requestFrom(uint8_t, uint8_t) = 0;
+  virtual uint8_t requestFrom(uint8_t, uint8_t, uint8_t) = 0;
+  virtual uint8_t requestFrom(uint8_t, uint8_t, uint32_t, uint8_t, uint8_t) = 0;
+  virtual size_t write(uint8_t) = 0;
+  virtual size_t write(const uint8_t *, size_t) = 0;
+  virtual int available(void) = 0;
+  virtual int read(void) = 0;
+  virtual int peek(void) = 0;
+  virtual void flush(void) = 0;
+  virtual void onReceive(void (*)(int)) = 0;
+  virtual void onRequest(void (*)(void)) = 0;
+};
+
+class WireFakeProxy : public StreamFakeProxy, public TwoWire {
+private:
+  WireFake *wireFake;
+
+public:
+  WireFakeProxy(WireFake *fake) : StreamFakeProxy(fake) { wireFake = fake; }
+
+  WireFake *getWireFake() { return wireFake; }
+};
diff --git a/src/arduino/Wire.h b/src/arduino/Wire.h
@@ -0,0 +1,43 @@
+#ifndef TwoWire_h
+#define TwoWire_h
+
+#include "Stream.h"
+#include <inttypes.h>
+
+class TwoWire : public Stream {
+public:
+  void begin();
+  void begin(uint8_t);
+  void begin(int);
+  void end();
+  void setClock(uint32_t);
+  void setWireTimeout(uint32_t timeout = 25000,
+                      bool reset_with_timeout = false);
+  bool getWireTimeoutFlag(void);
+  void clearWireTimeoutFlag(void);
+  void beginTransmission(uint8_t);
+  void beginTransmission(int);
+  uint8_t endTransmission(void);
+  uint8_t endTransmission(bool);
+  uint8_t requestFrom(uint8_t, uint8_t);
+  uint8_t requestFrom(uint8_t, uint8_t, uint8_t);
+  uint8_t requestFrom(uint8_t, uint8_t, uint32_t, uint8_t, uint8_t);
+  virtual size_t write(uint8_t);
+  virtual size_t write(const uint8_t *, size_t);
+  virtual int available(void);
+  virtual int read(void);
+  virtual int peek(void);
+  virtual void flush(void);
+  void onReceive(void (*)(int));
+  void onRequest(void (*)(void));
+
+  inline size_t write(unsigned long n) { return write((uint8_t)n); }
+  inline size_t write(long n) { return write((uint8_t)n); }
+  inline size_t write(unsigned int n) { return write((uint8_t)n); }
+  inline size_t write(int n) { return write((uint8_t)n); }
+  using Print::write;
+};
+
+extern TwoWire Wire;
+
+#endif
diff --git a/test/main.cpp b/test/main.cpp
@@ -9,6 +9,7 @@ using namespace fakeit;
 #include "test_print.h"
 #include "test_stream.h"
 #include "test_serial.h"
+#include "test_wire.h"
 #include "test_client.h"
 #include "test_arduino_string.h"
 #include "test_include.h"
@@ -36,6 +37,7 @@ int main(int argc, char **argv)
     RUN_TEST_GROUP(PrintTest);
     RUN_TEST_GROUP(StreamTest);
     RUN_TEST_GROUP(SerialTest);
+    RUN_TEST_GROUP(WireTest);
     RUN_TEST_GROUP(ClientTest);
     RUN_TEST_GROUP(IncludeTest);
 
diff --git a/test/test_wire.h b/test/test_wire.h
@@ -0,0 +1,109 @@
+#ifdef UNIT_TEST
+
+namespace WireTest {
+void test_extends_stream(void) {
+  TEST_ASSERT_NOT_EQUAL(ArduinoFakeInstance(Stream), ArduinoFakeInstance(Wire));
+
+  char print_char_var = 'A';
+  char stream_char_var = 'B';
+
+  int print_int_var = 123;
+  int stream_int_var = 321;
+
+  When(OverloadedMethod(ArduinoFake(Stream), print, size_t(char)))
+      .AlwaysReturn();
+  When(OverloadedMethod(ArduinoFake(Stream), print, size_t(int, int)))
+      .AlwaysReturn();
+
+  When(OverloadedMethod(ArduinoFake(Wire), print, size_t(char))).AlwaysReturn();
+  When(OverloadedMethod(ArduinoFake(Wire), print, size_t(int, int)))
+      .AlwaysReturn();
+
+  Stream *stream = ArduinoFakeMock(Stream);
+  TwoWire *wire = ArduinoFakeMock(Wire);
+
+  stream->print(stream_char_var);
+  stream->print(stream_int_var, DEC);
+
+  wire->print(print_char_var);
+  wire->print(print_int_var, DEC);
+
+  Verify(OverloadedMethod(ArduinoFake(Stream), print, size_t(char))
+             .Using(stream_char_var))
+      .Once();
+  Verify(OverloadedMethod(ArduinoFake(Stream), print, size_t(int, int))
+             .Using(stream_int_var, DEC))
+      .Once();
+
+  Verify(OverloadedMethod(ArduinoFake(Wire), print, size_t(char))
+             .Using(print_char_var))
+      .Once();
+  Verify(OverloadedMethod(ArduinoFake(Wire), print, size_t(int, int))
+             .Using(print_int_var, DEC))
+      .Once();
+}
+
+void test_global_wire(void) {
+  When(Method(ArduinoFake(Wire), available)).Return(1);
+  When(OverloadedMethod(ArduinoFake(Wire), print, size_t(char))).Return(1);
+
+  TEST_ASSERT_EQUAL(1, Wire.available());
+  TEST_ASSERT_EQUAL(1, Wire.print('A'));
+
+  Verify(Method(ArduinoFake(Wire), available)).Once();
+  Verify(OverloadedMethod(ArduinoFake(Wire), print, size_t(char)).Using('A'))
+      .Once();
+}
+
+void test_basics(void) {
+
+  uint8_t device_addr = 0xab;
+  uint8_t register_addr = 0xcd;
+  int num_bytes_to_read = 1;
+  bool send_stop = false;
+  When(OverloadedMethod(ArduinoFake(Wire), begin, void(void))).AlwaysReturn();
+  When(OverloadedMethod(ArduinoFake(Wire), beginTransmission, void(uint8_t)))
+      .AlwaysReturn();
+  When(OverloadedMethod(ArduinoFake(Wire), write, size_t(uint8_t)))
+      .Return(true);
+  When(OverloadedMethod(ArduinoFake(Wire), endTransmission, uint8_t(bool)))
+      .Return(0);
+  When(OverloadedMethod(ArduinoFake(Wire), requestFrom, uint8_t(uint8_t, uint8_t)))
+      .Return(0);
+  When(OverloadedMethod(ArduinoFake(Wire), available, int(void))).Return(1);
+  When(OverloadedMethod(ArduinoFake(Wire), read, int(void))).Return(1);
+
+  Wire.begin();
+  Wire.beginTransmission(device_addr);
+  Wire.write(register_addr);
+  Wire.endTransmission(send_stop);
+  Wire.requestFrom(device_addr, num_bytes_to_read);
+  if (Wire.available()) {
+    Wire.read();
+  }
+
+  Verify(OverloadedMethod(ArduinoFake(Wire), begin, void(void))).Exactly(1);
+  Verify(OverloadedMethod(ArduinoFake(Wire), beginTransmission, void(uint8_t))
+             .Using(device_addr))
+      .Exactly(1);
+  Verify(OverloadedMethod(ArduinoFake(Wire), write, size_t(uint8_t))
+             .Using(register_addr))
+      .Exactly(1);
+  Verify(OverloadedMethod(ArduinoFake(Wire), endTransmission, uint8_t(bool))
+             .Using(send_stop))
+      .Exactly(1);
+  Verify(OverloadedMethod(ArduinoFake(Wire), requestFrom, uint8_t(uint8_t, uint8_t))
+             .Using(device_addr, num_bytes_to_read))
+      .Exactly(1);
+  Verify(OverloadedMethod(ArduinoFake(Wire), available, int(void))).Exactly(1);
+  Verify(OverloadedMethod(ArduinoFake(Wire), read, int(void))).Exactly(1);
+}
+
+void run_tests() {
+  RUN_TEST(WireTest::test_extends_stream);
+  RUN_TEST(WireTest::test_global_wire);
+  RUN_TEST(WireTest::test_basics);
+}
+} // namespace WireTest
+
+#endif
