arduino_ci 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b23f7b008729652fa65a7e3ed99bd86e703d847ccb13b56d8483eb557242633c
-  data.tar.gz: bcb9729486d9326e45cb07b8f3c61311f9fd61290460548c0d6130eb7986a521
+  metadata.gz: 1553aff5cd187c7db5ea325fd2ee878914fae57692d70042f1ceb0a6cd184f18
+  data.tar.gz: 8c948d1eec2967ee364fc2fa983bed1746dc1204089d2ea0f355ab27b0aa97f6
 SHA512:
-  metadata.gz: 047e0f22cfc56a8802817ef49f5bac03c6037b755d4d36651661a7bba0a46590765867233f8c8e488cc414180dee89e385745e788036558a1eff04c1216f90cc
-  data.tar.gz: 962d9c99d23d4bb341663cc1a3b222f3272badbcffdf774c7efce449e930fbafc2be3a55d27e1edabc0d09066bf94575e5d19e1d147355fe60bcf7ede38b46e8
+  metadata.gz: 43bbc201c5d38e8852a71e3a0b4da85400d764fc2e4b248e0fd14f6d79c1111c4bc778aecdc7e49bea8c7c73e4417b28f4ae9d3e5c3ba4814768929bf5ae2c7b
+  data.tar.gz: '069ce22a67dc335c5b1d97bdecc91476bf8f6484740b9acfd063e4c2741db0cfa808c5b5599dce970721f2d808825ebf0297857e88fe7a75bfa2611a4cda23bf'

data/README.md

