libbsock/test.c

#include <assert.h>
#include <errno.h>

#include "bsock.h"
#include "ringbuf.h"

static int
ringbuf_verify(struct bsock_ringbuf *buf, char *start, size_t sz)
{
	int ret = 1;

	ret = ret && (start == buf->start);
	ret = ret && (buf->sz == sz);

	if (buf->start <= buf->end) {
		ret = ret && (buf->end - buf->start == (int)sz);
	} else {
		ret = ret && (buf->start - buf->end == (int)(buf->max_sz - sz));
	}

	return ret;
}

static void
assert_write(struct bsock_ringbuf *rbuf, void *ctx, struct bsock_ringbuf_io *io, char *buf,
    size_t sz)
{
	char *start = rbuf->start;
	size_t ssz = rbuf->sz;
	assert(bsock_ringbuf_write(rbuf, ctx, io, buf, sz) == (int)sz);
	assert(ringbuf_verify(rbuf, start, ssz + sz));
}

static void
assert_read(struct bsock_ringbuf *rbuf, char *buf, size_t sz)
{
	char *start = rbuf->start;
	size_t ssz = rbuf->sz;
	assert(bsock_ringbuf_read(rbuf, buf, sz) == (int)(sz));
	if (start + sz > rbuf->buf + rbuf->max_sz) {
		start = start + sz - rbuf->max_sz;
	} else {
		start = start + sz;
	}
	assert(ringbuf_verify(rbuf, start, ssz - sz));
}

static void
rbuf_set(struct bsock_ringbuf *rbuf, char *start, size_t sz)
{
	rbuf->start = start;
	rbuf->sz = sz;
	rbuf->end = start + sz;
	if (rbuf->end > rbuf->start + rbuf->max_sz) {
		rbuf->end = rbuf->end - rbuf->max_sz;
	}
}

