creole/c_test/encode_decode.c

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

#if 0
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);
	}
}
#endif

void encode_decode_byte_seq(creole_word max, unsigned encode_to, unsigned high_bits) {
	unsigned char buf[7];
	struct creole_reader r = {0};
	struct word w;
	creole_word i = 0;

	for (;;) {
		r.p = buf;
		r.left = encode_to;
		assert(creole_encode(i, encode_to, high_bits,
		                        buf) == 1);

		assert(decode_seq(&r, &w) == 1);
		assert(w.len == encode_to);
		if (w.high_bits != high_bits) {
			printf("high bits %u != %u\n", w.high_bits, high_bits);
			abort();
		}

		if (w.word != i) {
			printf("word %X != %X\n", w.word, i);
			abort();
		}

		if (i == max)
			break;
		i++;
	}
}

static void test_encode_decode(void) {
	unsigned high_bits = 0;
	int encode_len;
	const creole_word maxima[6] = {0x7F, 0xFFF, 0x1FFFF, 0x3FFFFF, 0x7FFFFFF, 0xFFFFFFFF};

	encode_decode_byte_seq(0x7F, 1, 0);

#pragma omp parallel for collapse(2) num_threads(8)
	for (high_bits = 0; high_bits < 16; high_bits++) {
		for (encode_len = 2; encode_len < 8; encode_len++)
			encode_decode_byte_seq(maxima[encode_len - 2], encode_len, high_bits);
	}
}

int main(void) {
	printf("test encode\n");
	test_encode_decode();

	printf("finished\n");
	return 0;
}