check_vectors.c (4707B)
1 #include <check.h> 2 #include <stdlib.h> 3 #include <string.h> 4 5 #include "rlp.h" 6 7 START_TEST(rlp_dog_test) { 8 char buf[1024]; 9 char *zbuf = (char*)&buf; 10 int l; 11 12 char state = RLP_STRING; 13 14 rlp_encoder_t encoder; 15 16 rlp_init(&encoder, 1024, NULL); 17 char *x_dog = "dog"; 18 char r_dog[4] = {0x83, 'd', 'o', 'g'}; 19 rlp_add(&encoder, 3, x_dog); 20 ck_assert_mem_eq(encoder.buf, r_dog, 4); 21 ck_assert_int_eq(encoder.size, 4); 22 23 // reuse for decode 24 rlp_init(&encoder, 4, encoder.buf); 25 rlp_next(&encoder, &l, &zbuf); 26 ck_assert_mem_eq(&encoder.state, &state, 1); 27 ck_assert_int_eq(l, 3); 28 ck_assert_mem_eq(zbuf, x_dog, l); 29 30 state = RLP_END; 31 rlp_next(&encoder, &l, &zbuf); 32 ck_assert_mem_eq(&encoder.state, &state, 1); 33 34 rlp_free(&encoder); 35 } 36 END_TEST 37 38 START_TEST(rlp_catdog_test) { 39 rlp_encoder_t encoder; 40 41 char buf[1024]; 42 char *zbuf = (char*)&buf; 43 int l; 44 char state; 45 46 char *x_dog = "dog"; 47 char *x_cat = "cat"; 48 char r_catdog[9] = {0xc8, 0x83, 'c', 'a', 't', 0x83, 'd', 'o', 'g'}; 49 50 rlp_init(&encoder, 1024, NULL); 51 rlp_descend(&encoder); 52 rlp_add(&encoder, 3, x_cat); 53 rlp_add(&encoder, 3, x_dog); 54 rlp_ascend(&encoder); 55 ck_assert_mem_eq(encoder.buf, r_catdog, 9); 56 ck_assert_int_eq(encoder.size, 9); 57 58 // reuse for decode 59 state = RLP_LIST_DESCEND; 60 rlp_init(&encoder, 9, encoder.buf); 61 rlp_next(&encoder, &l, &zbuf); 62 ck_assert_mem_eq(&encoder.state, &state, 1); 63 ck_assert_int_eq(l, 8); 64 65 state = RLP_STRING; 66 rlp_next(&encoder, &l, &zbuf); 67 ck_assert_mem_eq(&encoder.state, &state, 1); 68 ck_assert_mem_eq(zbuf, x_cat, l); 69 70 rlp_next(&encoder, &l, &zbuf); 71 ck_assert_mem_eq(&encoder.state, &state, 1); 72 ck_assert_mem_eq(zbuf, x_dog, l); 73 74 state = RLP_END; 75 rlp_next(&encoder, &l, &zbuf); 76 ck_assert_mem_eq(&encoder.state, &state, 1); 77 78 rlp_free(&encoder); 79 } 80 END_TEST 81 82 START_TEST(rlp_lorem_test) { 83 rlp_encoder_t encoder; 84 85 char buf[1024]; 86 char *zbuf = (char*)&buf; 87 int l; 88 char state; 89 90 char *lorem = "Lorem ipsum dolor sit amet, consectetur adipisicing elit"; 91 char target[2] = {0xb8, strlen(lorem)}; 92 93 rlp_init(&encoder, 1024, NULL); 94 rlp_add(&encoder, strlen(lorem), lorem); 95 ck_assert_mem_eq(encoder.buf, target, 2); 96 ck_assert_mem_eq(encoder.buf+2, lorem, strlen(lorem)); 97 ck_assert_int_eq(encoder.size, 2 + strlen(lorem)); 98 99 // reuse for decode 100 state = RLP_STRING; 101 rlp_init(&encoder, strlen(lorem) + 2, encoder.buf); 102 rlp_next(&encoder, &l, &zbuf); 103 ck_assert_mem_eq(&encoder.state, &state, 1); 104 ck_assert_int_eq(l, strlen(lorem)); 105 ck_assert_mem_eq(zbuf, lorem, l); 106 107 state = RLP_END; 108 rlp_next(&encoder, &l, &zbuf); 109 ck_assert_mem_eq(&encoder.state, &state, 1); 110 111 rlp_free(&encoder); 112 } 113 END_TEST 114 115 START_TEST(rlp_set_theoretical_representation_of_three) { 116 117 unsigned char target[8] = {0xc7, 0xc0, 0xc1, 0xc0, 0xc3, 0xc0, 0xc1, 0xc0}; 118 int target_lengths[15] = { 119 7, 120 0, 121 0, 122 1, 123 0, 124 0, 125 0, 126 3, 127 0, 128 0, 129 1, 130 0, 131 0, 132 0, 133 0, 134 }; 135 136 enum rlp_state target_states[15] = { 137 RLP_LIST_DESCEND, 138 RLP_LIST_DESCEND, 139 RLP_LIST_ASCEND, 140 RLP_LIST_DESCEND, 141 RLP_LIST_DESCEND, 142 RLP_LIST_ASCEND, 143 RLP_LIST_ASCEND, 144 RLP_LIST_DESCEND, 145 RLP_LIST_DESCEND, 146 RLP_LIST_ASCEND, 147 RLP_LIST_DESCEND, 148 RLP_LIST_DESCEND, 149 RLP_LIST_ASCEND, 150 RLP_LIST_ASCEND, 151 RLP_LIST_ASCEND, 152 }; 153 154 char *zbuf = NULL; 155 int i; 156 int l; 157 char state = RLP_LIST_ASCEND; 158 159 rlp_encoder_t encoder; 160 161 rlp_init(&encoder, 1024, NULL); 162 163 // [ [] [ [] ] [ [] [ []] ] ] 164 rlp_descend(&encoder); 165 166 rlp_descend(&encoder); 167 rlp_ascend(&encoder); 168 169 rlp_descend(&encoder); 170 rlp_descend(&encoder); 171 rlp_ascend(&encoder); 172 rlp_ascend(&encoder); 173 174 rlp_descend(&encoder); 175 rlp_descend(&encoder); 176 rlp_ascend(&encoder); 177 rlp_descend(&encoder); 178 rlp_descend(&encoder); 179 rlp_ascend(&encoder); 180 rlp_ascend(&encoder); 181 rlp_ascend(&encoder); 182 183 rlp_ascend(&encoder); 184 185 ck_assert_mem_eq(encoder.buf, target, 8); 186 ck_assert_int_eq(encoder.size, 8); 187 188 rlp_init(&encoder, 1024, encoder.buf); 189 for (i = 0; i < 15; i++) { 190 rlp_next(&encoder, &l, &zbuf); 191 ck_assert_int_eq(target_states[i], encoder.state); 192 ck_assert_int_eq(target_lengths[i], l); 193 } 194 195 rlp_free(&encoder); 196 } 197 END_TEST 198 199 200 Suite *rlp_vector_suite(void) { 201 Suite *s; 202 TCase *tcb; 203 204 s = suite_create("rlp_vector"); 205 tcb = tcase_create("basic"); // examples from https://eth.wiki/fundamentals/rlp 206 tcase_add_test(tcb, rlp_dog_test); 207 tcase_add_test(tcb, rlp_catdog_test); 208 tcase_add_test(tcb, rlp_lorem_test); 209 tcase_add_test(tcb, rlp_set_theoretical_representation_of_three); 210 suite_add_tcase(s, tcb); 211 212 213 return s; 214 } 215 216 217 int main(void) { 218 int num_fail; 219 220 Suite *s; 221 SRunner *sr; 222 223 s = rlp_vector_suite(); 224 sr = srunner_create(s); 225 226 srunner_run_all(sr, CK_VERBOSE); 227 num_fail = srunner_ntests_failed(sr); 228 srunner_free(sr); 229 230 return (num_fail == 0) ? EXIT_SUCCESS : EXIT_FAILURE; 231 }