cdo/imp
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Make AM registers into an array

Browse Source
This commit is contained in:
Camden Dixie O'Brien
2025-08-10 20:30:07 +01:00
parent 52a42d2937
commit 57c39fd00b
14 changed files with 311 additions and 288 deletions
Download Patch File Download Diff File Expand all files Collapse all files

26
tests/am_tests.c
View File

@@ -18,28 +18,30 @@ void tearDown(void)
static void test_expr_value_restored_after_push_modify_pop(void)
{
expr_t a, b;
am.expr = &a;
am.regs[EXPR] = &a;
am_push(&am);
am.expr = &b;
am.regs[EXPR] = &b;
am_pop(&am);
TEST_ASSERT_EQUAL(&a, am.expr);
TEST_ASSERT_EQUAL(&a, am.regs[EXPR]);
}
static void test_append_arg_42_with_empty_argl(void)
{
am.argl = expr_empty_list(&am);
am.val = expr_integer(&am, 42);
am.regs[ARGL] = expr_empty_list(&am);
am.regs[VAL] = expr_integer(&am, 42);
am_append_arg(&am);
TEST_ASSERT_FALSE(am.argl->is_atom);
TEST_ASSERT_NOT_NULL(CAR(am.argl));
TEST_ASSERT_FALSE(am.regs[ARGL]->is_atom);
TEST_ASSERT_NOT_NULL(CAR(am.regs[ARGL]));
TEST_ASSERT_TRUE(CAR(am.argl)->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_INTEGER, CAR(am.argl)->atom.type);
TEST_ASSERT_EQUAL(42, CAR(am.argl)->atom.integer);
TEST_ASSERT_TRUE(CAR(am.regs[ARGL])->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_INTEGER, CAR(am.regs[ARGL])->atom.type);
TEST_ASSERT_EQUAL(42, CAR(am.regs[ARGL])->atom.integer);
TEST_ASSERT_TRUE(CDR(am.argl)->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_EMPTY_LIST, CDR(am.argl)->atom.type);
TEST_ASSERT_TRUE(CDR(am.regs[ARGL])->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_EMPTY_LIST, CDR(am.regs[ARGL])->atom.type);
}
int main(void)

34
tests/env_tests.c
View File

@@ -16,36 +16,36 @@ void tearDown(void)
static void test_set_foo_to_42_then_fetch(void)
{
am.expr = expr_str_symbol(&am, "foo");
am.val = expr_integer(&am, 42);
am.regs[EXPR] = expr_str_symbol(&am, "foo");
am.regs[VAL] = expr_integer(&am, 42);
env_set(&am);
am.expr = expr_str_symbol(&am, "foo");
am.val = NULL;
am.regs[EXPR] = expr_str_symbol(&am, "foo");
am.regs[VAL] = NULL;
env_fetch(&am);
TEST_ASSERT_NOT_NULL(am.val);
TEST_ASSERT_TRUE(am.val->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_INTEGER, am.val->atom.type);
TEST_ASSERT_EQUAL(42, am.val->atom.integer);
TEST_ASSERT_NOT_NULL(am.regs[VAL]);
TEST_ASSERT_TRUE(am.regs[VAL]->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_INTEGER, am.regs[VAL]->atom.type);
TEST_ASSERT_EQUAL(42, am.regs[VAL]->atom.integer);
}
static void test_update_foo_from_123_to_456_then_fetch(void)
{
am.expr = expr_str_symbol(&am, "foo");
am.val = expr_integer(&am, 123);
am.regs[EXPR] = expr_str_symbol(&am, "foo");
am.regs[VAL] = expr_integer(&am, 123);
env_set(&am);
am.val = expr_integer(&am, 456);
am.regs[VAL] = expr_integer(&am, 456);
env_set(&am);
am.expr = expr_str_symbol(&am, "foo");
am.val = NULL;
am.regs[EXPR] = expr_str_symbol(&am, "foo");
am.regs[VAL] = NULL;
env_fetch(&am);
TEST_ASSERT_NOT_NULL(am.val);
TEST_ASSERT_TRUE(am.val->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_INTEGER, am.val->atom.type);
TEST_ASSERT_EQUAL(456, am.val->atom.integer);
TEST_ASSERT_NOT_NULL(am.regs[VAL]);
TEST_ASSERT_TRUE(am.regs[VAL]->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_INTEGER, am.regs[VAL]->atom.type);
TEST_ASSERT_EQUAL(456, am.regs[VAL]->atom.integer);
}
int main(void)

62
tests/eval_tests.c
View File

