Roman_Schenk/snp-lab-code
1
1
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

P06 lab code added

Browse Source
This commit is contained in:
Andreas Gieriet
2020-03-29 23:46:39 +02:00
parent 2f61cf20b1
commit c26659919d
14 changed files with 1440 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files
P06_Integer_Rechner/integer-rechner/tests/tests.c
+263
View File
@@ -0,0 +1,263 @@
/* ----------------------------------------------------------------------------
* -- _____ ______ _____ -
* -- |_ _| | ____|/ ____| -
* -- | | _ __ | |__ | (___ Institute of Embedded Systems -
* -- | | | '_ \| __| \___ \ Zuercher Hochschule Winterthur -
* -- _| |_| | | | |____ ____) | (University of Applied Sciences) -
* -- |_____|_| |_|______|_____/ 8401 Winterthur, Switzerland -
* ----------------------------------------------------------------------------
*/
/**
* @file
* @brief Test suite for the given package.
*/
#include <stdio.h>
#include <stdlib.h>
#include <sys/wait.h>
#include <time.h>
#include <assert.h>
#include <CUnit/Basic.h>
#include "test_utils.h"
#include "stack.h"
#ifndef TARGET // must be given by the make file --> see test target
#error missing TARGET define
#endif
/// @brief alias for EXIT_SUCCESS
#define OK EXIT_SUCCESS
/// @brief alias for EXIT_FAILURE
#define FAIL EXIT_FAILURE
/// @brief The name of the STDOUT text file.
#define OUTFILE "stdout.txt"
/// @brief The name of the STDERR text file.
#define ERRFILE "stderr.txt"
#define TRACE_INDENT "\n " ///< allow for better stdout formatting in case of error
// setup & cleanup
static int setup(void)
{
remove_file_if_exists(OUTFILE);
remove_file_if_exists(ERRFILE);
return 0; // success
}
static int teardown(void)
{
// Do nothing.
// Especially: do not remove result files - they are removed in int setup(void) *before* running a test.
return 0; // success
}
// tests
static void test_stack_new(void)
{
// arrange
const size_t size = 2;
// act
stack_t *instance = stack_new(size);
// assert
CU_ASSERT_PTR_NOT_NULL_FATAL(instance);
CU_ASSERT_EQUAL(stack_is_empty(instance), 1);
// cleanup
stack_destroy(instance);
}
static void test_stack_push(void)
{
// arrange
const size_t size = 2;
stack_t *instance = stack_new(size);
CU_ASSERT_PTR_NOT_NULL_FATAL(instance);
// act & assert
for(size_t i = 0; i < size; i++) {
stack_push(instance, i);
CU_ASSERT_EQUAL(stack_top(instance), i);
}
// cleanup
stack_destroy(instance);
}
static void test_stack_top(void)
{
// arrange
const size_t size = 2;
stack_t *instance = stack_new(size);
CU_ASSERT_PTR_NOT_NULL_FATAL(instance);
// act & assert
CU_ASSERT_EQUAL(stack_is_empty(instance), 1);
for(size_t i = 0; i < size; i++) {
CU_ASSERT_EQUAL(stack_is_full(instance), 0);
stack_push(instance, i);
CU_ASSERT_EQUAL(stack_is_empty(instance), 0);
CU_ASSERT_EQUAL(stack_top(instance), i);
}
CU_ASSERT_EQUAL(stack_is_full(instance), 1);
// cleanup
stack_destroy(instance);
}
static void test_stack_pop(void)
{
// arrange
const size_t size = 2;
stack_t *instance = stack_new(size);
CU_ASSERT_PTR_NOT_NULL_FATAL(instance);
for(size_t i = 0; i < size; i++) {
stack_push(instance, i);
}
// act & assert
for(size_t i = size; i > 0; i--) {
CU_ASSERT_EQUAL(stack_is_empty(instance), 0);
CU_ASSERT_EQUAL(stack_pop(instance), i-1);
CU_ASSERT_EQUAL(stack_is_full(instance), 0);
}
// cleanup
stack_destroy(instance);
}
static void test_stack_is_empty(void)
{
// arrange
const size_t size = 2;
stack_t *instance = stack_new(size);
CU_ASSERT_PTR_NOT_NULL_FATAL(instance);
// act & assert
CU_ASSERT_EQUAL(stack_is_empty(instance), 1);
for(size_t i = 0; i < size; i++) {
stack_push(instance, i);
CU_ASSERT_EQUAL(stack_is_empty(instance), 0);
}
for(size_t i = size; i > 0; i--) {
CU_ASSERT_EQUAL(stack_is_empty(instance), 0);
stack_pop(instance);
}
CU_ASSERT_EQUAL(stack_is_empty(instance), 1);
// cleanup
stack_destroy(instance);
}
static void test_stack_is_full(void)
{
// arrange
const size_t size = 2;
stack_t *instance = stack_new(size);
CU_ASSERT_PTR_NOT_NULL_FATAL(instance);
// act & assert
CU_ASSERT_EQUAL(stack_is_full(instance), 0);
for(size_t i = 0; i < size; i++) {
CU_ASSERT_EQUAL(stack_is_full(instance), 0);
stack_push(instance, i);
}
CU_ASSERT_EQUAL(stack_is_full(instance), 1);
for(size_t i = size; i > 0; i--) {
stack_pop(instance);
CU_ASSERT_EQUAL(stack_is_full(instance), 0);
}
CU_ASSERT_EQUAL(stack_is_full(instance), 0);
// cleanup
stack_destroy(instance);
}
static void test_silent(void)
{
const char *out_txt[] = {
"--- RESULT ---\n",
"dec=3\n",
"hex=0x00000003\n",
"oct=000000000003\n",
"bin=0b00000000000000000000000000000011\n",
};
const char *err_txt[] = {
NULL,
};
// arrange & act & assert
CU_ASSERT_EQUAL_FATAL(WEXITSTATUS(system("echo '1 + 2' | " XSTR(TARGET) " 0 >" OUTFILE " 2>" ERRFILE)), OK);
assert_lines(OUTFILE, out_txt, sizeof(out_txt)/sizeof(*out_txt));
assert_lines(ERRFILE, err_txt, sizeof(err_txt)/sizeof(*err_txt));
// arrange & act & assert
CU_ASSERT_EQUAL_FATAL(WEXITSTATUS(system("echo '1 + 2' | " XSTR(TARGET) " >" OUTFILE " 2>" ERRFILE)), OK);
assert_lines(OUTFILE, out_txt, sizeof(out_txt)/sizeof(*out_txt));
assert_lines(ERRFILE, err_txt, sizeof(err_txt)/sizeof(*err_txt));
}
static void test_verbose(void)
{
const char *out_txt[] = {
"--- RESULT ---\n",
"dec=3\n",
"hex=0x00000003\n",
"oct=000000000003\n",
"bin=0b00000000000000000000000000000011\n",
};
const char *err_txt[] = {
"hex=0x00000001\n",
"hex=0x00000002\n",
"OP_ADD\n",
};
// arrange & act & assert
CU_ASSERT_EQUAL_FATAL(WEXITSTATUS(system("echo '1 + 2' | " XSTR(TARGET) " 1 >" OUTFILE " 2>" ERRFILE)), OK);
assert_lines(OUTFILE, out_txt, sizeof(out_txt)/sizeof(*out_txt));
assert_lines(ERRFILE, err_txt, sizeof(err_txt)/sizeof(*err_txt));
}
static void test_all(void)
{
const char *out_txt[] = {
"--- RESULT ---\n",
"dec=8\n",
"hex=0x00000008\n",
"oct=000000000010\n",
"bin=0b00000000000000000000000000001000\n",
};
const char *err_txt[] = {
NULL,
};
// arrange & act & assert
CU_ASSERT_EQUAL_FATAL(WEXITSTATUS(system("echo '(8 | 7 ^ 5) & 4 << 3 + 2 * (~1+(1>>0))' | " XSTR(TARGET) " >" OUTFILE " 2>" ERRFILE)), OK);
assert_lines(OUTFILE, out_txt, sizeof(out_txt)/sizeof(*out_txt));
assert_lines(ERRFILE, err_txt, sizeof(err_txt)/sizeof(*err_txt));
}
static void test_error(void)
{
const char *out_txt[] = {
NULL,
};
const char *err_txt[] = {
"ERROR: at or near position 5: number or '(' ... ')' expected\n",
};
// arrange & act & assert
CU_ASSERT_EQUAL_FATAL(WEXITSTATUS(system("echo '1 + ' | " XSTR(TARGET) " >" OUTFILE " 2>" ERRFILE)), FAIL);
assert_lines(OUTFILE, out_txt, sizeof(out_txt)/sizeof(*out_txt));
assert_lines(ERRFILE, err_txt, sizeof(err_txt)/sizeof(*err_txt));
}
/**
* @brief Registers and runs the tests.
* @returns success (0) or one of the CU_ErrorCode (>0)
*/
int main(void)
{
// setup, run, teardown
TestMainBasic("lab test", setup, teardown
, test_stack_new
, test_stack_push
, test_stack_top
, test_stack_pop
, test_stack_is_empty
, test_stack_is_full
, test_silent
, test_verbose
, test_all
, test_error
);
}