test_consistency.c
philosophy/test_consistency.c · 246 line(s) · c
#include "consistency_monitor.h"
#include "signal_toss.h"
#include <assert.h>
#include <inttypes.h>
#include <math.h>
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
/* ---- Structural invariant checks --------------------------------------- */
static void test_structure(void) {
sl_branch_view b;
b.trait_count = 10u;
b.weight = 5u;
b.studies_economy = false;
b.economy_arity = 0u;
b.left_branchpoints = 10u;
b.right_branchpoints = 12u;
b.refs = NULL;
b.ref_count = 0u;
assert(sl_branch_check(&b) == SL_CONSISTENT);
/* 45 traits is the hard maximum (ok); 46 is inconsistent. */
b.trait_count = SL_BRANCH_TRAIT_MAX;
assert(sl_branch_check(&b) == SL_CONSISTENT);
assert(sl_branch_trait_warn(&b)); /* 45 >= warn 44 */
b.trait_count = 44u;
assert(sl_branch_trait_warn(&b));
b.trait_count = 43u;
assert(!sl_branch_trait_warn(&b));
b.trait_count = 46u;
assert(sl_branch_check(&b) == SL_INCONSISTENT_TRAITS);
b.trait_count = 10u;
/* Weight band [1,9]. */
b.weight = 0u;
assert(sl_branch_check(&b) == SL_INCONSISTENT_WEIGHT);
b.weight = 10u;
assert(sl_branch_check(&b) == SL_INCONSISTENT_WEIGHT);
assert(sl_branch_clamp_weight(0) == 1u);
assert(sl_branch_clamp_weight(100) == 9u);
assert(sl_branch_clamp_weight(4) == 4u);
b.weight = 5u;
/* A weight-9 economic branch studies exactly two things. */
b.weight = 9u;
b.studies_economy = true;
b.economy_arity = 2u;
assert(sl_branch_check(&b) == SL_CONSISTENT);
b.economy_arity = 3u;
assert(sl_branch_check(&b) == SL_INCONSISTENT_ECONOMY_ARITY);
b.economy_arity = 1u;
assert(sl_branch_check(&b) == SL_INCONSISTENT_ECONOMY_ARITY);
/* The two-things rule only binds weight-9 economic branches. */
b.weight = 8u;
assert(sl_branch_check(&b) == SL_CONSISTENT);
b.weight = 9u;
b.economy_arity = 2u;
/* Neither side exceeds 15 branching points. */
b.left_branchpoints = 15u;
b.right_branchpoints = 15u;
assert(sl_branch_check(&b) == SL_CONSISTENT);
b.left_branchpoints = 16u;
assert(sl_branch_check(&b) == SL_INCONSISTENT_LEFT_HEIGHT);
b.left_branchpoints = 10u;
b.right_branchpoints = 16u;
assert(sl_branch_check(&b) == SL_INCONSISTENT_RIGHT_HEIGHT);
}
/* ---- Maturity by reference weighting ----------------------------------- */
static void test_maturity(void) {
sl_branch_view b;
sl_maturity_result m;
/* High-confidence references: all strongly support maturity. */
sl_reference strong[] = {{3.0, 0.99}, {2.0, 0.98}, {1.0, 0.95}};
/* Split references: weighted truth sits between the gates. */
sl_reference mid[] = {{1.0, 1.0}, {1.0, 0.65}}; /* mean 0.825 */
/* Minority support: below the decisive 0.51 gate. */
sl_reference weak[] = {{1.0, 0.40}, {1.0, 0.30}}; /* mean 0.35 */
/* Exactly on the majority boundary. */
sl_reference edge[] = {{1.0, 0.51}};
b.trait_count = 1u; b.weight = 1u; b.studies_economy = false;
b.economy_arity = 0u; b.left_branchpoints = 0u; b.right_branchpoints = 0u;
b.refs = strong; b.ref_count = 3u;
m = sl_branch_maturity(&b);
assert(m.stage == SL_MATURITY_STRONG); /* >= 0.97 */
assert(m.object_mature);
assert(m.confidence >= SL_MATURE_STRONG);
b.refs = mid; b.ref_count = 2u;
m = sl_branch_maturity(&b);
assert(m.stage == SL_MATURITY_PROVISIONAL);/* >= 0.80, < 0.97 */
assert(m.object_mature); /* > 0.51 */
b.refs = weak; b.ref_count = 2u;
m = sl_branch_maturity(&b);
assert(m.stage == SL_MATURITY_IMMATURE);
assert(!m.object_mature); /* below 0.51 */
b.refs = edge; b.ref_count = 1u;
m = sl_branch_maturity(&b);
assert(m.object_mature); /* exactly 0.51 counts as yes */
assert(m.stage == SL_MATURITY_IMMATURE); /* 0.51 < 0.80 */
/* No references => not mature, confidence 0. */
b.refs = NULL; b.ref_count = 0u;
m = sl_branch_maturity(&b);
assert(!m.object_mature && m.confidence == 0.0);
}
/* ---- Update accounting: +4 per branch, +5 per mature length ------------ */
static void test_accounting(void) {
sl_consistency_report r;
sl_branch_view mature, immature;
sl_reference high[] = {{1.0, 0.99}};
sl_reference low[] = {{1.0, 0.10}};
sl_consistency_report_init(&r);
mature.trait_count = 2u; mature.weight = 3u; mature.studies_economy = false;
mature.economy_arity = 0u; mature.left_branchpoints = 1u;
mature.right_branchpoints = 1u; mature.refs = high; mature.ref_count = 1u;
immature = mature;
immature.refs = low; immature.ref_count = 1u;
/* One mature branch: +4 (branch) +5 (mature length) = 9. */
assert(sl_consistency_consider(&r, &mature) == SL_CONSISTENT);
assert(r.branch_considerations == 1u);
assert(r.mature_length_considerations == 1u);
assert(r.updates == SL_UPDATES_PER_BRANCH + SL_UPDATES_PER_MATURE_LENGTH);
/* One immature branch: +4 only. */
assert(sl_consistency_consider(&r, &immature) == SL_CONSISTENT);
assert(r.branch_considerations == 2u);
assert(r.mature_length_considerations == 1u);
assert(r.updates == 2u * SL_UPDATES_PER_BRANCH + SL_UPDATES_PER_MATURE_LENGTH);
/* An inconsistent branch still counts as considered (+4) but not mature. */
mature.trait_count = 99u; /* too many traits */
assert(sl_consistency_consider(&r, &mature) == SL_INCONSISTENT_TRAITS);
assert(r.inconsistencies == 1u);
assert(r.branch_considerations == 3u);
assert(r.mature_length_considerations == 1u);
}
/* ---- Signal toss cadence & 800-1200/hr throttle ------------------------ */
static bool ever_mature_sampler(sl_branch_view *out, void *ctx) {
static sl_reference refs[] = {{1.0, 0.99}};
unsigned *remaining = (unsigned *)ctx;
out->trait_count = 3u;
out->weight = 9u;
out->studies_economy = true;
out->economy_arity = 2u;
out->left_branchpoints = 12u;
out->right_branchpoints = 13u;
out->refs = refs;
out->ref_count = 1u;
if (*remaining == 0u) return false;
--*remaining;
return true;
}
static void test_toss_rates(void) {
unsigned remaining;
sl_signal_toss *toss;
sl_consistency_report snap;
uint64_t t_ms;
unsigned i;
/* Sample interval is ~22 ms => ~44 Hz. */
assert(sl_signal_toss_sample_interval_ms() == 1000u / SL_TOSS_SAMPLE_HZ);
/* Rate clamping into the 800-1200/hr band. */
remaining = 1u;
toss = sl_signal_toss_create(ever_mature_sampler, &remaining, 500u);
assert(toss);
/* 500 clamps to 800/hr => 4500 ms interval. */
assert(sl_signal_toss_commit_interval_ms(toss) == 3600000u / 800u);
sl_signal_toss_destroy(toss);
remaining = 1u;
toss = sl_signal_toss_create(ever_mature_sampler, &remaining, 5000u);
assert(sl_signal_toss_commit_interval_ms(toss) == 3600000u / 1200u);
sl_signal_toss_destroy(toss);
remaining = 1u;
toss = sl_signal_toss_create(ever_mature_sampler, &remaining, 0u); /* midpoint 1000 */
assert(sl_signal_toss_commit_interval_ms(toss) == 3600000u / 1000u);
/* Drive the step loop over a simulated hour at 44 Hz and confirm the
* committed-update count lands in [800, 1200]. Each mature consistent
* sample accrues +9 updates but commits are throttled by the interval. */
remaining = 0xFFFFFFFFu; /* never asks to stop via remaining */
t_ms = 0u;
{
const uint32_t step = sl_signal_toss_sample_interval_ms();
const uint64_t hour = 3600000u;
for (t_ms = 0u; t_ms < hour; t_ms += step)
(void)sl_signal_toss_step(toss, t_ms);
}
snap = sl_signal_toss_snapshot(toss);
{
uint64_t commits = sl_signal_toss_commits(toss);
printf(" simulated hour: samples=%" PRIu64 " updates=%" PRIu64
" commits=%" PRIu64 "\n",
snap.branch_considerations, snap.updates, commits);
assert(commits >= SL_TOSS_COMMIT_MIN_PER_HOUR);
assert(commits <= SL_TOSS_COMMIT_MAX_PER_HOUR + 1u); /* +1 boundary */
/* ~44 Hz across an hour ~= 162k samples; each mature branch => +9. */
assert(snap.branch_considerations > 100000u);
assert(snap.updates == snap.branch_considerations * 9u);
}
(void)i;
sl_signal_toss_destroy(toss);
}
/* ---- Threaded smoke test ----------------------------------------------- */
static void test_toss_thread(void) {
unsigned remaining = 200u;
sl_signal_toss *toss = sl_signal_toss_create(ever_mature_sampler, &remaining, 1000u);
sl_consistency_report snap;
assert(toss);
assert(sl_signal_toss_start(toss) == 0);
/* Let the worker run briefly, then stop and join. */
sl_sleep_ms(250u);
sl_signal_toss_stop(toss);
snap = sl_signal_toss_snapshot(toss);
assert(snap.branch_considerations > 0u);
assert(snap.inconsistencies == 0u);
sl_signal_toss_destroy(toss);
}
int main(void) {
printf("test_structure...\n"); test_structure();
printf("test_maturity...\n"); test_maturity();
printf("test_accounting...\n"); test_accounting();
printf("test_toss_rates...\n"); test_toss_rates();
printf("test_toss_thread...\n"); test_toss_thread();
printf("all consistency tests passed\n");
return 0;
}