adding SPIFake

Author: nerdyscout

src/ArduinoFake.h

@@ -18,6 +18,7 @@
 #include "WireFake.h"
 #include "ClientFake.h"
 #include "PrintFake.h"
+#include "SPIFake.h"
 
 #define ArduinoFake(mock) _ArduinoFakeGet##mock()
 
@@ -36,6 +37,7 @@
 #define _ArduinoFakeGetFunction() _ArduinoFakeGetMock(Function)
 #define _ArduinoFakeGetSerial() _ArduinoFakeGetMock(Serial)
 #define _ArduinoFakeGetWire() _ArduinoFakeGetMock(Wire)
+#define _ArduinoFakeGetSPI() _ArduinoFakeGetMock(SPI)
 #define _ArduinoFakeGetStream() _ArduinoFakeGetMock(Stream)
 #define _ArduinoFakeGetClient() _ArduinoFakeGetMock(Client)
 #define _ArduinoFakeGetPrint() _ArduinoFakeGetMock(Print)
@@ -70,6 +72,7 @@ struct ArduinoFakeMocks
     fakeit::Mock<StreamFake> Stream;
     fakeit::Mock<ClientFake> Client;
     fakeit::Mock<PrintFake> Print;
+    fakeit::Mock<SPIFake> SPI;
 };
 
 struct ArduinoFakeInstances
@@ -80,6 +83,7 @@ struct ArduinoFakeInstances
     StreamFake* Stream;
     ClientFake* Client;
     PrintFake* Print;
+    SPIFake* SPI;
 };
 
 class ArduinoFakeContext
@@ -95,12 +99,14 @@ class ArduinoFakeContext
         _ArduinoFakeInstanceGetter1(Wire)
         _ArduinoFakeInstanceGetter1(Client)
         _ArduinoFakeInstanceGetter1(Function)
+        _ArduinoFakeInstanceGetter1(SPI)
 
         _ArduinoFakeInstanceGetter2(Print, Print)
         _ArduinoFakeInstanceGetter2(Client, Client)
         _ArduinoFakeInstanceGetter2(Stream, Stream)
         _ArduinoFakeInstanceGetter2(Serial, Serial_)
         _ArduinoFakeInstanceGetter2(Wire, TwoWire)
+        _ArduinoFakeInstanceGetter2(SPI, SPIClass)
 
         ArduinoFakeContext()
         {
@@ -117,9 +123,11 @@ class ArduinoFakeContext
             this->Mocks->Wire.Reset();
             this->Mocks->Client.Reset();
             this->Mocks->Print.Reset();
+            this->Mocks->SPI.Reset();
 
             Mapping[&::Serial] = this->Serial();
             Mapping[&::Wire] = this->Wire();
+            Mapping[&::SPI] = this->SPI();
         }
 };
 

src/SPI.h

@@ -0,0 +1 @@
+#include "SPIFake.h"

src/SPIFake.cpp

@@ -0,0 +1,24 @@
+#include "ArduinoFake.h"
+#include "SPIFake.h"
+
+void SPIClass::begin() { ArduinoFakeInstance(SPI)->begin(); };
+
+void SPIClass::end() { ArduinoFakeInstance(SPI)->end(); };
+
+void SPIClass::beginTransaction(SPISettings settings) {
+  ArduinoFakeInstance(SPI)->beginTransaction(settings);
+};
+
+void SPIClass::endTransaction(void) {
+  ArduinoFakeInstance(SPI)->endTransaction();
+};
+
+uint8_t SPIClass::transfer(uint8_t data) {
+  return ArduinoFakeInstance(SPI)->transfer(data);
+};
+
+void SPIClass::transfer(void *buf, size_t count) {
+  return ArduinoFakeInstance(SPI)->transfer(buf, count);
+};
+
+SPIClass SPI = SPIFakeProxy(ArduinoFakeInstance(SPI));

