WIP: VUB respirator patches

include/arduino-mock/Arduino.h

@@ -24,6 +24,8 @@ extern "C" {
 #define false 0x0
 #endif
 
+#include "binary.h"
+
 #define PI 3.1415926535897932384626433832795
 #define HALF_PI 1.5707963267948966192313216916398
 #define TWO_PI 6.283185307179586476925286766559
@@ -67,6 +69,8 @@ void detachInterrupt(uint8_t);
 void setup(void);
 void loop(void);
 
+uint8_t pgm_read_byte_near(const char *);
+
 #ifdef __cplusplus
 } // extern "C"
 #endif

include/arduino-mock/Print.h

@@ -0,0 +1,63 @@
+
+#ifndef Print_h
+#define Print_h
+
+#include <inttypes.h>
+#include <stdio.h> // for size_t
+#include <cstring> // for strlen
+
+#define DEC 10
+#define HEX 16
+#define OCT 8
+#define BIN 2
+
+class Print {
+    // private:
+    //   int write_error;
+    //   size_t printNumber(unsigned long, uint8_t);
+    //   size_t printFloat(double, uint8_t);
+    // protected:
+    //   void setWriteError(int err = 1) { write_error = err; }
+  public:
+    //   Print() : write_error(0) {}
+    //
+    //   int getWriteError() { return write_error; }
+    //   void clearWriteError() { setWriteError(0); }
+    //
+    virtual size_t write(uint8_t) = 0;
+    size_t write(const char *str) {
+      if (str == NULL) return 0;
+      return write((const uint8_t *)str, strlen(str));
+    }
+    virtual size_t write(const uint8_t *buffer, size_t size);
+    size_t write(const char *buffer, size_t size) {
+      return write((const uint8_t *)buffer, size);
+    }
+    //
+    //   size_t print(const __FlashStringHelper *);
+    //   size_t print(const String &);
+    virtual size_t print(const char[]);
+    //   size_t print(char);
+    //   size_t print(unsigned char, int = DEC);
+    virtual size_t print(int, int = DEC);
+    virtual size_t print(unsigned int, int = DEC);
+    //   size_t print(long, int = DEC);
+    //   size_t print(unsigned long, int = DEC);
+    //   size_t print(double, int = 2);
+    //   size_t print(const Printable&);
+    //
+    //   size_t println(const __FlashStringHelper *);
+    //   size_t println(const String &s);
+    virtual size_t println(const char[]);
+    //   size_t println(char);
+    //   size_t println(unsigned char, int = DEC);
+    virtual size_t println(int, int = DEC);
+    virtual size_t println(unsigned int, int = DEC);
+    //   size_t println(long, int = DEC);
+    //   size_t println(unsigned long, int = DEC);
+    //   size_t println(double, int = 2);
+    //   size_t println(const Printable&);
+    //   size_t println(void);
+};
+
+#endif

include/arduino-mock/Serial.h

@@ -7,6 +7,8 @@
 #include <stdint.h>
 #include <gmock/gmock.h>
 
+#include <Stream.h>
+
 #define DEC 10
 #define HEX 16
 #define OCT 8
@@ -50,44 +52,53 @@ class SerialMock {
     */
 };
 