@@ -1,6 +1,6 @@
 [![Gem Version](https://badge.fury.io/rb/arduino_ci.svg)](https://rubygems.org/gems/arduino_ci)
 [![Build Status](https://travis-ci.org/ifreecarve/arduino_ci.svg)](https://travis-ci.org/ifreecarve/arduino_ci)
-[![Documentation](http://img.shields.io/badge/docs-rdoc.info-blue.svg)](http://www.rubydoc.info/gems/arduino_ci/0.1.4)
+[![Documentation](http://img.shields.io/badge/docs-rdoc.info-blue.svg)](http://www.rubydoc.info/gems/arduino_ci/0.1.5)
 
 # ArduinoCI Ruby gem (`arduino_ci`)
 
@@ -28,6 +28,8 @@ script:
 
 That's literally all there is to it on the repository side.  You'll need to go to https://travis-ci.org/profile/ and enable testing for your Arduino project.  Once that happens, you should be all set.  The script will test all example projects of the library and all unit tests.
 
+> **Note:** `arduino_ci_remote.rb` expects to be run from the root directory of your Arduino project library.
+
 ### Unit tests in `test/`
 
 All `.cpp` files in the `test/` directory of your Arduino library are assumed to contain unit tests.  Each and every one will be compiled and executed on its own.
@@ -61,13 +63,85 @@ unittest(example_godmode_stuff)
   state->resetClock();               //  - you can reset just the clock (to zero)
   state->resetPins();                //  - or just the pins
   state->micros = 1;                 // manually set the clock such that micros() returns 1
-  state->digitalPin[4];              // stores the commanded state of digital pin 4
+  state->digitalPin[4];              // tells you the commanded state of digital pin 4
   state->digitalPin[4] = HIGH;       // digitalRead(4) will now return HIGH
-  state->analogPin[3];               // stores the commanded state of analog pin 3
+  state->analogPin[3];               // tells you the commanded state of analog pin 3
   state->analogPin[3] = 99;          // analogRead(3) will now return 99
 }
 ```
 
+#### Pin Histories
+
+Of course, it's possible that your code might flip the bit more than once in a function.  For that scenario, you may want to examine the history of a pin's commanded outputs:
+
+```C++
+unittest(pin_history)
+{
+  GodmodeState* state = GODMODE();
+  int myPin = 3;
+  state->reset();            // pin will start LOW
+  digitalWrite(myPin, HIGH);
+  digitalWrite(myPin, LOW);
+  digitalWrite(myPin, LOW);
+  digitalWrite(myPin, HIGH);
+  digitalWrite(myPin, HIGH);
+
+  assertEqual(6, state->digitalPin[1].size());
+  bool expected[6] = {LOW, HIGH, LOW, LOW, HIGH, HIGH};
+  bool actual[6];
+
+  // move history queue into an array because at the moment, reading
+  // the history is destructive -- it's a linked-list queue.  this
+  // means that if toArray or hasElements fails, the queue will be in
+  // an unknown state and you should reset it before continuing with
+  // other tests
+  int numMoved = state->digitalPin[myPin].toArray(actual, 6);
+  assertEqual(6, numMoved);
+
+  // verify each element
+  for (int i = 0; i < 6; ++i) {
+    assertEqual(expected[i], actual[i]);
+  }
+```
+
+
+#### Pin Futures
+
+Reading the pin more than once per function is also a possibility.  In that case, we want to queue up a few values for the `digitalRead` or `analogRead` to find.
+
+```C++
+unittest(pin_read_history)
+{
+  GodmodeState* state = GODMODE();
+  state->reset();
+
+  int future[6] = {33, 22, 55, 11, 44, 66};
+  state->analogPin[1].fromArray(future, 6);
+  for (int i = 0; i < 6; ++i)
+  {
+    assertEqual(future[i], analogRead(1));
+  }
+
+  // for digital pins, we have the added possibility of specifying
+  // a stream of input bytes encoded as ASCII
+  bool bigEndian = true;
+  state->digitalPin[1].fromAscii("Yo", bigEndian);
+
+  // digitial history as serial data, big-endian
+  bool expectedBits[16] = {
+    0, 1, 0, 1, 1, 0, 0, 1,  // Y
+    0, 1, 1, 0, 1, 1, 1, 1   // o
+  };
+
+  for (int i = 0; i < 16; ++i) {
+    assertEqual(expectedBits[i], digitalRead(1));
+  }
+}
+```
+
+#### Serial Data
+
+
 A more complicated example: working with serial port IO.  Let's say I have the following function:
 
 ```C++
@@ -125,6 +199,132 @@ unittest(two_flips)
 }
 ```
 
+#### Pin History as ASCII
+
+
+For additional complexity, there are some cases where you want to use a pin as a serial port.  There are history functions for that too.
+
+```C++
+  int myPin = 3;
+
+  // digitial history as serial data, big-endian
+  bool bigEndian = true;
+  bool binaryAscii[24] = {
+    0, 1, 0, 1, 1, 0, 0, 1,  // Y
+    0, 1, 1, 0, 0, 1, 0, 1,  // e
+    0, 1, 1, 1, 0, 0, 1, 1   // s
+  };
+
+  // "send" these bits
+  for (int i = 0; i < 24; digitalWrite(myPin, binaryAscii[i++]));
+
+  // The first bit in the history is the initial value, which we will ignore
+  int offset = 1;
+
+  // We should be able to parse the bits as ascii
+  assertEqual("Yes", state->digitalPin[myPin].toAscii(offset, bigEndian));
+```
+
+Instead of queueing bits as ASCII for future use with `toAscii`, you can send those bits directly (and immediately) to the output using `outgoingFromAscii`.  Likewise, you can reinterpret/examine (as ASCII) the bits you have previously queued up by calling `incomingToAscii` on the PinHistory object.
+
+
+#### Interactivity of "Devices" with Observers
+
+Even pin history and input/output buffers aren't capable of testing interactive code.  For example, queueing the canned responses from a serial device before the requests are even sent to it is not a sane test environment; the library under test will see the entire future waiting for it on the input pin instead of a buffer that fills and empties over time.  This calls for something more complicated.
+
+In this example, we create a simple class to emulate a Hayes modem.  (For more information, dig into the `DataStreamObserver` code on which `DeviceUsingBytes` is based.
+
+```c++
+class FakeHayesModem : public DeviceUsingBytes {
+  public:
+    String mLast;
+
+    FakeHayesModem() : DeviceUsingBytes() {
+      mLast = "";
+      addResponseLine("AT", "OK");
+      addResponseLine("ATV1", "NO CARRIER");
+    }
+    virtual ~FakeHayesModem() {}
+    virtual void onMatchInput(String output) { mLast = output; }
+};
+
+unittest(modem_hardware)
+{
+  GodmodeState* state = GODMODE();
+  state->reset();
+  FakeHayesModem m;
+  m.attach(&Serial);
+
+  Serial.write("AT\n");
+  assertEqual("AT\n", state->serialPort[0].dataOut);
+  assertEqual("OK\n", m.mLast);
+}
+```
+
+Note that instead of setting `mLast = output` in the `onMatchInput()` function for test purposes, we could just as easily queue some bytes to state->serialPort[0].dataIn for the library under test to find on its next `peek()` or `read()`.  Or we could execute some action on a digital or analog input pin; the possibilities are fairly endless in this regard, although you will have to define them yourself -- from scratch -- extending the `DataStreamObserver` class to emulate your physical device.
+
+
+## Overriding default build behavior
+
+You can add `.arduino-ci.yml` files to the project directory (which will then apply to both `test/` and `examples/`), as well as to the `test/` directory and each example directory in `examples/`.  All defined fields can be overridden.
+
+You may define new platforms, or edit existing platform definitions:
+
+```yaml
+platforms:
+  bogo:
+    board: fakeduino:beep:bogo
+    package: potato:salad
+    gcc:
+      features:
+        - omit-frame-pointer  # becomes -fomit-frame-pointer flag
+      defines:
+        - HAVE_THING          # becomes -DHAVE_THING flag
+      warnings:
+        - no-implicit         # becomes -Wno-implicit flag
+      flags:
+        - -foobar             # becomes -foobar flag
+
+  zero: ~                     # undefines the `zero` board completely
+
+  esp8266:                    # redefines the existing esp8266
+    board: esp8266:esp8266:booo
+    package: esp8266:esp8266
+    gcc:
+      features:
+      defines:
+      warnings:
+      flags:
+```
+
+
+For your example programs, you may set external libraries to be installed and included.  You may also choose the platforms on which the compilation will be attempted:
+
+```yaml
+compile:
+  libraries:
+    - "Adafruit FONA Library"
+  platforms:
+    - esp8266
+```
+
+
+For your unit tests, in addition to setting specific libraries and platforms, you may filter the list of test files that are compiled and tested.  This may help speed up targeted testing.
+
+```yaml
+unittest:
+  testfiles:
+    select:
+      - "*-*.*"
+    reject:
+      - "sam-squamsh.*"
+  libraries:
+    - "abc123"
+    - "def456"
+  platforms:
+    - bogo
+```
+
 ## More Documentation
 
 This software is in alpha.  But [SampleProjects/DoSomething](SampleProjects/DoSomething) has a decent writeup and is a good bare-bones example of all the features.
@@ -133,7 +333,6 @@ This software is in alpha.  But [SampleProjects/DoSomething](SampleProjects/DoSo
 
 * The Arduino library is not fully mocked.
 * I don't have preprocessor defines for all the Arduino board flavors
-* Arduino Zero boards don't work in CI.  I'm confused.
 * https://github.com/ifreecarve/arduino_ci/issues
 
 

data/cpp/arduino/Arduino.cpp

@@ -1,23 +1,2 @@
-#include "Arduino.h"
 #include "Godmode.h"
 
-
-void digitalWrite(unsigned char pin, unsigned char val) {
-  GodmodeState* godmode = GODMODE();
-  godmode->digitalPin[pin] = val;
-}
-
-int digitalRead(unsigned char pin) {
-  GodmodeState* godmode = GODMODE();
-  return godmode->digitalPin[pin];
-}
-
-int analogRead(unsigned char pin) {
-  GodmodeState* godmode = GODMODE();
-  return godmode->analogPin[pin];
-}
-
-void analogWrite(unsigned char pin, int val) {
-  GodmodeState* godmode = GODMODE();
-  godmode->analogPin[pin] = val;
-}

data/cpp/arduino/Arduino.h

@@ -57,16 +57,6 @@ typedef unsigned int word;
 
 #define bit(b) (1UL << (b))
 
-// io pins
-#define pinMode(...) _NOP()
-#define analogReference(...) _NOP()
-
-void digitalWrite(uint8_t, uint8_t);
-int digitalRead(uint8_t);
-int analogRead(uint8_t);
-void analogWrite(uint8_t, int);
-#define analogReadResolution(...) _NOP()
-#define analogWriteResolution(...) _NOP()
 
 
 /*

data/cpp/arduino/ArduinoDefines.h

@@ -87,4 +87,3 @@
 #define TIMER5B 17
 #define TIMER5C 18
 
-#include "include/io.h"

data/cpp/arduino/AvrMath.h

@@ -4,6 +4,11 @@
 #define constrain(x,l,h) ((x)<(l)?(l):((x)>(h)?(h):(x)))
 #define map(x,inMin,inMax,outMin,outMax) (((x)-(inMin))*((outMax)-(outMin))/((inMax)-(inMin))+outMin)
 
+#define sq(x) ((x)*(x))
+
+#define radians(deg) ((deg)*DEG_TO_RAD)
+#define degrees(rad) ((rad)*RAD_TO_DEG)
+
 #ifdef abs
 #undef abs
 #endif
@@ -19,9 +24,3 @@
 #endif
 #define min(a,b) ((a)<(b)?(a):(b))
 
-#define sq(x) ((x)*(x))
-
-#define radians(deg) ((deg)*DEG_TO_RAD)
-#define degrees(rad) ((rad)*RAD_TO_DEG)
-
-

data/cpp/arduino/Godmode.cpp

@@ -46,6 +46,27 @@ long random(long vmin, long vmax)
   return vmin < vmax ? (random(vmax - vmin) + vmin) : vmin;
 }
 
+void digitalWrite(unsigned char pin, unsigned char val) {
+  GodmodeState* godmode = GODMODE();
+  godmode->digitalPin[pin] = val;
+}
+
+int digitalRead(unsigned char pin) {
+  GodmodeState* godmode = GODMODE();
+  return godmode->digitalPin[pin].retrieve();
+}
+
+void analogWrite(unsigned char pin, int val) {
+  GodmodeState* godmode = GODMODE();
+  godmode->analogPin[pin] = val;
+}
+
+int analogRead(unsigned char pin) {
+  GodmodeState* godmode = GODMODE();
+  return godmode->analogPin[pin].retrieve();
+}
+
+
 // Serial ports
 #if defined(HAVE_HWSERIAL0)
   HardwareSerial Serial(&godmode.serialPort[0].dataIn, &godmode.serialPort[0].dataOut, &godmode.serialPort[0].readDelayMicros);
@@ -60,3 +81,8 @@ long random(long vmin, long vmax)
   HardwareSerial Serial3(&godmode.serialPort[3].dataIn, &godmode.serialPort[3].dataOut, &godmode.serialPort[3].readDelayMicros);
 #endif
 
+template <typename T>
+inline std::ostream& operator << ( std::ostream& out, const PinHistory<T>& ph ) {
+  out << ph;
+  return out;
+}

data/cpp/arduino/Godmode.h

@@ -1,6 +1,21 @@
 #pragma once
 #include "ArduinoDefines.h"
+#include <avr/io.h>
 #include "WString.h"
+#include "PinHistory.h"
+
+// random
+void randomSeed(unsigned long seed);
+long random(long vmax);
+long random(long vmin, long vmax);
+
+
+// Time
+void delay(unsigned long millis);
+void delayMicroseconds(unsigned long micros);
+unsigned long millis();
+unsigned long micros();
+
 
 #define MOCK_PINS_COUNT 256
 
@@ -16,7 +31,6 @@
   #define NUM_SERIAL_PORTS 0
 #endif
 
-
 class GodmodeState {
   struct PortDef {
     String dataIn;
@@ -28,14 +42,14 @@ class GodmodeState {
     unsigned long micros;
     unsigned long seed;
     // not going to put pinmode here unless its really needed. can't think of why it would be
-    bool digitalPin[MOCK_PINS_COUNT];
-    int analogPin[MOCK_PINS_COUNT];
+    PinHistory<bool> digitalPin[MOCK_PINS_COUNT];
+    PinHistory<int> analogPin[MOCK_PINS_COUNT];
     struct PortDef serialPort[NUM_SERIAL_PORTS];
 
     void resetPins() {
       for (int i = 0; i < MOCK_PINS_COUNT; ++i) {
-        digitalPin[i] = LOW;
-        analogPin[i] = 0;
+        digitalPin[i].reset(LOW);
+        analogPin[i].reset(0);
       }
     }
 
@@ -49,26 +63,34 @@ class GodmodeState {
       seed = 1;
     }
 
-    GodmodeState() {
+    int serialPorts() {
+      return NUM_SERIAL_PORTS;
+    }
+
+    GodmodeState()
+    {
       reset();
-      for (int i = 0; i < NUM_SERIAL_PORTS; ++i) {
-        serialPort[i] = {"", "", 0};
+      for (int i = 0; i < serialPorts(); ++i)
+      {
+        serialPort[i].dataIn = "";
+        serialPort[i].dataOut = "";
+        serialPort[i].readDelayMicros = 0;
       }
-    }
+  }
 
 };
 
-GodmodeState* GODMODE();
+// io pins
+#define pinMode(...) _NOP()
+#define analogReference(...) _NOP()
 
-// random
-void randomSeed(unsigned long seed);
-long random(long vmax);
-long random(long vmin, long vmax);
+void digitalWrite(uint8_t, uint8_t);
+int digitalRead(uint8_t);
+int analogRead(uint8_t);
+void analogWrite(uint8_t, int);
+#define analogReadResolution(...) _NOP()
+#define analogWriteResolution(...) _NOP()
 
 
-// Time
-void delay(unsigned long millis);
-void delayMicroseconds(unsigned long micros);
-unsigned long millis();
-unsigned long micros();
+GodmodeState* GODMODE();