Implementation of mock and first RPC unit-test

Author: cmaglie

extras/test/CMakeLists.txt

@@ -84,7 +84,6 @@ set(TEST_TARGET_SRCS
   src/itoa.cpp
   src/MillisFake.cpp
   src/PrintMock.cpp
-  src/StreamMock.cpp
   ${TEST_SRCS}
   ${TEST_DUT_SRCS}
 )

extras/test/include/StreamMock.h

@@ -12,27 +12,71 @@
  **************************************************************************************/
 
 #include <deque>
-
 #include <api/Stream.h>
 
-/**************************************************************************************
- * CLASS DECLARATION
- **************************************************************************************/
-
 class StreamMock : public arduino::Stream
 {
 public:
+  void operator << (char const * str) {
+    for (size_t c = 0; c < strlen(str); c++) {
+      _readStream.push_back(str[c]);
+    }
+  }
+
+  void push_array(const unsigned char *str, size_t len) {
+    for (size_t c = 0; c < len; c++) {
+      _readStream.push_back(static_cast<char>(str[c]));
+    }
+  }
 
-  void operator << (char const * str);
+  int pull_available() {
+    return _writeStream.size();
+  }
 
-  virtual size_t write(uint8_t ch) override;
-  virtual int available() override;
-  virtual int read() override;
-  virtual int peek() override;
+  int pull_array(unsigned char *str, size_t len) {
+    if (_writeStream.size() < len) {
+      return 0; // Not enough data to read
+    }
+    for (size_t c = 0; c < len; c++) {
+      str[c] = _writeStream.front();
+      _writeStream.pop_front();
+    }
+    return len;
+  }
 
 private:
-  std::deque<char> _stream;
+  std::deque<unsigned char> _readStream;
+  std::deque<unsigned char> _writeStream;
+
+public:
+  // --------------------------------
+  // Implementation of Stream methods
+  // --------------------------------
+
+  virtual size_t write(uint8_t ch) override {
+    _writeStream.push_back(static_cast<char>(ch));
+    return 1;
+  }
+
+  virtual int available() override {
+    return _readStream.size();
+  }
+
+  virtual int read() override {
+    if (available() == 0) {
+      return -1;
+    }
+    unsigned char c = _readStream.at(0);
+    _readStream.pop_front();
+    return c;
+  }
 
+  virtual int peek() override {
+    if (available() == 0) {
+      return -1;
+    }
+    return _readStream.at(0);
+  }
 };
 
 #endif /* STREAM_MOCK_H_ */

extras/test/src/RPC/test_RPCClient.cpp

@@ -4,79 +4,63 @@
  * SPDX-License-Identifier: MIT
  */
 
-/**************************************************************************************
- * INCLUDE
- **************************************************************************************/
-
 #include <catch.hpp>
-
 #include <StreamMock.h>
 #include <Arduino_RPClite.h>
 
-/**************************************************************************************
- * TEST CODE
- **************************************************************************************/
-
-TEST_CASE ("Test RPCClient call", "[RPCClient-01]")
-{
-  StreamMock mock;
-
-  WHEN ("'target' is contained in stream")
-  {
-    mock << "This is a test string";
-
-
-    REQUIRE(mock.find("test") == true);
-    REQUIRE(mock.readString() == arduino::String(" string"));
-  }
-  WHEN ("'target' is not contained in stream")
-  {
-    mock << "This is a string";
-
-    REQUIRE(mock.find("test") == false);
-    REQUIRE(mock.readString() == arduino::String(""));
+// MsgPack codes
+#define ARRAY_N(x) (0x90 + (x))
+#define STRING_N(x) (0xA0 + (x))
+#define NIL 0xc0
+#define FLOAT_32 0xcb
+#define CALL_TAG 0x00
+#define RESP_TAG 0x01
+
+#define COMPARE_ARRAYS(expected, got) compareArrays(Catch::getResultCapture().getCurrentTestName(), __LINE__, expected, got, sizeof(expected), sizeof(got))
+template <typename T>
+void compareArrays(const std::string & test, unsigned line, const T *expected, const T *got, size_t expectedSize, size_t gotSize) {
+  INFO("Test case [" << test << "] failed at line " << line); // Reported only if REQUIRE fails
+  INFO("Array size: expected: " << expectedSize << ", got: " << gotSize);
+  REQUIRE(expectedSize == gotSize);
+  for (size_t i = 0; i < expectedSize; ++i) {
+    INFO("Index " << i << ": expected " << static_cast<int>(expected[i]) << ", got " << static_cast<int>(got[i]));
+    REQUIRE(expected[i] == got[i]);
   }
 }
 
-TEST_CASE ("Testing find(const char *target, size_t length)", "[Stream-find-02]")
+TEST_CASE("RPCClient::call", "[RPCClient-01]")
 {
   StreamMock mock;
+  SerialTransport transport(&mock);
+  RPCClient rpc(transport);
 
-  WHEN ("'target' is contained in stream")
+  WHEN("Make an RPC call")
   {
-    mock << "This is a test string";
-
-    /* 'length' should actually be '4' or strlen("test"). I'd rather
-     * think this API should not be exposed at all.
-     */
-    REQUIRE(mock.find("test", 3) == true);
-    REQUIRE(mock.readString() == arduino::String("t string"));
-  }
-  WHEN ("'target' is not contained in stream")
-  {
-    mock << "This is a string";
-
-    REQUIRE(mock.find("test", 3) == false);
-    REQUIRE(mock.readString() == arduino::String(""));
-  }
-}
-
-TEST_CASE ("Testing find(char target)", "[Stream-find-03]")
-{
-  StreamMock mock;
-
-  WHEN ("'target' is contained in stream")
-  {
-    mock << "This is a test string";
-
-    REQUIRE(mock.find('t') == true);
-    REQUIRE(mock.readString() == arduino::String("est string"));
-  }
-  WHEN ("'target' is not contained in stream")
-  {
-    mock << "This is a string";
-
-    REQUIRE(mock.find('!') == false);
-    REQUIRE(mock.readString() == arduino::String(""));
+    const unsigned char response[] = {
+      ARRAY_N(4),
+        RESP_TAG,
+        0,
+        NIL,
+        FLOAT_32, 0x40, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 // 6.0
+    };
+    mock.push_array(response, sizeof(response));
+
+    float result;
+    bool ok = rpc.call("mult", result, 2.0, 3.0);
+    REQUIRE(ok == true);
+    REQUIRE(result == 6.0f);
+    const unsigned char expected[] = {
+      ARRAY_N(4),
+        CALL_TAG,
+        0, // msg_id
+        STRING_N(4), 'm', 'u', 'l', 't',
+        ARRAY_N(2), // args
+          FLOAT_32, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 2.0
+          FLOAT_32, 0x40, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00  // 3.0
+    };
+    REQUIRE(mock.pull_available() == sizeof(expected));
+    unsigned char got[sizeof(expected)];
+    REQUIRE(mock.pull_array(got, sizeof(expected)) == sizeof(expected));
+    COMPARE_ARRAYS(expected, got);
   }
 }