tests(runtime,engine,io,core): move large test fixtures off stack

Author: arancormonk

tests/core/test_core_audio_group_gate.c

@@ -41,12 +41,17 @@ int
 main(void) {
     int rc = 0;
 
-    dsd_opts opts;
-    memset(&opts, 0, sizeof(opts));
+    // dsd_opts is sizeable enough to keep off the function stack in tests.
+    dsd_opts* opts = (dsd_opts*)calloc(1, sizeof(*opts));
+    if (!opts) {
+        fprintf(stderr, "alloc-failed: dsd_opts\n");
+        return 1;
+    }
 
     dsd_state* st = (dsd_state*)calloc(1, sizeof(*st));
     if (!st) {
         fprintf(stderr, "alloc-failed: dsd_state\n");
+        free(opts);
         return 1;
     }
 
@@ -56,45 +61,45 @@ main(void) {
     set_group(st, 1, 200UL, "B", "BLOCK");
     {
         int outL = -1, outR = -1;
-        rc |= expect_eq("case1-ret", dsd_audio_group_gate_dual(&opts, st, 100UL, 200UL, 0, 0, &outL, &outR), 0);
+        rc |= expect_eq("case1-ret", dsd_audio_group_gate_dual(opts, st, 100UL, 200UL, 0, 0, &outL, &outR), 0);
         rc |= expect_eq("case1-outL", outL, 0);
         rc |= expect_eq("case1-outR", outR, 1);
     }
 
     // Case 2: Allow-list mode defaults unknown TGs to blocked.
-    memset(&opts, 0, sizeof(opts));
+    memset(opts, 0, sizeof(*opts));
     memset(st, 0, sizeof(*st));
-    opts.trunk_use_allow_list = 1;
+    opts->trunk_use_allow_list = 1;
     st->group_tally = 1;
     set_group(st, 0, 300UL, "A", "ONLY");
     {
         int outL = -1, outR = -1;
-        rc |= expect_eq("case2-ret", dsd_audio_group_gate_dual(&opts, st, 300UL, 301UL, 0, 0, &outL, &outR), 0);
+        rc |= expect_eq("case2-ret", dsd_audio_group_gate_dual(opts, st, 300UL, 301UL, 0, 0, &outL, &outR), 0);
         rc |= expect_eq("case2-outL", outL, 0);
         rc |= expect_eq("case2-outR", outR, 1);
     }
 
     // Case 2b: "DE" lockout mode should be treated as blocked by audio gate.
-    memset(&opts, 0, sizeof(opts));
+    memset(opts, 0, sizeof(*opts));
     memset(st, 0, sizeof(*st));
     st->group_tally = 1;
     set_group(st, 0, 310UL, "DE", "ENC-LOCKOUT");
     {
         int outL = -1;
-        rc |= expect_eq("case2b-ret", dsd_audio_group_gate_mono(&opts, st, 310UL, 0, &outL), 0);
+        rc |= expect_eq("case2b-ret", dsd_audio_group_gate_mono(opts, st, 310UL, 0, &outL), 0);
         rc |= expect_eq("case2b-outL", outL, 1);
     }
 
     // Case 3: TG hold mutes non-matching slot and force-unmutes matching slot.
-    memset(&opts, 0, sizeof(opts));
+    memset(opts, 0, sizeof(*opts));
     memset(st, 0, sizeof(*st));
     st->group_tally = 2;
     set_group(st, 0, 400UL, "A", "LEFT");
     set_group(st, 1, 401UL, "B", "RIGHT-BLOCKED");
     st->tg_hold = 401U;
     {
         int outL = -1, outR = -1;
-        rc |= expect_eq("case3-ret", dsd_audio_group_gate_dual(&opts, st, 400UL, 401UL, 0, 0, &outL, &outR), 0);
+        rc |= expect_eq("case3-ret", dsd_audio_group_gate_dual(opts, st, 400UL, 401UL, 0, 0, &outL, &outR), 0);
         rc |= expect_eq("case3-outL", outL, 1);
         rc |= expect_eq("case3-outR", outR, 0);
     }
@@ -103,27 +108,27 @@ main(void) {
     {
         int out = 0;
         rc |= expect_eq("null-mono", dsd_audio_group_gate_mono(NULL, st, 0UL, 0, &out), -1);
-        rc |= expect_eq("null-dual", dsd_audio_group_gate_dual(&opts, st, 0UL, 0UL, 0, 0, NULL, &out), -1);
-        rc |= expect_eq("null-record-mono", dsd_audio_record_gate_mono(&opts, NULL, &out), -1);
+        rc |= expect_eq("null-dual", dsd_audio_group_gate_dual(opts, st, 0UL, 0UL, 0, 0, NULL, &out), -1);
+        rc |= expect_eq("null-record-mono", dsd_audio_record_gate_mono(opts, NULL, &out), -1);
     }
 
     // Case 4: Mono per-call recording gate respects block mode.
-    memset(&opts, 0, sizeof(opts));
+    memset(opts, 0, sizeof(*opts));
     memset(st, 0, sizeof(*st));
     st->group_tally = 1;
     st->lasttg = 500UL;
     st->dmr_encL = 0;
     set_group(st, 0, 500UL, "B", "REC-BLOCK");
     {
         int allow = -1;
-        rc |= expect_eq("case4-rec-ret", dsd_audio_record_gate_mono(&opts, st, &allow), 0);
+        rc |= expect_eq("case4-rec-ret", dsd_audio_record_gate_mono(opts, st, &allow), 0);
         rc |= expect_eq("case4-rec-allow", allow, 0);
     }
 
     // Case 5: Mono per-call recording gate uses slot-specific TG/encryption state.
-    memset(&opts, 0, sizeof(opts));
+    memset(opts, 0, sizeof(*opts));
     memset(st, 0, sizeof(*st));
-    opts.trunk_use_allow_list = 1;
+    opts->trunk_use_allow_list = 1;
     st->currentslot = 1;
     st->group_tally = 1;
     st->lasttg = 600UL;
@@ -133,26 +138,27 @@ main(void) {
     set_group(st, 0, 601UL, "A", "RIGHT-ONLY");
     {
         int allow = -1;
-        rc |= expect_eq("case5-rec-ret", dsd_audio_record_gate_mono(&opts, st, &allow), 0);
+        rc |= expect_eq("case5-rec-ret", dsd_audio_record_gate_mono(opts, st, &allow), 0);
         rc |= expect_eq("case5-rec-allow", allow, 1);
     }
 
     // Case 6: P25 Phase 2 recording gate follows the per-slot audio-allowed flag.
-    memset(&opts, 0, sizeof(opts));
+    memset(opts, 0, sizeof(*opts));
     memset(st, 0, sizeof(*st));
     st->synctype = DSD_SYNC_P25P2_POS;
     st->currentslot = 1;
     st->p25_p2_audio_allowed[0] = 0;
     st->p25_p2_audio_allowed[1] = 1;
     {
         int allow = -1;
-        rc |= expect_eq("case6-rec-ret", dsd_audio_record_gate_mono(&opts, st, &allow), 0);
+        rc |= expect_eq("case6-rec-ret", dsd_audio_record_gate_mono(opts, st, &allow), 0);
         rc |= expect_eq("case6-rec-allow", allow, 1);
     }
 
     if (rc == 0) {
         printf("CORE_AUDIO_GROUP_GATE: OK\n");
     }
+    free(opts);
     free(st);
     return rc;
 }

tests/engine/test_engine_no_carrier_reset.c

@@ -19,7 +19,7 @@
 #include "dsd-neo/core/state_fwd.h"
 
 #include <stdio.h>
-#include <string.h>
+#include <stdlib.h>
 
 static int
 expect_true(const char* tag, int cond) {
@@ -40,56 +40,83 @@ ui_start(dsd_opts* opts, dsd_state* state) {
 void
 ui_stop(void) {}
 
+static int
+init_test_runtime(dsd_opts** opts_out, dsd_state** state_out) {
+    // dsd_state is multi-megabyte; keep it off the function stack.
+    dsd_opts* opts = (dsd_opts*)calloc(1, sizeof(*opts));
+    dsd_state* state = (dsd_state*)calloc(1, sizeof(*state));
+    if (opts == NULL || state == NULL) {
+        fprintf(stderr, "alloc-failed: runtime\n");
+        free(opts);
+        free(state);
+        return 1;
+    }
+
+    initOpts(opts);
+    initState(state);
+
+    *opts_out = opts;
+    *state_out = state;
+    return 0;
+}
+
+static void
+free_test_runtime(dsd_opts* opts, dsd_state* state) {
+    if (state != NULL) {
+        freeState(state);
+    }
+    free(state);
+    free(opts);
+}
+
 int
 main(void) {
     int rc = 0;
+    dsd_opts* opts = NULL;
+    dsd_state* state = NULL;
 
-    dsd_opts opts;
-    dsd_state state;
-    memset(&opts, 0, sizeof(opts));
-    memset(&state, 0, sizeof(state));
-
-    initOpts(&opts);
-    initState(&state);
+    if (init_test_runtime(&opts, &state) != 0) {
+        return 1;
+    }
 
     for (int i = 0; i < 200; i++) {
-        state.dmr_payload_buf[i] = 0x7F7F7F7F;
-        if (state.dmr_reliab_buf != NULL) {
-            state.dmr_reliab_buf[i] = 0xA5U;
+        state->dmr_payload_buf[i] = 0x7F7F7F7F;
+        if (state->dmr_reliab_buf != NULL) {
+            state->dmr_reliab_buf[i] = 0xA5U;
         }
     }
 
-    state.dmr_payload_p = state.dibit_buf + 321;
-    if (state.dmr_reliab_buf != NULL) {
-        state.dmr_reliab_p = state.dmr_reliab_buf + 321;
+    state->dmr_payload_p = state->dibit_buf + 321;
+    if (state->dmr_reliab_buf != NULL) {
+        state->dmr_reliab_p = state->dmr_reliab_buf + 321;
     }
 
-    noCarrier(&opts, &state);
+    noCarrier(opts, state);
 
-    rc |= expect_true("dmr-payload-pointer-buffer", state.dmr_payload_p == state.dmr_payload_buf + 200);
-    rc |= expect_true("dmr-payload-pointer-not-dibit", state.dmr_payload_p != state.dibit_buf + 200);
-    rc |= expect_true("dibit-pointer-reset", state.dibit_buf_p == state.dibit_buf + 200);
+    rc |= expect_true("dmr-payload-pointer-buffer", state->dmr_payload_p == state->dmr_payload_buf + 200);
+    rc |= expect_true("dmr-payload-pointer-not-dibit", state->dmr_payload_p != state->dibit_buf + 200);
+    rc |= expect_true("dibit-pointer-reset", state->dibit_buf_p == state->dibit_buf + 200);
 
     for (int i = 0; i < 200; i++) {
-        if (state.dmr_payload_buf[i] != 0) {
-            fprintf(stderr, "dmr payload buf[%d] not reset: %d\n", i, state.dmr_payload_buf[i]);
+        if (state->dmr_payload_buf[i] != 0) {
+            fprintf(stderr, "dmr payload buf[%d] not reset: %d\n", i, state->dmr_payload_buf[i]);
             rc = 1;
             break;
         }
     }
 
-    if (state.dmr_reliab_buf != NULL) {
-        rc |= expect_true("dmr-reliab-pointer-buffer", state.dmr_reliab_p == state.dmr_reliab_buf + 200);
+    if (state->dmr_reliab_buf != NULL) {
+        rc |= expect_true("dmr-reliab-pointer-buffer", state->dmr_reliab_p == state->dmr_reliab_buf + 200);
         for (int i = 0; i < 200; i++) {
-            if (state.dmr_reliab_buf[i] != 0U) {
-                fprintf(stderr, "dmr reliab buf[%d] not reset: %u\n", i, (unsigned)state.dmr_reliab_buf[i]);
+            if (state->dmr_reliab_buf[i] != 0U) {
+                fprintf(stderr, "dmr reliab buf[%d] not reset: %u\n", i, (unsigned)state->dmr_reliab_buf[i]);
                 rc = 1;
                 break;
             }
         }
     }
 
-    freeState(&state);
+    free_test_runtime(opts, state);
 
     if (rc == 0) {
         printf("ENGINE_NO_CARRIER_RESET: OK\n");