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

progc: replace tabs with spaces to follow coding guideline

This commit is contained in:
Robert Hunger 2020-02-06 23:44:56 +01:00
parent 8ef4d4182d
commit c3f83f6315
3 changed files with 200 additions and 200 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

160
testlib/src/test_utils.c
View File

@ -22,96 +22,96 @@
int file_exists(const char file_path[]) int file_exists(const char file_path[])
{ {
// preconditions // preconditions
assert(file_path); assert(file_path);
int errno_safe = errno; int errno_safe = errno;
errno = 0; errno = 0;
// try and forgive... // try and forgive...
FILE *file = fopen(file_path, "r"); FILE *file = fopen(file_path, "r");
assert(file || (!file && (errno == ENOENT))); // either it exists or "No such file or directory" error code (see man errno). assert(file || (!file && (errno == ENOENT))); // either it exists or "No such file or directory" error code (see man errno).
errno = errno_safe; // fopen will set errno if the file does not exist errno = errno_safe; // fopen will set errno if the file does not exist
if (file) { if (file) {
assert(0 == fclose(file)); assert(0 == fclose(file));
return 1; // existed return 1; // existed
} }
return 0; // did not exist return 0; // did not exist
} }
void remove_file_if_exists(const char file_path[]) void remove_file_if_exists(const char file_path[])
{ {
// we take the risk that between checking and removing, some undesired file access may happen and jeopardize the control logic... // we take the risk that between checking and removing, some undesired file access may happen and jeopardize the control logic...
if (file_exists(file_path)) { if (file_exists(file_path)) {
assert(0 == unlink(file_path)); assert(0 == unlink(file_path));
} }
} }
void assert_lines(const char file[], const char *lines[], size_t n_lines) void assert_lines(const char file[], const char *lines[], size_t n_lines)
{ {
// preconditions // preconditions
CU_ASSERT_PTR_NOT_NULL_FATAL(file); CU_ASSERT_PTR_NOT_NULL_FATAL(file);
CU_ASSERT_PTR_NOT_NULL_FATAL(lines); CU_ASSERT_PTR_NOT_NULL_FATAL(lines);
// file access may always fail // file access may always fail
FILE *input = fopen(file, "r"); FILE *input = fopen(file, "r");
if (!input) perror(file); if (!input) perror(file);
CU_ASSERT_PTR_NOT_NULL_FATAL(input); CU_ASSERT_PTR_NOT_NULL_FATAL(input);
// process all lines and compare to the file content // process all lines and compare to the file content
size_t i = 0; size_t i = 0;
size_t n = 0; size_t n = 0;
for(i = 0; i < n_lines && n == 0; i++) { for(i = 0; i < n_lines && n == 0; i++) {
const char *line = lines[i]; const char *line = lines[i];
CU_ASSERT_PTR_NOT_NULL(line); CU_ASSERT_PTR_NOT_NULL(line);
if (line) { if (line) {
size_t len = n = strlen(line); size_t len = n = strlen(line);
CU_ASSERT(n > 0); CU_ASSERT(n > 0);
while (n > 0) { while (n > 0) {
int c = fgetc(input); int c = fgetc(input);
CU_ASSERT_FALSE(feof(input)); CU_ASSERT_FALSE(feof(input));
CU_ASSERT_EQUAL(c, *line); CU_ASSERT_EQUAL(c, *line);
if (c != *line) { if (c != *line) {
printf("\nfile %s: line %zu, pos %zu = %d = '%c', expected = %d = '%c'\n", printf("\nfile %s: line %zu, pos %zu = %d = '%c', expected = %d = '%c'\n",
file, i+1, len-n+1, c, isprint(c) ? c : '.', *line, isprint(*line) ? *line : '.'); file, i+1, len-n+1, c, isprint(c) ? c : '.', *line, isprint(*line) ? *line : '.');
break; break;
} }
line++; line++;
n--; n--;
} }
} }
} }
CU_ASSERT_FALSE(feof(input)); CU_ASSERT_FALSE(feof(input));
(void)fgetc(input); (void)fgetc(input);
CU_ASSERT_TRUE(feof(input)); CU_ASSERT_TRUE(feof(input));
CU_ASSERT_EQUAL(i, n_lines); CU_ASSERT_EQUAL(i, n_lines);
CU_ASSERT_EQUAL(n, 0); CU_ASSERT_EQUAL(n, 0);
// successfully reached the end... // successfully reached the end...
int fclose_result = fclose(input); int fclose_result = fclose(input);
CU_ASSERT(0 == fclose_result); CU_ASSERT(0 == fclose_result);
// print actual versus expected in case of error
if (n != 0 || i != n_lines) {
printf("---- EXPECTED ----\n");
for(int i = 0; i < n_lines; i++) {
const char *p = lines[i];
while(p && *p) {
putchar(*p);
p++;
}
}
printf("---- ACTUAL (%s) ----\n", file);
FILE* fd = fopen(file, "r");
int last = 0;
while(fd && !feof(fd)) {
int c = fgetc(fd);
if (c != EOF) {
last = c;
putchar(c);
}
}
if (fd) fclose(fd);
if (last != '\n') putchar('\n');
printf("---- END ----\n");
}
// print actual versus expected in case of error
if (n != 0 || i != n_lines) {
printf("---- EXPECTED ----\n");
for(int i = 0; i < n_lines; i++) {
const char *p = lines[i];
while(p && *p) {
putchar(*p);
p++;
}
}
printf("---- ACTUAL (%s) ----\n", file);
FILE* fd = fopen(file, "r");
int last = 0;
while(fd && !feof(fd)) {
int c = fgetc(fd);
if (c != EOF) {
last = c;
putchar(c);
}
}
if (fd) fclose(fd);
if (last != '\n') putchar('\n');
printf("---- END ----\n");
}
} }

