refactor: write more tests in C

1 files changed, 156 insertions, 0 deletions

diff --git a/tests/types.c b/tests/types.c
new file mode 100644
index 0000000..7743489
--- /dev/null
+++ b/tests/types.c
@@ -0,0 +1,156 @@
+#include <helpers.h>
+#include <stdarg.h>
+
+struct Token {
+    int kind;
+    char* value;
+};
+
+struct Define {
+    char* from;
+    struct Token* to;
+};
+
+struct AstNode;
+
+struct Type {
+    int kind;
+    struct Type* to;
+    struct AstNode* members;
+};
+
+struct AstNode {
+    int kind;
+    struct AstNode* next;
+    struct AstNode* last;
+    char* name;
+    struct AstNode* func_params;
+    struct AstNode* func_body;
+    int int_value;
+    struct AstNode* expr1;
+    struct AstNode* expr2;
+    struct AstNode* expr3;
+    int op;
+    struct Type* ty;
+    int var_index;
+    struct AstNode* node1;
+    struct AstNode* node2;
+    char** str_literals;
+};
+
+struct LVar {
+    char* name;
+    struct Type* ty;
+};
+
+struct Func {
+    char* name;
+    struct Type* ty;
+};
+
+struct Parser {
+    struct Token* tokens;
+    int pos;
+    struct LVar* locals;
+    int n_locals;
+    struct Func* funcs;
+    int n_funcs;
+    char** str_literals;
+    int n_str_literals;
+};
+
+struct CodeGen {
+    int next_label;
+    int* loop_labels;
+};
+
+struct S_var {
+    long x;
+    long y;
+};
+
+enum E {
+    A,
+    B,
+    C,
+};
+
+enum E1 {
+    E1_A = 10,
+    E1_B,
+    E1_C = 20,
+    E1_D,
+};
+
+enum E2 {
+    E2_E,
+    E2_F = 5,
+    E2_G,
+    E2_H = E2_G,
+};
+
+int main() {
+    short a = 42;
+    ASSERT_EQ(2, sizeof(a));
+    ASSERT_EQ(42, a);
+    short* b = &a;
+    *b = 123;
+    ASSERT_EQ(8, sizeof(b));
+    ASSERT_EQ(123, *b);
+
+    ASSERT_EQ(4, sizeof(int));
+    ASSERT_EQ(8, sizeof(int*));
+    ASSERT_EQ(1, sizeof(char));
+    ASSERT_EQ(8, sizeof(char*));
+    ASSERT_EQ(8, sizeof(long));
+    ASSERT_EQ(8, sizeof(long*));
+    ASSERT_EQ(8, sizeof(void*));
+    ASSERT_EQ(8, sizeof(int**));
+    ASSERT_EQ(8, sizeof(char**));
+    ASSERT_EQ(8, sizeof(long**));
+    ASSERT_EQ(8, sizeof(void**));
+    ASSERT_EQ(8, sizeof(int***));
+    ASSERT_EQ(8, sizeof(char***));
+    ASSERT_EQ(8, sizeof(long***));
+    ASSERT_EQ(8, sizeof(void***));
+
+    ASSERT_EQ(16, sizeof(struct Token));
+    ASSERT_EQ(16, sizeof(struct Define));
+    ASSERT_EQ(24, sizeof(struct Type));
+    ASSERT_EQ(128, sizeof(struct AstNode));
+    ASSERT_EQ(16, sizeof(struct LVar));
+    ASSERT_EQ(16, sizeof(struct Func));
+    ASSERT_EQ(64, sizeof(struct Parser));
+    ASSERT_EQ(16, sizeof(struct CodeGen));
+
+    ASSERT_EQ(24, sizeof(va_list));
+
+    int va;
+    long vb;
+    char vc[123];
+    struct S_var vd;
+    void* ve;
+    struct S_var vf[123];
+
+    ASSERT_EQ(4, sizeof(va));
+    ASSERT_EQ(8, sizeof(vb));
+    ASSERT_EQ(123, sizeof(vc));
+    ASSERT_EQ(16, sizeof(vd));
+    ASSERT_EQ(8, sizeof(ve));
+    ASSERT_EQ(1968, sizeof(vf));
+
+    ASSERT_EQ(4, sizeof(enum E));
+    ASSERT_EQ(0, A);
+    ASSERT_EQ(1, B);
+    ASSERT_EQ(2, C);
+
+    ASSERT_EQ(10, E1_A);
+    ASSERT_EQ(11, E1_B);
+    ASSERT_EQ(20, E1_C);
+    ASSERT_EQ(21, E1_D);
+
+    ASSERT_EQ(0, E2_E);
+    ASSERT_EQ(5, E2_F);
+    ASSERT_EQ(6, E2_G);
+    ASSERT_EQ(6, E2_H);
+}