| /* Copyright 2000-2004 Ryan Bloom |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| * Portions of this file were taken from testall.c in the APR test suite, |
| * written by members of the Apache Software Foundation. |
| */ |
| |
| #include "abts.h" |
| #include "abts_tests.h" |
| #include "testutil.h" |
| |
| |
| |
| #define ABTS_STAT_SIZE 6 |
| static char status[ABTS_STAT_SIZE] = {'|', '/', '-', '|', '\\', '-'}; |
| static int curr_char; |
| static int verbose = 0; |
| static int exclude = 0; |
| static int quiet = 0; |
| static int list_tests = 0; |
| |
| const char** testlist = NULL; |
| // defined in logunit.cpp |
| abts_suite* abts_run_suites(abts_suite*); |
| |
| static int find_test_name(const char* testname) |
| { |
| int i; |
| |
| for (i = 0; testlist[i] != NULL; i++) |
| { |
| if (!strcmp(testlist[i], testname)) |
| { |
| return 1; |
| } |
| } |
| |
| return 0; |
| } |
| |
| /* Determine if the test should be run at all */ |
| static int should_test_run(const char* testname) |
| { |
| int found = 0; |
| |
| if (list_tests == 1) |
| { |
| return 0; |
| } |
| |
| if (testlist == NULL) |
| { |
| return 1; |
| } |
| |
| found = find_test_name(testname); |
| |
| if ((found && !exclude) || (!found && exclude)) |
| { |
| return 1; |
| } |
| |
| return 0; |
| } |
| |
| static void reset_status(void) |
| { |
| curr_char = 0; |
| } |
| |
| static void update_status(void) |
| { |
| if (!quiet) |
| { |
| curr_char = (curr_char + 1) % ABTS_STAT_SIZE; |
| fprintf(stdout, "\b%c", status[curr_char]); |
| fflush(stdout); |
| } |
| } |
| |
| static void end_suite(abts_suite* suite) |
| { |
| if (suite != NULL) |
| { |
| sub_suite* last = suite->tail; |
| |
| if (!quiet) |
| { |
| fprintf(stdout, "\b"); |
| fflush(stdout); |
| } |
| |
| if (last->failed == 0) |
| { |
| fprintf(stdout, "SUCCESS\n"); |
| fflush(stdout); |
| } |
| else |
| { |
| fprintf(stdout, "FAILED %d of %d\n", last->failed, last->num_test); |
| fflush(stdout); |
| } |
| } |
| } |
| |
| abts_suite* abts_add_suite(abts_suite* suite, const char* suite_name_full) |
| { |
| sub_suite* subsuite; |
| const char* p; |
| const char* suite_name; |
| curr_char = 0; |
| |
| /* Only end the suite if we actually ran it */ |
| if (suite && suite->tail && !suite->tail->not_run) |
| { |
| end_suite(suite); |
| } |
| |
| subsuite = (sub_suite*) malloc(sizeof(*subsuite)); |
| subsuite->num_test = 0; |
| subsuite->failed = 0; |
| subsuite->next = NULL; |
| /* suite_name_full may be an absolute path depending on __FILE__ |
| * expansion */ |
| suite_name = strrchr(suite_name_full, '/'); |
| |
| if (suite_name) |
| { |
| suite_name++; |
| } |
| else |
| { |
| suite_name = suite_name_full; |
| } |
| |
| p = strrchr(suite_name, '.'); |
| |
| if (p) |
| { |
| subsuite->name = (const char*) memcpy(calloc(p - suite_name + 1, 1), |
| suite_name, p - suite_name); |
| } |
| else |
| { |
| subsuite->name = suite_name; |
| } |
| |
| if (list_tests) |
| { |
| fprintf(stdout, "%s\n", subsuite->name); |
| } |
| |
| subsuite->not_run = 0; |
| |
| if (suite == NULL) |
| { |
| suite = (abts_suite*) malloc(sizeof(*suite)); |
| suite->head = subsuite; |
| suite->tail = subsuite; |
| } |
| else |
| { |
| suite->tail->next = subsuite; |
| suite->tail = subsuite; |
| } |
| |
| if (!should_test_run(subsuite->name)) |
| { |
| subsuite->not_run = 1; |
| return suite; |
| } |
| |
| reset_status(); |
| fprintf(stdout, "%-20s: ", subsuite->name); |
| update_status(); |
| fflush(stdout); |
| |
| return suite; |
| } |
| |
| void abts_run_test(abts_suite* ts, test_func f, void* value) |
| { |
| abts_case tc; |
| sub_suite* ss; |
| |
| if (!should_test_run(ts->tail->name)) |
| { |
| return; |
| } |
| |
| ss = ts->tail; |
| |
| tc.failed = 0; |
| tc.suite = ss; |
| |
| ss->num_test++; |
| update_status(); |
| |
| f(&tc, value); |
| |
| if (tc.failed) |
| { |
| ss->failed++; |
| } |
| } |
| |
| static int report(abts_suite* suite) |
| { |
| int count = 0; |
| sub_suite* dptr; |
| |
| if (suite && suite->tail && !suite->tail->not_run) |
| { |
| end_suite(suite); |
| } |
| |
| for (dptr = suite->head; dptr; dptr = dptr->next) |
| { |
| count += dptr->failed; |
| } |
| |
| if (list_tests) |
| { |
| return 0; |
| } |
| |
| if (count == 0) |
| { |
| printf("All tests passed.\n"); |
| return 0; |
| } |
| |
| dptr = suite->head; |
| fprintf(stdout, "%-15s\t\tTotal\tFail\tFailed %%\n", "Failed Tests"); |
| fprintf(stdout, "===================================================\n"); |
| |
| while (dptr != NULL) |
| { |
| if (dptr->failed != 0) |
| { |
| float percent = ((float)dptr->failed / (float)dptr->num_test); |
| fprintf(stdout, "%-15s\t\t%5d\t%4d\t%6.2f%%\n", dptr->name, |
| dptr->num_test, dptr->failed, percent * 100); |
| } |
| |
| dptr = dptr->next; |
| } |
| |
| return 1; |
| } |
| |
| void abts_log_message(const char* fmt, ...) |
| { |
| va_list args; |
| update_status(); |
| |
| if (verbose) |
| { |
| va_start(args, fmt); |
| vfprintf(stderr, fmt, args); |
| va_end(args); |
| fprintf(stderr, "\n"); |
| fflush(stderr); |
| } |
| } |
| |
| void abts_int_equal(abts_case* tc, const int expected, const int actual, int lineno) |
| { |
| update_status(); |
| |
| if (tc->failed) |
| { |
| return; |
| } |
| |
| if (expected == actual) |
| { |
| return; |
| } |
| |
| tc->failed = TRUE; |
| |
| if (verbose) |
| { |
| fprintf(stderr, "Line %d: expected <%d>, but saw <%d>\n", lineno, expected, actual); |
| fflush(stderr); |
| } |
| } |
| |
| void abts_int_nequal(abts_case* tc, const int expected, const int actual, int lineno) |
| { |
| update_status(); |
| |
| if (tc->failed) |
| { |
| return; |
| } |
| |
| if (expected != actual) |
| { |
| return; |
| } |
| |
| tc->failed = TRUE; |
| |
| if (verbose) |
| { |
| fprintf(stderr, "Line %d: expected <%d>, but saw <%d>\n", lineno, expected, actual); |
| fflush(stderr); |
| } |
| } |
| |
| void abts_size_equal(abts_case* tc, size_t expected, size_t actual, int lineno) |
| { |
| update_status(); |
| |
| if (tc->failed) |
| { |
| return; |
| } |
| |
| if (expected == actual) |
| { |
| return; |
| } |
| |
| tc->failed = TRUE; |
| |
| if (verbose) |
| { |
| /* Note that the comparison is type-exact, reporting must be a best-fit */ |
| fprintf(stderr, "Line %d: expected %lu, but saw %lu\n", lineno, |
| (unsigned long)expected, (unsigned long)actual); |
| fflush(stderr); |
| } |
| } |
| |
| void abts_str_equal(abts_case* tc, const char* expected, const char* actual, int lineno) |
| { |
| update_status(); |
| |
| if (tc->failed) |
| { |
| return; |
| } |
| |
| if (!expected && !actual) |
| { |
| return; |
| } |
| |
| if (expected && actual) |
| if (!strcmp(expected, actual)) |
| { |
| return; |
| } |
| |
| tc->failed = TRUE; |
| |
| if (verbose) |
| { |
| fprintf(stderr, "Line %d: expected <%s>, but saw <%s>\n", lineno, expected, actual); |
| fflush(stderr); |
| } |
| } |
| |
| void abts_str_nequal(abts_case* tc, const char* expected, const char* actual, |
| size_t n, int lineno) |
| { |
| update_status(); |
| |
| if (tc->failed) |
| { |
| return; |
| } |
| |
| if (!strncmp(expected, actual, n)) |
| { |
| return; |
| } |
| |
| tc->failed = TRUE; |
| |
| if (verbose) |
| { |
| fprintf(stderr, "Line %d: expected <%s>, but saw <%s>\n", lineno, expected, actual); |
| fflush(stderr); |
| } |
| } |
| |
| void abts_ptr_notnull(abts_case* tc, const void* ptr, int lineno) |
| { |
| update_status(); |
| |
| if (tc->failed) |
| { |
| return; |
| } |
| |
| if (ptr != NULL) |
| { |
| return; |
| } |
| |
| tc->failed = TRUE; |
| |
| if (verbose) |
| { |
| fprintf(stderr, "Line %d: Expected NULL, but saw <%p>\n", lineno, ptr); |
| fflush(stderr); |
| } |
| } |
| |
| void abts_ptr_equal(abts_case* tc, const void* expected, const void* actual, int lineno) |
| { |
| update_status(); |
| |
| if (tc->failed) |
| { |
| return; |
| } |
| |
| if (expected == actual) |
| { |
| return; |
| } |
| |
| tc->failed = TRUE; |
| |
| if (verbose) |
| { |
| fprintf(stderr, "Line %d: expected <%p>, but saw <%p>\n", lineno, expected, actual); |
| fflush(stderr); |
| } |
| } |
| |
| void abts_fail(abts_case* tc, const char* message, int lineno) |
| { |
| update_status(); |
| |
| if (tc->failed) |
| { |
| return; |
| } |
| |
| tc->failed = TRUE; |
| |
| if (verbose) |
| { |
| fprintf(stderr, "Line %d: %s\n", lineno, message); |
| fflush(stderr); |
| } |
| } |
| |
| void abts_assert(abts_case* tc, const char* message, int condition, int lineno) |
| { |
| update_status(); |
| |
| if (tc->failed) |
| { |
| return; |
| } |
| |
| if (condition) |
| { |
| return; |
| } |
| |
| tc->failed = TRUE; |
| |
| if (verbose) |
| { |
| fprintf(stderr, "Line %d: %s\n", lineno, message); |
| fflush(stderr); |
| } |
| } |
| |
| void abts_true(abts_case* tc, int condition, int lineno) |
| { |
| update_status(); |
| |
| if (tc->failed) |
| { |
| return; |
| } |
| |
| if (condition) |
| { |
| return; |
| } |
| |
| tc->failed = TRUE; |
| |
| if (verbose) |
| { |
| fprintf(stderr, "Line %d: Condition is false, but expected true\n", lineno); |
| fflush(stderr); |
| } |
| } |
| |
| void abts_not_impl(abts_case* tc, const char* message, int lineno) |
| { |
| update_status(); |
| |
| tc->suite->not_impl++; |
| |
| if (verbose) |
| { |
| fprintf(stderr, "Line %d: %s\n", lineno, message); |
| fflush(stderr); |
| } |
| } |
| |
| int main(int argc, const char* const argv[]) |
| { |
| int i; |
| int rv; |
| int list_provided = 0; |
| abts_suite* suite = NULL; |
| |
| initialize(); |
| |
| #if defined(_MSC_VER) |
| quiet = 1; |
| #else |
| quiet = !isatty(STDOUT_FILENO); |
| #endif |
| |
| for (i = 1; i < argc; i++) |
| { |
| if (!strcmp(argv[i], "-v")) |
| { |
| verbose = 1; |
| continue; |
| } |
| |
| if (!strcmp(argv[i], "-x")) |
| { |
| exclude = 1; |
| continue; |
| } |
| |
| if (!strcmp(argv[i], "-l")) |
| { |
| list_tests = 1; |
| continue; |
| } |
| |
| if (!strcmp(argv[i], "-q")) |
| { |
| quiet = 1; |
| continue; |
| } |
| |
| if (argv[i][0] == '-') |
| { |
| fprintf(stderr, "Invalid option: `%s'\n", argv[i]); |
| exit(1); |
| } |
| |
| list_provided = 1; |
| } |
| |
| if (list_provided) |
| { |
| /* Waste a little space here, because it is easier than counting the |
| * number of tests listed. Besides it is at most three char *. |
| */ |
| testlist = (const char**) calloc(argc + 1, sizeof(char*)); |
| |
| for (i = 1; i < argc; i++) |
| { |
| testlist[i - 1] = argv[i]; |
| } |
| } |
| |
| suite = abts_run_suites(suite); |
| |
| if (suite == 0) |
| { |
| fputs("No tests selected\n", stderr); |
| } |
| else |
| { |
| rv = report(suite); |
| // |
| // clean up suite |
| // |
| sub_suite* next; |
| |
| for (sub_suite* head = suite->head; head != NULL; head = next) |
| { |
| next = head->next; |
| free((void*) head->name); |
| free(head); |
| } |
| |
| free(suite); |
| } |
| |
| return rv; |
| } |