Naut/tests/unit/test_worker.c

#include "naut/hash.h"
#include "naut/worker.h"
#include "test.h"

#include <poll.h>
#include <stdint.h>
#include <string.h>
#include <unistd.h>

#define JOBS 256

typedef struct {
    naut_job job;
    uint8_t input[4096];
    uint8_t digest[NAUT_SHA256_LEN];
} hash_job;

static void run_hash(naut_job *base) {
    hash_job *job = base->context;
    naut_sha256(job->input, sizeof job->input, job->digest);
    base->result = NAUT_OK;
}

int main(void) {
    naut_worker_pool *pool = naut_worker_pool_create(4, 512, -1);
    CHECK(pool != NULL);
    CHECK_EQ(naut_worker_threads(pool), 4);
    CHECK(naut_worker_eventfd(pool) >= 0);

    hash_job jobs[JOBS];
    for (int i = 0; i < JOBS; i++) {
        memset(jobs[i].input, i, sizeof jobs[i].input);
        jobs[i].job.run = run_hash;
        jobs[i].job.context = &jobs[i];
        jobs[i].job.result = NAUT_ERR_AGAIN;
        CHECK(naut_worker_submit(pool, &jobs[i].job));
    }

    int complete = 0;
    while (complete < JOBS) {
        struct pollfd pfd = {
            .fd = naut_worker_eventfd(pool),
            .events = POLLIN,
        };
        CHECK(poll(&pfd, 1, 5000) > 0);
        uint64_t count;
        (void)read(pfd.fd, &count, sizeof count);
        naut_job *base;
        while (naut_worker_complete(pool, &base)) {
            hash_job *job = base->context;
            uint8_t expected[NAUT_SHA256_LEN];
            naut_sha256(job->input, sizeof job->input, expected);
            CHECK(base->result == NAUT_OK);
            CHECK(memcmp(job->digest, expected, sizeof expected) == 0);
            complete++;
        }
    }
    CHECK_EQ(complete, JOBS);
    naut_worker_pool_destroy(pool);
    TEST_MAIN_END();
}