kbf/test/test_task.cpp

#include <unity.h>

#include <atomic>

#include "kbf.h"
#include "kbf/task.h"

/** delay between cycles */
#define KBF_TASK_TEST_DELAY 100

/** counter increase factor for the "runner" task */
#define KBF_TASK_TEST_RUNNER_INC 10

/** counter increase factor for the "quitter" task */
#define KBF_TASK_TEST_QUITTER_INC 1

/** number of cycles to run for each testing stage */
#define KBF_TASK_TEST_CYCLES 5

using namespace std;

atomic<int> counter{0};

/** function that runs until stopped */
[[noreturn]] void runner(void *arg);

/** function that stops after KBF_TASK_TEST_CYCLES cycles */
void quitter(void *arg);

struct QuitterArg {
    int delay;
    int cycles;
};

TEST_CASE("Task handling functions", "[kbf_task]") {
    counter = 0;

    int        delay = KBF_TASK_TEST_DELAY;
    QuitterArg arg   = {KBF_TASK_TEST_DELAY, KBF_TASK_TEST_CYCLES};

    auto runnerTask  = new kbf::Task("test_runner", runner, &delay);
    auto quitterTask = kbf::Task("test_quitter", quitter, &arg);

    kbf::sleep(40); // make sure the tasks have started

    int expected = 0;

    // both tasks are running
    for (int i = 0; i < KBF_TASK_TEST_CYCLES; i++) {
        expected += KBF_TASK_TEST_RUNNER_INC + KBF_TASK_TEST_QUITTER_INC;
        TEST_ASSERT_EQUAL(expected, counter);
        TEST_ASSERT_TRUE(runnerTask->isRunning())
        TEST_ASSERT_TRUE(quitterTask.isRunning())
        kbf::sleep(KBF_TASK_TEST_DELAY);
    }

    // quitter has quit, only runner is left
    for (int i = 0; i < KBF_TASK_TEST_CYCLES; i++) {
        expected += KBF_TASK_TEST_RUNNER_INC;
        TEST_ASSERT_EQUAL(expected, counter);
        TEST_ASSERT_TRUE(runnerTask->isRunning())
        TEST_ASSERT_FALSE(quitterTask.isRunning())
        kbf::sleep(KBF_TASK_TEST_DELAY);
    }

    // killing runner via destructor; no more updates
    delete runnerTask;
    expected += KBF_TASK_TEST_RUNNER_INC; // runner went another cycle while we were sleeping
    for (int i = 0; i < KBF_TASK_TEST_CYCLES; i++) {
        TEST_ASSERT_EQUAL(expected, counter);
        kbf::sleep(KBF_TASK_TEST_DELAY);
    }
}

[[noreturn]] void runner(void *arg) {
    auto delay = static_cast<int *>(arg);
    TEST_ASSERT_EQUAL(KBF_TASK_TEST_DELAY, *delay);

    while (true) {
        counter += KBF_TASK_TEST_RUNNER_INC;
        kbf::sleep(*delay);
    }
}

void quitter(void *arg) {
    auto argData = static_cast<QuitterArg *>(arg);
    TEST_ASSERT_EQUAL(KBF_TASK_TEST_DELAY, argData->delay);
    TEST_ASSERT_EQUAL(KBF_TASK_TEST_CYCLES, argData->cycles);

    for (int i = 0; i < argData->cycles; i++) {
        counter += KBF_TASK_TEST_QUITTER_INC;
        kbf::sleep(argData->delay);
    }
}