@@ -21,57 +21,57 @@ void tearDown(void)
static void test_42_self_evals(void)
{
am.expr = expr_integer(&am, 42);
am.regs[EXPR] = expr_integer(&am, 42);
eval(&am);
TEST_ASSERT_NOT_NULL(am.val);
TEST_ASSERT_TRUE(am.val->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_INTEGER, am.val->atom.type);
TEST_ASSERT_EQUAL(42, am.val->atom.integer);
TEST_ASSERT_NOT_NULL(am.regs[VAL]);
TEST_ASSERT_TRUE(am.regs[VAL]->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_INTEGER, am.regs[VAL]->atom.type);
TEST_ASSERT_EQUAL(42, am.regs[VAL]->atom.integer);
}
static void test_empty_list_self_evals(void)
{
am.expr = expr_empty_list(&am);
am.regs[EXPR] = expr_empty_list(&am);
eval(&am);
TEST_ASSERT_NOT_NULL(am.val);
TEST_ASSERT_TRUE(am.val->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_EMPTY_LIST, am.val->atom.type);
TEST_ASSERT_NOT_NULL(am.regs[VAL]);
TEST_ASSERT_TRUE(am.regs[VAL]->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_EMPTY_LIST, am.regs[VAL]->atom.type);
}
static void test_prim_proc_self_evals(void)
{
am.expr = expr_prim_proc(&am, test_prim_proc);
am.regs[EXPR] = expr_prim_proc(&am, test_prim_proc);
eval(&am);
TEST_ASSERT_NOT_NULL(am.val);
TEST_ASSERT_TRUE(am.val->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_PRIM_PROC, am.val->atom.type);
TEST_ASSERT_EQUAL(test_prim_proc, am.val->atom.prim_proc);
TEST_ASSERT_NOT_NULL(am.regs[VAL]);
TEST_ASSERT_TRUE(am.regs[VAL]->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_PRIM_PROC, am.regs[VAL]->atom.type);
TEST_ASSERT_EQUAL(test_prim_proc, am.regs[VAL]->atom.prim_proc);
}
static void test_foo_evals_to_42_when_set_in_env(void)
{
am.expr = expr_str_symbol(&am, "foo");
am.val = expr_integer(&am, 42);
am.regs[EXPR] = expr_str_symbol(&am, "foo");
am.regs[VAL] = expr_integer(&am, 42);
env_set(&am);
am.val = NULL;
am.regs[VAL] = NULL;
eval(&am);
TEST_ASSERT_NOT_NULL(am.val);
TEST_ASSERT_TRUE(am.val->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_INTEGER, am.val->atom.type);
TEST_ASSERT_EQUAL(42, am.val->atom.integer);
TEST_ASSERT_NOT_NULL(am.regs[VAL]);
TEST_ASSERT_TRUE(am.regs[VAL]->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_INTEGER, am.regs[VAL]->atom.type);
TEST_ASSERT_EQUAL(42, am.regs[VAL]->atom.integer);
}
static void test_add_1_2_3_evals_to_6(void)
{
am.expr = expr_pair(
am.regs[EXPR] = expr_pair(
&am, expr_str_symbol(&am, "+"),
expr_pair(
&am, expr_integer(&am, 1),
@@ -82,15 +82,15 @@ static void test_add_1_2_3_evals_to_6(void)
eval(&am);
TEST_ASSERT_NOT_NULL(am.val);
TEST_ASSERT_TRUE(am.val->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_INTEGER, am.val->atom.type);
TEST_ASSERT_EQUAL(6, am.val->atom.integer);
TEST_ASSERT_NOT_NULL(am.regs[VAL]);
TEST_ASSERT_TRUE(am.regs[VAL]->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_INTEGER, am.regs[VAL]->atom.type);
TEST_ASSERT_EQUAL(6, am.regs[VAL]->atom.integer);
}
static void test_add_1_mul_2_3_evals_to_7(void)
{
am.expr = expr_pair(
am.regs[EXPR] = expr_pair(
&am, expr_str_symbol(&am, "+"),
expr_pair(
&am, expr_integer(&am, 1),
@@ -107,10 +107,10 @@ static void test_add_1_mul_2_3_evals_to_7(void)
eval(&am);
TEST_ASSERT_NOT_NULL(am.val);
TEST_ASSERT_TRUE(am.val->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_INTEGER, am.val->atom.type);
TEST_ASSERT_EQUAL(7, am.val->atom.integer);
TEST_ASSERT_NOT_NULL(am.regs[VAL]);
TEST_ASSERT_TRUE(am.regs[VAL]->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_INTEGER, am.regs[VAL]->atom.type);
TEST_ASSERT_EQUAL(7, am.regs[VAL]->atom.integer);
}
int main(void)

129
tests/parse_tests.c
View File

@@ -23,10 +23,10 @@ static void test_integer_123(void)
const parse_state_t state = parse_proc(&ctx, &token);
TEST_ASSERT_EQUAL(PARSE_STATE_DONE, state);
TEST_ASSERT_NOT_NULL(am.expr);
TEST_ASSERT_TRUE(am.expr->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_INTEGER, am.expr->atom.type);
TEST_ASSERT_EQUAL(123, am.expr->atom.integer);
TEST_ASSERT_NOT_NULL(am.regs[EXPR]);
TEST_ASSERT_TRUE(am.regs[EXPR]->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_INTEGER, am.regs[EXPR]->atom.type);
TEST_ASSERT_EQUAL(123, am.regs[EXPR]->atom.integer);
}
static void test_integer_321(void)
@@ -36,10 +36,10 @@ static void test_integer_321(void)
const parse_state_t state = parse_proc(&ctx, &token);
TEST_ASSERT_EQUAL(PARSE_STATE_DONE, state);
TEST_ASSERT_NOT_NULL(am.expr);
TEST_ASSERT_TRUE(am.expr->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_INTEGER, am.expr->atom.type);
TEST_ASSERT_EQUAL(321, am.expr->atom.integer);
TEST_ASSERT_NOT_NULL(am.regs[EXPR]);
TEST_ASSERT_TRUE(am.regs[EXPR]->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_INTEGER, am.regs[EXPR]->atom.type);
TEST_ASSERT_EQUAL(321, am.regs[EXPR]->atom.integer);
}
static void test_symbol_foo(void)
@@ -52,11 +52,11 @@ static void test_symbol_foo(void)
const parse_state_t state = parse_proc(&ctx, &token);
TEST_ASSERT_EQUAL(PARSE_STATE_DONE, state);
TEST_ASSERT_NOT_NULL(am.expr);
TEST_ASSERT_TRUE(am.expr->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_SYMBOL, am.expr->atom.type);
TEST_ASSERT_EQUAL(3, am.expr->atom.symbol.len);
TEST_ASSERT_EQUAL_MEMORY("foo", am.expr->atom.symbol.buf, 3);
TEST_ASSERT_NOT_NULL(am.regs[EXPR]);
TEST_ASSERT_TRUE(am.regs[EXPR]->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_SYMBOL, am.regs[EXPR]->atom.type);
TEST_ASSERT_EQUAL(3, am.regs[EXPR]->atom.symbol.len);
TEST_ASSERT_EQUAL_MEMORY("foo", am.regs[EXPR]->atom.symbol.buf, 3);
}
static void test_symbol_quux(void)
@@ -69,11 +69,11 @@ static void test_symbol_quux(void)
const parse_state_t state = parse_proc(&ctx, &token);
TEST_ASSERT_EQUAL(PARSE_STATE_DONE, state);
TEST_ASSERT_NOT_NULL(am.expr);
TEST_ASSERT_TRUE(am.expr->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_SYMBOL, am.expr->atom.type);
TEST_ASSERT_EQUAL(4, am.expr->atom.symbol.len);
TEST_ASSERT_EQUAL_MEMORY("quux", am.expr->atom.symbol.buf, 4);
TEST_ASSERT_NOT_NULL(am.regs[EXPR]);
TEST_ASSERT_TRUE(am.regs[EXPR]->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_SYMBOL, am.regs[EXPR]->atom.type);
TEST_ASSERT_EQUAL(4, am.regs[EXPR]->atom.symbol.len);
TEST_ASSERT_EQUAL_MEMORY("quux", am.regs[EXPR]->atom.symbol.buf, 4);
}
static void test_open_paren_close_paren(void)
@@ -90,9 +90,9 @@ static void test_open_paren_close_paren(void)
state = parse_proc(&ctx, tokens + 1);
TEST_ASSERT_EQUAL(PARSE_STATE_DONE, state);
TEST_ASSERT_NOT_NULL(am.expr);
TEST_ASSERT_TRUE(am.expr->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_EMPTY_LIST, am.expr->atom.type);
TEST_ASSERT_NOT_NULL(am.regs[EXPR]);
TEST_ASSERT_TRUE(am.regs[EXPR]->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_EMPTY_LIST, am.regs[EXPR]->atom.type);
}
static void test_open_paren_foo_42_close_paren(void)
@@ -116,28 +116,29 @@ static void test_open_paren_foo_42_close_paren(void)
state = parse_proc(&ctx, tokens + NELEMS(tokens) - 1);
TEST_ASSERT_EQUAL(PARSE_STATE_DONE, state);
TEST_ASSERT_NOT_NULL(am.expr);
TEST_ASSERT_FALSE(am.expr->is_atom);
TEST_ASSERT_NOT_NULL(am.regs[EXPR]);
TEST_ASSERT_FALSE(am.regs[EXPR]->is_atom);
TEST_ASSERT_NOT_NULL(am.expr->pair.car);
TEST_ASSERT_TRUE(am.expr->pair.car->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_SYMBOL, am.expr->pair.car->atom.type);
TEST_ASSERT_EQUAL(3, am.expr->pair.car->atom.symbol.len);
TEST_ASSERT_EQUAL_MEMORY("foo", am.expr->pair.car->atom.symbol.buf, 3);
TEST_ASSERT_NOT_NULL(am.regs[EXPR]->pair.car);
TEST_ASSERT_TRUE(am.regs[EXPR]->pair.car->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_SYMBOL, am.regs[EXPR]->pair.car->atom.type);
TEST_ASSERT_EQUAL(3, am.regs[EXPR]->pair.car->atom.symbol.len);
TEST_ASSERT_EQUAL_MEMORY(
"foo", am.regs[EXPR]->pair.car->atom.symbol.buf, 3);
TEST_ASSERT_NOT_NULL(am.expr->pair.cdr);
TEST_ASSERT_FALSE(am.expr->pair.cdr->is_atom);
TEST_ASSERT_NOT_NULL(am.regs[EXPR]->pair.cdr);
TEST_ASSERT_FALSE(am.regs[EXPR]->pair.cdr->is_atom);
TEST_ASSERT_NOT_NULL(am.expr->pair.cdr->pair.car);
TEST_ASSERT_TRUE(am.expr->pair.cdr->pair.car->is_atom);
TEST_ASSERT_NOT_NULL(am.regs[EXPR]->pair.cdr->pair.car);
TEST_ASSERT_TRUE(am.regs[EXPR]->pair.cdr->pair.car->is_atom);
TEST_ASSERT_EQUAL(
ATOM_TYPE_INTEGER, am.expr->pair.cdr->pair.car->atom.type);
TEST_ASSERT_EQUAL(42, am.expr->pair.cdr->pair.car->atom.integer);
ATOM_TYPE_INTEGER, am.regs[EXPR]->pair.cdr->pair.car->atom.type);
TEST_ASSERT_EQUAL(42, am.regs[EXPR]->pair.cdr->pair.car->atom.integer);
TEST_ASSERT_NOT_NULL(am.expr->pair.cdr->pair.cdr);
TEST_ASSERT_TRUE(am.expr->pair.cdr->pair.cdr->is_atom);
TEST_ASSERT_NOT_NULL(am.regs[EXPR]->pair.cdr->pair.cdr);
TEST_ASSERT_TRUE(am.regs[EXPR]->pair.cdr->pair.cdr->is_atom);
TEST_ASSERT_EQUAL(
ATOM_TYPE_EMPTY_LIST, am.expr->pair.cdr->pair.cdr->atom.type);
ATOM_TYPE_EMPTY_LIST, am.regs[EXPR]->pair.cdr->pair.cdr->atom.type);
}
static void test_open_paren_1_open_paren_2_close_paren_3_close_paren(void)
@@ -161,48 +162,50 @@ static void test_open_paren_1_open_paren_2_close_paren_3_close_paren(void)
state = parse_proc(&ctx, tokens + NELEMS(tokens) - 1);
TEST_ASSERT_EQUAL(PARSE_STATE_DONE, state);
TEST_ASSERT_NOT_NULL(am.expr);
TEST_ASSERT_FALSE(am.expr->is_atom);
TEST_ASSERT_NOT_NULL(am.regs[EXPR]);
TEST_ASSERT_FALSE(am.regs[EXPR]->is_atom);
TEST_ASSERT_NOT_NULL(am.expr->pair.car);
TEST_ASSERT_TRUE(am.expr->pair.car->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_INTEGER, am.expr->pair.car->atom.type);
TEST_ASSERT_EQUAL(1, am.expr->pair.car->atom.integer);
TEST_ASSERT_NOT_NULL(am.regs[EXPR]->pair.car);
TEST_ASSERT_TRUE(am.regs[EXPR]->pair.car->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_INTEGER, am.regs[EXPR]->pair.car->atom.type);
TEST_ASSERT_EQUAL(1, am.regs[EXPR]->pair.car->atom.integer);
TEST_ASSERT_NOT_NULL(am.expr->pair.cdr);
TEST_ASSERT_FALSE(am.expr->pair.cdr->is_atom);
TEST_ASSERT_NOT_NULL(am.regs[EXPR]->pair.cdr);
TEST_ASSERT_FALSE(am.regs[EXPR]->pair.cdr->is_atom);
TEST_ASSERT_NOT_NULL(am.expr->pair.cdr->pair.car);
TEST_ASSERT_FALSE(am.expr->pair.cdr->pair.car->is_atom);
TEST_ASSERT_NOT_NULL(am.regs[EXPR]->pair.cdr->pair.car);
TEST_ASSERT_FALSE(am.regs[EXPR]->pair.cdr->pair.car->is_atom);
TEST_ASSERT_NOT_NULL(am.expr->pair.cdr->pair.car->pair.car);
TEST_ASSERT_TRUE(am.expr->pair.cdr->pair.car->pair.car->is_atom);
TEST_ASSERT_NOT_NULL(am.regs[EXPR]->pair.cdr->pair.car->pair.car);
TEST_ASSERT_TRUE(am.regs[EXPR]->pair.cdr->pair.car->pair.car->is_atom);
TEST_ASSERT_EQUAL(
ATOM_TYPE_INTEGER, am.expr->pair.cdr->pair.car->pair.car->atom.type);
ATOM_TYPE_INTEGER,
am.regs[EXPR]->pair.cdr->pair.car->pair.car->atom.type);
TEST_ASSERT_EQUAL(
2, am.expr->pair.cdr->pair.car->pair.car->atom.integer);
2, am.regs[EXPR]->pair.cdr->pair.car->pair.car->atom.integer);
TEST_ASSERT_NOT_NULL(am.expr->pair.cdr->pair.car->pair.cdr);
TEST_ASSERT_TRUE(am.expr->pair.cdr->pair.car->pair.cdr->is_atom);
TEST_ASSERT_NOT_NULL(am.regs[EXPR]->pair.cdr->pair.car->pair.cdr);
TEST_ASSERT_TRUE(am.regs[EXPR]->pair.cdr->pair.car->pair.cdr->is_atom);
TEST_ASSERT_EQUAL(
ATOM_TYPE_EMPTY_LIST,
am.expr->pair.cdr->pair.car->pair.cdr->atom.type);
am.regs[EXPR]->pair.cdr->pair.car->pair.cdr->atom.type);
TEST_ASSERT_NOT_NULL(am.expr->pair.cdr->pair.cdr);
TEST_ASSERT_FALSE(am.expr->pair.cdr->pair.cdr->is_atom);
TEST_ASSERT_NOT_NULL(am.regs[EXPR]->pair.cdr->pair.cdr);
TEST_ASSERT_FALSE(am.regs[EXPR]->pair.cdr->pair.cdr->is_atom);
TEST_ASSERT_NOT_NULL(am.expr->pair.cdr->pair.cdr->pair.car);
TEST_ASSERT_TRUE(am.expr->pair.cdr->pair.cdr->pair.car->is_atom);
TEST_ASSERT_NOT_NULL(am.regs[EXPR]->pair.cdr->pair.cdr->pair.car);
TEST_ASSERT_TRUE(am.regs[EXPR]->pair.cdr->pair.cdr->pair.car->is_atom);
TEST_ASSERT_EQUAL(
ATOM_TYPE_INTEGER, am.expr->pair.cdr->pair.cdr->pair.car->atom.type);
ATOM_TYPE_INTEGER,
am.regs[EXPR]->pair.cdr->pair.cdr->pair.car->atom.type);
TEST_ASSERT_EQUAL(
3, am.expr->pair.cdr->pair.cdr->pair.car->atom.integer);
3, am.regs[EXPR]->pair.cdr->pair.cdr->pair.car->atom.integer);
TEST_ASSERT_NOT_NULL(am.expr->pair.cdr->pair.cdr->pair.cdr);
TEST_ASSERT_TRUE(am.expr->pair.cdr->pair.cdr->pair.cdr->is_atom);
TEST_ASSERT_NOT_NULL(am.regs[EXPR]->pair.cdr->pair.cdr->pair.cdr);
TEST_ASSERT_TRUE(am.regs[EXPR]->pair.cdr->pair.cdr->pair.cdr->is_atom);
TEST_ASSERT_EQUAL(
ATOM_TYPE_EMPTY_LIST,
am.expr->pair.cdr->pair.cdr->pair.cdr->atom.type);
am.regs[EXPR]->pair.cdr->pair.cdr->pair.cdr->atom.type);
}
static void test_close_paren(void)

