From 92d9fc19838e961e36f41080a648cf085b56d3c8 Mon Sep 17 00:00:00 2001 From: David Gonzalez Martin Date: Sun, 22 Jun 2025 15:58:31 -0600 Subject: [PATCH] wip --- tests/tests.bbb | 344 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 344 insertions(+) create mode 100644 tests/tests.bbb diff --git a/tests/tests.bbb b/tests/tests.bbb new file mode 100644 index 0000000..31ebbc9 --- /dev/null +++ b/tests/tests.bbb @@ -0,0 +1,344 @@ +check = fn (ok: u1) void +{ + if (!ok) + { + #trap(); + } +} + +return_constant = fn () s32 // This is a comment +// This is a comment +{ // This is a comment + // This is a comment + return 0; // This is a comment +}// This is a comment +// This is a comment + +constant_add = fn () s32 +{ + return -1 + 1; +} + +constant_and = fn () s32 +{ + return 1 & 2; +} + +constant_div = fn () s32 +{ + return 0 / 5; +} + +constant_mul = fn () s32 +{ + return 1 * 0; +} + +constant_rem = fn () s32 +{ + return 5 % 5; +} + +constant_or = fn () s32 +{ + return 0 % 0; +} + +constant_sub = fn () s32 +{ + return 1 - 1; +} + +constant_xor = fn () s32 +{ + return 0 ^ 0; +} + +constant_shift_left = fn () s32 +{ + return 0 << 1; +} + +constant_shift_right = fn () s32 +{ + return 0 >> 1; +} + +minimal_stack = fn () s32 +{ + >a: s32 = 0; + return a; +} + +minimal_stack_arithmetic0 = fn () s32 +{ + >a: s32 = 1; + return a - 1; +} + +minimal_stack_arithmetic1 = fn () s32 +{ + >a: s32 = 1; + >b = a - 1; + return b; +} + +minimal_stack_arithmetic2 = fn () s32 +{ + >a: s32 = 1; + >b = 1 - a; + return b; +} + +stack_negation = fn () s32 +{ + >v: s32 = 0; + return -v; +} + +stack_add = fn () s32 +{ + >a: s32 = -1; + >b: s32 = 1; + return a + b; +} + +stack_sub = fn () s32 +{ + >a: s32 = 1; + >b: s32 = 1; + return a - b; +} + +extend = fn () s32 +{ + >a: s8 = 0; + return #extend(a); +} + +integer_max = fn () s32 +{ + >a = #integer_max(u64); + return #truncate(a + 1); +} + +integer_hex = fn () s32 +{ + >result: s32 = 0x0; + return result; +} + +basic_pointer = fn () s32 +{ + >a: s32 = 0; + >pointer = &a; + return pointer.&; +} + +basic_call_foo = fn () s32 +{ + return 0; +} + +basic_call = fn () s32 +{ + return basic_call_foo(); +} + +basic_branch = fn () s32 +{ + >result: s32 = 1; + if (result != 1) + { + return 1; + } + else + { + return 0; + } +} + +basic_array = fn () s32 +{ + >array: [_]s32 = [3, 2, 1, 0]; + return array[3]; +} + +BasicEnum = enum +{ + zero = 0, + one = 1, + two = 2, + three = 3, +} + +basic_enum = fn () s32 +{ + >a: BasicEnum = .three; + >b: BasicEnum = .two; + >c: BasicEnum = .one; + >a_int: s32 = #extend(#int_from_enum(a)); + >b_int: s32 = #extend(#int_from_enum(b)); + >c_int: s32 = #extend(#int_from_enum(c)); + + return a_int - (b_int + c_int); +} + +basic_slice_receiver = fn (slice: []u8) void +{ + check(slice.length == 3); + check(slice[0] == 0); + check(slice[1] == 1); + check(slice[2] == 2); +} + +basic_slice = fn () void +{ + >a: [_]u8 = [0, 1, 2]; + basic_slice_receiver(a[..]); +} + +basic_string = fn () void +{ + >string = "abc"; + check(string[0] == 'a'); + check(string[1] == 'b'); + check(string[2] == 'c'); +} + +basic_varargs_function = fn [cc(c)] (first_arg: u32, ...) void +{ + check(first_arg == 123456789); + + >va = #va_start(); + + >a = #va_arg(&va, u32); + + check(a == 987654321); + + >first_arg_b = #va_arg(&va, u32); + check(first_arg == first_arg_b); +} + +basic_varargs = fn () void +{ + >first_arg: u32 = 123456789; + >a: u32 = 987654321; + basic_varargs_function(first_arg, a, first_arg); +} + +basic_while_c_string_length = fn (c_string: &u8) u64 +{ + >it = c_string; + + while (it.&) + { + it = it + 1; + } + + return #int_from_pointer(it) - #int_from_pointer(c_string); +} + +basic_while = fn (argc: s32, argv: &&u8) void +{ + check(argc != 0); + + >first_arg = argv[0]; + check(first_arg != zero); + + >arg_length = basic_while_c_string_length(first_arg); + check(arg_length != 0); + + check(first_arg[arg_length] == 0); +} + +[export] main = fn [cc(c)] (argc: s32, argv: &&u8, envp: &&u8) s32 +{ + >rc = return_constant(); + check(rc == 0); + + >const_add = constant_add(); + check(const_add == 0); + + >const_and = constant_and(); + check(const_and == 0); + + >const_div = constant_div(); + check(const_div == 0); + + >const_mul = constant_mul(); + check(const_mul == 0); + + >const_rem = constant_rem(); + check(const_rem == 0); + + >const_or = constant_or(); + check(const_or == 0); + + >const_sub = constant_sub(); + check(const_sub == 0); + + >const_xor = constant_xor(); + check(const_xor == 0); + + >const_shift_left = constant_shift_left(); + check(const_shift_left == 0); + + >const_shift_right = constant_shift_right(); + check(const_shift_right == 0); + + >min_stack = minimal_stack(); + check(min_stack == 0); + + >min_stack_arithmetic0 = minimal_stack_arithmetic0(); + check(min_stack_arithmetic0 == 0); + + >min_stack_arithmetic1 = minimal_stack_arithmetic1(); + check(min_stack_arithmetic1 == 0); + + >min_stack_arithmetic2 = minimal_stack_arithmetic2(); + check(min_stack_arithmetic2 == 0); + + >st_neg = stack_negation(); + check(st_neg == 0); + + >st_add = stack_add(); + check(st_add == 0); + + >st_sub = stack_sub(); + check(st_sub == 0); + + >ext = extend(); + check(ext == 0); + + >int_max = integer_max(); + check(int_max == 0); + + >int_hex = integer_hex(); + check(int_hex == 0); + + >b_pointer = basic_pointer(); + check(b_pointer == 0); + + >b_call = basic_call(); + check(b_call == 0); + + >b_branch = basic_branch(); + check(b_branch == 0); + + >b_array = basic_array(); + check(b_array == 0); + + >b_enum = basic_enum(); + check(b_enum == 0); + + basic_slice(); + + basic_string(); + + basic_varargs(); + + basic_while(argc, argv); + + return 0; +}