src/SPIFake.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "ArduinoFake.h"
+#include "arduino/SPI.h"
+
+struct SPIFake {
+  virtual uint8_t transfer(uint8_t data) = 0;
+  virtual void transfer(void *buf, size_t count) = 0;
+
+  virtual void beginTransaction(SPISettings settings) = 0;
+  virtual void endTransaction(void) = 0;
+
+  virtual void begin() = 0;
+  virtual void end() = 0;
+};
+
+class SPIFakeProxy : public SPIClass {
+ private:
+  SPIFake *spiFake;
+
+ public:
+  SPIFakeProxy(SPIFake *fake) { spiFake = fake; }
+
+  SPIFake *getSPIFake() { return spiFake; }
+};

src/arduino/SPI.h

@@ -0,0 +1,103 @@
+/*
+ * Copyright (c) 2010 by Cristian Maglie <c.maglie@arduino.cc>
+ * Copyright (c) 2014 by Paul Stoffregen <paul@pjrc.com> (Transaction API)
+ * Copyright (c) 2014 by Matthijs Kooijman <matthijs@stdin.nl> (SPISettings AVR)
+ * Copyright (c) 2014 by Andrew J. Kroll <xxxajk@gmail.com> (atomicity fixes)
+ * SPI Master library for arduino.
+ *
+ * This file is free software; you can redistribute it and/or modify
+ * it under the terms of either the GNU General Public License version 2
+ * or the GNU Lesser General Public License version 2.1, both as
+ * published by the Free Software Foundation.
+ */
+
+#pragma once
+#include <stdint.h>
+#include <stdlib.h>
+#include <sys/types.h>
+
+// SPI_HAS_TRANSACTION means SPI has beginTransaction(), endTransaction(),
+// usingInterrupt(), and SPISetting(clock, bitOrder, dataMode)
+#define SPI_HAS_TRANSACTION 1
+
+// SPI_HAS_NOTUSINGINTERRUPT means that SPI has notUsingInterrupt() method
+#define SPI_HAS_NOTUSINGINTERRUPT 1
+
+// SPI_ATOMIC_VERSION means that SPI has atomicity fixes and what version.
+// This way when there is a bug fix you can check this define to alert users
+// of your code if it uses better version of this library.
+// This also implies everything that SPI_HAS_TRANSACTION as documented above is
+// available too.
+#define SPI_ATOMIC_VERSION 1
+
+// Uncomment this line to add detection of mismatched begin/end transactions.
+// A mismatch occurs if other libraries fail to use SPI.endTransaction() for
+// each SPI.beginTransaction().  Connect an LED to this pin.  The LED will turn
+// on if any mismatch is ever detected.
+// #define SPI_TRANSACTION_MISMATCH_LED 5
+
+#ifndef LSBFIRST
+#define LSBFIRST 0
+#endif
+#ifndef MSBFIRST
+#define MSBFIRST 1
+#endif
+
+#define SPI_CLOCK_DIV4 0x00
+#define SPI_CLOCK_DIV16 0x01
+#define SPI_CLOCK_DIV64 0x02
+#define SPI_CLOCK_DIV128 0x03
+#define SPI_CLOCK_DIV2 0x04
+#define SPI_CLOCK_DIV8 0x05
+#define SPI_CLOCK_DIV32 0x06
+
+#define SPI_MODE0 0x00
+#define SPI_MODE1 0x04
+#define SPI_MODE2 0x08
+#define SPI_MODE3 0x0C
+
+#define SPI_MODE_MASK 0x0C     // CPOL = bit 3, CPHA = bit 2 on SPCR
+#define SPI_CLOCK_MASK 0x03    // SPR1 = bit 1, SPR0 = bit 0 on SPCR
+#define SPI_2XCLOCK_MASK 0x01  // SPI2X = bit 0 on SPSR
+
+// define SPI_AVR_EIMSK for AVR boards with external interrupt pins
+#if defined(EIMSK)
+#define SPI_AVR_EIMSK EIMSK
+#elif defined(GICR)
+#define SPI_AVR_EIMSK GICR
+#elif defined(GIMSK)
+#define SPI_AVR_EIMSK GIMSK
+#endif
+
+class SPISettings {
+ public:
+  SPISettings(uint32_t clock, uint8_t bitOrder, uint8_t dataMode) {}
+  SPISettings() { SPISettings(4000000, MSBFIRST, SPI_MODE0); }
+  friend class SPIClass;
+};
+
+class SPIClass {
+ public:
+  // Initialize the SPI library
+  virtual void begin();
+  virtual void end();
+
+  // Before using SPI.transfer() or asserting chip select pins,
+  // this function is used to gain exclusive access to the SPI bus
+  // and configure the correct settings.
+  virtual void beginTransaction(SPISettings settings);
+
+  // Write to the SPI bus (MOSI pin) and also receive (MISO pin)
+  virtual uint8_t transfer(uint8_t data);
+  virtual void transfer(void *buf, size_t count);
+
+  // After performing a group of transfers and releasing the chip select
+  // signal, this function allows others to access the SPI bus
+  virtual void endTransaction(void);
+
+  //  virtual ~SPIClass();
+
+ private:
+};
+
+extern SPIClass SPI;