64
testlib/src/test_utils.h
View File

@ -109,38 +109,38 @@ typedef void (*test_function_t)(void);
* } * }
* @endcode * @endcode
*/ */
#define TestMainBasic(suite, setup, cleanup, ...) \ #define TestMainBasic(suite, setup, cleanup, ...) \
do { \ do { \
CU_pSuite pSuite = NULL; \ CU_pSuite pSuite = NULL; \
\ \
/* initialize the CUnit test registry */ \ /* initialize the CUnit test registry */ \
if (CUE_SUCCESS != CU_initialize_registry()) \ if (CUE_SUCCESS != CU_initialize_registry()) \
return CU_get_error(); \ return CU_get_error(); \
\ \
/* functions and their names */ \ /* functions and their names */ \
test_function_t tests[] = { __VA_ARGS__ }; \ test_function_t tests[] = { __VA_ARGS__ }; \
char all_names[] = #__VA_ARGS__; \ char all_names[] = #__VA_ARGS__; \
const size_t n = sizeof(tests)/sizeof(*tests); \ const size_t n = sizeof(tests)/sizeof(*tests); \
const char *names[sizeof(tests)/sizeof(*tests)] = { strtok(all_names, ", ") } ; \ const char *names[sizeof(tests)/sizeof(*tests)] = { strtok(all_names, ", ") } ; \
for(size_t i = 1; i < n; i++) { \ for(size_t i = 1; i < n; i++) { \
names[i] = strtok(NULL, ", "); \ names[i] = strtok(NULL, ", "); \
} \ } \
/* init suite and tests */ \ /* init suite and tests */ \
pSuite = CU_add_suite(suite, setup, cleanup); \ pSuite = CU_add_suite(suite, setup, cleanup); \
if (pSuite) { \ if (pSuite) { \
size_t i; \ size_t i; \
for(i = 0; i < n; i++) { \ for(i = 0; i < n; i++) { \
if (!CU_add_test(pSuite, names[i], tests[i])) break; \ if (!CU_add_test(pSuite, names[i], tests[i])) break; \
} \ } \
/* Run all tests using the CUnit Basic interface */ \ /* Run all tests using the CUnit Basic interface */ \
if (i == n) { \ if (i == n) { \
CU_basic_set_mode(CU_BRM_VERBOSE); \ CU_basic_set_mode(CU_BRM_VERBOSE); \
CU_basic_run_tests(); \ CU_basic_run_tests(); \
} \ } \
} \ } \
CU_cleanup_registry(); \ CU_cleanup_registry(); \
return CU_get_error(); \ return CU_get_error(); \
} while(0) \ } while(0) \
#endif #endif

