Add mocks for more builtins

CHANGELOG.md

@@ -6,8 +6,21 @@ and this project adheres to [Semantic Versioning](http://semver.org/).
 
 ## [Unreleased]
 ### Added
+- Support for all builtin Math functions https://www.arduino.cc/reference/en/
+- Support for all builtin Bits and Bytes functions https://www.arduino.cc/reference/en/
+- Support for GODMODE and time functions
+- Support for Character functions https://www.arduino.cc/reference/en/
+- Mocks for `random` functions with seed control
+- Many original Arduino `#define`s
+- Mocks for pinMode, analog/digital read/write
+- Support for WString
+- Support for Print
+- Support for Stream (backed by a String implementation)
+- All the IO stuff (pins, serial port support flags, etc) from the Arduino library
+- Support for Serial (backed by GODMODE)
 
 ### Changed
+- Made `wget` have quieter output
 
 ### Deprecated
 

README.md

@@ -49,6 +49,26 @@ unittest_main()
 This test defines one `unittest` (a macro provided by `ArduionUnitTests.h`), called `your_test_name`, which makes some assertions on the target library.  The `unittest_main()` is a macro for the `int main()` boilerplate required for unit testing.
 
 
+### Using `GODMODE`
+
+Complete control of the Arduino environment is available in your unit tests through a construct called `GODMODE()`.
+
+```C++
+unittest(example_godmode_stuff)
+{
+  GodmodeState* state = GODMODE();   // get access to the state
+  state->reset();                    // does a full reset of the state.
+  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] = HIGH;       // digitalRead(4) will now return HIGH
+  state->analogPin[3];               // stores the commanded state of analog pin 3
+  state->analogPin[3] = 99;          // analogRead(3) will now return 99
+}
+```
+
+
 ## 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.

SampleProjects/TestSomething/README.md

@@ -1,3 +1,5 @@
 # TestSomething
 
 This is a "beater" example that is referenced by tests of the Arduino CI module itself.
+
+All the tests of our mocked `Arduino.h` implementation live here.

SampleProjects/TestSomething/test/good-defines.cpp

@@ -0,0 +1,11 @@
+#include <ArduinoUnitTests.h>
+#include <Arduino.h>
+
+unittest(binary)
+{
+  assertEqual(1, B1);
+  assertEqual(10, B1010);
+  assertEqual(100, B1100100);
+}
+
+unittest_main()

SampleProjects/TestSomething/test/good-godmode.cpp

@@ -0,0 +1,68 @@
+#include <ArduinoUnitTests.h>
+#include <Arduino.h>
+
+unittest(millis_micros_and_delay)
+{
+  GodmodeState* state = GODMODE();
+  state->reset();
+  assertEqual(0, millis());
+  assertEqual(0, micros());
+  delay(3);
+  assertEqual(3, millis());
+  assertEqual(3000, micros());
+  delayMicroseconds(11000);
+  assertEqual(14, millis());
+  assertEqual(14000, micros());
+}
+
+unittest(random)
+{
+  randomSeed(1);
+  unsigned long x;
+  x = random(4294967293);
+  assertEqual(4294967292, x);
+  x = random(50, 100);
+  assertEqual(83, x);
+  x = random(100);
+  assertEqual(74, x);
+}
+
+void myInterruptHandler() {
+}
+
+unittest(interrupts)
+{
+  // these are meaningless for testing; just call the routine directly.
+  // make sure our mocks work though
+  attachInterrupt(2, myInterruptHandler, CHANGE);
+  detachInterrupt(2);
+}
+
+unittest(pins)
+{
+  GodmodeState* state = GODMODE();
+  state->reset();
+  pinMode(1, OUTPUT);  // this is a no-op in unit tests.  it's just here to prove compilation
+  digitalWrite(1, HIGH);
+  assertEqual(HIGH, state->digitalPin[1]);
+  digitalWrite(1, LOW);
+  assertEqual(LOW, state->digitalPin[1]);
+
+  pinMode(1, INPUT);
+  state->digitalPin[1] = HIGH;
+  assertEqual(HIGH, digitalRead(1));
+  state->digitalPin[1] = LOW;
+  assertEqual(LOW, digitalRead(1));
+
+  analogWrite(1, 37);
+  assertEqual(37, state->analogPin[1]);
+  analogWrite(1, 22);
+  assertEqual(22, state->analogPin[1]);
+
+  state->analogPin[1] = 99;
+  assertEqual(99, analogRead(1));
+  state->analogPin[1] = 56;
+  assertEqual(56, analogRead(1));
+}
+
+unittest_main()

SampleProjects/TestSomething/test/good-math.cpp

@@ -0,0 +1,69 @@
+#include <ArduinoUnitTests.h>
+#include <Arduino.h>
+
+unittest(abs)
+{
+  assertEqual(1, abs(1));
+  assertEqual(1, abs(-1));
+  assertEqual(1.0, abs(1.0));
+  assertEqual(1.0, abs(-1.0));
+}
+
+unittest(constrain)
+{
+  assertEqual(3, constrain(1, 3, 5));
+  assertEqual(5, constrain(9, 3, 5));
+  assertEqual(2.0, constrain(1, 2.0, 5));
+  assertEqual(6.0, constrain(1.3, 6.0, 9));
+}
+
+unittest(map)
+{
+  assertEqual(30, map(3, 0, 10, 0, 100));
+  assertEqual(30, map(20, 0, 50, 50, 0));
+  assertEqual(-4, map(26, 0, 50, 100, -100));
+}
+
+unittest(max)
+{
+  assertEqual(4, max(3, 4));
+  assertEqual(5, max(3.0, 5));
+  assertEqual(6.0, max(-4, 6.0));
+  assertEqual(7.0, max(5.0, 7.0));
+}
+
+unittest(min)
+{
+  assertEqual(3, min(3, 4));
+  assertEqual(3.0, min(3.0, 5));
+  assertEqual(-4, min(-4, 6.0));
+  assertEqual(5.0, min(5.0, 7.0));
+}
+
+unittest(pow)
+{
+  assertEqual(4.0, pow(2, 2));
+  assertEqual(4.0, pow(2.0, 2.0));
+  assertEqual(0.125, pow(2, -3));
+  assertLess(1.41420, pow(2, 0.5));
+  assertMore(1.41422, pow(2, 0.5));
+}
+
+unittest(sq)
+{
+  assertEqual(9, sq(3));
+  assertEqual(9.0, sq(3.0));
+  assertEqual(9, sq(-3));
+  assertEqual(9.0, sq(-3.0));
+  assertEqual(0.25, sq(0.5));
+  assertEqual(0.25, sq(-0.5));
+}
+
+unittest(sqrt)
+{
+  assertEqual(3, sqrt(9));
+  assertEqual(3.0, sqrt(9.0));
+}
+
+
+unittest_main()

SampleProjects/TestSomething/test/good-stream.cpp

@@ -0,0 +1,72 @@
+#include <ArduinoUnitTests.h>
+#include <Arduino.h>
+
+unittest(stream_construction)
+{
+  String data = "";
+  unsigned long micros = 100;
+
+  Stream s;
+  s.mGodmodeDataIn = &data;
+  s.mGodmodeMicrosDelay = &micros;
+
+  assertEqual(0, s.available());
+  data = "abcd";
+  assertEqual(4, s.available());
+  assertEqual('a', s.peek());
+  assertEqual('a', s.read());
+  assertEqual("bcd", s.readString());
+  assertEqual("", s.readString());
+
+}
+
+
+unittest(stream_find)
+{
+  String data = "";
+  unsigned long micros = 100;
+
+  Stream s;
+  s.mGodmodeDataIn = &data;
+  s.mGodmodeMicrosDelay = &micros;
+
+  data = "abcdefghijkl";
+  assertEqual('a', s.peek());
+  assertEqual(true, s.find('f'));
+  assertEqual('f', s.peek());
+  assertEqual("fghijkl", s.readString());
+  data = "fghijkl";
+  assertEqual(false, s.findUntil("k", "j"));
+  assertEqual('j', s.peek());
+}
+
+unittest(stream_parse)
+{
+  String data = "";
+  unsigned long micros = 100;
+
+  Stream s;
+  s.mGodmodeDataIn = &data;
+  s.mGodmodeMicrosDelay = &micros;
+
+  long l;
+  float f;
+  data = "abcdefghijkl-123-456abcd";
+  l = s.parseInt();
+  assertEqual(-123, l);
+  assertEqual('-', data[0]);
+  l = s.parseInt();
+  assertEqual(-456, l);
+  l = s.parseInt();
+  assertEqual(0, l);
+
+  data = "abc123.456-345.322";
+  f = s.parseFloat();
+  assertLess(123.456 - f, 0.0001);
+  assertEqual('-', data[0]);
+  f = s.parseFloat();
+  assertLess(-345.322 - f, 0.0001);
+
+}
+
+unittest_main()

SampleProjects/TestSomething/test/good-trig.cpp

@@ -0,0 +1,23 @@
+#include <ArduinoUnitTests.h>
+#include <Arduino.h>
+
+unittest(floor)
+{
+  assertEqual(1, floor(1.9));
+  assertEqual(1, floor(1));
+  assertEqual(1, floor(1.0));
+  assertEqual(1, floor(1.9999999));
+}
+
+unittest(cos)
+{
+  assertEqual(1.0, cos(0));
+  assertLess(-0.01, cos(3.141 / 2));
+  assertMore(0.01, cos(3.141 / 2));
+  assertMore(-0.99, cos(PI));
+  assertLess(-1.01, cos(PI));
+  assertLess(-0.01, cos(radians(90)));
+  assertMore(0.01, cos(radians(90)));
+}
+
+unittest_main()

SampleProjects/TestSomething/test/good-wcharacter.cpp

@@ -0,0 +1,93 @@
+#include <ArduinoUnitTests.h>
+#include <Arduino.h>
+
+unittest(isAlpha)
+{
+  assertTrue(isAlpha('a'));
+  assertFalse(isAlpha('3'));
+}
+
+unittest(isAlphaNumeric)
+{
+  assertTrue(isAlphaNumeric('a'));
+  assertTrue(isAlphaNumeric('3'));
+  assertFalse(isAlphaNumeric('!'));
+}
+
+unittest(isAscii)
+{
+  assertTrue(isAscii('a'));
+  assertTrue(isAscii('3'));
+  assertTrue(isAscii('!'));
+  assertFalse(isAlpha((int)0xAF));
+}
+
+unittest(isControl)
+{
+  assertFalse(isControl(' '));
+  assertTrue(isControl((int)0x03));
+}
+
+unittest(isDigit)
+{
+  assertFalse(isDigit(' '));
+  assertTrue(isDigit('2'));
+}
+
+unittest(isGraph)
+{
+  assertFalse(isGraph(' '));
+  assertTrue(isGraph('2'));
+}
+
+unittest(isHexadecimalDigit)
+{
+  assertTrue(isHexadecimalDigit('0'));
+  assertTrue(isHexadecimalDigit('a'));
+  assertTrue(isHexadecimalDigit('A'));
+  assertFalse(isHexadecimalDigit('G'));
+  assertFalse(isHexadecimalDigit('!'));
+}
+
+unittest(isLowerCase)
+{
+  assertFalse(isLowerCase('A'));
+  assertTrue(isLowerCase('a'));
+}
+
+unittest(isPrintable)
+{
+  assertFalse(isPrintable((int)0x03));
+  assertTrue(isPrintable('a'));
+}
+
+unittest(isPunct)
+{
+  assertFalse(isPunct('a'));
+  assertTrue(isPunct('!'));
+}
+
+unittest(isSpace)
+{
+  assertFalse(isSpace('a'));
+  assertTrue(isSpace(' '));
+}
+
+unittest(isUpperCase)
+{
+  assertFalse(isUpperCase('a'));
+  assertTrue(isUpperCase('A'));
+}
+
+unittest(isWhitespace)
+{
+  assertTrue(isWhitespace(' '));
+  assertTrue(isWhitespace('\r'));
+  assertTrue(isWhitespace('\f'));
+  assertTrue(isWhitespace('\t'));
+  assertTrue(isWhitespace('\v'));
+  assertTrue(isWhitespace('\n'));
+  assertFalse(isWhitespace('j'));
+}
+
+unittest_main()