Add timestamping to MockEventQueue

Author: ianfixes

CHANGELOG.md

@@ -12,6 +12,8 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 ### Changed
 * Shortened `ArduinoQueue` push and pop operations
 * `ci/Queue.h` is now `MockEventQueue.h`, with timing data
+* `MockEventQueue::Node` now contains struct `MockEvenntQueue::Event`, which contains both the templated type `T` and a field for a timestamp.
+* Construction of `MockEventQueue` now includes a constructor argument for the time-fetching function
 
 ### Deprecated
 

SampleProjects/TestSomething/test/fibonacciClock.h

@@ -0,0 +1,17 @@
+#pragma once
+
+// fibbonacci clock
+unsigned long lastFakeMicros = 1;
+unsigned long fakeMicros = 0;
+
+void resetFibClock() {
+  lastFakeMicros = 1;
+  fakeMicros = 0;
+}
+
+unsigned long fibMicros() {
+  unsigned long ret = lastFakeMicros + fakeMicros;
+  lastFakeMicros = fakeMicros;
+  fakeMicros = ret;
+  return ret;
+}

SampleProjects/TestSomething/test/queue.cpp

@@ -1,5 +1,6 @@
 #include <ArduinoUnitTests.h>
 #include <MockEventQueue.h>
+#include "fibonacciClock.h"
 
 unittest(basic_queue_dequeue_and_size)
 {
@@ -11,13 +12,14 @@ unittest(basic_queue_dequeue_and_size)
   for (int i = 0; i < 5; ++i) {
     assertEqual(i, q.size());
     q.push(data[i]);
-    assertEqual(data[i], q.back());
+    assertEqual(data[i], q.backData());
+    assertEqual(0, q.backTime()); // we didn't provide a function, so it should default to 0
     assertEqual(i + 1, q.size());
   }
 
   for (int i = 0; i < 5; ++i) {
     assertEqual(5 - i, q.size());
-    assertEqual(data[i], q.front());
+    assertEqual(data[i], q.frontData());
     q.pop();
     assertEqual(5 - i - 1, q.size());
   }
@@ -35,14 +37,14 @@ unittest(copy_constructor)
 
   for (int i = 0; i < 5; ++i) {
     assertEqual(5 - i, q2.size());
-    assertEqual(data[i], q2.front());
+    assertEqual(data[i], q2.frontData());
     q2.pop();
     assertEqual(5 - i - 1, q2.size());
   }
 
   for (int i = 0; i < 5; ++i) {
     assertEqual(5 - i, q.size());
-    assertEqual(data[i], q.front());
+    assertEqual(data[i], q.frontData());
     q.pop();
     assertEqual(5 - i - 1, q.size());
   }
@@ -64,4 +66,54 @@ unittest(boundaries)
 
 }
 
+unittest(timed_events)
+{
+  MockEventQueue<int> q;
+  int data[7] = {4, 50, 600, 8555, 9000, 9001, 1000000000};
+  for (int i = 0; i < 7; ++i) {
+    q.push(data[i], data[i]);
+    assertEqual(data[i], q.backData());
+    assertEqual(data[i], q.backTime());
+  }
+
+  for (int i = 0; i < 7; ++i) {
+    assertEqual(data[i], q.frontData());
+    assertEqual(data[i], q.frontTime());
+    q.pop();
+  }
+
+}
+
+unittest(my_fib)
+{
+  resetFibClock();
+  assertEqual(1, fibMicros());
+  assertEqual(1, fibMicros());
+  assertEqual(2, fibMicros());
+  assertEqual(3, fibMicros());
+  assertEqual(5, fibMicros());
+  assertEqual(8, fibMicros());
+  assertEqual(13, fibMicros());
+  assertEqual(21, fibMicros());
+}
+
+unittest(clocked_events)
+{
+  resetFibClock();
+  MockEventQueue<int> q(fibMicros);
+  int data[7] = {1, 1, 2, 3, 5, 8, 13}; //eureka
+  for (int i = 0; i < 7; ++i) {
+    q.push(data[i]);
+    assertEqual(data[i], q.backData());
+    assertEqual(data[i], q.backTime());
+  }
+
+  for (int i = 0; i < 7; ++i) {
+    assertEqual(data[i], q.frontData());
+    assertEqual(data[i], q.frontTime());
+    q.pop();
+  }
+
+}
+
 unittest_main()

cpp/arduino/MockEventQueue.h

