reg_synchro.c
test-suites/regression/c/reg_synchro.c · 374 line(s) · c
/*
* reg_synchro.c -- regression suite for impl/core/sleela_synchro.c (POSIX
* build; UDP probes against an echo server on the loopback interface)
*
* Contract (impl/core/sleela_synchro.h):
* - open refuses a NULL/empty host; every accessor tolerates a NULL handle;
* - dispatch sends one timestamped probe and returns the round-trip time in
* microseconds, or -1 on loss, timeout, a bad timeout argument or a send
* failure; a reply counts only when it echoes the probe's sequence tag;
* - payloads are clamped to 8..1472 bytes;
* - statistics come only from matched replies: min <= mean <= max, the
* percentile is clamped to 0..100 and is monotonic, loss is per mille;
* - the sample store is bounded (4096) and keeps working past that bound;
* - report is always NUL-terminated and never writes past the capacity.
*
* The echo server runs in a thread that never uses the REG_ macros.
*/
#define _POSIX_C_SOURCE 200809L
#include "../../../impl/core/sleela_synchro.h"
#include "regression.h"
#ifdef _WIN32
#include <stdio.h>
int main(void) { puts("SUITE synchro: skipped (POSIX-only suite)"); return 0; }
#else
#include <arpa/inet.h>
#include <netinet/in.h>
#include <poll.h>
#include <pthread.h>
#include <stdio.h>
#include <string.h>
#include <sys/socket.h>
#include <time.h>
#include <unistd.h>
static uint64_t now_ms(void) {
struct timespec ts; clock_gettime(CLOCK_MONOTONIC, &ts);
return (uint64_t)ts.tv_sec * 1000u + (uint64_t)ts.tv_nsec / 1000000u;
}
typedef enum {
MODE_ECHO, /* reply to every probe */
MODE_DROP_ODD, /* swallow every second probe */
MODE_STALE_FIRST, /* send a reply with a wrong tag, then the right one */
MODE_SHORT_FIRST, /* send a 2-byte datagram, then the right reply */
MODE_WRONG_ONLY /* only ever reply with a wrong tag */
} Mode;
typedef struct {
int fd;
uint16_t port;
Mode mode;
volatile int stop;
volatile int min_len; /* shortest / longest probe the server saw */
volatile int max_len;
volatile int seen;
} Server;
static void *serve(void *arg) {
Server *sv = (Server *)arg;
unsigned char buf[2048];
while (!sv->stop) {
struct pollfd p = { sv->fd, POLLIN, 0 };
struct sockaddr_in from;
socklen_t fl = sizeof from;
ssize_t n;
if (poll(&p, 1, 10) <= 0) continue;
n = recvfrom(sv->fd, buf, sizeof buf, 0, (struct sockaddr *)&from, &fl);
if (n < 0) continue;
sv->seen++;
if (sv->seen == 1 || (int)n < sv->min_len) sv->min_len = (int)n;
if ((int)n > sv->max_len) sv->max_len = (int)n;
switch (sv->mode) {
case MODE_ECHO:
sendto(sv->fd, buf, (size_t)n, 0, (struct sockaddr *)&from, fl);
break;
case MODE_DROP_ODD:
if (sv->seen % 2 == 1) sendto(sv->fd, buf, (size_t)n, 0, (struct sockaddr *)&from, fl);
break;
case MODE_STALE_FIRST: {
unsigned char wrong[8];
memcpy(wrong, buf, 8);
wrong[3] = (unsigned char)(wrong[3] + 77u); /* a different tag */
sendto(sv->fd, wrong, 8, 0, (struct sockaddr *)&from, fl);
sendto(sv->fd, buf, (size_t)n, 0, (struct sockaddr *)&from, fl);
break;
}
case MODE_SHORT_FIRST:
sendto(sv->fd, buf, 2, 0, (struct sockaddr *)&from, fl);
sendto(sv->fd, buf, (size_t)n, 0, (struct sockaddr *)&from, fl);
break;
case MODE_WRONG_ONLY: {
unsigned char wrong[8];
memcpy(wrong, buf, 8);
wrong[3] = (unsigned char)(wrong[3] + 77u);
sendto(sv->fd, wrong, 8, 0, (struct sockaddr *)&from, fl);
break;
}
}
}
return NULL;
}
static int server_start(Server *sv, pthread_t *th, Mode mode) {
struct sockaddr_in a;
socklen_t al = sizeof a;
memset(sv, 0, sizeof *sv);
sv->mode = mode;
sv->fd = socket(AF_INET, SOCK_DGRAM, 0);
if (sv->fd < 0) return 0;
memset(&a, 0, sizeof a);
a.sin_family = AF_INET;
a.sin_addr.s_addr = htonl(INADDR_LOOPBACK);
a.sin_port = 0; /* any free port */
if (bind(sv->fd, (struct sockaddr *)&a, sizeof a) != 0 ||
getsockname(sv->fd, (struct sockaddr *)&a, &al) != 0) { close(sv->fd); return 0; }
sv->port = ntohs(a.sin_port);
if (pthread_create(th, NULL, serve, sv) != 0) { close(sv->fd); return 0; }
return 1;
}
static void server_stop(Server *sv, pthread_t th) {
sv->stop = 1;
pthread_join(th, NULL);
close(sv->fd);
}
/* ---- arguments and empty state ---------------------------------------------- */
static void t_open_arguments(void) {
REG_CHECK(slsynchro_open(NULL, 9) == NULL);
REG_CHECK(slsynchro_open("", 9) == NULL);
REG_CHECK(slsynchro_open("host.invalid", 9) == NULL);
slsynchro_close(NULL); /* no-op */
}
static void t_null_handle_accessors(void) {
char out[32] = "junk";
REG_EQ_I(0, slsynchro_sent(NULL));
REG_EQ_I(0, slsynchro_received(NULL));
REG_EQ_I(-1, slsynchro_mean_us(NULL));
REG_EQ_I(-1, slsynchro_min_us(NULL));
REG_EQ_I(-1, slsynchro_max_us(NULL));
REG_EQ_I(-1, slsynchro_percentile_us(NULL, 50));
REG_EQ_I(0, slsynchro_loss_permille(NULL));
REG_EQ_I(-1, slsynchro_dispatch(NULL, 64, 10));
REG_EQ_I(0, slsynchro_report(NULL, out, sizeof out));
REG_EQ_I(0, out[0]); /* cleared, not left as junk */
REG_EQ_I(0, slsynchro_report(NULL, NULL, 0));
}
static void t_fresh_handle_has_no_statistics(void) {
Server sv; pthread_t th;
SLSynchro *s;
REG_REQUIRE(server_start(&sv, &th, MODE_ECHO));
s = slsynchro_open("127.0.0.1", sv.port);
REG_REQUIRE(s != NULL);
REG_EQ_I(0, slsynchro_sent(s));
REG_EQ_I(0, slsynchro_received(s));
REG_EQ_I(-1, slsynchro_mean_us(s)); /* no samples: -1, not 0 and not a crash */
REG_EQ_I(-1, slsynchro_min_us(s));
REG_EQ_I(-1, slsynchro_max_us(s));
REG_EQ_I(-1, slsynchro_percentile_us(s, 95));
REG_EQ_I(0, slsynchro_loss_permille(s));
slsynchro_close(s);
server_stop(&sv, th);
}
static void t_negative_timeout_is_refused(void) {
Server sv; pthread_t th;
SLSynchro *s;
REG_REQUIRE(server_start(&sv, &th, MODE_ECHO));
s = slsynchro_open("127.0.0.1", sv.port);
REG_REQUIRE(s != NULL);
REG_EQ_I(-1, slsynchro_dispatch(s, 64, -1));
REG_EQ_I(0, slsynchro_sent(s)); /* nothing was sent */
slsynchro_close(s);
server_stop(&sv, th);
}
/* ---- measurement ------------------------------------------------------------ */
static void t_round_trips_and_statistics(void) {
Server sv; pthread_t th;
SLSynchro *s;
int i;
int64_t last = 0, p0, p50, p95, p100, mn, mx, mean;
REG_REQUIRE(server_start(&sv, &th, MODE_ECHO));
s = slsynchro_open("127.0.0.1", sv.port);
REG_REQUIRE(s != NULL);
for (i = 0; i < 40; ++i) {
last = slsynchro_dispatch(s, 64, 500);
REG_CHECK(last >= 0 && last < 500000); /* a real reply, in under 500 ms */
}
REG_EQ_I(40, slsynchro_sent(s));
REG_EQ_I(40, slsynchro_received(s));
REG_EQ_I(0, slsynchro_loss_permille(s));
mn = slsynchro_min_us(s); mx = slsynchro_max_us(s); mean = slsynchro_mean_us(s);
REG_CHECK(mn >= 0 && mn <= mean && mean <= mx);
p0 = slsynchro_percentile_us(s, 0);
p50 = slsynchro_percentile_us(s, 50);
p95 = slsynchro_percentile_us(s, 95);
p100 = slsynchro_percentile_us(s, 100);
REG_EQ_I(mn, p0); /* p0 is the minimum, p100 the maximum */
REG_EQ_I(mx, p100);
REG_CHECK(p0 <= p50 && p50 <= p95 && p95 <= p100); /* monotonic in p */
REG_EQ_I(mn, slsynchro_percentile_us(s, -20)); /* out-of-range p is clamped */
REG_EQ_I(mx, slsynchro_percentile_us(s, 1000));
(void)last;
slsynchro_close(s);
server_stop(&sv, th);
}
static void t_payload_is_clamped(void) {
Server sv; pthread_t th;
SLSynchro *s;
REG_REQUIRE(server_start(&sv, &th, MODE_ECHO));
s = slsynchro_open("127.0.0.1", sv.port);
REG_REQUIRE(s != NULL);
REG_CHECK(slsynchro_dispatch(s, 0, 500) >= 0); /* too small: raised to 8 */
REG_CHECK(slsynchro_dispatch(s, 3, 500) >= 0);
REG_CHECK(slsynchro_dispatch(s, 100000, 500) >= 0); /* too large: cut to 1472 */
slsynchro_close(s);
server_stop(&sv, th);
REG_EQ_I(8, sv.min_len);
REG_EQ_I(1472, sv.max_len);
}
static void t_loss_is_counted(void) {
Server sv; pthread_t th;
SLSynchro *s;
int i, ok = 0, lost = 0;
REG_REQUIRE(server_start(&sv, &th, MODE_DROP_ODD));
s = slsynchro_open("127.0.0.1", sv.port);
REG_REQUIRE(s != NULL);
for (i = 0; i < 10; ++i) {
int64_t r = slsynchro_dispatch(s, 32, 250);
if (r >= 0) ++ok; else ++lost;
}
REG_EQ_I(5, ok);
REG_EQ_I(5, lost);
REG_EQ_I(10, slsynchro_sent(s));
REG_EQ_I(5, slsynchro_received(s));
REG_EQ_I(500, slsynchro_loss_permille(s));
REG_CHECK(slsynchro_mean_us(s) >= 0); /* only matched replies feed the statistics */
slsynchro_close(s);
server_stop(&sv, th);
}
static void t_stale_reply_is_ignored(void) {
Server sv; pthread_t th;
SLSynchro *s;
int64_t r;
REG_REQUIRE(server_start(&sv, &th, MODE_STALE_FIRST));
s = slsynchro_open("127.0.0.1", sv.port);
REG_REQUIRE(s != NULL);
r = slsynchro_dispatch(s, 32, 500);
REG_CHECK(r >= 0); /* the right reply still arrives behind it */
REG_EQ_I(1, slsynchro_received(s));
slsynchro_close(s);
server_stop(&sv, th);
}
static void t_short_reply_is_ignored(void) {
Server sv; pthread_t th;
SLSynchro *s;
REG_REQUIRE(server_start(&sv, &th, MODE_SHORT_FIRST));
s = slsynchro_open("127.0.0.1", sv.port);
REG_REQUIRE(s != NULL);
REG_CHECK(slsynchro_dispatch(s, 32, 500) >= 0);
REG_EQ_I(1, slsynchro_received(s));
slsynchro_close(s);
server_stop(&sv, th);
}
static void t_wrong_tag_only_times_out_on_budget(void) {
Server sv; pthread_t th;
SLSynchro *s;
uint64_t t0, dt;
REG_REQUIRE(server_start(&sv, &th, MODE_WRONG_ONLY));
s = slsynchro_open("127.0.0.1", sv.port);
REG_REQUIRE(s != NULL);
t0 = now_ms();
REG_EQ_I(-1, slsynchro_dispatch(s, 32, 120));
dt = now_ms() - t0;
REG_CHECK(dt >= 100 && dt < 2000); /* gave up at the budget, neither at once nor never */
REG_EQ_I(0, slsynchro_received(s)); /* a mismatched reply is never a sample */
REG_EQ_I(-1, slsynchro_mean_us(s));
REG_EQ_I(1000, slsynchro_loss_permille(s));
slsynchro_close(s);
server_stop(&sv, th);
}
static void t_dead_port_is_loss_not_hang(void) {
Server sv; pthread_t th;
SLSynchro *s;
uint64_t t0;
uint16_t port;
REG_REQUIRE(server_start(&sv, &th, MODE_ECHO));
port = sv.port;
server_stop(&sv, th); /* the port is now closed */
s = slsynchro_open("127.0.0.1", port);
REG_REQUIRE(s != NULL);
t0 = now_ms();
REG_EQ_I(-1, slsynchro_dispatch(s, 32, 300));
REG_CHECK(now_ms() - t0 < 2000);
REG_EQ_I(1, slsynchro_sent(s));
REG_EQ_I(0, slsynchro_received(s));
slsynchro_close(s);
}
/* The sample store holds 4096 entries; probes beyond that must not overflow it. */
static void t_sample_store_is_bounded(void) {
Server sv; pthread_t th;
SLSynchro *s;
int i, got = 0;
int64_t mn, mx, p50;
enum { PROBES = SL_SYNCHRO_MAX_SAMPLES + 300 };
REG_REQUIRE(server_start(&sv, &th, MODE_ECHO));
s = slsynchro_open("127.0.0.1", sv.port);
REG_REQUIRE(s != NULL);
for (i = 0; i < PROBES; ++i)
if (slsynchro_dispatch(s, 8, 1000) >= 0) ++got;
REG_EQ_I(got, slsynchro_received(s));
REG_CHECK(got > SL_SYNCHRO_MAX_SAMPLES); /* we really went past the bound */
mn = slsynchro_min_us(s); mx = slsynchro_max_us(s); p50 = slsynchro_percentile_us(s, 50);
REG_CHECK(mn >= 0 && mn <= p50 && p50 <= mx);
slsynchro_close(s);
server_stop(&sv, th);
}
/* ---- report ------------------------------------------------------------------ */
static void t_report_format_and_bounds(void) {
Server sv; pthread_t th;
SLSynchro *s;
char out[256], want[64], tiny[12];
int n, i;
REG_REQUIRE(server_start(&sv, &th, MODE_ECHO));
s = slsynchro_open("127.0.0.1", sv.port);
REG_REQUIRE(s != NULL);
for (i = 0; i < 3; ++i) REG_CHECK(slsynchro_dispatch(s, 16, 500) >= 0);
n = slsynchro_report(s, out, sizeof out);
REG_CHECK(n > 0 && (size_t)n == strlen(out));
snprintf(want, sizeof want, "synchro 127.0.0.1:%u sent=3 recv=3 loss=0permille", (unsigned)sv.port);
REG_CHECK(strncmp(out, want, strlen(want)) == 0);
REG_CHECK(strstr(out, "mean=") && strstr(out, "p95=") && strstr(out, "min=") && strstr(out, "max="));
memset(tiny, 'x', sizeof tiny);
n = slsynchro_report(s, tiny, sizeof tiny); /* truncated: capacity - 1, NUL-terminated */
REG_EQ_I((int)sizeof tiny - 1, n);
REG_EQ_I(0, tiny[sizeof tiny - 1]);
REG_EQ_I(0, slsynchro_report(s, out, 0));
slsynchro_close(s);
server_stop(&sv, th);
}
int main(void) {
alarm(180);
printf("synchro regression suite (loopback UDP)\n");
REG_RUN(t_open_arguments);
REG_RUN(t_null_handle_accessors);
REG_RUN(t_fresh_handle_has_no_statistics);
REG_RUN(t_negative_timeout_is_refused);
REG_RUN(t_round_trips_and_statistics);
REG_RUN(t_payload_is_clamped);
REG_RUN(t_loss_is_counted);
REG_RUN(t_stale_reply_is_ignored);
REG_RUN(t_short_reply_is_ignored);
REG_RUN(t_wrong_tag_only_times_out_on_budget);
REG_RUN(t_dead_port_is_loss_not_hang);
REG_RUN(t_sample_store_is_bounded);
REG_RUN(t_report_format_and_bounds);
return reg_finish("synchro");
}
#endif