mcci-catena · terrillmoore · May 1, 2018 · May 1, 2018 · May 2, 2018 · May 2, 2018
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -2,49 +2,60 @@
 
 ## 2.0.0
 
-* Rewrite
+	* Rewrite
 
 ## 2.1
 
-* Updated documentation
-* Tests for FakeStreamBuffer
-* Support for Arduino Due
-* Support for Flash Strings (avoid namespace collision with Arduino String)
-* Reset of FakeStream
+	* Updated documentation
+	* Tests for FakeStreamBuffer
+	* Support for Arduino Due
+	* Support for Flash Strings (avoid namespace collision with Arduino String)
+	* Reset of FakeStream
 
 ## 2.1.1
 
-* Support for Arduino Due (adjust examples)
-* Add library.properties file
+	* Support for Arduino Due (adjust examples)
+	* Add library.properties file
 
 ## 2.2.0
 
-* Move to Arduino 1.5 compliant library directory structure
-* Move utility to ArduinoUnitUtility to avoid conflict with other libraries
-* Adjust firmware test to explain basic usage
-* Support for comparing various string types in (#iss47)
-* Add Compare.h and mkCompare in meta for comparing strings
+	* Move to Arduino 1.5 compliant library directory structure
+	* Move utility to ArduinoUnitUtility to avoid conflict with other libraries
+	* Adjust firmware test to explain basic usage
+	* Support for comparing various string types in (#iss47)
+	* Add Compare.h and mkCompare in meta for comparing strings
 
 ## 2.3.0
 
-* Remove support of very old gcc compiler
-* Add support for de-duplicaton of flash strings
-* Add support for ESP 8266 and ESP 32
-* Use more standard file names (README.md, LICENSE, and CHANGELOG.md)
-* Use less likely to fail version of `while (!Serial) {}` in examples and documentation.
-* Make Test::TestString ArduinoUnitString, and refactor Compare to leverage that code.
-* Add an optional lazy message last argument to every assert.
-* Add building outside of arduino environment
-* Significant reduction of code implementation and compiled size (Compare.h is now small)
-* Add minimal mock builds on dev (in vitro) platform
-* Add better mock builds.
-* Use type widening to reduce specializations.
-* Depricate FakeStream for MockStream and MockPrint
-* Resolve a<b equivalence regresion (issue 77)
-* Resolve builds for ESP8266/ESP32
-* Prefer `decltype` over `__typeof__`
-* Added a guidebook
-* assertNear(a,b,max[,message]) for float/double
-* assertRelation(args [,message [,retval]])
-* assertRelativelyNear(a,b,max[,message]) for float/double
-
+	* Remove support of very old gcc compiler
+	* Add support for de-duplicaton of flash strings
+	* Add support for ESP 8266 and ESP 32
+	* Use more standard file names (README.md, LICENSE, and CHANGELOG.md)
+	* Use less likely to fail version of `while (!Serial) {}` in examples and documentation.
+	* Make Test::TestString ArduinoUnitString, and refactor Compare to leverage that code.
+	* Add an optional lazy message last argument to every assert.
+	* Add building outside of arduino environment
+	* Significant reduction of code implementation and compiled size (Compare.h is now small)
+	* Add minimal mock builds on dev (in vitro) platform
+	* Add better mock builds.
+	* Use type widening to reduce specializations.
+	* Depricate FakeStream for MockStream and MockPrint
+	* Resolve a<b equivalence regresion (issue 77)
+	* Resolve builds for ESP8266/ESP32
+	* Prefer `decltype` over `__typeof__`
+	* Added a guidebook
+	* assertNear(a,b,max[,message]) for float/double
+	* assertRelation(args [,message [,retval]])
+	* assertRelativelyNear(a,b,max[,message]) for float/double
+	* Test::abort() to complete all unresolved tests
+	* Provide "en vitro" simple example & build scripts
+## 3.0.0
+	* Provide preliminary Continuous Integration Testing support (ci)
+## 3.0.2
+	* Data deduplication bug fix patch.
+## 3.0.3
+        * Support for Teensy (#87)
+## 3.0.4
+	* Skipped message bug fixed (#86)
+	* Debug (alpha) documented for simavr/avr-gdb (ci.md)
+
diff --git a/Makefile b/Makefile
@@ -1,7 +1,7 @@
 UNAME := $(shell uname)
 
 ifeq ($(UNAME), Linux)
-  ARDUINO_DIR=/usr/share/arduino
+  ARDUINO_DIR=$(HOME)/Arduino
 endif
 ifeq ($(UNAME), Darwin)
   ARDUINO_DIR=$(HOME)/Documents/Arduino

diff --git a/README.md b/README.md
@@ -62,8 +62,8 @@ The following asserts are supported [with an optional footnote and return value]
 | Assertion | Description |
 | --- | --- |
 | `assertEqual(a,b [,footnote [,retval]])` | `a == b`? |
-| `assertNear(a,b,maxerr, [,footnote[,retval]])` | `|b-a|<=maxerr`? |
-| `assertRelativelyNear(a,b,maxerr, [,footnote[,retval]])` | `|b-a|/(½(|a|+|b|))<=maxerr`? |
+| `assertNear(a,b,maxerr, [,footnote[,retval]])` | `abs(b-a)<=maxerr`? |
+| `assertRelativelyNear(a,b,maxerr, [,footnote[,retval]])` | `abs(b-a)/abs(½(abs(a)+abs(b)))<=maxerr`? |
 | `assertNotEqual(a,b [,footnote[,retval]])` | `a != b`? |
 | `assertLess(a,b [,footnote[,retval]])` | `a < b`? |
 | `assertLessOrEqual(a,b [,footnote[,retval]])` | `a <= b`? |
@@ -137,6 +137,55 @@ void setup()
 }
 ```
 
+## Re-running tests (advanced)
+Typically, you just want to run all tests once and then show the result.
+If so, you can skip this section.
+
+In more advanced situations, you might want to run the entire test suite
+multiple times (for example if your tests can be configured with
+different parameters). To facilitate this, you can use the
+`Test::resetDoneTests()` function.
+
+Calling this function will reset all completed tests (passed, failed or
+skipped) back to their initial state. For tests that define a `setup`
+method, this will be run again on the next `Test::run()`. If any tests
+were not completed yet, these are unaffected. The statistics (number of
+passed, failed and skipped tests) are also reset to 0.
+
+Note that excluded tests (using `Test::exclude()`) are treated as
+skipped tests, so these are also re-run (you will need to call
+`Test::exclude()` again after `resetDoneTests()` if you want keep these
+tests excluded). Tests removed with their `remove()` method are really
+removed, so not re-run when using `resetDoneTests()`.
+
+Typically, you would use this after all tests are completed (but if you
+call `resetDoneTests()` when some tests are still pending, those
+tests are unaffected). You must never call `resetDoneTests()` from
+inside a test, only between calls to `Test::run()`.
+
+Below is an example that runs all tests once, then changes a global
+variable and runs all tests again. To have a bit more direct control
+over running the tests, this example does not call `Test::run()`
+infinitely in the `loop()`, but instead uses `Test:runUntilDone()` which
+repeatedly calls `Test::run()` until all tests are completed.
+
+```
+bool some_global_setting = false;
+
+void setup() {
+  Serial.begin(9600);
+  while(!Serial) {} // Portability for Leonardo/Micro
+
+  Test::runUntilDone();
+
+  some_global_setting = true;
+  Test::resetDoneTests();
+  Test::runUntilDone();
+}
+
+void loop() { }
+```
+
 # Output
 
 The `Test::out` value is the *shared* value for all tests describing where output for all tests goes.  The default is 

diff --git a/bin/compile-avr b/bin/compile-avr
diff --git a/bin/compile-lib-avr b/bin/compile-lib-avr
@@ -8,6 +8,9 @@ compile() {
         echo "compile time error: avr."
         exit 1
     fi
+
+    cp "${ARDUINO_TARGET_HEX}" "${ARDUINO_TARGET_INO%.ino}.hex"
+
     if [ "${ARDUINO_TARGET_UPLOAD}" = "true" -a -e "${ARDUINO_TARGET_PORT}" ] ; then
         if ! ${ARDUINO_DIR}/hardware/tools/avr/bin/avrdude -C${ARDUINO_DIR}/hardware/tools/avr/etc/avrdude.conf -v -p${ARDUINO_TARGET_BOARD##*cpu=} -cwiring -P"${ARDUINO_TARGET_PORT}" -b${ARDUINO_TARGET_BAUD} -D -Uflash:w:"${ARDUINO_TARGET_HEX}":i
         then

diff --git a/ci.md b/ci.md
@@ -0,0 +1,140 @@
+# CI - Continuous Integration
+
+This is preliminary support for continuous integration.  These have been tested in Linux (Ubuntu 16.04) and Mac OSX.  These are tool agnostic: you can run them by hand, as part of a commit hook (no server), or using a continuous integration service like Travis CI or Jenkins.  They also support en vitro, simulator, and en vivo tests.
+
+## Install
+
+There really is nothing to install.  The CI tools are bash scripts that can be run from anywhere.  They maintain a set of IDE's under the $HOME/.arduino directory so you can test your project with different versions of the IDE and different installed libraries.
+
+### Prerequisites
+
+#### macosx
+
+On a OS X, you will have to install the XCode command line tools and homebrew:
+
+```bash
+if ! which git ; then xcode-select --install ; fi # xcode cli
+if ! which brew ; then /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)" ; fi # homebrew
+```
+
+#### linux
+
+In linux, you need git make g++ unzip and curl:
+
+```bash
+sudo apt install -y git make g++ unzip curl
+```
+
+#### windows
+
+Install Windows Subsystem for Linux, then Ubuntu under WSL, then follow the linux instructions in a WSL/Ubuntu terminal.  I think.
+
+This has not been tested in windows.  I believe using the Windows Subsystem for Linux and installing Ubuntu 16.04 would be a path to success [WSL](https://devtidbits.com/2017/06/08/run-ubuntu-16-04-on-windows-10-creators-update/), although some tweaks may be necessary.  __All commands are assumed to be running from a bash shell.___
+
+### Setup
+
+Copy the arduinounit (or at least the ci sub-folder) and its contents to clone this repository in your projects folder, as in:
+
+```bash
+# the directory is where you keep your projects...
+mkdir -p "$HOME/projects"
+cd "$HOME/projects"
+git clone https://github.com/mmurdoch/arduinounit.git
+```
+
+To make the tools easier to use, you can define the `au` bash function by sourcing `au` in the `ci` directory (notice the dot with a space):
+
+```bash
+. "$HOME/projects/arduinounit/ci/au"
+
+```
+
+You can put this in your `.profile` if you like, so it is set every time you log in.  
+
+To test (you may have to log out and log back in), try:
+
+```bash
+au dir
+au dir_cache
+au arduino_dir
+au sketchbook
+au arduino --pref update.check=false --install-library ArduinoUnit
+```
+
+In the `examples/basic` arduinounit folder, try,
+
+```bash
+au compile_uno
+au simavr_uno
+```
+
+If you want to see the output in junit format (you really don't, but Jenkins, TravisCI and similar CI tools do), try
+
+```bash
+au simavr_uno | au au2ju
+```
+
+In the vitro example, you can run tests 3 different ways: on the hardware, on the simulator, or on the dev system:
+
+```bash
+au compile_vitro
+./vitro 
+./vitro | au au2ju
+au compile_uno
+au simavr_uno --hex=vitro.hex
+au upload_uno
+```
+
+You may have to specify --port=[port] to upload, assuming an UNO board is connected.
+
+These all take `--os=(macosx|linux64|linux32|linuxarm|windows)` and `--version=(arduino_ide_version)` options.
+
+### Important
+
+The CI tools do NOT use the standard install location for arduino.  This is because tool configuration tests [checking if your project builds with certain version of the IDE or dependent librarie(s)] would be very inconvenient if that required the removal and installation of your standard arduino environment.  Instead the IDE and simavr tools are cached in a directory structure:
+
+```bash
+${HOME}/.arduino/
+  cache/
+    arduino-${VERSION}-${OS}(.zip|.tar.xz)
+    arduino-${VERSION}-${OS}(.zip|.tar.xz).sha512sum.txt
+    simavr/
+      ... git clone https://github.com/buserror/simavr .
+    ${VERSION}-${OS}/
+      ...
+  portable/
+    sketchbook/
+      libraries/
+```
+
+The CI tools install the IDE in "portable" mode so they do not use or modify your default IDE. When making a "clean install test", do NOT delete the zip/tar files in the cache.  These are checked against the very secure sha512 (and will be re-downloaded if they checksum fails).  Downloading these again is very slow and a waste of bandwidth.
+
+A clean (except the ide cache which is pointless and slow) install can be started with:
+
+```bash
+au reset
+```
+
+## debug
+
+*Warning* this is a hack.  But stepping through code is amazingly useful.  I have only worked out steps on Ubuntu 18.04, and depends on the simavr tool, which gives no uart output.  Still it is better than nothing.
+
+1. Install simavr (sudo apt install simavr).  This should also install avr-gcc.
+1. Install this toolset in in Ubunutu: run `au arduino` to spin up the basic working cache of the ide.
+1. Create and set the TMP environment variable so the system does not build and erase a temporary file.  I used "<project>/tmpdir" and made that folder.
+1. Compile the project with `au compile_avr` in the project directory.  The build residue should be in TMP.
+1. Look in the TMP directory, and find the build folder.
+1. Open two terminals here; one to run the program and one to debug from.
+1. In your run terminal, type
+```bash
+simavr -g -m atmega328p -f 16000000 basic.ino.elf
+```
+1. In your debug terminal, type `avr-gdb` to start the avr debugger, then in th prompts type
+```bash
+tui enable
+file basic.ino.elf
+target remote :1234
+b setup
+c
+s
+```
diff --git a/ci/au b/ci/au
@@ -0,0 +1,9 @@
+# find directory of this sourced context
+
+pushd $(dirname "${BASH_SOURCE[0]}") >/dev/null
+arduinounit_ci_bin="$PWD/bin"
+popd >/dev/null
+
+eval 'au() { local cmd="$1"; shift; "'"$arduinounit_ci_bin"'/$cmd" "$@"; }; export -f au;'
+
+