/* bestof_smoke.c -- C-level smoke test for the best-of selection engine. * * Verifies the honest selection contract: a measured-good route beats an * unproven one; weights actually steer the choice; version and cost gates * exclude candidates; certainty tracks delivered fraction; and the winning * choice reports the parts of the internet selected. */ #include "sleela_bestof.h" #include #include static int failures = 0; static void check(int cond, const char* what) { if (!cond) { printf("FAIL: %s\n", what); failures++; } } int main(void) { SLBestOf* b = slbestof_new(); check(b != NULL, "selector opens"); if (!b) { printf("bestof smoke: FAILED\n"); return 1; } /* Three candidate routes with different settings/flags/versions/costs. */ int fast = slbestof_add_candidate(b, "fast-edge", "sdps://edge:19866", 200, 64, 5, SL_BESTOF_FLAG_CRYPTO | SL_BESTOF_FLAG_PACING, 2, 10, 3); int slow = slbestof_add_candidate(b, "slow-relay", "tcp://relay:8080", 2000, 512, 0, SL_BESTOF_FLAG_RETRY, 1, 30, 1); int unproven = slbestof_add_candidate(b, "spare", "tcp://spare:9090", 1000, 128, 0, 0, 2, 5, 1); check(fast == 0 && slow == 1 && unproven == 2, "three candidates registered"); /* Fold honest Synchro-style measurements: fast route is quick + reliable; * slow route is slow with some loss; spare route is never measured. */ for (int i = 0; i < 10; i++) slbestof_record(b, fast, 800 + (i % 3) * 50); /* ~0.8ms */ for (int i = 0; i < 10; i++) slbestof_record(b, slow, (i % 4 == 0) ? -1 : 40000); /* 40ms + 25% loss */ /* spare: no measurements -> unproven */ check(slbestof_mean_us(b, fast) > 0 && slbestof_mean_us(b, fast) < 2000, "fast mean is sub-2ms"); check(slbestof_loss_permille(b, slow) >= 200, "slow route shows real loss"); check(slbestof_certainty_permille(b, unproven) == 0, "unproven route has zero certainty (never assumed good)"); check(slbestof_certainty_permille(b, fast) > slbestof_certainty_permille(b, slow), "fast route earns higher certainty than lossy slow route"); /* Data-weighted: the measured-fast route should win. */ slbestof_weight(b, SL_BESTOF_AXIS_DATA, 70); slbestof_weight(b, SL_BESTOF_AXIS_DECISIONS, 20); slbestof_weight(b, SL_BESTOF_AXIS_COSTS, 5); slbestof_weight(b, SL_BESTOF_AXIS_VERSIONS, 5); int best = slbestof_best(b); check(best == fast, "data-weighted best-of picks the measured-fast route"); check(slbestof_score(b, fast) > slbestof_score(b, unproven), "a measured-good route outscores an unproven one"); /* Version gate: require v2 -> the slow v1 route is excluded. */ slbestof_min_version(b, 2); check(slbestof_best(b) != slow, "min-version gate excludes the v1 route"); /* Cost budget: cap at 8 -> only the spare (cost 5) qualifies among v>=2. */ slbestof_min_version(b, 0); slbestof_cost_budget(b, 8); int budgeted = slbestof_best(b); check(budgeted == unproven, "cost budget selects the only affordable candidate"); /* Internet-architecture fitness (NETWORK.md): DiffServ / IntServ / MPLS. * Record + read back the architecture a route is served by. */ slbestof_candidate_arch(b, fast, SL_BESTOF_ARCH_DIFFSERV, 46, SL_BESTOF_ARCH_REALIZED); slbestof_candidate_arch(b, slow, SL_BESTOF_ARCH_INTSERV, 2000, SL_BESTOF_ARCH_DENIED); slbestof_candidate_arch(b, unproven, SL_BESTOF_ARCH_MPLS, 17, SL_BESTOF_ARCH_REALIZED); check(slbestof_arch(b, fast) == SL_BESTOF_ARCH_DIFFSERV, "edge records DiffServ"); check(slbestof_arch_param(b, fast) == 46, "edge records DSCP 46 (EF)"); check(slbestof_arch_state(b, slow) == SL_BESTOF_ARCH_DENIED, "relay RSVP is denied"); /* Isolate the architecture axis: two candidates with IDENTICAL measurements * but different realized architectures. IntServ (end-to-end reservation) * outranks DiffServ (per-hop marking) when architecture is what differs. */ SLBestOf* a = slbestof_new(); slbestof_weight(a, SL_BESTOF_AXIS_DATA, 0); slbestof_weight(a, SL_BESTOF_AXIS_DECISIONS, 0); slbestof_weight(a, SL_BESTOF_AXIS_COSTS, 0); slbestof_weight(a, SL_BESTOF_AXIS_VERSIONS, 0); slbestof_weight(a, SL_BESTOF_AXIS_ARCHITECTURE, 100); int ds = slbestof_add_candidate(a, "ds", "tcp://a:1", 100, 64, 0, 0, 1, 10, 1); int is = slbestof_add_candidate(a, "is", "tcp://b:1", 100, 64, 0, 0, 1, 10, 1); int mp = slbestof_add_candidate(a, "mp", "tcp://c:1", 100, 64, 0, 0, 1, 10, 1); int be = slbestof_add_candidate(a, "be", "tcp://d:1", 100, 64, 0, 0, 1, 10, 1); slbestof_candidate_arch(a, ds, SL_BESTOF_ARCH_DIFFSERV, 46, SL_BESTOF_ARCH_REALIZED); slbestof_candidate_arch(a, is, SL_BESTOF_ARCH_INTSERV, 2000, SL_BESTOF_ARCH_REALIZED); slbestof_candidate_arch(a, mp, SL_BESTOF_ARCH_MPLS, 17, SL_BESTOF_ARCH_REALIZED); /* be is left best-effort */ check(slbestof_best(a) == is, "realized IntServ (end-to-end) is the top architecture"); check(slbestof_score(a, is) > slbestof_score(a, mp), "IntServ > MPLS on architecture"); check(slbestof_score(a, mp) > slbestof_score(a, ds), "MPLS > DiffServ on architecture"); check(slbestof_score(a, ds) > slbestof_score(a, be), "realized DiffServ > best-effort"); /* A denied reservation drops below best-effort; re-realizing recovers it. */ slbestof_arch_realized(a, is, SL_BESTOF_ARCH_DENIED); check(slbestof_score(a, is) < slbestof_score(a, be), "denied IntServ falls below best-effort"); slbestof_arch_realized(a, is, SL_BESTOF_ARCH_REALIZED); check(slbestof_best(a) == is, "re-realized IntServ recovers the top spot"); slbestof_close(a); /* The winning choice reports the parts of the internet selected. */ slbestof_weight(b, SL_BESTOF_AXIS_DATA, 70); slbestof_weight(b, SL_BESTOF_AXIS_DECISIONS, 20); slbestof_weight(b, SL_BESTOF_AXIS_COSTS, 5); slbestof_weight(b, SL_BESTOF_AXIS_VERSIONS, 5); slbestof_weight(b, SL_BESTOF_AXIS_ARCHITECTURE, 15); char choice[512]; int n = slbestof_choice(b, choice, sizeof(choice)); check(n > 0 && strstr(choice, "://") != NULL, "choice names the winning route"); check(strstr(choice, "flags=[") != NULL, "choice names the selected flags"); check(strstr(choice, "arch=") != NULL, "choice names the selected architecture"); printf("choice: %s\n", choice); char report[2048]; slbestof_report(b, report, sizeof(report)); printf("%s", report); slbestof_close(b); if (failures) { printf("bestof smoke: FAILED (%d)\n", failures); return 1; } printf("bestof smoke: PASS\n"); return 0; }