creole/test_encode_decode.c

#include "creole.c"
#include <string.h>
#include <assert.h>
#include <stdio.h>
#include <stdlib.h>

struct seq {
	creole_word max;
	unsigned encode_to;
	unsigned high_bits;

	unsigned char minbuf[7];
	unsigned char maxbuf[7];
};

void bprint(unsigned char c) {
	int i;

	for (i = 0; i < 8; i++) {
		printf("%u", (c >> (7 - i)) & 1);
	}
}

void bprintb(unsigned char *b, int len) {
	while (len-- > 0) {
		bprint(*b++);
		printf(" ");
	}
}

static void encode_byte_seq(struct seq *s) {
	creole_word i = 0;
	int j;
	unsigned char buf[7];

	for (;;) {

		assert(creole_encode(i, s->encode_to, s->high_bits,
		                        buf) == 1);
		if (memcmp(s->minbuf, buf, s->encode_to) != 0) {
			printf("0x%X ", i);
			bprintb(s->minbuf, s->encode_to);
			printf("|");
			bprintb(buf, s->encode_to);
			printf("\n");
			abort();
		}

		if (i == s->max)
			break;
		i++;

		for (j = s->encode_to - 1; j > 0; j--) {
			if (s->minbuf[j] == 0xBF) {
				s->minbuf[j] = 0x80;
			} else {
				s->minbuf[j]++;
				break;
			}
		}

		if (j == 0)
			s->minbuf[0]++;
	}
	assert(memcmp(s->maxbuf, s->minbuf, s->encode_to) == 0);
}

static void encode_1(void) {
	struct seq s;

	s.max = 0x7F;
	s.encode_to = 1;
	s.high_bits = 0;
	s.minbuf[0] = 0x00;
	s.maxbuf[0] = 0x7F;

	encode_byte_seq(&s);
}

static void encode_2(unsigned high_bits) {
	struct seq s;
	s.high_bits = high_bits;

	memset(s.maxbuf, 0xBF, sizeof(s.maxbuf));
	memset(s.minbuf, 0x80, sizeof(s.minbuf));
	s.max = 0x7F;
	s.encode_to = 2;
	s.maxbuf[0] = s.minbuf[0] = 0xC0 | (high_bits << 1);
	s.maxbuf[0] = 0xC1 | (high_bits << 1);
	s.minbuf[1] = 0x80;
	encode_byte_seq(&s);
}

static void encode_3(unsigned high_bits) {
	struct seq s;
	s.high_bits = high_bits;

	memset(s.maxbuf, 0xBF, sizeof(s.maxbuf));
	memset(s.minbuf, 0x80, sizeof(s.minbuf));
	s.max = 0xFFF;
	s.encode_to = 3;
	s.minbuf[0] = 0xE0 | high_bits;
	s.maxbuf[0] = 0xE0 | high_bits;
	s.minbuf[1] = 0x80;
	encode_byte_seq(&s);
}

static void encode_4(unsigned high_bits) {
	struct seq s;
	s.high_bits = high_bits;

	memset(s.maxbuf, 0xBF, sizeof(s.maxbuf));
	memset(s.minbuf, 0x80, sizeof(s.minbuf));
	s.max = 0x1FFFF;
	s.encode_to = 4;
	s.maxbuf[0] = s.minbuf[0] = 0xF0 | (high_bits >> 1);
	s.minbuf[1] = 0x80 | ((high_bits & 0x1) << 5);
	s.maxbuf[1] = 0x9F | ((high_bits & 0x1) << 5);
	encode_byte_seq(&s);
}

static void encode_5(unsigned high_bits) {
	struct seq s;
	s.high_bits = high_bits;

	memset(s.maxbuf, 0xBF, sizeof(s.maxbuf));
	memset(s.minbuf, 0x80, sizeof(s.minbuf));
	s.max = 0x3FFFFF;
	s.encode_to = 5;
	s.maxbuf[0] = s.minbuf[0] = 0xF8 | (high_bits >> 2);
	s.minbuf[1] = 0x80 | ((high_bits & 0x3) << 4);
	s.maxbuf[1] = 0x8F | ((high_bits & 0x3) << 4);
	encode_byte_seq(&s);
}

static void encode_6(unsigned high_bits) {
	struct seq s;
	s.high_bits = high_bits;

	memset(s.maxbuf, 0xBF, sizeof(s.maxbuf));
	memset(s.minbuf, 0x80, sizeof(s.minbuf));
	s.max = 0x7FFFFFF;
	s.encode_to = 6;
	s.maxbuf[0] = s.minbuf[0] = 0xFC | (high_bits >> 3);
	s.minbuf[1] = 0x80 | ((high_bits & 0x7) << 3);
	s.maxbuf[1] = 0x87 | ((high_bits & 0x7) << 3);
	encode_byte_seq(&s);
}

static void encode_7(unsigned high_bits) {
	struct seq s;
	s.high_bits = high_bits;

	memset(s.maxbuf, 0xBF, sizeof(s.maxbuf));
	memset(s.minbuf, 0x80, sizeof(s.minbuf));
	s.max = 0xFFFFFFFF;
	s.encode_to = 7;
	s.maxbuf[0] = s.minbuf[0] = 0xFE;
	s.minbuf[1] = 0x80 | (high_bits << 2);
	s.maxbuf[1] = 0x83 | (high_bits << 2);
	encode_byte_seq(&s);
}

static void test_encode(void) {
	void (*tests[6])(unsigned) = {encode_2, encode_3, encode_4, encode_5, encode_6, encode_7};
	unsigned high_bits;
	unsigned test;
	encode_1();

# pragma omp parallel for collapse(2) num_threads(8)
	for (high_bits = 0; high_bits < 16; high_bits++) {
		for (test = 0; test < 6; test++)
			tests[test](high_bits);
	}
}

int main(void) {
	test_encode();
	return 0;
}