121
tests/prim_tests.c
View File

@@ -15,116 +15,117 @@ void tearDown(void)
static void test_add_empty_list_is_0(void)
{
am.expr = expr_str_symbol(&am, "+");
am.regs[EXPR] = expr_str_symbol(&am, "+");
env_fetch(&am);
TEST_ASSERT_NOT_NULL(am.val);
TEST_ASSERT_TRUE(am.val->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_PRIM_PROC, am.val->atom.type);
TEST_ASSERT_NOT_NULL(am.regs[VAL]);
TEST_ASSERT_TRUE(am.regs[VAL]->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_PRIM_PROC, am.regs[VAL]->atom.type);
am.argl = expr_empty_list(&am);
am.val->atom.prim_proc(&am);
am.regs[ARGL] = expr_empty_list(&am);
am.regs[VAL]->atom.prim_proc(&am);
TEST_ASSERT_NOT_NULL(am.val);
TEST_ASSERT_TRUE(am.val->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_INTEGER, am.val->atom.type);
TEST_ASSERT_EQUAL(0, am.val->atom.integer);
TEST_ASSERT_NOT_NULL(am.regs[VAL]);
TEST_ASSERT_TRUE(am.regs[VAL]->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_INTEGER, am.regs[VAL]->atom.type);
TEST_ASSERT_EQUAL(0, am.regs[VAL]->atom.integer);
}
static void test_add_1_2_3_is_6(void)
{
am.expr = expr_str_symbol(&am, "+");
am.regs[EXPR] = expr_str_symbol(&am, "+");
env_fetch(&am);
TEST_ASSERT_NOT_NULL(am.val);
TEST_ASSERT_TRUE(am.val->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_PRIM_PROC, am.val->atom.type);
TEST_ASSERT_NOT_NULL(am.regs[VAL]);
TEST_ASSERT_TRUE(am.regs[VAL]->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_PRIM_PROC, am.regs[VAL]->atom.type);
am.argl = expr_pair(
am.regs[ARGL] = expr_pair(
&am, expr_integer(&am, 1),
expr_pair(
&am, expr_integer(&am, 2),
expr_pair(&am, expr_integer(&am, 3), expr_empty_list(&am))));
am.val->atom.prim_proc(&am);
am.regs[VAL]->atom.prim_proc(&am);
TEST_ASSERT_NOT_NULL(am.val);
TEST_ASSERT_TRUE(am.val->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_INTEGER, am.val->atom.type);
TEST_ASSERT_EQUAL(6, am.val->atom.integer);
TEST_ASSERT_NOT_NULL(am.regs[VAL]);
TEST_ASSERT_TRUE(am.regs[VAL]->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_INTEGER, am.regs[VAL]->atom.type);
TEST_ASSERT_EQUAL(6, am.regs[VAL]->atom.integer);
}
static void test_mul_empty_list_is_1(void)
{
am.expr = expr_str_symbol(&am, "*");
am.regs[EXPR] = expr_str_symbol(&am, "*");
env_fetch(&am);
TEST_ASSERT_NOT_NULL(am.val);
TEST_ASSERT_TRUE(am.val->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_PRIM_PROC, am.val->atom.type);
TEST_ASSERT_NOT_NULL(am.regs[VAL]);
TEST_ASSERT_TRUE(am.regs[VAL]->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_PRIM_PROC, am.regs[VAL]->atom.type);
am.argl = expr_empty_list(&am);
am.val->atom.prim_proc(&am);
am.regs[ARGL] = expr_empty_list(&am);
am.regs[VAL]->atom.prim_proc(&am);
TEST_ASSERT_NOT_NULL(am.val);
TEST_ASSERT_TRUE(am.val->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_INTEGER, am.val->atom.type);
TEST_ASSERT_EQUAL(1, am.val->atom.integer);
TEST_ASSERT_NOT_NULL(am.regs[VAL]);
TEST_ASSERT_TRUE(am.regs[VAL]->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_INTEGER, am.regs[VAL]->atom.type);
TEST_ASSERT_EQUAL(1, am.regs[VAL]->atom.integer);
}
static void test_mul_2_3_4_is_24(void)
{
am.expr = expr_str_symbol(&am, "*");
am.regs[EXPR] = expr_str_symbol(&am, "*");
env_fetch(&am);
TEST_ASSERT_NOT_NULL(am.val);
TEST_ASSERT_TRUE(am.val->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_PRIM_PROC, am.val->atom.type);
TEST_ASSERT_NOT_NULL(am.regs[VAL]);
TEST_ASSERT_TRUE(am.regs[VAL]->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_PRIM_PROC, am.regs[VAL]->atom.type);
am.argl = expr_pair(
am.regs[ARGL] = expr_pair(
&am, expr_integer(&am, 2),
expr_pair(
&am, expr_integer(&am, 3),
expr_pair(&am, expr_integer(&am, 4), expr_empty_list(&am))));
am.val->atom.prim_proc(&am);
am.regs[VAL]->atom.prim_proc(&am);
TEST_ASSERT_NOT_NULL(am.val);
TEST_ASSERT_TRUE(am.val->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_INTEGER, am.val->atom.type);
TEST_ASSERT_EQUAL(24, am.val->atom.integer);
TEST_ASSERT_NOT_NULL(am.regs[VAL]);
TEST_ASSERT_TRUE(am.regs[VAL]->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_INTEGER, am.regs[VAL]->atom.type);
TEST_ASSERT_EQUAL(24, am.regs[VAL]->atom.integer);
}
static void test_sub_1_is_minus_1(void)
{
am.expr = expr_str_symbol(&am, "-");
am.regs[EXPR] = expr_str_symbol(&am, "-");
env_fetch(&am);
TEST_ASSERT_NOT_NULL(am.val);
TEST_ASSERT_TRUE(am.val->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_PRIM_PROC, am.val->atom.type);
TEST_ASSERT_NOT_NULL(am.regs[VAL]);
TEST_ASSERT_TRUE(am.regs[VAL]->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_PRIM_PROC, am.regs[VAL]->atom.type);
am.argl = expr_pair(&am, expr_integer(&am, 1), expr_empty_list(&am));
am.val->atom.prim_proc(&am);
am.regs[ARGL]
= expr_pair(&am, expr_integer(&am, 1), expr_empty_list(&am));
am.regs[VAL]->atom.prim_proc(&am);
TEST_ASSERT_NOT_NULL(am.val);
TEST_ASSERT_TRUE(am.val->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_INTEGER, am.val->atom.type);
TEST_ASSERT_EQUAL(-1, am.val->atom.integer);
TEST_ASSERT_NOT_NULL(am.regs[VAL]);
TEST_ASSERT_TRUE(am.regs[VAL]->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_INTEGER, am.regs[VAL]->atom.type);
TEST_ASSERT_EQUAL(-1, am.regs[VAL]->atom.integer);
}
static void test_sub_5_4_3_is_minus_2(void)
{
am.expr = expr_str_symbol(&am, "-");
am.regs[EXPR] = expr_str_symbol(&am, "-");
env_fetch(&am);
TEST_ASSERT_NOT_NULL(am.val);
TEST_ASSERT_TRUE(am.val->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_PRIM_PROC, am.val->atom.type);
TEST_ASSERT_NOT_NULL(am.regs[VAL]);
TEST_ASSERT_TRUE(am.regs[VAL]->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_PRIM_PROC, am.regs[VAL]->atom.type);
am.argl = expr_pair(
am.regs[ARGL] = expr_pair(
&am, expr_integer(&am, 5),
expr_pair(
&am, expr_integer(&am, 4),
expr_pair(&am, expr_integer(&am, 3), expr_empty_list(&am))));
am.val->atom.prim_proc(&am);
am.regs[VAL]->atom.prim_proc(&am);
TEST_ASSERT_NOT_NULL(am.val);
TEST_ASSERT_TRUE(am.val->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_INTEGER, am.val->atom.type);
TEST_ASSERT_EQUAL(-2, am.val->atom.integer);
TEST_ASSERT_NOT_NULL(am.regs[VAL]);
TEST_ASSERT_TRUE(am.regs[VAL]->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_INTEGER, am.regs[VAL]->atom.type);
TEST_ASSERT_EQUAL(-2, am.regs[VAL]->atom.integer);
}
int main(void)

10
tests/print_tests.c
View File

@@ -20,7 +20,7 @@ void tearDown(void)
static void test_integer_5(void)
{
am.val = expr_integer(&am, 5);
am.regs[VAL] = expr_integer(&am, 5);
const size_t len = print(&am, buffer, BUFFER_SIZE);
TEST_ASSERT_EQUAL(1, len);
TEST_ASSERT_EQUAL_MEMORY("5", buffer, 1);
@@ -28,7 +28,7 @@ static void test_integer_5(void)
static void test_integer_1234(void)
{
am.val = expr_integer(&am, 1234);
am.regs[VAL] = expr_integer(&am, 1234);
const size_t len = print(&am, buffer, BUFFER_SIZE);
TEST_ASSERT_EQUAL(4, len);
TEST_ASSERT_EQUAL_MEMORY("1234", buffer, 4);
@@ -36,7 +36,7 @@ static void test_integer_1234(void)
static void test_integer_0(void)
{
am.val = expr_integer(&am, 0);
am.regs[VAL] = expr_integer(&am, 0);
const size_t len = print(&am, buffer, BUFFER_SIZE);
TEST_ASSERT_EQUAL(1, len);
TEST_ASSERT_EQUAL_MEMORY("0", buffer, 1);
@@ -44,7 +44,7 @@ static void test_integer_0(void)
static void test_integer_10(void)
{
am.val = expr_integer(&am, 10);
am.regs[VAL] = expr_integer(&am, 10);
const size_t len = print(&am, buffer, BUFFER_SIZE);
TEST_ASSERT_EQUAL(2, len);
TEST_ASSERT_EQUAL_MEMORY("10", buffer, 2);
@@ -52,7 +52,7 @@ static void test_integer_10(void)
static void test_integer_minus_4321(void)
{
am.val = expr_integer(&am, -4321);
am.regs[VAL] = expr_integer(&am, -4321);
const size_t len = print(&am, buffer, BUFFER_SIZE);
TEST_ASSERT_EQUAL(5, len);
TEST_ASSERT_EQUAL_MEMORY("-4321", buffer, 5);

81
tests/read_tests.c
View File

@@ -36,58 +36,59 @@ static void test_nested_expression(void)
read(&am, (stream_t *)&stream);
TEST_ASSERT_NOT_NULL(am.expr);
TEST_ASSERT_FALSE(am.expr->is_atom);
TEST_ASSERT_NOT_NULL(am.regs[EXPR]);
TEST_ASSERT_FALSE(am.regs[EXPR]->is_atom);
TEST_ASSERT_NOT_NULL(CAR(am.expr));
TEST_ASSERT_TRUE(CAR(am.expr)->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_SYMBOL, CAR(am.expr)->atom.type);
TEST_ASSERT_EQUAL(1, CAR(am.expr)->atom.symbol.len);
TEST_ASSERT_EQUAL_MEMORY("+", CAR(am.expr)->atom.symbol.buf, 1);
TEST_ASSERT_NOT_NULL(CAR(am.regs[EXPR]));
TEST_ASSERT_TRUE(CAR(am.regs[EXPR])->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_SYMBOL, CAR(am.regs[EXPR])->atom.type);
TEST_ASSERT_EQUAL(1, CAR(am.regs[EXPR])->atom.symbol.len);
TEST_ASSERT_EQUAL_MEMORY("+", CAR(am.regs[EXPR])->atom.symbol.buf, 1);
TEST_ASSERT_NOT_NULL(CDR(am.expr));
TEST_ASSERT_FALSE(CDR(am.expr)->is_atom);
TEST_ASSERT_NOT_NULL(CDR(am.regs[EXPR]));
TEST_ASSERT_FALSE(CDR(am.regs[EXPR])->is_atom);
TEST_ASSERT_NOT_NULL(CADR(am.expr));
TEST_ASSERT_TRUE(CADR(am.expr)->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_INTEGER, CADR(am.expr)->atom.type);
TEST_ASSERT_EQUAL(1, CADR(am.expr)->atom.integer);
TEST_ASSERT_NOT_NULL(CADR(am.regs[EXPR]));
TEST_ASSERT_TRUE(CADR(am.regs[EXPR])->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_INTEGER, CADR(am.regs[EXPR])->atom.type);
TEST_ASSERT_EQUAL(1, CADR(am.regs[EXPR])->atom.integer);
TEST_ASSERT_NOT_NULL(CDDR(am.expr));
TEST_ASSERT_FALSE(CDDR(am.expr)->is_atom);
TEST_ASSERT_NOT_NULL(CDDR(am.regs[EXPR]));
TEST_ASSERT_FALSE(CDDR(am.regs[EXPR])->is_atom);
TEST_ASSERT_NOT_NULL(CADDR(am.expr));
TEST_ASSERT_FALSE(CADDR(am.expr)->is_atom);
TEST_ASSERT_NOT_NULL(CADDR(am.regs[EXPR]));
TEST_ASSERT_FALSE(CADDR(am.regs[EXPR])->is_atom);
TEST_ASSERT_NOT_NULL(CAADDR(am.expr));
TEST_ASSERT_TRUE(CAADDR(am.expr)->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_SYMBOL, CAADDR(am.expr)->atom.type);
TEST_ASSERT_EQUAL(1, CAADDR(am.expr)->atom.symbol.len);
TEST_ASSERT_EQUAL_MEMORY("*", CAADDR(am.expr)->atom.symbol.buf, 1);
TEST_ASSERT_NOT_NULL(CAADDR(am.regs[EXPR]));
TEST_ASSERT_TRUE(CAADDR(am.regs[EXPR])->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_SYMBOL, CAADDR(am.regs[EXPR])->atom.type);
TEST_ASSERT_EQUAL(1, CAADDR(am.regs[EXPR])->atom.symbol.len);
TEST_ASSERT_EQUAL_MEMORY("*", CAADDR(am.regs[EXPR])->atom.symbol.buf, 1);
TEST_ASSERT_NOT_NULL(CDADDR(am.expr));
TEST_ASSERT_FALSE(CDADDR(am.expr)->is_atom);
TEST_ASSERT_NOT_NULL(CDADDR(am.regs[EXPR]));
TEST_ASSERT_FALSE(CDADDR(am.regs[EXPR])->is_atom);
TEST_ASSERT_NOT_NULL(CADADDR(am.expr));
TEST_ASSERT_TRUE(CADADDR(am.expr)->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_INTEGER, CADADDR(am.expr)->atom.type);
TEST_ASSERT_EQUAL(2, CADADDR(am.expr)->atom.integer);
TEST_ASSERT_NOT_NULL(CADADDR(am.regs[EXPR]));
TEST_ASSERT_TRUE(CADADDR(am.regs[EXPR])->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_INTEGER, CADADDR(am.regs[EXPR])->atom.type);
TEST_ASSERT_EQUAL(2, CADADDR(am.regs[EXPR])->atom.integer);
TEST_ASSERT_NOT_NULL(CDDADDR(am.expr));
TEST_ASSERT_FALSE(CDDADDR(am.expr)->is_atom);
TEST_ASSERT_NOT_NULL(CDDADDR(am.regs[EXPR]));
TEST_ASSERT_FALSE(CDDADDR(am.regs[EXPR])->is_atom);
TEST_ASSERT_NOT_NULL(CADDADDR(am.expr));
TEST_ASSERT_TRUE(CADDADDR(am.expr)->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_INTEGER, CADDADDR(am.expr)->atom.type);
TEST_ASSERT_EQUAL(3, CADDADDR(am.expr)->atom.integer);
TEST_ASSERT_NOT_NULL(CADDADDR(am.regs[EXPR]));
TEST_ASSERT_TRUE(CADDADDR(am.regs[EXPR])->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_INTEGER, CADDADDR(am.regs[EXPR])->atom.type);
TEST_ASSERT_EQUAL(3, CADDADDR(am.regs[EXPR])->atom.integer);
TEST_ASSERT_NOT_NULL(CDDDADDR(am.expr));
TEST_ASSERT_TRUE(CDDDADDR(am.expr)->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_EMPTY_LIST, CDDDADDR(am.expr)->atom.type);
TEST_ASSERT_NOT_NULL(CDDDADDR(am.regs[EXPR]));
TEST_ASSERT_TRUE(CDDDADDR(am.regs[EXPR])->is_atom);
TEST_ASSERT_EQUAL(
ATOM_TYPE_EMPTY_LIST, CDDDADDR(am.regs[EXPR])->atom.type);
TEST_ASSERT_NOT_NULL(CDDDR(am.expr));
TEST_ASSERT_TRUE(CDDDR(am.expr)->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_EMPTY_LIST, CDDDR(am.expr)->atom.type);
TEST_ASSERT_NOT_NULL(CDDDR(am.regs[EXPR]));
TEST_ASSERT_TRUE(CDDDR(am.regs[EXPR])->is_atom);
TEST_ASSERT_EQUAL(ATOM_TYPE_EMPTY_LIST, CDDDR(am.regs[EXPR])->atom.type);
}
int main(void)