tests moved to IoAbstraction SimpleTest

Author: dave

tests/taskMgrTests/ESPMultiThreadedTest.cpp

@@ -1,9 +1,9 @@
 
-#include <AUnit.h>
+#include <testing/SimpleTest.h>
 #include <TaskManagerIO.h>
 #include "test_utils.h"
 
-using namespace aunit;
+using namespace SimpleTest;
 
 int counts[6];
 
@@ -41,7 +41,7 @@ void testCall5() {
 // schedules, this is the most important test to pass in the whole suite.
 //
 
-class HighThroughputFixture : public TestOnce {
+class HighThroughputFixture : public UnitTestExecutor {
 public:
     /**
      * This method checks that taskmanager tasks are in proper and stable order. And that only running tasks
@@ -103,12 +103,12 @@ testF(HighThroughputFixture, taskManagerHighThroughputTest) {
 
     Serial.print("Dumping threads"); Serial.println(taskManager.checkAvailableSlots(slotData, sizeof slotData));
 
-    assertEqual(counts[5], 10); 	// should be 10 runs as it's manually repeating
-    assertMore(counts[1], 140);		// should be at least 140 runs, scheduled every 100 millis,
-    assertMore(counts[3], 14);		// should be at least 14 runs, as this test lasts about 20 seconds.
-    assertMore(counts[0], 1400);	// should be at least 1400 runs it's scheduled every 10 millis
-    assertEqual(counts[4], 1); 		// should have been triggered once
-    assertNotEqual(counts[2], 0); 	// meaningless to count micros calls. check it happened
+    assertEquals(10, counts[5]); 	// should be 10 runs as it's manually repeating
+    assertMoreThan(140, counts[1]);		// should be at least 140 runs, scheduled every 100 millis,
+    assertMoreThan(14, counts[3]);		// should be at least 14 runs, as this test lasts about 20 seconds.
+    assertMoreThan(1400, counts[0]);	// should be at least 1400 runs it's scheduled every 10 millis
+    assertEquals(1, counts[4]); 		// should have been triggered once
+    assertNotEquals(0, counts[2]); 	// meaningless to count micros calls. check it happened
 }
 
 //
@@ -152,7 +152,7 @@ testF(HighThroughputFixture, testCancellingsTasksWithinAnotherTask) {
 
     // the cancelled job should have run at least once before cancellation
     // and then must have been cancelled. Tasks should be in order
-    assertNotEqual(0, counts[0]);
+    assertNotEquals(0, counts[0]);
     assertTrue(taskCancelled);
 
     count = 500;
@@ -170,7 +170,7 @@ testF(HighThroughputFixture, testCancellingsTasksWithinAnotherTask) {
         Serial.print("Dumping threads"); Serial.println(taskManager.checkAvailableSlots(slotData, sizeof slotData));
     }
 
-    assertNotEqual(counts[1], storedCount1);
-    assertNotEqual(counts[2], storedCount1);
+    assertNotEquals(counts[1], storedCount1);
+    assertNotEquals(counts[2], storedCount1);
 }
 

tests/taskMgrTests/HighThroughputTestCases.cpp

@@ -1,9 +1,9 @@
 
-#include <AUnit.h>
+#include <testing/SimpleTest.h>
 #include "TaskManagerIO.h"
 #include "test_utils.h"
 
-using namespace aunit;
+using namespace SimpleTest;
 
 class MockedInterruptAbstraction : public InterruptAbstraction {
 private:
@@ -54,8 +54,8 @@ testF(TimingHelpFixture, interruptSupportMarshalling) {
     taskManager.addInterrupt(&interruptAbs, 2, CHANGE);
 
     // make sure the interrupt is properly registered.
-    assertEqual(pintype_t(2), interruptAbs.getInterruptPin());
-    assertEqual(CHANGE, interruptAbs.getTheMode());
+    assertEquals(pintype_t(2), interruptAbs.getInterruptPin());
+    assertEquals(CHANGE, interruptAbs.getTheMode());
     assertFalse(interruptAbs.isIntHandlerNull());
 
     // now pretend the interrupt took place.
@@ -65,5 +65,5 @@ testF(TimingHelpFixture, interruptSupportMarshalling) {
     assertThatTaskRunsOnTime(0, 250);
 
     // and the pin should be 2
-    assertEqual(2, pinNo);
+    assertEquals(2, pinNo);
 }

tests/taskMgrTests/InterruptTestCases.cpp

@@ -1,11 +1,11 @@
 
 #ifdef __AVR__
 
-#include <AUnit.h>
+#include <testing/SimpleTest.h>
 #include <util/atomic.h>
 #include "TaskManagerIO.h"
 
-using namespace aunit;
+using namespace SimpleTest;
 
 // We can only reset the clock to a new value on AVR, this is very useful and allows us to ensure the
 // rollover cases work properly at least for milliseconds. As millisecond and microsecond logic are very
@@ -67,13 +67,13 @@ test(testClockRollover) {
     dumpTaskTiming();
 
     // the one second task should have executed exactly once.
-    assertEqual(avrCount1, 1);
-    assertMore(avrCount2, 1000);
+    assertEquals(1, avrCount1);
+    assertMoreThan(1000, avrCount2);
 
     // make sure millis has wrapped now.
     assertTrue(millis() < 10000UL);
 
-    // and make sure the microsecond job is still going..
+    // and make sure the microsecond job is still going.
     int avrCount2Then = avrCount2;
     taskManager.yieldForMicros(10000);
     assertTrue(avrCount2Then != avrCount2);

tests/taskMgrTests/avrClockRollTests.cpp

@@ -1,10 +1,10 @@
 
-#include <AUnit.h>
+#include <testing/SimpleTest.h>
 #include <ExecWithParameter.h>
 #include "TaskManagerIO.h"
 #include "test_utils.h"
 
-using namespace aunit;
+using namespace SimpleTest;
 
 bool taskWithinEvent;
 
@@ -124,7 +124,7 @@ testF(TimingHelpFixture, testNotifyEventThatStartsAnotherTask) {
         externalEvent.markTriggeredAndNotify();
         taskManager.yieldForMicros(100);
         assertTrue(runScheduleUntilMatchOrTimeout([] { return taskWithinEvent; }));
-        assertEqual(i + 1, externalEvent.getExecCalls());
+        assertEquals(i + 1, externalEvent.getExecCalls());
     }
 
     // now we let the task complete and after one more cycle it should be removed by task manager.
@@ -137,7 +137,7 @@ testF(TimingHelpFixture, testNotifyEventThatStartsAnotherTask) {
     externalEvent.markTriggeredAndNotify();
     taskManager.yieldForMicros(200);
     assertFalse(externalEvent.wasNextCheckCalled());
-    assertEqual(0, externalEvent.getExecCalls());
+    assertEquals(0, externalEvent.getExecCalls());
 
     // it should not be in task manager any longer.
     assertFalse(taskManager.getTask(taskId)->isEvent());

tests/taskMgrTests/eventTestCases.cpp

@@ -1,10 +1,10 @@
 
-#include <AUnit.h>
+#include <testing/SimpleTest.h>
 #include <SimpleSpinLock.h>
 #include "TaskManagerIO.h"
 #include "test_utils.h"
 
-using namespace aunit;
+using namespace SimpleTest;
 
 SimpleSpinLock testLock;
 taskid_t runTaskId1;
@@ -24,7 +24,7 @@ test(testGettingRunningTaskAlwaysCorrect) {
     runCount1 = runCount2 = runCount3 = 0;
 
     taskManager.reset();
-    assertEqual(nullptr, taskManager.getRunningTask());
+    assertEquals(nullptr, taskManager.getRunningTask());
 
     serdebugF("Starting running task check");
 
@@ -48,12 +48,12 @@ test(testGettingRunningTaskAlwaysCorrect) {
     unsigned long then = millis();
     taskManager.yieldForMicros(millisToMicros(100));
     int diff = int(millis() - then);
-    assertMore(diff, 90);
+    assertMoreThan(90, diff);
 
     serdebugF("Finished running task check, asserting.");
 
     assertTrue(task1RunningPtrCheck);
     assertTrue(task2RunningPtrCheck);
-    assertMore(runCount1, 30);
-    assertMore(runCount2, 250);
+    assertMoreThan(30, runCount1);
+    assertMoreThan(250, runCount2);
 }

tests/taskMgrTests/reentrantLockingTests.cpp

@@ -1,10 +1,10 @@
 
-#include <AUnit.h>
+#include <testing/SimpleTest.h>
 #include <ExecWithParameter.h>
 #include "TaskManagerIO.h"
 #include "test_utils.h"
 
-using namespace aunit;
+using namespace SimpleTest;
 
 void dumpTasks() {
     Serial.println("Dumping the task queue contents");
@@ -57,10 +57,10 @@ class TestingExec : public Executable {
 TestingExec exec;
 
 testF(TimingHelpFixture, testRunningUsingExecutorClass) {
-    taskManager.scheduleFixedRate(10, &exec);
+    taskManager.scheduleFixedRate(10, &::exec);
     taskManager.scheduleOnce(250, recordingJob);
     assertThatTaskRunsOnTime(250000L, MILLIS_ALLOWANCE);
-    assertMore(exec.noOfTimesRun, 10);
+    assertMoreThan(10, ::exec.noOfTimesRun);
 }
 
 testF(TimingHelpFixture, schedulingTaskOnceInMicroseconds) {
@@ -96,7 +96,7 @@ testF(TimingHelpFixture, enableAndDisableSupport) {
     static int myTaskCounter = 0;
     auto myTaskId = taskManager.scheduleFixedRate(1, [] { myTaskCounter++; }, TIME_MILLIS);
     taskManager.yieldForMicros(20000);
-    assertNotEqual(0, myTaskCounter);
+    assertNotEquals(0, myTaskCounter);
 
     // "turn off" the task
     taskManager.setTaskEnabled(myTaskId, false);
@@ -107,32 +107,32 @@ testF(TimingHelpFixture, enableAndDisableSupport) {
 
     // now run the task for some time, it should never get scheduled.
     taskManager.yieldForMicros(20000);
-    assertEqual(myTaskCounter, oldTaskCount);
+    assertEquals(myTaskCounter, oldTaskCount);
 
     // "turn on" the task and see if it increases again
     taskManager.setTaskEnabled(myTaskId, true);
     taskManager.yieldForMicros(20000);
-    assertNotEqual(myTaskCounter, oldTaskCount);
+    assertNotEquals(myTaskCounter, oldTaskCount);
 
 }
 
 testF(TimingHelpFixture, scheduleFixedRateTestCase) {
-    assertEqual(taskManager.getFirstTask(), NULL);
+    assertEquals(taskManager.getFirstTask(), NULL);
 
     auto taskId1 = taskManager.scheduleFixedRate(10, recordingJob, TIME_MILLIS);
     auto taskId2 = taskManager.scheduleFixedRate(100, recordingJob2, TIME_MICROS);
 
     // now check the task registration in detail.
-    assertNotEqual(taskId1, TASKMGR_INVALIDID);
+    assertNotEquals(taskId1, TASKMGR_INVALIDID);
     TimerTask* task = taskManager.getFirstTask();
-    assertNotEqual(task, NULL);
+    assertNotEquals(task, NULL);
     assertFalse(task->isMillisSchedule());
     assertTrue(task->isMicrosSchedule());
 
     // now check the task registration in detail.
-    assertNotEqual(taskId2, TASKMGR_INVALIDID);
+    assertNotEquals(taskId2, TASKMGR_INVALIDID);
     task = task->getNext();
-    assertNotEqual(task, NULL);
+    assertNotEquals(task, NULL);
     assertTrue(task->isMillisSchedule());
     assertFalse(task->isMicrosSchedule());
 
@@ -145,26 +145,26 @@ testF(TimingHelpFixture, scheduleFixedRateTestCase) {
     dumpTasks();
 
     // make sure the yield timings were in range.
-    assertLess(timeTaken, (uint32_t) 25);
-    assertMoreOrEqual(timeTaken, (uint32_t) 20);
+    assertLessThan((uint32_t) 25, timeTaken);
+    assertMoreThan((uint32_t) 19, timeTaken);
 
     // now make sure that we got in the right ball park of calls.
-    assertMore(count, 1);
-    assertMore(count2, 150);
+    assertMoreThan(1, count);
+    assertMoreThan(150, count2);
 }
 
 testF(TimingHelpFixture, cancellingAJobAfterCreation) {
-    assertEqual(taskManager.getFirstTask(), NULL);
+    assertEquals(taskManager.getFirstTask(), nullptr);
 
     auto taskId = taskManager.scheduleFixedRate(10, recordingJob, TIME_MILLIS);
 
     // now check the task registration in detail.
-    assertNotEqual(taskId, TASKMGR_INVALIDID);
+    assertNotEquals(taskId, TASKMGR_INVALIDID);
     TimerTask* task = taskManager.getFirstTask();
-    assertNotEqual(task, NULL);
+    assertNotEquals(task, NULL);
     assertTrue(task->isMillisSchedule());
     assertFalse(task->isMicrosSchedule());
-    assertMore(task->microsFromNow(), 8000UL);
+    assertMoreThan(8000UL, task->microsFromNow());
 
     assertThatTaskRunsOnTime(10000, MILLIS_ALLOWANCE);
 
@@ -174,5 +174,5 @@ testF(TimingHelpFixture, cancellingAJobAfterCreation) {
     taskManager.yieldForMicros(100); // needs to run the cancellation task.
     assertTasksSpacesTaken(0);
 
-    assertEqual(taskManager.getFirstTask(), NULL);
+    assertEquals(taskManager.getFirstTask(), NULL);
 }

tests/taskMgrTests/taskManagerCoreTests.cpp

@@ -1,16 +1,14 @@
 
 #include <Arduino.h>
-#include <AUnit.h>
+#include <testing/SimpleTest.h>
 #include <Wire.h>
 
-using namespace aunit;
+using namespace SimpleTest;
 
 void setup() {
     Serial.begin(115200);
     while (!Serial);
+    startTesting();
 }
 
-void loop() {
-    TestRunner::setTimeout(60);
-    TestRunner::run();
-}
+DEFAULT_TEST_RUNLOOP