@@ -2,55 +2,81 @@
 
 template <typename T>
 class MockEventQueue {
-  private:
+  public:
     struct Event {
       T data;
       unsigned long micros;
-      Event* next;
+
+      Event(const T &d, unsigned long const t) : data(d), micros(t) { }
+    };
+
+  private:
+    struct Node {
+      Event event;
+      Node* next;
+
+      Node(const Event &e, Node* n) : event(e), next(n) { }
     };
 
-    Event* mFront;
-    Event* mBack;
+    Node* mFront;
+    Node* mBack;
     unsigned long mSize;
     T mNil;
+    unsigned long (*mGetMicros)(void);
 
-    void init() {
+    void init(unsigned long (*getMicros)(void)) {
       mFront = mBack = nullptr;
       mSize = 0;
+      mGetMicros = getMicros;
     }
 
   public:
-    MockEventQueue(): mNil() { init(); }
+    MockEventQueue(unsigned long (*getMicros)(void)): mNil() { init(getMicros); }
+    MockEventQueue(): mNil() { init(nullptr); }
 
     MockEventQueue(const MockEventQueue<T>& q) {
-      init();
-      for (Event* n = q.mFront; n; n = n->next) push(n->data);
+      init(q.mGetMicros);
+      for (Node* n = q.mFront; n; n = n->next) push(n->event);
     }
 
+    void setMicrosRetriever(unsigned long (*getMicros)(void)) { mGetMicros = getMicros; }
+
     inline unsigned long size() const { return mSize; }
     inline bool empty() const { return 0 == mSize; }
-    T front() const { return empty() ? mNil : mFront->data; }
-    T back() const { return empty() ? mNil : mBack->data; }
+    inline Event front() const { return empty() ? Event(mNil, 0) : mFront->event; }
+    inline Event back() const { return empty() ?  Event(mNil, 0) : mBack->event; }
+    inline T frontData() const { return front().data; }
+    inline T backData() const { return back().data; }
+    inline unsigned long frontTime() const { return front().micros; }
+    inline unsigned long backTime() const { return back().micros; }
+
 
-    bool pushEvent(const T& v, unsigned long const time)
-    {
-      Event *n = new Event;
+    // fully formed event
+    bool push(const Event& e) {
+      Node *n = new Node(e, nullptr);
       if (n == nullptr) return false;
-      n->data = v;
-      n->micros = time;
-      n->next = nullptr;
       mBack = (mFront == nullptr ? mFront : mBack->next) = n;
       return ++mSize;
     }
 
-    bool push(const T& v); // need to use GODMODE here, so defined in Godmode.h
+    // fully specfied event
+    bool push(const T& v, unsigned long const time) {
+      Event e = {v, time};
+      return push(e);
+    }
+
+    // event needing timestamp
+    bool push(const T& v) {
+      unsigned long micros = mGetMicros == nullptr ? 0 : mGetMicros();
+      return push(v, micros);
+    }
 
     void pop() {
       if (empty()) return;
-      Event* n = mFront;
+      Node* n = mFront;
       mFront = mFront->next;
       delete n;
-      if (--mSize) mBack = nullptr;
+      if (--mSize == 0) mBack = nullptr;
     }
 
     void clear() { while (!empty()) pop(); }

cpp/arduino/PinHistory.h

@@ -23,7 +23,7 @@ class PinHistory : public ObservableDataStream {
           int shift = bigEndian ? 7 - i : i;
           unsigned char mask = (0x01 << shift);
           q.push(mask & input[j]);
-          if (advertise) advertiseBit(q.back()); // not valid for all possible types but whatever
+          if (advertise) advertiseBit(q.backData()); // not valid for all possible types but whatever
         }
       }
     }
@@ -48,7 +48,7 @@ class PinHistory : public ObservableDataStream {
         unsigned char acc = 0x00;
         for (int i = 0; i < 8; ++i) {
           int shift = bigEndian ? 7 - i : i;
-          T val = q2.front();
+          T val = q2.frontData();
           unsigned char bit = val ? 0x1 : 0x0;
           acc |= (bit << shift);
           q2.pop();
@@ -79,8 +79,8 @@ class PinHistory : public ObservableDataStream {
 
     // This returns the "value" of the pin in a raw sense
     operator T() const {
-      if (!qIn.empty()) return qIn.front();
-      return qOut.back();
+      if (!qIn.empty()) return qIn.frontData();
+      return qOut.backData();
     }
 
     // this sets the value of the pin authoritatively
@@ -89,23 +89,23 @@ class PinHistory : public ObservableDataStream {
     T operator=(const T& i) {
       qIn.clear();
       qOut.push(i);
-      advertiseBit(qOut.back()); // not valid for all possible types but whatever
-      return qOut.back();
+      advertiseBit(qOut.backData()); // not valid for all possible types but whatever
+      return qOut.backData();
     }
 
     // This returns the "value" of the pin according to the queued values
     // if there is input, advance it to the output.
     // then take the latest output.
     T retrieve() {
       if (!qIn.empty()) {
-        T hack_required_by_travis_ci = qIn.front();
+        T hack_required_by_travis_ci = qIn.frontData();
         qIn.pop();
         qOut.push(hack_required_by_travis_ci);
       }
-      return qOut.back();
+      return qOut.backData();
     }
 
-    // enqueue a set of elements
+    // enqueue a set of data elements
     void fromArray(T const * const arr, unsigned int length) {
       for (int i = 0; i < length; ++i) qIn.push(arr[i]);
     }
@@ -124,34 +124,34 @@ class PinHistory : public ObservableDataStream {
     // start from offset, consider endianness
     String incomingToAscii(bool bigEndian) const { return incomingToAscii(asciiEncodingOffsetIn, bigEndian); }
 
-    // convert the pin history to a string as if it was Serial comms
+    // convert the pin history data to a string as if it was Serial comms
     // start from offset, consider endianness
     String toAscii(unsigned int offset, bool bigEndian) const { return q2a(qOut, offset, bigEndian); }
 
-    // convert the pin history to a string as if it was Serial comms
+    // convert the pin history data to a string as if it was Serial comms
     // start from offset, consider endianness
     String toAscii(bool bigEndian) const { return toAscii(asciiEncodingOffsetOut, bigEndian); }
 
-    // copy elements to an array, up to a given length
+    // copy data elements to an array, up to a given length
     // return the number of elements moved
     int toArray (T* arr, unsigned int length) const {
       MockEventQueue<T> q2(qOut);
 
       int ret = 0;
       for (int i = 0; i < length && q2.size(); ++i) {
-        arr[i] = q2.front();
+        arr[i] = q2.frontData();
         q2.pop();
         ++ret;
       }
       return ret;
     }
 
-    // see if the array matches the elements in the queue
+    // see if the array matches the data of the elements in the queue
     bool hasElements (T const * const arr, unsigned int length) const {
       int i;
       MockEventQueue<T> q2(qOut);
       for (i = 0; i < length && q2.size(); ++i) {
-        if (q2.front() != arr[i]) return false;
+        if (q2.frontData() != arr[i]) return false;
         q2.pop();
       }
       return i == length;