test/main.cpp

@@ -10,6 +10,7 @@ using namespace fakeit;
 #include "test_stream.h"
 #include "test_serial.h"
 #include "test_wire.h"
+#include "test_spi.h"
 #include "test_client.h"
 #include "test_arduino_string.h"
 #include "test_include.h"
@@ -38,6 +39,7 @@ int main(int argc, char **argv)
     RUN_TEST_GROUP(StreamTest);
     RUN_TEST_GROUP(SerialTest);
     RUN_TEST_GROUP(WireTest);
+    RUN_TEST_GROUP(SpiTest);
     RUN_TEST_GROUP(ClientTest);
     RUN_TEST_GROUP(IncludeTest);
 

test/test_spi.h

@@ -0,0 +1,37 @@
+#ifdef UNIT_TEST
+
+namespace SpiTest {
+
+#include "arduino/SPI.h"
+
+void test_basics(void) {
+  SPISettings settings(4000000, MSBFIRST, SPI_MODE0);
+  uint8_t buffer1=0x01;
+  uint8_t buffer2[]={0x02};
+
+  When(OverloadedMethod(ArduinoFake(SPI), begin, void(void))).AlwaysReturn();
+  When(OverloadedMethod(ArduinoFake(SPI), end, void(void))).AlwaysReturn();
+//  When(OverloadedMethod(ArduinoFake(SPI), beginTransaction, void(SPISettings)).Using(settings)).AlwaysReturn();
+  When(OverloadedMethod(ArduinoFake(SPI), endTransaction, void(void))).AlwaysReturn();
+  When(OverloadedMethod(ArduinoFake(SPI), transfer, uint8_t(uint8_t)).Using(buffer1)).AlwaysReturn();
+//  When(OverloadedMethod(ArduinoFake(SPI), transfer, void(void*, size_t)).Using(buffer2,sizeof(buffer2))).AlwaysReturn();
+
+  SPI.begin();
+//  SPI.beginTransaction(settings);
+  SPI.transfer(0x01);
+//  SPI.transfer(buffer2, sizeof(buffer2));
+  SPI.endTransaction();
+  SPI.end();
+
+  Verify(OverloadedMethod(ArduinoFake(SPI), begin, void(void))).Once();
+  Verify(OverloadedMethod(ArduinoFake(SPI), end, void(void))).Once();
+//  Verify(OverloadedMethod(ArduinoFake(SPI), beginTransaction, void(SPISettings))).Once();
+  Verify(OverloadedMethod(ArduinoFake(SPI), endTransaction, void(void))).Once();
+  Verify(OverloadedMethod(ArduinoFake(SPI), transfer, uint8_t(uint8_t))).Once();
+//  Verify(OverloadedMethod(ArduinoFake(SPI), transfer, void(void*, size_t))).Once();
+}
+
+void run_tests() { RUN_TEST(SpiTest::test_basics); }
+}  // namespace SpiTest
+
+#endif