void
bsock_test(void)
{
	struct bsock_ringbuf rbuf;
	struct bsock_ringbuf_io io = bsock_io_posix();
	char *buf = malloc(1024);
	char *sbuf = malloc(1024);
	for (int i = 0; i < 1024; i++) {
		sbuf[i] = rand() % 256;
	}
	char *buf3 = malloc(1024);

	printf("ringbuf - read/write [128]\n");
	memset(buf3, 0, 1024);
	bsock_ringbuf_init(&rbuf, buf, 1024);
	assert_write(&rbuf, NULL, NULL, sbuf, 128);
	assert_read(&rbuf, buf3, 128);
	assert(memcmp(sbuf, buf3, 128) == 0);

	printf("ringbuf - read overflow\n");
	memset(buf3, 0, 1024);
	bsock_ringbuf_init(&rbuf, buf, 1024);
	assert_write(&rbuf, NULL, NULL, sbuf, 128);
	assert(bsock_ringbuf_read(&rbuf, buf3, 129) == 128);

	printf("ringbuf - read/write [1024]\n");
	memset(buf3, 0, 1024);
	bsock_ringbuf_init(&rbuf, buf, 1024);
	assert_write(&rbuf, NULL, NULL, sbuf, 1024);
	assert_read(&rbuf, buf3, 1024);
	assert(memcmp(sbuf, buf3, 128) == 0);

	printf("ringbuf - read/write [mid]\n");
	memset(buf3, 0, 1024);
	bsock_ringbuf_init(&rbuf, buf, 1024);
	rbuf_set(&rbuf, buf + 256, 0);
	assert_write(&rbuf, NULL, NULL, sbuf, 256);
	assert_read(&rbuf, buf3, 256);
	assert(memcmp(sbuf, buf3, 256) == 0);

	printf("ringbuf - read/write [wrapping + small]\n");
	memset(buf3, 0, 1024);
	bsock_ringbuf_init(&rbuf, buf, 1024);
	rbuf_set(&rbuf, buf + 768, 0);
	assert_write(&rbuf, NULL, NULL, sbuf, 512);
	assert(memcmp(buf + 768, sbuf, 256) == 0);
	assert(memcmp(buf, sbuf + 256, 512 - 256) == 0);
	assert_read(&rbuf, buf3, 128);
	assert(memcmp(sbuf, buf3, 128) == 0);

	printf("ringbuf - read/write [wrapping]\n");
	memset(buf3, 0, 1024);
	bsock_ringbuf_init(&rbuf, buf, 1024);
	rbuf_set(&rbuf, buf + 768, 0);
	assert_write(&rbuf, NULL, NULL, sbuf, 512);
	assert_read(&rbuf, buf3, 512);
	assert(memcmp(sbuf, buf3, 512) == 0);

	int pipes[2];
	printf("ringbuf - write overflow\n");
	assert(pipe(pipes) == 0);
	memset(buf3, 0, 1024);
	bsock_ringbuf_init(&rbuf, buf, 1024);
	assert_write(&rbuf, (void *)(uintptr_t)pipes[1], &io, sbuf, 768);
	assert(bsock_ringbuf_write(&rbuf, (void *)(uintptr_t)pipes[1], &io, sbuf, 512) == 512);
	assert(ringbuf_verify(&rbuf, buf + 768, 512));
	assert(read(pipes[0], buf3, 768) == 768);
	assert(memcmp(sbuf, buf3, 768) == 0);
	assert_read(&rbuf, buf3, 512);
	assert(memcmp(sbuf, buf3, 512) == 0);

	printf("ringbuf - write large\n");
	assert(pipe(pipes) == 0);
	memset(buf3, 0, 1024);
	bsock_ringbuf_init(&rbuf, buf, 768);
	assert_write(&rbuf, (void *)(uintptr_t)pipes[1], &io, sbuf, 512);
	assert(bsock_ringbuf_write(&rbuf, (void *)(uintptr_t)pipes[1], &io, sbuf, 1024) == 1024);
	assert(read(pipes[0], buf3, 512) == 512);
	assert(memcmp(sbuf, buf3, 512) == 0);
	assert(read(pipes[0], buf3, 1024) == 1024);
	assert(memcmp(sbuf, buf3, 1024) == 0);
	assert(ringbuf_verify(&rbuf, buf + 512, 0));


	printf("ringbuf - write no buffering\n");
	assert(pipe(pipes) == 0);
	memset(buf3, 0, 1024);
	bsock_ringbuf_init(&rbuf, NULL, 0);
	assert(bsock_ringbuf_write(&rbuf, (void *)(uintptr_t)pipes[1], &io, sbuf, 1024) == 1024);
	assert(read(pipes[0], buf3, 1024) == 1024);
	assert(memcmp(sbuf, buf3, 1024) == 0);
	assert(ringbuf_verify(&rbuf, NULL, 0));

	printf("ringbuf - poll/flush fp\n");
	assert(pipe(pipes) == 0);
	assert(write(pipes[0], sbuf, 512) == 512);
	bsock_ringbuf_init(&rbuf, buf, 1024);
	assert(bsock_ringbuf_poll(&rbuf, (void *)(uintptr_t)pipes[1], &io, 566) == 512);
	assert(ringbuf_verify(&rbuf, buf, 512));
	assert(bsock_ringbuf_flush(&rbuf, (void *)(uintptr_t)pipes[1], &io, 500) == 500);
	assert(ringbuf_verify(&rbuf, buf + 500, 12));
	assert(read(pipes[0], buf3, 500) == 500);
	assert(memcmp(sbuf, buf3, 500) == 0);

	printf("ringbuf - poll fp [wrapping]\n");
	assert(pipe(pipes) == 0);
	assert(write(pipes[0], sbuf, 512) == 512);
	bsock_ringbuf_init(&rbuf, buf, 1024);
	rbuf_set(&rbuf, buf + 768, 0);
	assert(bsock_ringbuf_poll(&rbuf, (void *)(uintptr_t)pipes[1], &io, 512) == 512);
	assert(ringbuf_verify(&rbuf, buf + 768, 512));
	assert_read(&rbuf, buf3, 512);
	assert(memcmp(sbuf, buf3, 512) == 0);

	printf("ringbuf - flush fp [wrapping]\n");
	assert(pipe(pipes) == 0);
	assert(write(pipes[0], sbuf, 512) == 512);
	bsock_ringbuf_init(&rbuf, buf, 1024);
	rbuf_set(&rbuf, buf + 768, 0);
	assert_write(&rbuf, (void *)(uintptr_t)pipes[1], &io, sbuf, 512);
	assert(bsock_ringbuf_flush(&rbuf, (void *)(uintptr_t)pipes[1], &io, 512) == 512);
	assert(ringbuf_verify(&rbuf, buf + 256, 0));
	assert(read(pipes[0], buf3, 512) == 512);
	assert(memcmp(sbuf, buf3, 512) == 0);
}

int
main(void)
{
	printf("Starting tests...\n");
	bsock_test();

	printf("Tests done!\n");
	return 0;
}