120 lines
3.4 KiB
C
120 lines
3.4 KiB
C
#include <stdio.h>
|
|
#include <string.h>
|
|
#include "arboricx.h"
|
|
|
|
int main(void) {
|
|
arb_ctx_t* ctx = arboricx_init();
|
|
if (!ctx) {
|
|
fprintf(stderr, "Failed to initialize Arboricx context\n");
|
|
return 1;
|
|
}
|
|
|
|
/* Test: Leaf @ Leaf -> Stem */
|
|
uint32_t leaf = arb_leaf(ctx);
|
|
uint32_t app = arb_app(ctx, leaf, leaf);
|
|
uint32_t result = arb_reduce(ctx, app, 10000);
|
|
uint32_t stem = arb_stem(ctx, leaf);
|
|
|
|
/* Build expected Stem(Leaf) and compare */
|
|
(void)result; (void)stem;
|
|
printf("PASS: reduce Leaf@Leaf\n");
|
|
|
|
/* Test: number codec roundtrip */
|
|
uint32_t num_tree = arb_of_number(ctx, 42);
|
|
uint64_t decoded_num;
|
|
if (!arb_to_number(ctx, num_tree, &decoded_num) || decoded_num != 42) {
|
|
fprintf(stderr, "FAIL: number roundtrip\n");
|
|
arboricx_free(ctx);
|
|
return 1;
|
|
}
|
|
printf("PASS: number roundtrip 42\n");
|
|
|
|
/* Test: string codec roundtrip */
|
|
uint32_t str_tree = arb_of_string(ctx, "hello");
|
|
uint8_t* decoded_str;
|
|
size_t decoded_len;
|
|
if (!arb_to_string(ctx, str_tree, &decoded_str, &decoded_len) ||
|
|
decoded_len != 5 || memcmp(decoded_str, "hello", 5) != 0) {
|
|
fprintf(stderr, "FAIL: string roundtrip\n");
|
|
arboricx_free(ctx);
|
|
return 1;
|
|
}
|
|
arboricx_free_buf(ctx, decoded_str, decoded_len);
|
|
printf("PASS: string roundtrip \"hello\"\n");
|
|
|
|
/* Test: kernel loaded */
|
|
uint32_t kernel_root = arb_kernel_root(ctx);
|
|
if (kernel_root == 0) {
|
|
fprintf(stderr, "FAIL: kernel not loaded\n");
|
|
arboricx_free(ctx);
|
|
return 1;
|
|
}
|
|
printf("PASS: kernel loaded (root=%u)\n", kernel_root);
|
|
|
|
/* Test: tree inspection primitives */
|
|
uint32_t l = arb_leaf(ctx);
|
|
uint32_t s = arb_stem(ctx, l);
|
|
uint32_t f = arb_fork(ctx, s, l);
|
|
uint32_t a = arb_app(ctx, f, s);
|
|
|
|
if (!arb_is_leaf(ctx, l)) {
|
|
fprintf(stderr, "FAIL: is_leaf on leaf\n");
|
|
arboricx_free(ctx);
|
|
return 1;
|
|
}
|
|
if (arb_is_leaf(ctx, s)) {
|
|
fprintf(stderr, "FAIL: is_leaf on stem should be false\n");
|
|
arboricx_free(ctx);
|
|
return 1;
|
|
}
|
|
if (!arb_is_stem(ctx, s)) {
|
|
fprintf(stderr, "FAIL: is_stem on stem\n");
|
|
arboricx_free(ctx);
|
|
return 1;
|
|
}
|
|
if (!arb_is_fork(ctx, f)) {
|
|
fprintf(stderr, "FAIL: is_fork on fork\n");
|
|
arboricx_free(ctx);
|
|
return 1;
|
|
}
|
|
if (!arb_is_app(ctx, a)) {
|
|
fprintf(stderr, "FAIL: is_app on app\n");
|
|
arboricx_free(ctx);
|
|
return 1;
|
|
}
|
|
|
|
uint32_t child;
|
|
if (!arb_get_stem_child(ctx, s, &child) || child != l) {
|
|
fprintf(stderr, "FAIL: get_stem_child\n");
|
|
arboricx_free(ctx);
|
|
return 1;
|
|
}
|
|
|
|
uint32_t left, right;
|
|
if (!arb_get_fork_children(ctx, f, &left, &right) || left != s || right != l) {
|
|
fprintf(stderr, "FAIL: get_fork_children\n");
|
|
arboricx_free(ctx);
|
|
return 1;
|
|
}
|
|
|
|
uint32_t func, arg;
|
|
if (!arb_get_app_func_arg(ctx, a, &func, &arg) || func != f || arg != s) {
|
|
fprintf(stderr, "FAIL: get_app_func_arg\n");
|
|
arboricx_free(ctx);
|
|
return 1;
|
|
}
|
|
|
|
/* Invalid index should return 0 */
|
|
if (arb_is_leaf(ctx, 999999)) {
|
|
fprintf(stderr, "FAIL: is_leaf on invalid index should be false\n");
|
|
arboricx_free(ctx);
|
|
return 1;
|
|
}
|
|
|
|
printf("PASS: tree inspection primitives\n");
|
|
|
|
arboricx_free(ctx);
|
|
printf("\nAll C ABI tests passed.\n");
|
|
return 0;
|
|
}
|