interim commit from macos, tests do not pass.

Author: dave

src/TaskManagerIO.cpp

@@ -177,6 +177,14 @@ void TaskManager::dealWithInterrupt() {
         auto task = getTask(i);
         if(task->isInUse() && task->isEvent()) {
             task->processEvent();
+            removeFromQueue(task);
+            if(task->isRepeating()) {
+                putItemIntoQueue(task);
+            }
+            else {
+                task->clear();
+                tm_internal::tmNotification(tm_internal::TM_INFO_TASK_FREE, TASKMGR_INVALIDID);
+            }
         }
     }
 }

tests/taskMgrTests/eventTestCases.cpp

@@ -0,0 +1,87 @@
+
+#include <AUnit.h>
+#include <ExecWithParameter.h>
+#include "TaskManagerIO.h"
+#include "test_utils.h"
+
+using namespace aunit;
+
+bool taskWithinEvent;
+
+class TestPolledEvent : public BaseEvent {
+private:
+    int execCalls;
+    int scheduleCalls;
+    uint32_t interval;
+    bool triggerNow;
+public:
+    TestPolledEvent() {
+        execCalls = scheduleCalls = 0;
+        interval = 100000; // 100 millis
+        triggerNow = false;
+        taskWithinEvent = false;
+    }
+
+    ~TestPolledEvent() override = default;
+
+    void exec() override {
+        execCalls++;
+        taskManager.scheduleOnce(100, [] {
+            taskWithinEvent = true;
+        });
+        setCompleted(true);
+    }
+
+    uint32_t timeOfNextCheck() override {
+        scheduleCalls++;
+        setTriggered(triggerNow);
+        return interval;
+    }
+
+    void startTriggering() {
+        triggerNow = true;
+        interval = 10000;
+    }
+
+    int getScheduleCalls() const { return scheduleCalls; }
+
+    int getExecCalls() const { return execCalls; }
+} polledEvent;
+
+testF(TimingHelpFixture, testRepeatedRaisingOfEvent) {
+    fail();
+}
+
+testF(TimingHelpFixture, testInterruptTestStartsTask) {
+    fail();
+}
+
+typedef bool (*TMPredicate)();
+
+bool runScheduleUntilMatchOrTimeout(TMPredicate predicate) {
+    unsigned long startTime = millis();
+    // wait until the predicate matches, or it takes too long.
+    while (!predicate() && (millis() - startTime) < 1000) {
+        taskManager.yieldForMicros(10000);
+    }
+    return predicate();
+}
+
+testF(TimingHelpFixture, testRaiseEventStartTaskCompleted) {
+    EnsureExecutionWithin timelyChecker(500);
+
+    //taskManager.registerEvent(&polledEvent);
+
+    assertTrue(runScheduleUntilMatchOrTimeout([] { return polledEvent.getScheduleCalls() >= 10; } ));
+
+    // and now we tell the event to trigger itself
+    polledEvent.startTriggering();
+
+    // wait until the exec() method is called
+    assertTrue(runScheduleUntilMatchOrTimeout([] { return polledEvent.getExecCalls() != 0; }));
+
+    // and then make sure that the task registed inside the event triggers
+    assertTrue(runScheduleUntilMatchOrTimeout([] { return taskWithinEvent; }));
+
+    assertTrue(timelyChecker.ensureTimely());
+}

tests/taskMgrTests/taskManagerCoreTests.cpp

@@ -1,5 +1,6 @@
 
 #include <AUnit.h>
+#include <ExecWithParameter.h>
 #include "TaskManagerIO.h"
 #include "test_utils.h"
 
@@ -151,66 +152,3 @@ testF(TimingHelpFixture, cancellingAJobAfterCreation) {
 
     assertEqual(taskManager.getFirstTask(), NULL);
 }
-
-class TestPolledEvent : public BaseEvent {
-private:
-    int execCalls;
-    int scheduleCalls;
-    uint32_t interval;
-    bool triggerNow;
-public:
-    TestPolledEvent() {
-        execCalls = scheduleCalls = 0;
-        interval = 100000; // 100 millis
-        triggerNow = false;
-    }
-    ~TestPolledEvent() override = default;
-
-    void exec() override {
-        execCalls++;
-    }
-
-    uint32_t timeOfNextCheck() override {
-        setTriggered(triggerNow);
-        return interval;
-    }
-
-    void startTriggering() {
-        triggerNow = true;
-        interval = 10000;
-    }
-
-    int getScheduleCalls() const { return scheduleCalls; }
-    int getExecCalls() const { return execCalls; }
-} polledEvent;
-
-
-
-testF(TimingHelpFixture, testRaisingEventsWithTaskMgr) {
-    unsigned long startTime = millis();
-
-    polledEvent.markTriggeredAndNotify();
-
-    taskManager.yieldForMicros(1000);
-
-    assertMoreOrEqual(1, polledEvent.getExecCalls());
-
-    // wait until the task is marked as scheduled.
-    while(polledEvent.getScheduleCalls() < 10 && (millis() - startTime) < 1000) {
-        taskManager.yieldForMicros(10000);
-    }
-
-    // we must have called the schedule call at least 10 times.
-    assertMoreOrEqual(10, polledEvent.getScheduleCalls());
-
-    polledEvent.startTriggering();
-
-    // wait until the task is marked as scheduled.
-    while(polledEvent.getExecCalls() < 10 && (millis() - startTime) < 1000) {
-        taskManager.yieldForMicros(10000);
-    }
-
-    assertMoreOrEqual(10, polledEvent.getExecCalls());
-
-    assertLess(500UL, millis() - startTime);
-}

tests/taskMgrTests/test_utils.h

@@ -3,6 +3,7 @@
 #define TASKMANGERIO_TEST_UTILS_H
 
 #include <AUnit.h>
+#include <IoLogging.h>
 
 void dumpTasks();
 
@@ -20,6 +21,26 @@ extern uint8_t pinNo;
 
 using namespace aunit;
 
+class EnsureExecutionWithin {
+private:
+    unsigned long startMillis;
+    unsigned long maximumTime;
+public:
+    explicit EnsureExecutionWithin(unsigned long maxWaiting) {
+        startMillis = millis();
+        maximumTime = maxWaiting;
+    }
+    bool ensureTimely() {
+        if(millis() > (startMillis + maximumTime)) {
+            serdebugF2("TEST EXECUTION OUT OF RANGE ", int(millis() - startMillis));
+            return false;
+        }
+
+        serdebugF2("Test execution within range: ", int(millis() - startMillis));
+        return true;
+    }
+};
+
 class TimingHelpFixture : public TestOnce {
 protected:
     void setup() override {