alloc: first cut of tiny allocator (down to 2 bytes!)
[ccan] / ccan / alloc / test / run-tiny-encode.c
1 #include <ccan/tap/tap.h>
2 #include "config.h"
3 #include <ccan/alloc/tiny.c>
4 #include <ccan/alloc/bitops.c>
5 #include <stdlib.h>
6 #include <err.h>
7
8 /* Test encoding and decoding. */
9 #define ARR_SIZE 10
10
11 int main(void)
12 {
13         unsigned char array[ARR_SIZE];
14         unsigned int i, prev;
15
16         plan_tests(567);
17
18         prev = 0;
19         /* Test encode_length */
20         for (i = 1; i < 0x8000000; i *= 2) {
21                 ok1(encode_length(i-1) >= prev);
22                 ok1(encode_length(i) >= encode_length(i-1));
23                 ok1(encode_length(i+1) >= encode_length(i));
24                 prev = encode_length(i);
25         }
26
27         /* Test it against actual encoding return val. */
28         for (i = 1; i < 0x8000000; i *= 2) {
29                 ok1(encode_length(i-1) == encode(i - 1 + MIN_BLOCK_SIZE,
30                                                  false, array, ARR_SIZE));
31                 ok1(encode_length(i) == encode(i + MIN_BLOCK_SIZE,
32                                                false, array, ARR_SIZE));
33                 ok1(encode_length(i+1) == encode(i + 1 + MIN_BLOCK_SIZE,
34                                                  false, array, ARR_SIZE));
35         }
36
37         /* Test encoder vs. decoder. */
38         for (i = 1; i < 0x8000000; i *= 2) {
39                 unsigned long hdrlen, len;
40                 bool free;
41
42                 hdrlen = encode(i - 1 + MIN_BLOCK_SIZE, false, array, ARR_SIZE);
43                 ok1(decode(&len, &free, array) == hdrlen);
44                 ok1(len == i - 1 + MIN_BLOCK_SIZE);
45                 ok1(free == false);
46
47                 hdrlen = encode(i + MIN_BLOCK_SIZE, true, array, ARR_SIZE);
48                 ok1(decode(&len, &free, array) == hdrlen);
49                 ok1(len == i + MIN_BLOCK_SIZE);
50                 ok1(free == true);
51
52                 hdrlen = encode(i + 1 + MIN_BLOCK_SIZE, true, array, ARR_SIZE);
53                 ok1(decode(&len, &free, array) == hdrlen);
54                 ok1(len == i + 1 + MIN_BLOCK_SIZE);
55                 ok1(free == true);
56         }
57
58         /* Test encoder limit enforcement. */
59         for (i = 1; i < 0x8000000; i *= 2) {
60                 unsigned char *arr;
61                 unsigned int len;
62
63                 /* These should fit. */
64                 ok1(encode(i-1 + MIN_BLOCK_SIZE, false, array,
65                            encode_length(i-1)) == encode_length(i-1));
66                 ok1(encode(i + MIN_BLOCK_SIZE, false, array,
67                            encode_length(i)) == encode_length(i));
68                 ok1(encode(i+1 + MIN_BLOCK_SIZE, false, array,
69                            encode_length(i+1)) == encode_length(i+1));
70
71                 /* These should not: malloc so valgrind finds overruns. */
72                 len = encode_length(i-1) - 1;
73                 arr = malloc(len);
74                 ok1(encode(i-1 + MIN_BLOCK_SIZE, true, arr, len) == 0);
75                 free(arr);
76
77                 len = encode_length(i-1) - 1;
78                 arr = malloc(len);
79                 ok1(encode(i + MIN_BLOCK_SIZE, false, arr, len) == 0);
80                 free(arr);
81
82                 len = encode_length(i+1) - 1;
83                 arr = malloc(len);
84                 ok1(encode(i+1 + MIN_BLOCK_SIZE, false, arr, len) == 0);
85                 free(arr);
86         }
87         return exit_status();
88 }