io_protocol_test.c (8773B)
1 #include <stdio.h> 2 #include <string.h> 3 #include "helpers.h" 4 5 int main(void) { 6 arb_ctx_t* ctx = arboricx_init(); 7 if (!ctx) { 8 fprintf(stderr, "Failed to initialize Arboricx context\n"); 9 return 1; 10 } 11 12 /* Test: construct and verify pure action = Fork 0 Leaf */ 13 arb_handle_t leaf = checked_arb_leaf(ctx); 14 arb_handle_t zero = checked_arb_of_number(ctx, 0); 15 arb_handle_t pure_action = checked_arb_fork(ctx, zero, leaf); 16 17 if (!checked_arb_is_fork(ctx, pure_action)) { 18 fprintf(stderr, "FAIL: pure action should be fork\n"); 19 arboricx_free(ctx); 20 return 1; 21 } 22 23 arb_handle_t tag, payload; 24 if (!(arb_get_fork_children(ctx, pure_action, &tag, &payload) == ARB_OK) || 25 !same_value(ctx, tag, zero) || !same_value(ctx, payload, leaf)) { 26 fprintf(stderr, "FAIL: pure action children mismatch\n"); 27 arboricx_free(ctx); 28 return 1; 29 } 30 31 uint64_t tag_num; 32 if (!(arb_to_number(ctx, tag, &tag_num) == ARB_OK) || tag_num != 0) { 33 fprintf(stderr, "FAIL: pure action tag should be 0\n"); 34 arboricx_free(ctx); 35 return 1; 36 } 37 printf("PASS: pure action shape\n"); 38 39 /* Test: construct and verify bind action = Fork 1 (Fork left k) */ 40 arb_handle_t one = checked_arb_of_number(ctx, 1); 41 arb_handle_t left = checked_arb_fork(ctx, zero, leaf); /* pure Leaf */ 42 arb_handle_t k = checked_arb_fork(ctx, leaf, leaf); /* identity as Fork Leaf Leaf */ 43 arb_handle_t bind_pair = checked_arb_fork(ctx, left, k); 44 arb_handle_t bind_action = checked_arb_fork(ctx, one, bind_pair); 45 46 if (!(arb_get_fork_children(ctx, bind_action, &tag, &payload) == ARB_OK) || 47 !(arb_to_number(ctx, tag, &tag_num) == ARB_OK) || tag_num != 1) { 48 fprintf(stderr, "FAIL: bind action tag should be 1\n"); 49 arboricx_free(ctx); 50 return 1; 51 } 52 53 arb_handle_t bind_left, bind_k; 54 if (!(arb_get_fork_children(ctx, payload, &bind_left, &bind_k) == ARB_OK) || 55 !same_value(ctx, bind_left, left) || !same_value(ctx, bind_k, k)) { 56 fprintf(stderr, "FAIL: bind payload should be Fork left k\n"); 57 arboricx_free(ctx); 58 return 1; 59 } 60 printf("PASS: bind action shape\n"); 61 62 /* Test: construct and verify IO sentinel = Fork "tricuIO" (Fork 1 action) */ 63 arb_handle_t sentinel_str = checked_arb_of_string(ctx, "tricuIO"); 64 arb_handle_t version = checked_arb_of_number(ctx, 1); 65 arb_handle_t version_action_pair = checked_arb_fork(ctx, version, pure_action); 66 arb_handle_t io_sentinel = checked_arb_fork(ctx, sentinel_str, version_action_pair); 67 68 if (!checked_arb_is_fork(ctx, io_sentinel)) { 69 fprintf(stderr, "FAIL: IO sentinel should be fork\n"); 70 arboricx_free(ctx); 71 return 1; 72 } 73 74 arb_handle_t sent_left, sent_right; 75 if (!(arb_get_fork_children(ctx, io_sentinel, &sent_left, &sent_right) == ARB_OK)) { 76 fprintf(stderr, "FAIL: get_fork_children on IO sentinel\n"); 77 arboricx_free(ctx); 78 return 1; 79 } 80 81 /* Verify sentinel string */ 82 uint8_t* decoded_sentinel; 83 size_t decoded_len; 84 if (!(arb_to_string(ctx, sent_left, &decoded_sentinel, &decoded_len) == ARB_OK) || 85 decoded_len != 7 || memcmp(decoded_sentinel, "tricuIO", 7) != 0) { 86 fprintf(stderr, "FAIL: IO sentinel string mismatch\n"); 87 arboricx_free(ctx); 88 return 1; 89 } 90 arboricx_free_buf(ctx, decoded_sentinel, decoded_len); 91 92 /* Verify version = 1 and action = pure */ 93 arb_handle_t ver, act; 94 if (!(arb_get_fork_children(ctx, sent_right, &ver, &act) == ARB_OK) || 95 !(arb_to_number(ctx, ver, &tag_num) == ARB_OK) || tag_num != 1 || 96 !same_value(ctx, act, pure_action)) { 97 fprintf(stderr, "FAIL: IO sentinel version/action mismatch\n"); 98 arboricx_free(ctx); 99 return 1; 100 } 101 printf("PASS: IO sentinel shape\n"); 102 103 /* Test: putStr action = Fork 10 string */ 104 arb_handle_t ten = checked_arb_of_number(ctx, 10); 105 arb_handle_t msg = checked_arb_of_string(ctx, "hello"); 106 arb_handle_t putStr_action = checked_arb_fork(ctx, ten, msg); 107 108 if (!(arb_get_fork_children(ctx, putStr_action, &tag, &payload) == ARB_OK) || 109 !(arb_to_number(ctx, tag, &tag_num) == ARB_OK) || tag_num != 10) { 110 fprintf(stderr, "FAIL: putStr tag should be 10\n"); 111 arboricx_free(ctx); 112 return 1; 113 } 114 printf("PASS: putStr action shape\n"); 115 116 /* Test: getLine action = Fork 11 Leaf */ 117 arb_handle_t eleven = checked_arb_of_number(ctx, 11); 118 arb_handle_t getLine_action = checked_arb_fork(ctx, eleven, leaf); 119 120 if (!(arb_get_fork_children(ctx, getLine_action, &tag, &payload) == ARB_OK) || 121 !(arb_to_number(ctx, tag, &tag_num) == ARB_OK) || tag_num != 11 || 122 !same_value(ctx, payload, leaf)) { 123 fprintf(stderr, "FAIL: getLine tag should be 11 with Leaf payload\n"); 124 arboricx_free(ctx); 125 return 1; 126 } 127 printf("PASS: getLine action shape\n"); 128 129 /* Test: readFile action = Fork 20 path */ 130 arb_handle_t twenty = checked_arb_of_number(ctx, 20); 131 arb_handle_t path = checked_arb_of_string(ctx, "/tmp/test.txt"); 132 arb_handle_t readFile_action = checked_arb_fork(ctx, twenty, path); 133 134 if (!(arb_get_fork_children(ctx, readFile_action, &tag, &payload) == ARB_OK) || 135 !(arb_to_number(ctx, tag, &tag_num) == ARB_OK) || tag_num != 20) { 136 fprintf(stderr, "FAIL: readFile tag should be 20\n"); 137 arboricx_free(ctx); 138 return 1; 139 } 140 printf("PASS: readFile action shape\n"); 141 142 /* Test: writeFile action = Fork 21 (Fork path contents) */ 143 arb_handle_t twenty_one = checked_arb_of_number(ctx, 21); 144 arb_handle_t contents = checked_arb_of_string(ctx, "data"); 145 arb_handle_t write_pair = checked_arb_fork(ctx, path, contents); 146 arb_handle_t writeFile_action = checked_arb_fork(ctx, twenty_one, write_pair); 147 148 if (!(arb_get_fork_children(ctx, writeFile_action, &tag, &payload) == ARB_OK) || 149 !(arb_to_number(ctx, tag, &tag_num) == ARB_OK) || tag_num != 21) { 150 fprintf(stderr, "FAIL: writeFile tag should be 21\n"); 151 arboricx_free(ctx); 152 return 1; 153 } 154 155 arb_handle_t wf_path, wf_contents; 156 if (!(arb_get_fork_children(ctx, payload, &wf_path, &wf_contents) == ARB_OK) || 157 !same_value(ctx, wf_path, path) || !same_value(ctx, wf_contents, contents)) { 158 fprintf(stderr, "FAIL: writeFile payload should be Fork path contents\n"); 159 arboricx_free(ctx); 160 return 1; 161 } 162 printf("PASS: writeFile action shape\n"); 163 164 /* Test: ok result = Fork (Stem Leaf) (Fork val Leaf) */ 165 arb_handle_t stem_leaf = checked_arb_stem(ctx, leaf); 166 arb_handle_t val_pair = checked_arb_fork(ctx, msg, leaf); 167 arb_handle_t ok_result = checked_arb_fork(ctx, stem_leaf, val_pair); 168 169 if (!checked_arb_is_fork(ctx, ok_result)) { 170 fprintf(stderr, "FAIL: ok result should be fork\n"); 171 arboricx_free(ctx); 172 return 1; 173 } 174 175 arb_handle_t ok_tag, ok_rest; 176 if (!(arb_get_fork_children(ctx, ok_result, &ok_tag, &ok_rest) == ARB_OK) || 177 !checked_arb_is_stem(ctx, ok_tag)) { 178 fprintf(stderr, "FAIL: ok result left should be stem\n"); 179 arboricx_free(ctx); 180 return 1; 181 } 182 183 arb_handle_t ok_val, ok_leaf; 184 if (!(arb_get_fork_children(ctx, ok_rest, &ok_val, &ok_leaf) == ARB_OK) || 185 !same_value(ctx, ok_val, msg) || !same_value(ctx, ok_leaf, leaf)) { 186 fprintf(stderr, "FAIL: ok result right should be Fork val Leaf\n"); 187 arboricx_free(ctx); 188 return 1; 189 } 190 printf("PASS: ok result shape\n"); 191 192 /* Test: err result = Fork Leaf (Fork code Leaf) */ 193 arb_handle_t err_code = checked_arb_of_number(ctx, 42); 194 arb_handle_t err_pair = checked_arb_fork(ctx, err_code, leaf); 195 arb_handle_t err_result = checked_arb_fork(ctx, leaf, err_pair); 196 197 if (!checked_arb_is_fork(ctx, err_result)) { 198 fprintf(stderr, "FAIL: err result should be fork\n"); 199 arboricx_free(ctx); 200 return 1; 201 } 202 203 arb_handle_t err_tag, err_rest; 204 if (!(arb_get_fork_children(ctx, err_result, &err_tag, &err_rest) == ARB_OK) || 205 !checked_arb_is_leaf(ctx, err_tag)) { 206 fprintf(stderr, "FAIL: err result left should be leaf\n"); 207 arboricx_free(ctx); 208 return 1; 209 } 210 211 arb_handle_t err_c, err_l; 212 if (!(arb_get_fork_children(ctx, err_rest, &err_c, &err_l) == ARB_OK) || 213 !same_value(ctx, err_c, err_code) || !same_value(ctx, err_l, leaf)) { 214 fprintf(stderr, "FAIL: err result right should be Fork code Leaf\n"); 215 arboricx_free(ctx); 216 return 1; 217 } 218 printf("PASS: err result shape\n"); 219 220 arboricx_free(ctx); 221 printf("\nAll IO protocol tests passed.\n"); 222 return 0; 223 }