767 lines
26 KiB
C
767 lines
26 KiB
C
/**
|
|
* Comprehensive unit tests for ll_queue module
|
|
* Focus on: waiters, flow control, edge cases, race conditions
|
|
*/
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <assert.h>
|
|
#include <unistd.h>
|
|
#include <sys/time.h>
|
|
|
|
#include "../src/ll_queue.h"
|
|
#include "../lib/u_async.h"
|
|
#include "../lib/debug_config.h"
|
|
|
|
/* Test statistics */
|
|
static struct {
|
|
int tests_run;
|
|
int tests_passed;
|
|
int tests_failed;
|
|
|
|
/* Callback counters */
|
|
int callback_count;
|
|
int waiter_callback_count;
|
|
int expected_callbacks;
|
|
|
|
/* Error tracking */
|
|
int memory_errors;
|
|
int race_condition_errors;
|
|
int invalid_parameter_errors;
|
|
} test_stats = {0};
|
|
|
|
/* Test result tracking */
|
|
#define TEST_START(name) do { \
|
|
printf("TEST: %s... ", name); \
|
|
test_stats.tests_run++; \
|
|
} while(0)
|
|
|
|
#define TEST_PASS() do { \
|
|
printf("PASS\n"); \
|
|
test_stats.tests_passed++; \
|
|
} while(0)
|
|
|
|
#define TEST_FAIL(msg) do { \
|
|
printf("FAIL: %s\n", msg); \
|
|
test_stats.tests_failed++; \
|
|
} while(0)
|
|
|
|
#define ASSERT_TRUE(cond, msg) do { \
|
|
if (!(cond)) { TEST_FAIL(msg); return; } \
|
|
} while(0)
|
|
|
|
#define ASSERT_FALSE(cond, msg) do { \
|
|
if (cond) { TEST_FAIL(msg); return; } \
|
|
} while(0)
|
|
|
|
#define ASSERT_EQ(a, b, msg) do { \
|
|
if ((a) != (b)) { TEST_FAIL(msg); return; } \
|
|
} while(0)
|
|
|
|
#define ASSERT_NE(a, b, msg) do { \
|
|
if ((a) == (b)) { TEST_FAIL(msg); return; } \
|
|
} while(0)
|
|
|
|
#define ASSERT_NULL(ptr, msg) do { \
|
|
if ((ptr) != NULL) { TEST_FAIL(msg); return; } \
|
|
} while(0)
|
|
|
|
#define ASSERT_NOT_NULL(ptr, msg) do { \
|
|
if ((ptr) == NULL) { TEST_FAIL(msg); return; } \
|
|
} while(0)
|
|
|
|
/* Test context for callbacks */
|
|
typedef struct {
|
|
int callback_count;
|
|
int expected_count;
|
|
int callback_arg;
|
|
ll_queue_t* queue;
|
|
int waiter_id;
|
|
int condition_met;
|
|
} test_context_t;
|
|
|
|
/* Test callback functions */
|
|
static void test_callback(ll_queue_t* q, ll_entry_t* entry, void* arg) {
|
|
(void)q; (void)entry;
|
|
test_context_t* ctx = (test_context_t*)arg;
|
|
ctx->callback_count++;
|
|
test_stats.callback_count++;
|
|
|
|
/* Just verify we got the right context */
|
|
ASSERT_NOT_NULL(ctx, "Callback context should not be NULL");
|
|
}
|
|
|
|
static void test_waiter_callback(ll_queue_t* q, void* arg) {
|
|
test_context_t* ctx = (test_context_t*)arg;
|
|
ctx->callback_count++;
|
|
ctx->condition_met = 1;
|
|
test_stats.waiter_callback_count++;
|
|
|
|
/* Verify queue pointer */
|
|
ASSERT_EQ(q, ctx->queue, "Queue pointer should match expected");
|
|
}
|
|
|
|
/* Test 1: Basic queue operations */
|
|
static void test_basic_queue_operations(void) {
|
|
TEST_START("Basic queue operations");
|
|
|
|
uasync_t* ua = uasync_create();
|
|
ASSERT_NOT_NULL(ua, "Failed to create uasync instance");
|
|
|
|
ll_queue_t* queue = queue_new(ua);
|
|
ASSERT_NOT_NULL(queue, "Failed to create queue");
|
|
|
|
/* Test initial state */
|
|
ASSERT_EQ(queue_entry_count(queue), 0, "New queue should be empty");
|
|
ASSERT_EQ(queue_total_bytes(queue), 0, "New queue should have 0 bytes");
|
|
|
|
/* Test entry creation */
|
|
ll_entry_t* entry1 = queue_entry_new(64);
|
|
ASSERT_NOT_NULL(entry1, "Failed to create entry");
|
|
ASSERT_EQ(entry1->size, 64, "Entry size should be 64");
|
|
ASSERT_NULL(entry1->next, "New entry should have NULL next");
|
|
|
|
/* Test entry data access */
|
|
void* data1 = ll_entry_data(entry1);
|
|
ASSERT_NOT_NULL(data1, "Entry data should not be NULL");
|
|
ASSERT_EQ(ll_entry_size(entry1), 64, "ll_entry_size should return correct size");
|
|
|
|
/* Test putting entry into queue */
|
|
int result = queue_entry_put(queue, entry1);
|
|
ASSERT_EQ(result, 0, "queue_entry_put should succeed");
|
|
ASSERT_EQ(queue_entry_count(queue), 1, "Queue should have 1 entry");
|
|
ASSERT_EQ(queue_total_bytes(queue), 64, "Queue should have 64 bytes");
|
|
|
|
/* Test getting entry from queue */
|
|
ll_entry_t* retrieved = queue_entry_get(queue);
|
|
ASSERT_EQ(retrieved, entry1, "Retrieved entry should match original");
|
|
ASSERT_EQ(queue_entry_count(queue), 0, "Queue should be empty after get");
|
|
ASSERT_EQ(queue_total_bytes(queue), 0, "Queue should have 0 bytes after get");
|
|
|
|
/* Clean up */
|
|
queue_entry_free(retrieved);
|
|
queue_free(queue);
|
|
uasync_destroy(ua);
|
|
|
|
TEST_PASS();
|
|
}
|
|
|
|
/* Test 2: FIFO ordering */
|
|
static void test_fifo_ordering(void) {
|
|
TEST_START("FIFO ordering");
|
|
|
|
uasync_t* ua = uasync_create();
|
|
ASSERT_NOT_NULL(ua, "Failed to create uasync instance");
|
|
|
|
ll_queue_t* queue = queue_new(ua);
|
|
ASSERT_NOT_NULL(queue, "Failed to create queue");
|
|
|
|
/* Create multiple entries */
|
|
ll_entry_t* entries[5];
|
|
for (int i = 0; i < 5; i++) {
|
|
entries[i] = queue_entry_new(10);
|
|
ASSERT_NOT_NULL(entries[i], "Failed to create entry");
|
|
|
|
/* Write data to identify entry */
|
|
int* data = (int*)ll_entry_data(entries[i]);
|
|
*data = i;
|
|
}
|
|
|
|
/* Put entries in order */
|
|
for (int i = 0; i < 5; i++) {
|
|
int result = queue_entry_put(queue, entries[i]);
|
|
ASSERT_EQ(result, 0, "queue_entry_put should succeed");
|
|
}
|
|
|
|
/* Verify FIFO ordering */
|
|
for (int i = 0; i < 5; i++) {
|
|
ll_entry_t* retrieved = queue_entry_get(queue);
|
|
ASSERT_NOT_NULL(retrieved, "Should retrieve entry");
|
|
|
|
int* data = (int*)ll_entry_data(retrieved);
|
|
if (*data != i) {
|
|
printf("FIFO ordering violated - expected %d, got %d\n", i, *data);
|
|
TEST_FAIL("FIFO ordering violated");
|
|
return;
|
|
}
|
|
|
|
queue_entry_free(retrieved);
|
|
}
|
|
|
|
ASSERT_EQ(queue_entry_count(queue), 0, "Queue should be empty");
|
|
|
|
queue_free(queue);
|
|
uasync_destroy(ua);
|
|
|
|
TEST_PASS();
|
|
}
|
|
|
|
/* Test 3: LIFO operations */
|
|
static void test_lifo_operations(void) {
|
|
TEST_START("LIFO operations");
|
|
|
|
uasync_t* ua = uasync_create();
|
|
ASSERT_NOT_NULL(ua, "Failed to create uasync instance");
|
|
|
|
ll_queue_t* queue = queue_new(ua);
|
|
ASSERT_NOT_NULL(queue, "Failed to create queue");
|
|
|
|
/* Create entries */
|
|
ll_entry_t* entries[3];
|
|
for (int i = 0; i < 3; i++) {
|
|
entries[i] = queue_entry_new(10);
|
|
ASSERT_NOT_NULL(entries[i], "Failed to create entry");
|
|
|
|
int* data = (int*)ll_entry_data(entries[i]);
|
|
*data = i;
|
|
}
|
|
|
|
/* Put entries in FIFO order */
|
|
for (int i = 0; i < 3; i++) {
|
|
int result = queue_entry_put(queue, entries[i]);
|
|
ASSERT_EQ(result, 0, "queue_entry_put should succeed");
|
|
}
|
|
|
|
/* Add high-priority entry using put_first */
|
|
ll_entry_t* priority_entry = queue_entry_new(10);
|
|
ASSERT_NOT_NULL(priority_entry, "Failed to create priority entry");
|
|
int* priority_data = (int*)ll_entry_data(priority_entry);
|
|
*priority_data = 999;
|
|
|
|
int result = queue_entry_put_first(queue, priority_entry);
|
|
ASSERT_EQ(result, 0, "queue_entry_put_first should succeed");
|
|
ASSERT_EQ(queue_entry_count(queue), 4, "Queue should have 4 entries");
|
|
|
|
/* Verify LIFO behavior - priority entry should come first */
|
|
ll_entry_t* first = queue_entry_get(queue);
|
|
ASSERT_NOT_NULL(first, "Should retrieve entry");
|
|
int* first_data = (int*)ll_entry_data(first);
|
|
ASSERT_EQ(*first_data, 999, "Priority entry should be retrieved first");
|
|
queue_entry_free(first);
|
|
|
|
/* Remaining entries should be in original FIFO order */
|
|
for (int i = 0; i < 3; i++) {
|
|
ll_entry_t* retrieved = queue_entry_get(queue);
|
|
ASSERT_NOT_NULL(retrieved, "Should retrieve entry");
|
|
int* data = (int*)ll_entry_data(retrieved);
|
|
ASSERT_EQ(*data, i, "Remaining entries should be in FIFO order");
|
|
queue_entry_free(retrieved);
|
|
}
|
|
|
|
queue_free(queue);
|
|
uasync_destroy(ua);
|
|
|
|
TEST_PASS();
|
|
}
|
|
|
|
/* Test 4: Waiter mechanism - basic functionality */
|
|
static void test_waiter_basic(void) {
|
|
TEST_START("Waiter mechanism - basic functionality");
|
|
|
|
uasync_t* ua = uasync_create();
|
|
ASSERT_NOT_NULL(ua, "Failed to create uasync instance");
|
|
|
|
ll_queue_t* queue = queue_new(ua);
|
|
ASSERT_NOT_NULL(queue, "Failed to create queue");
|
|
|
|
test_context_t ctx = {0};
|
|
ctx.queue = queue;
|
|
ctx.expected_count = 1;
|
|
|
|
/* Register waiter for empty queue (max_packets=0, max_bytes=0) */
|
|
queue_waiter_t* waiter = queue_wait_threshold(queue, 0, 0, test_waiter_callback, &ctx);
|
|
ASSERT_NULL(waiter, "Waiter should return NULL if condition already met");
|
|
ASSERT_EQ(ctx.callback_count, 1, "Callback should be called immediately");
|
|
ASSERT_TRUE(ctx.condition_met, "Condition should be marked as met");
|
|
|
|
/* Reset context */
|
|
ctx.callback_count = 0;
|
|
ctx.condition_met = 0;
|
|
|
|
/* Add some entries to queue */
|
|
ll_entry_t* entry = queue_entry_new(32);
|
|
ASSERT_NOT_NULL(entry, "Failed to create entry");
|
|
|
|
int result = queue_entry_put(queue, entry);
|
|
ASSERT_EQ(result, 0, "queue_entry_put should succeed");
|
|
ASSERT_EQ(queue_entry_count(queue), 1, "Queue should have 1 entry");
|
|
|
|
/* Register waiter for non-empty condition */
|
|
ctx.callback_count = 0;
|
|
waiter = queue_wait_threshold(queue, 0, 0, test_waiter_callback, &ctx);
|
|
ASSERT_NOT_NULL(waiter, "Waiter should be registered when condition not met");
|
|
ASSERT_EQ(ctx.callback_count, 0, "Callback should not be called immediately");
|
|
ASSERT_FALSE(ctx.condition_met, "Condition should not be met yet");
|
|
|
|
/* Empty the queue to trigger waiter */
|
|
ll_entry_t* retrieved = queue_entry_get(queue);
|
|
ASSERT_NOT_NULL(retrieved, "Should retrieve entry");
|
|
queue_entry_free(retrieved);
|
|
|
|
/* Process events to trigger waiter callback */
|
|
for (int i = 0; i < 10; i++) {
|
|
uasync_poll(ua, 1); /* 0.1ms poll */
|
|
}
|
|
|
|
ASSERT_EQ(ctx.callback_count, 1, "Waiter callback should be triggered");
|
|
ASSERT_TRUE(ctx.condition_met, "Condition should be marked as met");
|
|
|
|
queue_free(queue);
|
|
uasync_destroy(ua);
|
|
|
|
TEST_PASS();
|
|
}
|
|
|
|
/* Test 5: Waiter cancellation */
|
|
static void test_waiter_cancellation(void) {
|
|
TEST_START("Waiter cancellation");
|
|
|
|
uasync_t* ua = uasync_create();
|
|
ASSERT_NOT_NULL(ua, "Failed to create uasync instance");
|
|
|
|
ll_queue_t* queue = queue_new(ua);
|
|
ASSERT_NOT_NULL(queue, "Failed to create queue");
|
|
|
|
/* Add entries to make condition not met */
|
|
for (int i = 0; i < 5; i++) {
|
|
ll_entry_t* entry = queue_entry_new(10);
|
|
ASSERT_NOT_NULL(entry, "Failed to create entry");
|
|
int result = queue_entry_put(queue, entry);
|
|
ASSERT_EQ(result, 0, "queue_entry_put should succeed");
|
|
}
|
|
|
|
ASSERT_EQ(queue_entry_count(queue), 5, "Queue should have 5 entries");
|
|
|
|
test_context_t ctx = {0};
|
|
ctx.queue = queue;
|
|
|
|
/* Register waiter for condition that won't be met immediately */
|
|
queue_waiter_t* waiter = queue_wait_threshold(queue, 2, 0, test_waiter_callback, &ctx);
|
|
ASSERT_NOT_NULL(waiter, "Waiter should be registered");
|
|
ASSERT_EQ(ctx.callback_count, 0, "Callback should not be called immediately");
|
|
|
|
/* Cancel the waiter */
|
|
queue_cancel_wait(queue, waiter);
|
|
|
|
/* Empty the queue - waiter should not be called since it was cancelled */
|
|
ctx.callback_count = 0;
|
|
for (int i = 0; i < 5; i++) {
|
|
ll_entry_t* retrieved = queue_entry_get(queue);
|
|
ASSERT_NOT_NULL(retrieved, "Should retrieve entry");
|
|
queue_entry_free(retrieved);
|
|
}
|
|
|
|
/* Process events - no callback should be triggered */
|
|
for (int i = 0; i < 10; i++) {
|
|
uasync_poll(ua, 1);
|
|
}
|
|
|
|
ASSERT_EQ(ctx.callback_count, 0, "Cancelled waiter should not be called");
|
|
|
|
queue_free(queue);
|
|
uasync_destroy(ua);
|
|
|
|
TEST_PASS();
|
|
}
|
|
|
|
/* Test 6: Multiple waiters */
|
|
static void test_multiple_waiters(void) {
|
|
TEST_START("Multiple waiters");
|
|
|
|
uasync_t* ua = uasync_create();
|
|
ASSERT_NOT_NULL(ua, "Failed to create uasync instance");
|
|
|
|
ll_queue_t* queue = queue_new(ua);
|
|
ASSERT_NOT_NULL(queue, "Failed to create queue");
|
|
|
|
/* Add entries to make condition not met */
|
|
for (int i = 0; i < 10; i++) {
|
|
ll_entry_t* entry = queue_entry_new(10);
|
|
ASSERT_NOT_NULL(entry, "Failed to create entry");
|
|
int result = queue_entry_put(queue, entry);
|
|
ASSERT_EQ(result, 0, "queue_entry_put should succeed");
|
|
}
|
|
|
|
test_context_t ctx1 = {0};
|
|
test_context_t ctx2 = {0};
|
|
test_context_t ctx3 = {0};
|
|
ctx1.queue = queue;
|
|
ctx2.queue = queue;
|
|
ctx3.queue = queue;
|
|
|
|
/* Register multiple waiters with different conditions */
|
|
queue_waiter_t* waiter1 = queue_wait_threshold(queue, 5, 0, test_waiter_callback, &ctx1);
|
|
queue_waiter_t* waiter2 = queue_wait_threshold(queue, 3, 0, test_waiter_callback, &ctx2);
|
|
queue_waiter_t* waiter3 = queue_wait_threshold(queue, 1, 0, test_waiter_callback, &ctx3);
|
|
|
|
ASSERT_NOT_NULL(waiter1, "Waiter 1 should be registered");
|
|
ASSERT_NOT_NULL(waiter2, "Waiter 2 should be registered");
|
|
ASSERT_NOT_NULL(waiter3, "Waiter 3 should be registered");
|
|
|
|
/* Empty queue partially to trigger waiters */
|
|
for (int i = 0; i < 6; i++) { // Remove 6 entries, leaving 4
|
|
ll_entry_t* retrieved = queue_entry_get(queue);
|
|
ASSERT_NOT_NULL(retrieved, "Should retrieve entry");
|
|
queue_entry_free(retrieved);
|
|
}
|
|
|
|
/* Process events - should trigger waiters 1 and 2, but not 3 */
|
|
for (int i = 0; i < 10; i++) {
|
|
uasync_poll(ua, 1);
|
|
}
|
|
|
|
/* Check which waiters were triggered */
|
|
ASSERT_TRUE(ctx1.callback_count > 0, "Waiter 1 should be triggered (4 <= 5)");
|
|
ASSERT_EQ(ctx2.callback_count, 0, "Waiter 2 should not be triggered (4 > 3)");
|
|
ASSERT_EQ(ctx3.callback_count, 0, "Waiter 3 should not be triggered (4 > 1)");
|
|
|
|
queue_free(queue);
|
|
uasync_destroy(ua);
|
|
|
|
TEST_PASS();
|
|
}
|
|
|
|
/* Test 7: Queue size limits */
|
|
static void test_queue_size_limits(void) {
|
|
TEST_START("Queue size limits");
|
|
|
|
uasync_t* ua = uasync_create();
|
|
ASSERT_NOT_NULL(ua, "Failed to create uasync instance");
|
|
|
|
ll_queue_t* queue = queue_new(ua);
|
|
ASSERT_NOT_NULL(queue, "Failed to create queue");
|
|
|
|
/* Set size limit */
|
|
queue_set_size_limit(queue, 3);
|
|
|
|
/* Add entries up to limit */
|
|
for (int i = 0; i < 3; i++) {
|
|
ll_entry_t* entry = queue_entry_new(10);
|
|
ASSERT_NOT_NULL(entry, "Failed to create entry");
|
|
int result = queue_entry_put(queue, entry);
|
|
ASSERT_EQ(result, 0, "queue_entry_put should succeed below limit");
|
|
}
|
|
|
|
ASSERT_EQ(queue_entry_count(queue), 3, "Queue should be at limit");
|
|
|
|
/* Try to add one more - should be rejected */
|
|
ll_entry_t* excess_entry = queue_entry_new(10);
|
|
ASSERT_NOT_NULL(excess_entry, "Failed to create excess entry");
|
|
|
|
int result = queue_entry_put(queue, excess_entry);
|
|
ASSERT_EQ(result, -1, "queue_entry_put should fail at limit");
|
|
|
|
/* Entry should be freed automatically */
|
|
/* We can't easily verify this, but no leak should occur */
|
|
|
|
queue_free(queue);
|
|
uasync_destroy(ua);
|
|
|
|
TEST_PASS();
|
|
}
|
|
|
|
/* Test 8: Callback suspension and resumption */
|
|
static void test_callback_suspension(void) {
|
|
TEST_START("Callback suspension and resumption");
|
|
|
|
uasync_t* ua = uasync_create();
|
|
ASSERT_NOT_NULL(ua, "Failed to create uasync instance");
|
|
|
|
ll_queue_t* queue = queue_new(ua);
|
|
ASSERT_NOT_NULL(queue, "Failed to create queue");
|
|
|
|
test_context_t ctx = {0};
|
|
ctx.expected_count = 3;
|
|
|
|
/* Set callback */
|
|
queue_set_callback(queue, test_callback, &ctx);
|
|
|
|
/* Add first entry - callback should be called immediately */
|
|
ll_entry_t* entry1 = queue_entry_new(10);
|
|
ASSERT_NOT_NULL(entry1, "Failed to create entry");
|
|
int result = queue_entry_put(queue, entry1);
|
|
ASSERT_EQ(result, 0, "queue_entry_put should succeed");
|
|
|
|
/* Callback should have been called for the first entry */
|
|
ASSERT_EQ(ctx.callback_count, 1, "Callback should be called for first entry");
|
|
|
|
/* Add more entries - callback should be suspended during processing */
|
|
for (int i = 0; i < 2; i++) {
|
|
ll_entry_t* entry = queue_entry_new(10);
|
|
ASSERT_NOT_NULL(entry, "Failed to create entry");
|
|
int result = queue_entry_put(queue, entry);
|
|
ASSERT_EQ(result, 0, "queue_entry_put should succeed");
|
|
}
|
|
|
|
/* Callback should not be called again until we resume */
|
|
ASSERT_EQ(ctx.callback_count, 1, "Callback should not be called again until resume");
|
|
|
|
/* Simulate processing completion and resume */
|
|
queue_resume_callback(queue);
|
|
|
|
/* Process events - should trigger next callback */
|
|
for (int i = 0; i < 5; i++) {
|
|
uasync_poll(ua, 1);
|
|
}
|
|
|
|
ASSERT_EQ(ctx.callback_count, 2, "Callback should be called again after resume");
|
|
|
|
queue_free(queue);
|
|
uasync_destroy(ua);
|
|
|
|
TEST_PASS();
|
|
}
|
|
|
|
/* Test 9: Race condition scenarios */
|
|
static void test_race_conditions(void) {
|
|
TEST_START("Race condition scenarios");
|
|
|
|
uasync_t* ua = uasync_create();
|
|
ASSERT_NOT_NULL(ua, "Failed to create uasync instance");
|
|
|
|
ll_queue_t* queue = queue_new(ua);
|
|
ASSERT_NOT_NULL(queue, "Failed to create queue");
|
|
|
|
/* Scenario 1: Waiter registration while queue is being processed */
|
|
test_context_t ctx = {0};
|
|
ctx.queue = queue;
|
|
|
|
/* Add one entry */
|
|
ll_entry_t* entry = queue_entry_new(10);
|
|
ASSERT_NOT_NULL(entry, "Failed to create entry");
|
|
queue_entry_put(queue, entry);
|
|
|
|
/* Register waiter that will be called during processing */
|
|
queue_waiter_t* waiter = queue_wait_threshold(queue, 1, 0, test_waiter_callback, &ctx);
|
|
ASSERT_NULL(waiter, "Waiter should be called immediately if condition met (1 <= 1)");
|
|
|
|
/* Scenario 2: Multiple concurrent operations */
|
|
ctx.callback_count = 0;
|
|
|
|
/* Add entries to make condition not met initially */
|
|
for (int i = 0; i < 5; i++) {
|
|
ll_entry_t* new_entry = queue_entry_new(10);
|
|
ASSERT_NOT_NULL(new_entry, "Failed to create entry");
|
|
queue_entry_put(queue, new_entry);
|
|
}
|
|
|
|
/* Register waiter for condition that won't be met immediately */
|
|
ctx.condition_met = 0;
|
|
waiter = queue_wait_threshold(queue, 2, 0, test_waiter_callback, &ctx);
|
|
ASSERT_NOT_NULL(waiter, "Waiter should be registered when condition not met");
|
|
|
|
/* Simulate concurrent access */
|
|
for (int i = 0; i < 10; i++) {
|
|
uasync_poll(ua, 1);
|
|
}
|
|
|
|
/* Verify no race conditions occurred */
|
|
ASSERT_TRUE(ctx.condition_met >= 0, "No race conditions should cause crashes");
|
|
|
|
queue_free(queue);
|
|
uasync_destroy(ua);
|
|
|
|
TEST_PASS();
|
|
}
|
|
|
|
/* Test 10: Edge cases and error conditions */
|
|
static void test_edge_cases(void) {
|
|
TEST_START("Edge cases and error conditions");
|
|
|
|
/* Test NULL parameters */
|
|
/* Note: queue_new currently doesn't validate NULL uasync - this is a bug that should be fixed */
|
|
ll_queue_t* null_queue = queue_new(NULL);
|
|
ASSERT_NOT_NULL(null_queue, "queue_new currently creates queue even with NULL uasync (bug)");
|
|
queue_free(null_queue); /* Clean up */
|
|
|
|
/* Test invalid parameters */
|
|
uasync_t* ua = uasync_create();
|
|
ASSERT_NOT_NULL(ua, "Failed to create uasync instance");
|
|
|
|
ll_queue_t* queue = queue_new(ua);
|
|
ASSERT_NOT_NULL(queue, "Failed to create queue");
|
|
|
|
/* Test NULL parameters for functions */
|
|
queue_set_callback(NULL, test_callback, NULL); // Should not crash
|
|
queue_resume_callback(NULL); // Should not crash
|
|
queue_set_size_limit(NULL, 10); // Should not crash
|
|
|
|
queue_waiter_t* result = queue_wait_threshold(NULL, 0, 0, test_waiter_callback, NULL);
|
|
ASSERT_NULL(result, "queue_wait_threshold should fail with NULL queue");
|
|
|
|
result = queue_wait_threshold(queue, 0, 0, NULL, NULL);
|
|
ASSERT_NULL(result, "queue_wait_threshold should fail with NULL callback");
|
|
|
|
queue_cancel_wait(NULL, NULL); // Should not crash
|
|
queue_cancel_wait(queue, NULL); // Should not crash
|
|
|
|
/* Test empty queue operations */
|
|
ASSERT_NULL(queue_entry_get(NULL), "queue_entry_get should fail with NULL queue");
|
|
|
|
ll_entry_t* retrieved = queue_entry_get(queue);
|
|
ASSERT_NULL(retrieved, "queue_entry_get should return NULL for empty queue");
|
|
|
|
/* Test with zero-sized entries */
|
|
ll_entry_t* zero_entry = queue_entry_new(0);
|
|
ASSERT_NOT_NULL(zero_entry, "Should handle zero-sized entries");
|
|
|
|
int put_result = queue_entry_put(queue, zero_entry);
|
|
ASSERT_EQ(put_result, 0, "Should handle zero-sized entry put");
|
|
ASSERT_EQ(queue_entry_count(queue), 1, "Should count zero-sized entries");
|
|
|
|
queue_entry_free(zero_entry);
|
|
|
|
queue_free(queue);
|
|
uasync_destroy(ua);
|
|
|
|
TEST_PASS();
|
|
}
|
|
|
|
/* Test 11: Performance and stress testing */
|
|
static void test_performance_stress(void) {
|
|
TEST_START("Performance and stress testing");
|
|
|
|
uasync_t* ua = uasync_create();
|
|
ASSERT_NOT_NULL(ua, "Failed to create uasync instance");
|
|
|
|
ll_queue_t* queue = queue_new(ua);
|
|
ASSERT_NOT_NULL(queue, "Failed to create queue");
|
|
|
|
test_context_t ctx = {0};
|
|
|
|
/* Stress test: many entries */
|
|
const int num_entries = 1000;
|
|
ll_entry_t** entries = malloc(num_entries * sizeof(ll_entry_t*));
|
|
ASSERT_NOT_NULL(entries, "Failed to allocate entry array");
|
|
|
|
/* Create many entries */
|
|
for (int i = 0; i < num_entries; i++) {
|
|
entries[i] = queue_entry_new(64); // 64 bytes each
|
|
ASSERT_NOT_NULL(entries[i], "Failed to create entry");
|
|
|
|
int* data = (int*)ll_entry_data(entries[i]);
|
|
*data = i;
|
|
}
|
|
|
|
/* Put all entries */
|
|
for (int i = 0; i < num_entries; i++) {
|
|
int result = queue_entry_put(queue, entries[i]);
|
|
ASSERT_EQ(result, 0, "queue_entry_put should succeed");
|
|
}
|
|
|
|
ASSERT_EQ(queue_entry_count(queue), num_entries, "Queue should have all entries");
|
|
ASSERT_EQ(queue_total_bytes(queue), num_entries * 64, "Total bytes should be correct");
|
|
|
|
/* Retrieve all entries and verify order */
|
|
for (int i = 0; i < num_entries; i++) {
|
|
ll_entry_t* retrieved = queue_entry_get(queue);
|
|
ASSERT_NOT_NULL(retrieved, "Should retrieve entry");
|
|
|
|
int* data = (int*)ll_entry_data(retrieved);
|
|
ASSERT_EQ(*data, i, "FIFO order should be preserved");
|
|
|
|
queue_entry_free(retrieved);
|
|
}
|
|
|
|
ASSERT_EQ(queue_entry_count(queue), 0, "Queue should be empty");
|
|
|
|
/* Stress test: many waiters */
|
|
|
|
/* Add some entries back */
|
|
for (int i = 0; i < 100; i++) {
|
|
ll_entry_t* entry = queue_entry_new(10);
|
|
queue_entry_put(queue, entry);
|
|
}
|
|
|
|
/* Register many waiters */
|
|
queue_waiter_t** waiters = malloc(50 * sizeof(queue_waiter_t*));
|
|
ASSERT_NOT_NULL(waiters, "Failed to allocate waiter array");
|
|
|
|
for (int i = 0; i < 50; i++) {
|
|
test_context_t* waiter_ctx = malloc(sizeof(test_context_t));
|
|
ASSERT_NOT_NULL(waiter_ctx, "Failed to allocate waiter context");
|
|
waiter_ctx->callback_count = 0;
|
|
waiter_ctx->queue = queue;
|
|
waiter_ctx->waiter_id = i;
|
|
|
|
waiters[i] = queue_wait_threshold(queue, 50 - i, 0, test_waiter_callback, waiter_ctx);
|
|
}
|
|
|
|
/* Process events */
|
|
for (int i = 0; i < 100; i++) {
|
|
uasync_poll(ua, 1);
|
|
}
|
|
|
|
/* Verify waiters were triggered correctly */
|
|
int total_callbacks = 0;
|
|
for (int i = 0; i < 50; i++) {
|
|
test_context_t* waiter_ctx = (test_context_t*)waiters[i]->callback_arg;
|
|
total_callbacks += waiter_ctx->callback_count;
|
|
free(waiter_ctx);
|
|
}
|
|
|
|
/* At least some waiters should trigger as we empty the queue */
|
|
ASSERT_TRUE(total_callbacks >= 0, "Waiter callback count should be valid");
|
|
|
|
/* Clean up */
|
|
free(entries);
|
|
free(waiters);
|
|
queue_free(queue);
|
|
uasync_destroy(ua);
|
|
|
|
TEST_PASS();
|
|
}
|
|
|
|
/* Main test runner */
|
|
int main(void) {
|
|
printf("=== ll_queue Comprehensive Unit Tests ===\n");
|
|
printf("Testing waiters, flow control, edge cases, and race conditions\n\n");
|
|
|
|
/* Initialize debug system */
|
|
debug_config_init();
|
|
debug_set_level(DEBUG_LEVEL_INFO);
|
|
debug_set_categories(DEBUG_CATEGORY_LL_QUEUE);
|
|
|
|
/* Run all tests */
|
|
test_basic_queue_operations();
|
|
test_fifo_ordering();
|
|
test_lifo_operations();
|
|
test_waiter_basic();
|
|
test_waiter_cancellation();
|
|
test_multiple_waiters();
|
|
test_queue_size_limits();
|
|
test_callback_suspension();
|
|
test_race_conditions();
|
|
test_edge_cases();
|
|
test_performance_stress();
|
|
|
|
/* Print statistics */
|
|
printf("\n=== Test Statistics ===\n");
|
|
printf("Tests run: %d\n", test_stats.tests_run);
|
|
printf("Tests passed: %d\n", test_stats.tests_passed);
|
|
printf("Tests failed: %d\n", test_stats.tests_failed);
|
|
printf("\nCallback statistics:\n");
|
|
printf(" Queue callbacks: %d\n", test_stats.callback_count);
|
|
printf(" Waiter callbacks: %d\n", test_stats.waiter_callback_count);
|
|
printf("\nError statistics:\n");
|
|
printf(" Memory errors: %d\n", test_stats.memory_errors);
|
|
printf(" Race condition errors: %d\n", test_stats.race_condition_errors);
|
|
printf(" Invalid parameter errors: %d\n", test_stats.invalid_parameter_errors);
|
|
|
|
if (test_stats.tests_failed == 0) {
|
|
printf("\n✅ All tests passed! ll_queue module is working correctly.\n");
|
|
printf("\nKey areas verified:\n");
|
|
printf("- Basic queue operations (FIFO/LIFO)\n");
|
|
printf("- Waiter mechanism with multiple conditions\n");
|
|
printf("- Waiter cancellation and race condition handling\n");
|
|
printf("- Queue size limits and flow control\n");
|
|
printf("- Callback suspension and resumption\n");
|
|
printf("- Edge cases and error handling\n");
|
|
printf("- Performance under stress conditions\n");
|
|
return 0;
|
|
} else {
|
|
printf("\n❌ Some tests failed. Please check the implementation.\n");
|
|
return 1;
|
|
}
|
|
} |