infix-calculator/tests/reader_tests.c

#include "reader.h"
#include "testing.h"

static memory_pool_t pool;

static void input_1234_is_read_as_number_with_expected_value(void)
{
	init_memory_pool(&pool);
	const expression_t *result = read_expression(&pool, "1234", 4);
	ASSERT_NOT_NULL(result);
	ASSERT_TRUE(result->is_number);
	ASSERT_EQUAL(1234, result->number);
}

static void input_4321_is_read_as_number_with_expected_value(void)
{
	init_memory_pool(&pool);
	const expression_t *result = read_expression(&pool, "4321", 4);
	ASSERT_NOT_NULL(result);
	ASSERT_TRUE(result->is_number);
	ASSERT_EQUAL(4321, result->number);
}

static void input_1234_with_len_3_is_read_as_123(void)
{
	init_memory_pool(&pool);
	const expression_t *result = read_expression(&pool, "1234", 3);
	ASSERT_NOT_NULL(result);
	ASSERT_TRUE(result->is_number);
	ASSERT_EQUAL(123, result->number);
}

static void input_1_plus_2_with_no_spaces_is_read_as_an_add_application(void)
{
	init_memory_pool(&pool);
	const expression_t *result = read_expression(&pool, "1+2", 3);
	ASSERT_NOT_NULL(result);
	ASSERT_FALSE(result->is_number);
	ASSERT_EQUAL(OPERATOR_ADD, result->application.operator);
}

static void operands_of_15_plus_54_are_read_as_numbers(void)
{
	init_memory_pool(&pool);
	const expression_t *result = read_expression(&pool, "15+54", 5);
	ASSERT_NOT_NULL(result);
	ASSERT_FALSE(result->is_number);
	ASSERT_NOT_NULL(result->application.operands[0]);
	ASSERT_TRUE(result->application.operands[0]->is_number);
	ASSERT_EQUAL(15, result->application.operands[0]->number);
	ASSERT_NOT_NULL(result->application.operands[1]);
	ASSERT_TRUE(result->application.operands[1]->is_number);
	ASSERT_EQUAL(54, result->application.operands[1]->number);
}

static void
input_6_minus_2_with_no_spaces_is_read_as_a_subtract_application(void)
{
	init_memory_pool(&pool);
	const expression_t *result = read_expression(&pool, "6-2", 3);
	ASSERT_NOT_NULL(result);
	ASSERT_FALSE(result->is_number);
	ASSERT_EQUAL(OPERATOR_SUBTRACT, result->application.operator);
}

static void
input_1_plus_2_plus_3_is_parsed_as_a_left_nested_application(void)
{
	init_memory_pool(&pool);
	const expression_t *result = read_expression(&pool, "1+2+3", 5);
	ASSERT_NOT_NULL(result);
	ASSERT_FALSE(result->is_number);
	ASSERT_EQUAL(OPERATOR_ADD, result->application.operator);

	const expression_t *operand0 = result->application.operands[0];
	ASSERT_NOT_NULL(operand0);
	ASSERT_FALSE(operand0->is_number);
	ASSERT_EQUAL(OPERATOR_ADD, operand0->application.operator);
	ASSERT_NOT_NULL(operand0->application.operands[0]);
	ASSERT_TRUE(operand0->application.operands[0]->is_number);
	ASSERT_EQUAL(1, operand0->application.operands[0]->number);
	ASSERT_NOT_NULL(operand0->application.operands[1]);
	ASSERT_TRUE(operand0->application.operands[1]->is_number);
	ASSERT_EQUAL(2, operand0->application.operands[1]->number);

	const expression_t *operand1 = result->application.operands[1];
	ASSERT_NOT_NULL(operand1);
	ASSERT_TRUE(operand1->is_number);
	ASSERT_EQUAL(3, operand1->number);
}

static void
input_1_times_2_times_3_is_parsed_as_a_left_nested_application(void)
{
	init_memory_pool(&pool);
	const expression_t *result = read_expression(&pool, "1*2*3", 5);
	ASSERT_NOT_NULL(result);
	ASSERT_FALSE(result->is_number);
	ASSERT_EQUAL(OPERATOR_MULTIPLY, result->application.operator);

	const expression_t *operand0 = result->application.operands[0];
	ASSERT_NOT_NULL(operand0);
	ASSERT_FALSE(operand0->is_number);
	ASSERT_EQUAL(OPERATOR_MULTIPLY, operand0->application.operator);
	ASSERT_NOT_NULL(operand0->application.operands[0]);
	ASSERT_TRUE(operand0->application.operands[0]->is_number);
	ASSERT_EQUAL(1, operand0->application.operands[0]->number);
	ASSERT_NOT_NULL(operand0->application.operands[1]);
	ASSERT_TRUE(operand0->application.operands[1]->is_number);
	ASSERT_EQUAL(2, operand0->application.operands[1]->number);

	const expression_t *operand1 = result->application.operands[1];
	ASSERT_NOT_NULL(operand1);
	ASSERT_TRUE(operand1->is_number);
	ASSERT_EQUAL(3, operand1->number);
}

