Arduino ci (#1)

* initial arduino-ci
* add unit tests

Author: RobTillaart

.arduino-ci.yml

@@ -0,0 +1,7 @@
+compile:
+  # Choosing to run compilation tests on 2 different Arduino platforms
+  platforms:
+    - uno
+    - leonardo
+    - due
+    - zero

.github/workflows/arduino_test_runner.yml

@@ -0,0 +1,13 @@
+---
+name: Arduino CI
+
+on: [push, pull_request]
+
+jobs:
+  arduino_ci:
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v2
+      - uses: Arduino-CI/action@master
+          #   Arduino-CI/action@v0.1.1

Angle.cpp

@@ -1,14 +1,14 @@
 //
 //    FILE: Angle.cpp
 //  AUTHOR: Rob Tillaart
-// VERSION: 0.1.8
+// VERSION: 0.1.9
 // PURPOSE: library for Angle math for Arduino
 //     URL: https://github.com/RobTillaart/Angle
 //          http://forum.arduino.cc/index.php?topic=339402
 //
-// Released to the public domain
-// 0.1.8    2020-05-27 update library.json
-// 0.1.7    2020-03-26 refactor #pragma once
+// 0.1.9    2020-12-10  Arduino ci
+// 0.1.8    2020-05-27  update library.json
+// 0.1.7    2020-03-26  refactor #pragma once
 // 0.1.06 - fixed bug negative values.
 // 0.1.05 - added AngleFormat proxy added 03/03/15 by Christoper Andrews.
 // 0.1.04 - changed thousands in tenthousands, string constructor

Angle.h

@@ -2,7 +2,7 @@
 //
 //    FILE: Angle.h
 //  AUTHOR: Rob dot Tillaart at gmail dot com
-// VERSION: 0.1.8
+// VERSION: 0.1.9
 // PURPOSE: angle library for Arduino
 // HISTORY: See angle.cpp
 //
@@ -13,7 +13,7 @@
 #include "Arduino.h"
 #include "Printable.h"
 
-#define ANGLE_LIB_VERSION "0.1.8"
+#define ANGLE_LIB_VERSION "0.1.9"
 
 class Angle;
 
@@ -37,10 +37,10 @@ class Angle: public Printable
     Angle(double alpha);
     Angle(char * str);
 
-    int sign()   { return neg?-1:1; };
-    int degree() { return d; };
-    int minute() { return m; };
-    int second() { return s; };
+    int sign()        { return neg ? -1 : 1; };
+    int degree()      { return d; };
+    int minute()      { return m; };
+    int second()      { return s; };
     int tenthousand() { return t; };
 
     size_t printTo(Print& p) const { return printTo( p, T ); }

README.md

@@ -1,6 +1,12 @@
+
+[![Arduino CI](https://github.com/RobTillaart/Angle/workflows/Arduino%20CI/badge.svg)](https://github.com/marketplace/actions/arduino_ci)
+[![License: MIT](https://img.shields.io/badge/license-MIT-green.svg)](https://github.com/RobTillaart/Angle/blob/master/LICENSE)
+[![GitHub release](https://img.shields.io/github/release/RobTillaart/Angle.svg?maxAge=3600)](https://github.com/RobTillaart/Angle/releases)
+
+
 # Angle
 
-Arduino library for basic math for Angles in degrees, minute, seconds
+Arduino library for basic math for Angles in degrees, minute, seconds and tenthousands.
 
 ## Description
 
@@ -9,18 +15,20 @@ in degrees, minutes seconds and tenthousands. The class was created to be
 able to print an angle with minutes and seconds instead of as a floating point
 or radians.
 
-To make the library more useful basic math (+ - \* / ) 
-and comparisons ( == != < <= > >= ) 
-are added to the class.
+To make the library more useful basic math ( + - \* / ) 
+and comparisons ( == != < <= > >= ) are added to the class.
+
+## Interface
+
+There are three constructors
+- **Angle(int dd=0, int mm=0, int ss=0, int tt=0)**
+- **Angle(double alpha)**
+- **Angle(char \* str)**       // str represents a double as string e.g. "45.31234"
 
 ## Operation
 
-There are three constructors 
-* Angle(int dd=0, int mm=0, int ss=0, int tt=0);
-* Angle(double alpha);
-* Angle(char * str);		// str represents a double as string e.g. "45.31234"
+See examples
 
-For other functions and operators check examples for now. 
 
 ## Note
 The library has not been tested extensively and it could still contain

library.json

@@ -20,7 +20,7 @@
     "type": "git",
     "url": "https://github.com/RobTillaart/Angle.git"
   },
-  "version":"0.1.8",
+  "version":"0.1.9",
   "frameworks": "arduino",
   "platforms": "*"
 }

library.properties

@@ -1,5 +1,5 @@
 name=Angle
-version=0.1.8
+version=0.1.9
 author=Rob Tillaart <rob.tillaart@gmail.com>
 maintainer=Rob Tillaart <rob.tillaart@gmail.com>
 sentence=Library to convert between floating point angle to minutes hours representation.

test/unit_test_001.cpp

@@ -0,0 +1,170 @@
+//
+//    FILE: unit_test_001.cpp
+//  AUTHOR: Rob Tillaart
+// VERSION: 0.1.0
+//    DATE: 2020-12-03
+// PURPOSE: unit tests for the Angle library
+//          https://github.com/RobTillaart/Angle
+//          https://github.com/Arduino-CI/arduino_ci/blob/master/REFERENCE.md
+//
+
+// supported assertions
+// ----------------------------
+// assertEqual(expected, actual)
+// assertNotEqual(expected, actual)
+// assertLess(expected, actual)
+// assertMore(expected, actual)
+// assertLessOrEqual(expected, actual)
+// assertMoreOrEqual(expected, actual)
+// assertTrue(actual)
+// assertFalse(actual)
+// assertNull(actual)
+
+#include <ArduinoUnitTests.h>
+
+#include "Arduino.h"
+#include "Angle.h"
+
+
+unittest_setup()
+{
+}
+
+unittest_teardown()
+{
+}
+
+unittest(test_constructors)
+{
+  Angle a(1, 2, 3, 4);
+  Angle b(-45, 30);
+  Angle n(0);
+  Angle d(5.25);
+  Angle s("37.25");
+
+  assertEqual(1, a.sign());
+  assertEqual(1, a.degree());
+  assertEqual(2, a.minute());
+  assertEqual(3, a.second());
+  assertEqual(4, a.tenthousand());
+
+  assertEqual(-1, b.sign());
+  assertEqual(45, b.degree());
+  assertEqual(30, b.minute());
+  assertEqual(0, b.second());
+  assertEqual(0, b.tenthousand());
+
+  assertEqual(1, n.sign());
+  assertEqual(0, n.degree());
+  assertEqual(0, n.minute());
+  assertEqual(0, n.second());
+  assertEqual(0, n.tenthousand());
+
+  assertEqual(1, d.sign());
+  assertEqual(5, d.degree());
+  assertEqual(15, d.minute());
+  assertEqual(0, d.second());
+  assertEqual(0, d.tenthousand());
+
+  assertEqual(1, s.sign());
+  assertEqual(37, s.degree());
+  assertEqual(15, s.minute());
+  assertEqual(0, s.second());
+  assertEqual(0, s.tenthousand());
+}
+
+unittest(test_toDouble)
+{
+  Angle a(1, 2, 3, 4);
+  Angle b(-45, 30);
+  Angle n(0);
+  Angle d(5.25);
+  Angle s("37.25");
+
+  float fa = a.toDouble();
+  float fb = b.toDouble();
+  float fn = n.toDouble();
+  float fd = d.toDouble();
+  float fs = s.toDouble();
+
+  assertMoreOrEqual(2, fa);
+  assertMoreOrEqual(-45, fb);
+  assertEqual(0, fn);
+  assertMoreOrEqual(6, fd);
+  assertMoreOrEqual(38, fs);
+}
+
+unittest(test_Radians)
+{
+  Angle a(1, 2, 3, 4);
+  Angle b(-75, 30);
+  Angle n(0);
+  Angle d(5.25);
+  Angle s("91.25");
+
+  float ra = a.toRadians();
+  float rb = b.toRadians();
+  float rn = n.toRadians();
+  float rd = d.toRadians();
+  float rs = s.toRadians();
+
+  assertMoreOrEqual(1, ra);
+  assertMoreOrEqual(-1, rb);
+  assertEqual(0, rn);
+  assertMoreOrEqual(0.1, rd);
+  assertMoreOrEqual(PI, rs);  
+}
+
+
+// mainly tests if operators still work, not a quality test (yet)
+unittest(test_math)
+{
+  Angle a(1, 2, 3, 4);
+  Angle b(-45, 30);
+  Angle n(0);
+  Angle d(5.25);
+  Angle s("91.25");
+
+  Angle x = a + b - n + d + s;
+  assertNotEqual(0, x.toDouble());
+
+  x *= 2;
+  assertNotEqual(0, x.toDouble());
+  x /= 2;
+  assertNotEqual(0, x.toDouble());
+  x += 2;
+  assertNotEqual(0, x.toDouble());
+  x -= 2;
+  assertNotEqual(0, x.toDouble());
+
+  x = a * 2;
+  assertNotEqual(0, x.toDouble());
+  x = a / 2;
+  assertNotEqual(0, x.toDouble());
+  x = a + 2;
+  assertNotEqual(0, x.toDouble());
+  x = a - 2;
+  assertNotEqual(0, x.toDouble());
+  
+  x = -x;
+  assertNotEqual(0, x.toDouble());
+}
+
+
+unittest(test_compare)
+{
+  Angle a(1, 2, 3, 4);
+  Angle b(-45, 30);
+
+  assertTrue(a == a);
+  assertTrue(a != b);
+  assertTrue(b <= a);
+  assertTrue(b <  a);
+  assertTrue(a >  b);
+  assertTrue(a >= b);
+}
+
+
+unittest_main()
+
+// --------