-class Serial_ {
+class Serial_ : public Stream {
 
   private:
     static bool printToCout;
 
   public:
     static void setPrintToCout(bool flag);
 
-  public:
-    static size_t print(const char[]);
-    static size_t print(char);
-    static size_t print(unsigned char, int = DEC);
-    static size_t print(int, int = DEC);
-    static size_t print(unsigned int, int = DEC);
-    static size_t print(long, int = DEC);
-    static size_t print(unsigned long, int = DEC);
-    static size_t print(double, int = 2);
-
-    static size_t println(const char[]);
-    static size_t println(char);
-    static size_t println(unsigned char, int = DEC);
-    static size_t println(int, int = DEC);
-    static size_t println(unsigned int, int = DEC);
-    static size_t println(long, int = DEC);
-    static size_t println(unsigned long, int = DEC);
-    static size_t println(double, int = 2);
-    static size_t println(void);
-
-    size_t write(uint8_t);
+    size_t print(const char[]);
+    size_t print(char);
+    size_t print(unsigned char, int = DEC);
+    size_t print(int, int = DEC) override;
+    size_t print(unsigned int, int = DEC) override;
+    size_t print(long, int = DEC);
+    size_t print(unsigned long, int = DEC);
+    size_t print(double, int = 2);
+
+    size_t println(const char[]);
+    size_t println(char);
+    size_t println(unsigned char, int = DEC);
+    size_t println(int, int = DEC) override;
+    size_t println(unsigned int, int = DEC) override;
+    size_t println(long, int = DEC);
+    size_t println(unsigned long, int = DEC);
+    size_t println(double, int = 2);
+    size_t println(void);
+
+    size_t write(uint8_t) override;
     size_t write(const char *str);
-    size_t write(const uint8_t *buffer, size_t size);
+    size_t write(const uint8_t *buffer, size_t size) override;
 
     uint8_t begin(uint32_t);
 
-    uint8_t available();
-    uint8_t read();
+    uint8_t available() override;
+    uint8_t read() override;
+    int8_t peek() override;
+
+    void flush() override;
+
+    bool find(char *target) override;
+    bool find(uint8_t *target) override;
+
+    bool find(char *target, size_t length) override;
+    bool find(uint8_t *target, size_t length) override;
 
-    static void flush();
+    size_t readBytes( char *buffer, size_t length) override;
+    size_t readBytes( uint8_t *buffer, size_t length) override;
 
     /*
     TODO: Not implemented yet.

include/arduino-mock/Stream.h

@@ -0,0 +1,76 @@
+#ifndef STREAM_H
+#define STREAM_H
+
+#include "Print.h"
+#include <gmock/gmock.h>
+
+class Stream : public Print {
+  public:
+    virtual uint8_t available() = 0;
+    virtual uint8_t read() = 0;
+    virtual int8_t peek() = 0;
+    virtual void flush() = 0;
+    // virtual void setTimeout(unsigned long timeout);
+
+    virtual bool find(char *target) = 0;
+    virtual bool find(uint8_t *target) = 0;
+
+    virtual bool find(char *target, size_t length) = 0;
+    virtual bool find(uint8_t *target, size_t length) = 0;
+
+    // virtual bool findUntil(char *target, char *terminator) = 0;
+    // virtual bool findUntil(uint8_t *target, char *terminator) { return findUntil((char *)target, terminator) = 0; }
+    //
+    // virtual bool findUntil(char *target, size_t targetLen, char *terminate, size_t termLen) = 0;
+    // virtual bool findUntil(uint8_t *target, size_t targetLen, char *terminate, size_t termLen) {return findUntil((char *)target, targetLen, terminate, termLen) = 0; }
+    //
+    // virtual long parseInt() = 0;
+    //
+    // virtual float parseFloat() = 0;
+
+    virtual size_t readBytes( char *buffer, size_t length) = 0;
+    virtual size_t readBytes( uint8_t *buffer, size_t length) = 0;
+
+    // virtual size_t readBytesUntil( char terminator, char *buffer, size_t length);
+    // virtual size_t readBytesUntil( char terminator, uint8_t *buffer, size_t length) { return readBytesUntil(terminator, (char *)buffer, length); }
+    //
+    // virtual String readString();
+    // virtual String readStringUntil(char terminator);
+
+};
+
+class StreamMock : public Stream {
+  public:
+    MOCK_METHOD0(available, uint8_t ());
+    MOCK_METHOD0(read, uint8_t ());
+    MOCK_METHOD0(peek, int8_t ());
+    MOCK_METHOD0(flush, void ());
+
+    MOCK_METHOD1(find, bool (char *target));
+    MOCK_METHOD1(find, bool (uint8_t *target));
+    MOCK_METHOD2(find, bool (char *target, size_t length));
+    MOCK_METHOD2(find, bool (uint8_t *target, size_t length));
+
+    // virtual bool findUntil(char *target, char *terminator);
+    // virtual bool findUntil(uint8_t *target, char *terminator) { return findUntil((char *)target, terminator); }
+    //
+    // virtual bool findUntil(char *target, size_t targetLen, char *terminate, size_t termLen);
+    // virtual bool findUntil(uint8_t *target, size_t targetLen, char *terminate, size_t termLen) {return findUntil((char *)target, targetLen, terminate, termLen); }
+    //
+    // virtual long parseInt();
+    //
+    // virtual float parseFloat();
+    MOCK_METHOD2(readBytes, size_t (char *buffer, size_t length));
+    MOCK_METHOD2(readBytes, size_t (uint8_t *buffer, size_t length));
+
+    // virtual size_t readBytesUntil( char terminator, char *buffer, size_t length);
+    // virtual size_t readBytesUntil( char terminator, uint8_t *buffer, size_t length) { return readBytesUntil(terminator, (char *)buffer, length); }
+    //
+    // virtual String readString();
+    // virtual String readStringUntil(char terminator);
+
+    //Print functions
+    MOCK_METHOD2(write, size_t (const uint8_t*, size_t size));
+};
+
+#endif