176
testlib/tests/tests.c
View File

@ -34,125 +34,125 @@
// setup & teardown // setup & teardown
static int setup(void) static int setup(void)
{ {
remove_file_if_exists(OUTFILE); remove_file_if_exists(OUTFILE);
remove_file_if_exists(ERRFILE); remove_file_if_exists(ERRFILE);
remove_file_if_exists(EMPTYFILE); remove_file_if_exists(EMPTYFILE);
remove_file_if_exists(NONEMPTYFILE); remove_file_if_exists(NONEMPTYFILE);
remove_file_if_exists(NONEMPTYFILE_NONLEND); remove_file_if_exists(NONEMPTYFILE_NONLEND);
// do nothing // do nothing
return 0; // success return 0; // success
} }
static int teardown(void) static int teardown(void)
{ {
// do nothing // do nothing
return 0; // success return 0; // success
} }
// tests // tests
static void test_remove_file_that_exists(void) static void test_remove_file_that_exists(void)
{ {
// ** arrange ** // ** arrange **
// create a file // create a file
FILE *file = fopen(OUTFILE, "w"); FILE *file = fopen(OUTFILE, "w");
CU_ASSERT_PTR_NOT_NULL(file); CU_ASSERT_PTR_NOT_NULL(file);
CU_ASSERT_EQUAL(fclose(file), 0); CU_ASSERT_EQUAL(fclose(file), 0);
errno = 0; errno = 0;
// ** act ** // ** act **
remove_file_if_exists(OUTFILE); remove_file_if_exists(OUTFILE);
// ** assert ** // ** assert **
// make sure the file is removed // make sure the file is removed
CU_ASSERT_EQUAL(errno, 0); CU_ASSERT_EQUAL(errno, 0);
file = fopen(OUTFILE, "r"); file = fopen(OUTFILE, "r");
CU_ASSERT_TRUE(!file && errno == ENOENT); CU_ASSERT_TRUE(!file && errno == ENOENT);
// cleanup gracefully // cleanup gracefully
if (file) CU_ASSERT_EQUAL(fclose(file), 0); if (file) CU_ASSERT_EQUAL(fclose(file), 0);
errno = 0; errno = 0;
} }
static void test_remove_file_that_does_not_exist(void) static void test_remove_file_that_does_not_exist(void)
{ {
// ** arrange ** // ** arrange **
remove_file_if_exists(OUTFILE); remove_file_if_exists(OUTFILE);
// the file is now supposed to not exist any more --> see test_remove_file_that_exists test result // the file is now supposed to not exist any more --> see test_remove_file_that_exists test result
// ** act ** // ** act **
// call with a not existing file // call with a not existing file
remove_file_if_exists(OUTFILE); remove_file_if_exists(OUTFILE);
// must not fail in any internal assertion // must not fail in any internal assertion
// ** assert **
// make sure the file is removed // ** assert **
CU_ASSERT_EQUAL(errno, 0);
FILE *file = fopen(OUTFILE, "r"); // make sure the file is removed
CU_ASSERT_TRUE(!file && errno == ENOENT); CU_ASSERT_EQUAL(errno, 0);
// cleanup gracefully FILE *file = fopen(OUTFILE, "r");
if (file) CU_ASSERT_EQUAL(fclose(file), 0); CU_ASSERT_TRUE(!file && errno == ENOENT);
errno = 0; // cleanup gracefully
if (file) CU_ASSERT_EQUAL(fclose(file), 0);
errno = 0;
} }
static void test_assert_lines_empty_file(void) static void test_assert_lines_empty_file(void)
{ {
// ** arrange ** // ** arrange **
// empty file // empty file
remove_file_if_exists(EMPTYFILE); remove_file_if_exists(EMPTYFILE);
FILE *file = fopen(EMPTYFILE, "w"); FILE *file = fopen(EMPTYFILE, "w");
CU_ASSERT_PTR_NOT_NULL_FATAL(file); CU_ASSERT_PTR_NOT_NULL_FATAL(file);
CU_ASSERT_EQUAL(fclose(file), 0); CU_ASSERT_EQUAL(fclose(file), 0);
const char *lines[] = {}; const char *lines[] = {};
// ** act ** // ** act **
assert_lines(EMPTYFILE, lines, sizeof(lines)/sizeof(*lines)); assert_lines(EMPTYFILE, lines, sizeof(lines)/sizeof(*lines));
// ** assert **
// no assertions should have happened within assert_lines(...) // ** assert **
// no assertions should have happened within assert_lines(...)
} }
static void test_assert_lines_non_empty_file(void) static void test_assert_lines_non_empty_file(void)
{ {
// ** arrange ** // ** arrange **
// reference file // reference file
remove_file_if_exists(NONEMPTYFILE); remove_file_if_exists(NONEMPTYFILE);
FILE *file = fopen(NONEMPTYFILE, "w"); FILE *file = fopen(NONEMPTYFILE, "w");
CU_ASSERT_PTR_NOT_NULL_FATAL(file); CU_ASSERT_PTR_NOT_NULL_FATAL(file);
CU_ASSERT_EQUAL(fprintf(file, "LINE1\n"), 6); CU_ASSERT_EQUAL(fprintf(file, "LINE1\n"), 6);
CU_ASSERT_EQUAL(fprintf(file, "LINE2\n"), 6); CU_ASSERT_EQUAL(fprintf(file, "LINE2\n"), 6);
CU_ASSERT_EQUAL(fclose(file), 0); CU_ASSERT_EQUAL(fclose(file), 0);
const char *lines[] = { "LINE1\n", "LINE2\n"}; const char *lines[] = { "LINE1\n", "LINE2\n"};
// ** act ** // ** act **
assert_lines(NONEMPTYFILE, lines, sizeof(lines)/sizeof(*lines)); assert_lines(NONEMPTYFILE, lines, sizeof(lines)/sizeof(*lines));
// ** assert **
// no assertions should have happened within assert_lines(...) // ** assert **
// no assertions should have happened within assert_lines(...)
} }
static void test_assert_lines_no_newline_at_the_end(void) static void test_assert_lines_no_newline_at_the_end(void)
{ {
// ** arrange ** // ** arrange **
// reference file // reference file
remove_file_if_exists(NONEMPTYFILE_NONLEND); remove_file_if_exists(NONEMPTYFILE_NONLEND);
FILE *file = fopen(NONEMPTYFILE_NONLEND, "w"); FILE *file = fopen(NONEMPTYFILE_NONLEND, "w");
CU_ASSERT_PTR_NOT_NULL_FATAL(file); CU_ASSERT_PTR_NOT_NULL_FATAL(file);
CU_ASSERT_EQUAL(fprintf(file, "LINE1\n"), 6); CU_ASSERT_EQUAL(fprintf(file, "LINE1\n"), 6);
CU_ASSERT_EQUAL(fprintf(file, "LINE2"), 5); CU_ASSERT_EQUAL(fprintf(file, "LINE2"), 5);
CU_ASSERT_EQUAL(fclose(file), 0); CU_ASSERT_EQUAL(fclose(file), 0);
const char *lines[] = { "LINE1\n", "LINE2"}; const char *lines[] = { "LINE1\n", "LINE2"};
// ** act ** // ** act **
assert_lines(NONEMPTYFILE_NONLEND, lines, sizeof(lines)/sizeof(*lines)); assert_lines(NONEMPTYFILE_NONLEND, lines, sizeof(lines)/sizeof(*lines));
// ** assert **
// no assertions should have happened within assert_lines(...) // ** assert **
// no assertions should have happened within assert_lines(...)
} }
/** /**
@ -160,11 +160,11 @@ static void test_assert_lines_no_newline_at_the_end(void)
*/ */
int main(void) int main(void)
{ {
TestMainBasic("PROGC Test Lib", setup, teardown TestMainBasic("PROGC Test Lib", setup, teardown
, test_remove_file_that_exists , test_remove_file_that_exists
, test_remove_file_that_does_not_exist , test_remove_file_that_does_not_exist
, test_assert_lines_empty_file , test_assert_lines_empty_file
, test_assert_lines_non_empty_file , test_assert_lines_non_empty_file
, test_assert_lines_no_newline_at_the_end , test_assert_lines_no_newline_at_the_end
); );
} }