static void
input_1_plus_2_times_3_is_parsed_as_a_right_nested_application(void)
{
	init_memory_pool(&pool);
	const expression_t *result = read_expression(&pool, "1+2*3", 5);
	ASSERT_NOT_NULL(result);
	ASSERT_FALSE(result->is_number);
	ASSERT_EQUAL(OPERATOR_ADD, result->application.operator);

	const expression_t *operand0 = result->application.operands[0];
	ASSERT_NOT_NULL(operand0);
	ASSERT_TRUE(operand0->is_number);
	ASSERT_EQUAL(1, operand0->number);

	const expression_t *operand1 = result->application.operands[1];
	ASSERT_NOT_NULL(operand1);
	ASSERT_FALSE(operand1->is_number);
	ASSERT_EQUAL(OPERATOR_MULTIPLY, operand1->application.operator);
	ASSERT_NOT_NULL(operand1->application.operands[0]);
	ASSERT_TRUE(operand1->application.operands[0]->is_number);
	ASSERT_EQUAL(2, operand1->application.operands[0]->number);
	ASSERT_NOT_NULL(operand1->application.operands[1]);
	ASSERT_TRUE(operand1->application.operands[1]->is_number);
	ASSERT_EQUAL(3, operand1->application.operands[1]->number);
}

static void paren_1_plus_2_times_3_close_paren_parses_as_left_nested(void)
{
	init_memory_pool(&pool);
	const expression_t *result = read_expression(&pool, "(1+2)*3", 7);
	ASSERT_NOT_NULL(result);
	ASSERT_FALSE(result->is_number);
	ASSERT_EQUAL(OPERATOR_MULTIPLY, result->application.operator);

	const expression_t *operand0 = result->application.operands[0];
	ASSERT_NOT_NULL(operand0);
	ASSERT_FALSE(operand0->is_number);
	ASSERT_EQUAL(OPERATOR_ADD, operand0->application.operator);
	ASSERT_NOT_NULL(operand0->application.operands[0]);
	ASSERT_TRUE(operand0->application.operands[0]->is_number);
	ASSERT_EQUAL(1, operand0->application.operands[0]->number);
	ASSERT_NOT_NULL(operand0->application.operands[1]);
	ASSERT_TRUE(operand0->application.operands[1]->is_number);
	ASSERT_EQUAL(2, operand0->application.operands[1]->number);

	const expression_t *operand1 = result->application.operands[1];
	ASSERT_NOT_NULL(operand1);
	ASSERT_TRUE(operand1->is_number);
	ASSERT_EQUAL(3, operand1->number);
}

static void garbage_input_yeilds_null(void)
{
	init_memory_pool(&pool);
	const expression_t *result = read_expression(&pool, "arwizxhu", 8);
	ASSERT_NULL(result);
}

static void valid_expression_followed_by_garbage_yeilds_null(void)
{
	init_memory_pool(&pool);
	const expression_t *result = read_expression(&pool, "5+2jvkre", 8);
	ASSERT_NULL(result);
}

int main(void)
{
	TESTING_BEGIN();
	RUN_TEST(input_1234_is_read_as_number_with_expected_value);
	RUN_TEST(input_4321_is_read_as_number_with_expected_value);
	RUN_TEST(input_1234_with_len_3_is_read_as_123);
	RUN_TEST(operands_of_15_plus_54_are_read_as_numbers);
	RUN_TEST(input_1_plus_2_with_no_spaces_is_read_as_an_add_application);
	RUN_TEST(
	    input_6_minus_2_with_no_spaces_is_read_as_a_subtract_application);
	RUN_TEST(input_1_plus_2_plus_3_is_parsed_as_a_left_nested_application);
	RUN_TEST(input_1_times_2_times_3_is_parsed_as_a_left_nested_application);
	RUN_TEST(input_1_plus_2_times_3_is_parsed_as_a_right_nested_application);
	RUN_TEST(paren_1_plus_2_times_3_close_paren_parses_as_left_nested);
	RUN_TEST(garbage_input_yeilds_null);
	RUN_TEST(valid_expression_followed_by_garbage_yeilds_null);
	TESTING_END();
}