| /* | |
| * Copyright © 2015 Samsung Electronics Co., Ltd | |
| * | |
| * Permission is hereby granted, free of charge, to any person obtaining | |
| * a copy of this software and associated documentation files (the | |
| * "Software"), to deal in the Software without restriction, including | |
| * without limitation the rights to use, copy, modify, merge, publish, | |
| * distribute, sublicense, and/or sell copies of the Software, and to | |
| * permit persons to whom the Software is furnished to do so, subject to | |
| * the following conditions: | |
| * | |
| * The above copyright notice and this permission notice (including the | |
| * next paragraph) shall be included in all copies or substantial | |
| * portions of the Software. | |
| * | |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, | |
| * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF | |
| * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND | |
| * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS | |
| * BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN | |
| * ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN | |
| * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE | |
| * SOFTWARE. | |
| */ | |
| #include "config.h" | |
| #include <errno.h> | |
| #include <fcntl.h> | |
| #include <stdarg.h> | |
| #include <stdbool.h> | |
| #include <stdio.h> | |
| #include <stdlib.h> | |
| #include <string.h> | |
| #include <sys/types.h> | |
| #include <sys/wait.h> | |
| #include <time.h> | |
| #include <unistd.h> | |
| #include "zunitc/zunitc_impl.h" | |
| #include "zunitc/zunitc.h" | |
| #include "zuc_base_logger.h" | |
| #include "zuc_collector.h" | |
| #include "zuc_context.h" | |
| #include "zuc_event_listener.h" | |
| #include "zuc_junit_reporter.h" | |
| #include "shared/config-parser.h" | |
| #include "shared/helpers.h" | |
| #include "shared/zalloc.h" | |
| /* | |
| * If CLOCK_MONOTONIC is present on the system it will give us reliable | |
| * results under certain edge conditions that normally require manual | |
| * admin actions to trigger. If not, CLOCK_REALTIME is a reasonable | |
| * fallback. | |
| */ | |
| #if _POSIX_MONOTONIC_CLOCK | |
| static const clockid_t TARGET_TIMER = CLOCK_MONOTONIC; | |
| #else | |
| static const clockid_t TARGET_TIMER = CLOCK_REALTIME; | |
| #endif | |
| static char const DISABLED_PREFIX[] = "DISABLED_"; | |
| #define MS_PER_SEC 1000L | |
| #define NANO_PER_MS 1000000L | |
| /** | |
| * Simple single-linked list structure. | |
| */ | |
| struct zuc_slinked { | |
| void *data; | |
| struct zuc_slinked *next; | |
| }; | |
| static struct zuc_context g_ctx = { | |
| .case_count = 0, | |
| .cases = NULL, | |
| .fatal = false, | |
| .repeat = 0, | |
| .random = 0, | |
| .spawn = true, | |
| .break_on_failure = false, | |
| .fds = {-1, -1}, | |
| .listeners = NULL, | |
| .curr_case = NULL, | |
| .curr_test = NULL, | |
| }; | |
| static char *g_progname = NULL; | |
| static char *g_progbasename = NULL; | |
| typedef int (*comp_pred2)(intptr_t lhs, intptr_t rhs); | |
| static bool | |
| test_has_skip(struct zuc_test *test) | |
| { | |
| return test->skipped; | |
| } | |
| static bool | |
| test_has_failure(struct zuc_test *test) | |
| { | |
| return test->fatal || test->failed; | |
| } | |
| bool | |
| zuc_has_skip(void) | |
| { | |
| return g_ctx.curr_test ? | |
| test_has_skip(g_ctx.curr_test) : false; | |
| } | |
| bool | |
| zuc_has_failure(void) | |
| { | |
| return g_ctx.curr_test ? | |
| test_has_failure(g_ctx.curr_test) : false; | |
| } | |
| void | |
| zuc_set_filter(const char *filter) | |
| { | |
| g_ctx.filter = strdup(filter); | |
| } | |
| void | |
| zuc_set_repeat(int repeat) | |
| { | |
| g_ctx.repeat = repeat; | |
| } | |
| void | |
| zuc_set_random(int random) | |
| { | |
| g_ctx.random = random; | |
| } | |
| void | |
| zuc_set_spawn(bool spawn) | |
| { | |
| g_ctx.spawn = spawn; | |
| } | |
| void | |
| zuc_set_break_on_failure(bool break_on_failure) | |
| { | |
| g_ctx.break_on_failure = break_on_failure; | |
| } | |
| void | |
| zuc_set_output_junit(bool enable) | |
| { | |
| g_ctx.output_junit = enable; | |
| } | |
| const char * | |
| zuc_get_program_name(void) | |
| { | |
| return g_progname; | |
| } | |
| const char * | |
| zuc_get_program_basename(void) | |
| { | |
| return g_progbasename; | |
| } | |
| static struct zuc_test * | |
| create_test(int order, zucimpl_test_fn fn, zucimpl_test_fn_f fn_f, | |
| char const *case_name, char const *test_name, | |
| struct zuc_case *parent) | |
| { | |
| struct zuc_test *test = zalloc(sizeof(struct zuc_test)); | |
| ZUC_ASSERTG_NOT_NULL(test, out); | |
| test->order = order; | |
| test->fn = fn; | |
| test->fn_f = fn_f; | |
| test->name = strdup(test_name); | |
| if ((!fn && !fn_f) || | |
| (strncmp(DISABLED_PREFIX, | |
| test_name, sizeof(DISABLED_PREFIX) - 1) == 0)) | |
| test->disabled = 1; | |
| test->test_case = parent; | |
| out: | |
| return test; | |
| } | |
| static int | |
| compare_regs(const void *lhs, const void *rhs) | |
| { | |
| int rc = strcmp((*(struct zuc_registration **)lhs)->tcase, | |
| (*(struct zuc_registration **)rhs)->tcase); | |
| if (rc == 0) | |
| rc = strcmp((*(struct zuc_registration **)lhs)->test, | |
| (*(struct zuc_registration **)rhs)->test); | |
| return rc; | |
| } | |
| /* gcc-specific markers for auto test case registration: */ | |
| extern const struct zuc_registration __start_zuc_tsect; | |
| extern const struct zuc_registration __stop_zuc_tsect; | |
| static void | |
| register_tests(void) | |
| { | |
| size_t case_count = 0; | |
| size_t count = &__stop_zuc_tsect - &__start_zuc_tsect; | |
| size_t i; | |
| int idx = 0; | |
| const char *last_name = NULL; | |
| void **array = zalloc(sizeof(void *) * count); | |
| ZUC_ASSERT_NOT_NULL(array); | |
| for (i = 0; i < count; ++i) | |
| array[i] = (void *)(&__start_zuc_tsect + i); | |
| qsort(array, count, sizeof(array[0]), compare_regs); | |
| /* Count transitions to get number of test cases. */ | |
| last_name = NULL; | |
| for (i = 0; i < count; ++i) { | |
| const struct zuc_registration *reg = | |
| (const struct zuc_registration *)array[i]; | |
| if (!last_name || (strcmp(last_name, reg->tcase))) { | |
| last_name = reg->tcase; | |
| case_count++; | |
| } | |
| } | |
| /* Create test case data items. */ | |
| struct zuc_case **case_array = | |
| zalloc(sizeof(struct zuc_case *) * case_count); | |
| ZUC_ASSERT_NOT_NULL(case_array); | |
| struct zuc_case *last_case = NULL; | |
| size_t case_num = 0; | |
| for (i = 0; i < count; ++i) { | |
| const struct zuc_registration *reg = | |
| (const struct zuc_registration *)array[i]; | |
| if (!last_case || (strcmp(last_case->name, reg->tcase))) { | |
| last_case = zalloc(sizeof(struct zuc_case)); | |
| ZUC_ASSERT_NOT_NULL(last_case); | |
| last_case->order = count; | |
| last_case->name = strdup(reg->tcase); | |
| last_case->fxt = reg->fxt; | |
| last_case->test_count = i; | |
| if (case_num > 0) { | |
| int tcount = i | |
| - case_array[case_num - 1]->test_count; | |
| case_array[case_num - 1]->test_count = tcount; | |
| } | |
| case_array[case_num++] = last_case; | |
| } | |
| } | |
| case_array[case_count - 1]->test_count = count | |
| - case_array[case_count - 1]->test_count; | |
| /* Reserve space for tests per test case. */ | |
| for (case_num = 0; case_num < case_count; ++case_num) { | |
| case_array[case_num]->tests = | |
| zalloc(case_array[case_num]->test_count | |
| * sizeof(struct zuc_test *)); | |
| ZUC_ASSERT_NOT_NULL(case_array[case_num]->tests); | |
| } | |
| last_name = NULL; | |
| case_num = -1; | |
| for (i = 0; i < count; ++i) { | |
| const struct zuc_registration *reg = | |
| (const struct zuc_registration *)array[i]; | |
| int order = count - (1 + (reg - &__start_zuc_tsect)); | |
| if (!last_name || (strcmp(last_name, reg->tcase))) { | |
| last_name = reg->tcase; | |
| case_num++; | |
| idx = 0; | |
| } | |
| if (order < case_array[case_num]->order) | |
| case_array[case_num]->order = order; | |
| case_array[case_num]->tests[idx] = | |
| create_test(order, reg->fn, reg->fn_f, | |
| reg->tcase, reg->test, | |
| case_array[case_num]); | |
| if (case_array[case_num]->fxt != reg->fxt) | |
| printf("%s:%d: error: Mismatched fixtures for '%s'\n", | |
| __FILE__, __LINE__, case_array[case_num]->name); | |
| idx++; | |
| } | |
| free(array); | |
| g_ctx.case_count = case_count; | |
| g_ctx.cases = case_array; | |
| } | |
| static int | |
| compare_case_order(const void *lhs, const void *rhs) | |
| { | |
| return (*(struct zuc_case **)lhs)->order | |
| - (*(struct zuc_case **)rhs)->order; | |
| } | |
| static int | |
| compare_test_order(const void *lhs, const void *rhs) | |
| { | |
| return (*(struct zuc_test **)lhs)->order | |
| - (*(struct zuc_test **)rhs)->order; | |
| } | |
| static void | |
| order_cases(int count, struct zuc_case **cases) | |
| { | |
| int i; | |
| qsort(cases, count, sizeof(*cases), compare_case_order); | |
| for (i = 0; i < count; ++i) { | |
| qsort(cases[i]->tests, cases[i]->test_count, | |
| sizeof(*cases[i]->tests), compare_test_order); | |
| } | |
| } | |
| static void | |
| free_events(struct zuc_event **events) | |
| { | |
| struct zuc_event *evt = *events; | |
| *events = NULL; | |
| while (evt) { | |
| struct zuc_event *old = evt; | |
| evt = evt->next; | |
| free(old->file); | |
| if (old->valtype == ZUC_VAL_CSTR) { | |
| free((void *)old->val1); | |
| free((void *)old->val2); | |
| } | |
| free(old->expr1); | |
| free(old->expr2); | |
| free(old); | |
| } | |
| } | |
| static void | |
| free_test(struct zuc_test *test) | |
| { | |
| free(test->name); | |
| free_events(&test->events); | |
| free_events(&test->deferred); | |
| free(test); | |
| } | |
| static void | |
| free_test_case(struct zuc_case *test_case) | |
| { | |
| int i; | |
| free(test_case->name); | |
| for (i = test_case->test_count - 1; i >= 0; --i) { | |
| free_test(test_case->tests[i]); | |
| test_case->tests[i] = NULL; | |
| } | |
| free(test_case->tests); | |
| free(test_case); | |
| } | |
| /** | |
| * A very simple matching that is compatible with the algorithm used in | |
| * Google Test. | |
| * | |
| * @param wildcard sequence of '?', '*' or normal characters to match. | |
| * @param str string to check for matching. | |
| * @return true if the wildcard matches the entire string, false otherwise. | |
| */ | |
| static bool | |
| wildcard_matches(char const *wildcard, char const *str) | |
| { | |
| switch (*wildcard) { | |
| case '\0': | |
| return !*str; | |
| case '?': | |
| return *str && wildcard_matches(wildcard + 1, str + 1); | |
| case '*': | |
| return (*str && wildcard_matches(wildcard, str + 1)) | |
| || wildcard_matches(wildcard + 1, str); | |
| default: | |
| return (*wildcard == *str) | |
| && wildcard_matches(wildcard + 1, str + 1); | |
| }; | |
| } | |
| static char** | |
| segment_str(char *str) | |
| { | |
| int count = 1; | |
| char **parts = NULL; | |
| char *saved = NULL; | |
| char *tok = NULL; | |
| int i = 0; | |
| for (i = 0; str[i]; ++i) | |
| if (str[i] == ':') | |
| count++; | |
| parts = zalloc(sizeof(char*) * (count + 1)); | |
| ZUC_ASSERTG_NOT_NULL(parts, out); | |
| tok = strtok_r(str, ":", &saved); | |
| i = 0; | |
| parts[i++] = tok; | |
| while (tok) { | |
| tok = strtok_r(NULL, ":", &saved); | |
| parts[i++] = tok; | |
| } | |
| out: | |
| return parts; | |
| } | |
| static void | |
| filter_cases(int *count, struct zuc_case **cases, char const *filter) | |
| { | |
| int i = 0; | |
| int j = 0; | |
| int num_pos = 0; | |
| int negative = -1; | |
| char *buf = strdup(filter); | |
| char **parts = segment_str(buf); | |
| for (i = 0; parts[i]; ++i) { | |
| if (parts[i][0] == '-') { | |
| parts[i]++; | |
| negative = i; | |
| break; | |
| } | |
| num_pos++; | |
| } | |
| for (i = 0; i < *count; ++i) { | |
| /* Walk backwards for easier pruning. */ | |
| for (j = cases[i]->test_count - 1; j >= 0; --j) { | |
| int x; | |
| bool keep = num_pos == 0; | |
| char *name = NULL; | |
| struct zuc_test *test = cases[i]->tests[j]; | |
| if (asprintf(&name, "%s.%s", cases[i]->name, | |
| test->name) < 0) { | |
| printf("%s:%d: error: %d\n", __FILE__, __LINE__, | |
| errno); | |
| exit(EXIT_FAILURE); | |
| } | |
| for (x = 0; (x < num_pos) && !keep; ++x) | |
| keep = wildcard_matches(parts[x], name); | |
| if (keep && (negative >= 0)) | |
| for (x = negative; parts[x] && keep; ++x) | |
| keep &= !wildcard_matches(parts[x], | |
| name); | |
| if (!keep) { | |
| int w; | |
| free_test(test); | |
| for (w = j + 1; w < cases[i]->test_count; w++) | |
| cases[i]->tests[w - 1] = | |
| cases[i]->tests[w]; | |
| cases[i]->test_count--; | |
| } | |
| free(name); | |
| } | |
| } | |
| free(parts); | |
| parts = NULL; | |
| free(buf); | |
| buf = NULL; | |
| /* Prune any cases with no more tests. */ | |
| for (i = *count - 1; i >= 0; --i) { | |
| if (cases[i]->test_count < 1) { | |
| free_test_case(cases[i]); | |
| for (j = i + 1; j < *count; ++j) | |
| cases[j - 1] = cases[j]; | |
| cases[*count - 1] = NULL; | |
| (*count)--; | |
| } | |
| } | |
| } | |
| static unsigned int | |
| get_seed_from_time(void) | |
| { | |
| time_t sec = time(NULL); | |
| unsigned int seed = (unsigned int) sec % 100000; | |
| if (seed < 2) | |
| seed = 2; | |
| return seed; | |
| } | |
| static void | |
| initialize(void) | |
| { | |
| static bool init = false; | |
| if (init) | |
| return; | |
| init = true; | |
| register_tests(); | |
| if (g_ctx.fatal) | |
| return; | |
| if (g_ctx.random > 1) { | |
| g_ctx.seed = g_ctx.random; | |
| } else if (g_ctx.random == 1) { | |
| g_ctx.seed = get_seed_from_time(); | |
| } | |
| if (g_ctx.case_count) { | |
| order_cases(g_ctx.case_count, g_ctx.cases); | |
| if (g_ctx.filter && g_ctx.filter[0]) | |
| filter_cases(&g_ctx.case_count, g_ctx.cases, | |
| g_ctx.filter); | |
| } | |
| } | |
| int | |
| zuc_initialize(int *argc, char *argv[], bool *help_flagged) | |
| { | |
| int rc = EXIT_FAILURE; | |
| int opt_help = 0; | |
| int opt_nofork = 0; | |
| int opt_list = 0; | |
| int opt_repeat = 0; | |
| int opt_random = 0; | |
| int opt_break_on_failure = 0; | |
| int opt_junit = 0; | |
| char *opt_filter = NULL; | |
| char *help_param = NULL; | |
| int argc_in = *argc; | |
| const struct weston_option options[] = { | |
| { WESTON_OPTION_BOOLEAN, "zuc-nofork", 0, &opt_nofork }, | |
| { WESTON_OPTION_BOOLEAN, "zuc-list-tests", 0, &opt_list }, | |
| { WESTON_OPTION_INTEGER, "zuc-repeat", 0, &opt_repeat }, | |
| { WESTON_OPTION_INTEGER, "zuc-random", 0, &opt_random }, | |
| { WESTON_OPTION_BOOLEAN, "zuc-break-on-failure", 0, | |
| &opt_break_on_failure }, | |
| #if ENABLE_JUNIT_XML | |
| { WESTON_OPTION_BOOLEAN, "zuc-output-xml", 0, &opt_junit }, | |
| #endif | |
| { WESTON_OPTION_STRING, "zuc-filter", 0, &opt_filter }, | |
| }; | |
| /* | |
| *If a test binary is linked to our libzunitcmain it might want | |
| * to access the program 'name' from argv[0] | |
| */ | |
| free(g_progname); | |
| g_progname = NULL; | |
| free(g_progbasename); | |
| g_progbasename = NULL; | |
| if ((*argc > 0) && argv) { | |
| char *path = NULL; | |
| char *base = NULL; | |
| g_progname = strdup(argv[0]); | |
| /* basename() might modify the input, so needs a writeable | |
| * string. | |
| * It also may return a statically allocated buffer subject to | |
| * being overwritten so needs to be dup'd. | |
| */ | |
| path = strdup(g_progname); | |
| base = basename(path); | |
| g_progbasename = strdup(base); | |
| free(path); | |
| } else { | |
| g_progname = strdup(""); | |
| printf("%s:%d: warning: No valid argv[0] for initialization\n", | |
| __FILE__, __LINE__); | |
| } | |
| initialize(); | |
| if (g_ctx.fatal) | |
| return EXIT_FAILURE; | |
| if (help_flagged) | |
| *help_flagged = false; | |
| { | |
| /* Help param will be a special case and need restoring. */ | |
| int i = 0; | |
| char **argv_in = NULL; | |
| const struct weston_option help_options[] = { | |
| { WESTON_OPTION_BOOLEAN, "help", 'h', &opt_help }, | |
| }; | |
| argv_in = zalloc(sizeof(char *) * argc_in); | |
| if (!argv_in) { | |
| printf("%s:%d: error: alloc failed.\n", | |
| __FILE__, __LINE__); | |
| return EXIT_FAILURE; | |
| } | |
| for (i = 0; i < argc_in; ++i) | |
| argv_in[i] = argv[i]; | |
| parse_options(help_options, ARRAY_LENGTH(help_options), | |
| argc, argv); | |
| if (*argc < argc_in) { | |
| for (i = 1; (i < argc_in) && !help_param; ++i) { | |
| bool found = false; | |
| int j = 0; | |
| for (j = 0; (j < *argc) && !found; ++j) | |
| found = (argv[j] == argv_in[i]); | |
| if (!found) | |
| help_param = argv_in[i]; | |
| } | |
| } | |
| free(argv_in); | |
| } | |
| parse_options(options, ARRAY_LENGTH(options), argc, argv); | |
| if (help_param && (*argc < argc_in)) | |
| argv[(*argc)++] = help_param; | |
| if (opt_filter) { | |
| zuc_set_filter(opt_filter); | |
| free(opt_filter); | |
| } | |
| if (opt_help) { | |
| printf("Usage: %s [OPTIONS]\n" | |
| " --zuc-break-on-failure\n" | |
| " --zuc-filter=FILTER\n" | |
| " --zuc-list-tests\n" | |
| " --zuc-nofork\n" | |
| #if ENABLE_JUNIT_XML | |
| " --zuc-output-xml\n" | |
| #endif | |
| " --zuc-random=N [0|1|<seed number>]\n" | |
| " --zuc-repeat=N\n" | |
| " --help\n", | |
| argv[0]); | |
| if (help_flagged) | |
| *help_flagged = true; | |
| rc = EXIT_SUCCESS; | |
| } else if (opt_list) { | |
| zuc_list_tests(); | |
| rc = EXIT_FAILURE; | |
| } else { | |
| zuc_set_repeat(opt_repeat); | |
| zuc_set_random(opt_random); | |
| zuc_set_spawn(!opt_nofork); | |
| zuc_set_break_on_failure(opt_break_on_failure); | |
| zuc_set_output_junit(opt_junit); | |
| rc = EXIT_SUCCESS; | |
| } | |
| return rc; | |
| } | |
| static void | |
| dispatch_pre_run(struct zuc_context *ctx, int pass_count, int pass_num, | |
| int seed, const char *filter) | |
| { | |
| struct zuc_slinked *curr; | |
| for (curr = ctx->listeners; curr; curr = curr->next) { | |
| struct zuc_event_listener *listener = curr->data; | |
| if (listener->pre_run) | |
| listener->pre_run(listener->data, | |
| pass_count, | |
| pass_num, | |
| seed, | |
| filter); | |
| } | |
| } | |
| static void | |
| dispatch_run_started(struct zuc_context *ctx, int live_case_count, | |
| int live_test_count, int disabled_count) | |
| { | |
| struct zuc_slinked *curr; | |
| for (curr = ctx->listeners; curr; curr = curr->next) { | |
| struct zuc_event_listener *listener = curr->data; | |
| if (listener->run_started) | |
| listener->run_started(listener->data, | |
| live_case_count, | |
| live_test_count, | |
| disabled_count); | |
| } | |
| } | |
| static void | |
| dispatch_run_ended(struct zuc_context *ctx, | |
| int live_case_count, int live_test_count, int total_passed, | |
| int total_failed, int total_disabled, long total_elapsed) | |
| { | |
| struct zuc_slinked *curr; | |
| for (curr = ctx->listeners; curr; curr = curr->next) { | |
| struct zuc_event_listener *listener = curr->data; | |
| if (listener->run_ended) | |
| listener->run_ended(listener->data, | |
| ctx->case_count, | |
| ctx->cases, | |
| live_case_count, | |
| live_test_count, | |
| total_passed, | |
| total_failed, | |
| total_disabled, | |
| total_elapsed); | |
| } | |
| } | |
| static void | |
| dispatch_case_started(struct zuc_context *ctx,struct zuc_case *test_case, | |
| int live_test_count, int disabled_count) | |
| { | |
| struct zuc_slinked *curr; | |
| for (curr = ctx->listeners; curr; curr = curr->next) { | |
| struct zuc_event_listener *listener = curr->data; | |
| if (listener->case_started) | |
| listener->case_started(listener->data, | |
| test_case, | |
| live_test_count, | |
| disabled_count); | |
| } | |
| } | |
| static void | |
| dispatch_case_ended(struct zuc_context *ctx, struct zuc_case *test_case) | |
| { | |
| struct zuc_slinked *curr; | |
| for (curr = ctx->listeners; curr; curr = curr->next) { | |
| struct zuc_event_listener *listener = curr->data; | |
| if (listener->case_ended) | |
| listener->case_ended(listener->data, test_case); | |
| } | |
| } | |
| static void | |
| dispatch_test_started(struct zuc_context *ctx, struct zuc_test *test) | |
| { | |
| struct zuc_slinked *curr; | |
| for (curr = ctx->listeners; curr; curr = curr->next) { | |
| struct zuc_event_listener *listener = curr->data; | |
| if (listener->test_started) | |
| listener->test_started(listener->data, test); | |
| } | |
| } | |
| static void | |
| dispatch_test_ended(struct zuc_context *ctx, struct zuc_test *test) | |
| { | |
| struct zuc_slinked *curr; | |
| for (curr = ctx->listeners; curr; curr = curr->next) { | |
| struct zuc_event_listener *listener = curr->data; | |
| if (listener->test_ended) | |
| listener->test_ended(listener->data, test); | |
| } | |
| } | |
| static void | |
| dispatch_test_disabled(struct zuc_context *ctx, struct zuc_test *test) | |
| { | |
| struct zuc_slinked *curr; | |
| for (curr = ctx->listeners; curr; curr = curr->next) { | |
| struct zuc_event_listener *listener = curr->data; | |
| if (listener->test_disabled) | |
| listener->test_disabled(listener->data, test); | |
| } | |
| } | |
| static void | |
| dispatch_check_triggered(struct zuc_context *ctx, char const *file, int line, | |
| enum zuc_fail_state state, enum zuc_check_op op, | |
| enum zuc_check_valtype valtype, | |
| intptr_t val1, intptr_t val2, | |
| const char *expr1, const char *expr2) | |
| { | |
| struct zuc_slinked *curr; | |
| for (curr = ctx->listeners; curr; curr = curr->next) { | |
| struct zuc_event_listener *listener = curr->data; | |
| if (listener->check_triggered) | |
| listener->check_triggered(listener->data, | |
| file, line, | |
| state, op, valtype, | |
| val1, val2, | |
| expr1, expr2); | |
| } | |
| } | |
| static void | |
| dispatch_collect_event(struct zuc_context *ctx, char const *file, int line, | |
| const char *expr1) | |
| { | |
| struct zuc_slinked *curr; | |
| for (curr = ctx->listeners; curr; curr = curr->next) { | |
| struct zuc_event_listener *listener = curr->data; | |
| if (listener->collect_event) | |
| listener->collect_event(listener->data, | |
| file, line, expr1); | |
| } | |
| } | |
| static void | |
| migrate_deferred_events(struct zuc_test *test, bool transferred) | |
| { | |
| struct zuc_event *evt = test->deferred; | |
| if (!evt) | |
| return; | |
| test->deferred = NULL; | |
| if (test->events) { | |
| struct zuc_event *old = test->events; | |
| while (old->next) | |
| old = old->next; | |
| old->next = evt; | |
| } else { | |
| test->events = evt; | |
| } | |
| while (evt && !transferred) { | |
| dispatch_check_triggered(&g_ctx, | |
| evt->file, evt->line, | |
| evt->state, evt->op, | |
| evt->valtype, | |
| evt->val1, evt->val2, | |
| evt->expr1, evt->expr2); | |
| evt = evt->next; | |
| } | |
| } | |
| static void | |
| mark_single_failed(struct zuc_test *test, enum zuc_fail_state state) | |
| { | |
| switch (state) { | |
| case ZUC_CHECK_OK: | |
| /* no internal state to change */ | |
| break; | |
| case ZUC_CHECK_SKIP: | |
| if (test) | |
| test->skipped = 1; | |
| break; | |
| case ZUC_CHECK_FAIL: | |
| if (test) | |
| test->failed = 1; | |
| break; | |
| case ZUC_CHECK_ERROR: | |
| case ZUC_CHECK_FATAL: | |
| if (test) | |
| test->fatal = 1; | |
| break; | |
| } | |
| if (g_ctx.break_on_failure) | |
| raise(SIGABRT); | |
| } | |
| static void | |
| mark_failed(struct zuc_test *test, enum zuc_fail_state state) | |
| { | |
| if (!test && g_ctx.curr_test) | |
| test = g_ctx.curr_test; | |
| if (test) { | |
| mark_single_failed(test, state); | |
| } else if (g_ctx.curr_case) { | |
| /* In setup or tear-down of test suite */ | |
| int i; | |
| for (i = 0; i < g_ctx.curr_case->test_count; ++i) | |
| mark_single_failed(g_ctx.curr_case->tests[i], state); | |
| } | |
| if ((state == ZUC_CHECK_FATAL) || (state == ZUC_CHECK_ERROR)) | |
| g_ctx.fatal = true; | |
| } | |
| void | |
| zuc_attach_event(struct zuc_test *test, struct zuc_event *event, | |
| enum zuc_event_type event_type, bool transferred) | |
| { | |
| if (!test) { | |
| /* | |
| * consider adding events directly to the case. | |
| * would be for use during per-suite setup and teardown. | |
| */ | |
| printf("%s:%d: error: No current test.\n", __FILE__, __LINE__); | |
| } else if (event_type == ZUC_EVENT_DEFERRED) { | |
| if (test->deferred) { | |
| struct zuc_event *curr = test->deferred; | |
| while (curr->next) | |
| curr = curr->next; | |
| curr->next = event; | |
| } else { | |
| test->deferred = event; | |
| } | |
| } else { | |
| if (test) | |
| migrate_deferred_events(test, transferred); | |
| if (test->events) { | |
| struct zuc_event *curr = test->events; | |
| while (curr->next) | |
| curr = curr->next; | |
| curr->next = event; | |
| } else { | |
| test->events = event; | |
| } | |
| mark_failed(test, event->state); | |
| } | |
| } | |
| void | |
| zuc_add_event_listener(struct zuc_event_listener *event_listener) | |
| { | |
| if (!event_listener) /* ensure null entries are not added */ | |
| return; | |
| if (!g_ctx.listeners) { | |
| g_ctx.listeners = zalloc(sizeof(struct zuc_slinked)); | |
| ZUC_ASSERT_NOT_NULL(g_ctx.listeners); | |
| g_ctx.listeners->data = event_listener; | |
| } else { | |
| struct zuc_slinked *curr = g_ctx.listeners; | |
| while (curr->next) | |
| curr = curr->next; | |
| curr->next = zalloc(sizeof(struct zuc_slinked)); | |
| ZUC_ASSERT_NOT_NULL(curr->next); | |
| curr->next->data = event_listener; | |
| } | |
| } | |
| void | |
| zuc_cleanup(void) | |
| { | |
| int i; | |
| free(g_ctx.filter); | |
| g_ctx.filter = 0; | |
| for (i = 0; i < 2; ++i) | |
| if (g_ctx.fds[i] != -1) { | |
| close(g_ctx.fds[i]); | |
| g_ctx.fds[i] = -1; | |
| } | |
| if (g_ctx.listeners) { | |
| struct zuc_slinked *curr = g_ctx.listeners; | |
| while (curr) { | |
| struct zuc_slinked *old = curr; | |
| struct zuc_event_listener *listener = curr->data; | |
| if (listener->destroy) | |
| listener->destroy(listener->data); | |
| free(listener); | |
| curr = curr->next; | |
| free(old); | |
| } | |
| g_ctx.listeners = NULL; | |
| } | |
| for (i = g_ctx.case_count - 1; i >= 0; --i) { | |
| free_test_case(g_ctx.cases[i]); | |
| g_ctx.cases[i] = NULL; | |
| } | |
| free(g_ctx.cases); | |
| g_ctx.cases = NULL; | |
| free(g_progname); | |
| g_progname = NULL; | |
| free(g_progbasename); | |
| g_progbasename = NULL; | |
| } | |
| static void | |
| shuffle_cases(int count, struct zuc_case **cases, | |
| unsigned int seed) | |
| { | |
| int i; | |
| unsigned int rseed = seed; | |
| for (i = 0; i < count; ++i) { | |
| int j; | |
| for (j = cases[i]->test_count - 1; j > 0 ; --j) { | |
| int val = rand_r(&rseed); | |
| int b = ((val / (double)RAND_MAX) * j + 0.5); | |
| if (j != b) { | |
| struct zuc_test *tmp = cases[i]->tests[j]; | |
| cases[i]->tests[j] = cases[i]->tests[b]; | |
| cases[i]->tests[b] = tmp; | |
| } | |
| } | |
| } | |
| for (i = count - 1; i > 0; --i) { | |
| int val = rand_r(&rseed); | |
| int j = ((val / (double)RAND_MAX) * i + 0.5); | |
| if (i != j) { | |
| struct zuc_case *tmp = cases[i]; | |
| cases[i] = cases[j]; | |
| cases[j] = tmp; | |
| } | |
| } | |
| } | |
| void | |
| zuc_list_tests(void) | |
| { | |
| int i; | |
| int j; | |
| initialize(); | |
| if (g_ctx.fatal) | |
| return; | |
| for (i = 0; i < g_ctx.case_count; ++i) { | |
| printf("%s.\n", g_ctx.cases[i]->name); | |
| for (j = 0; j < g_ctx.cases[i]->test_count; ++j) { | |
| printf(" %s\n", g_ctx.cases[i]->tests[j]->name); | |
| } | |
| } | |
| } | |
| static void | |
| spawn_test(struct zuc_test *test, void *test_data, | |
| void (*cleanup_fn)(void *data), void *cleanup_data) | |
| { | |
| pid_t pid = -1; | |
| if (!test || (!test->fn && !test->fn_f)) | |
| return; | |
| if (pipe2(g_ctx.fds, O_CLOEXEC)) { | |
| printf("%s:%d: error: Unable to create pipe: %d\n", | |
| __FILE__, __LINE__, errno); | |
| mark_failed(test, ZUC_CHECK_ERROR); | |
| return; | |
| } | |
| fflush(NULL); /* important. avoid duplication of output */ | |
| pid = fork(); | |
| switch (pid) { | |
| case -1: /* Error forking */ | |
| printf("%s:%d: error: Problem with fork: %d\n", | |
| __FILE__, __LINE__, errno); | |
| mark_failed(test, ZUC_CHECK_ERROR); | |
| close(g_ctx.fds[0]); | |
| g_ctx.fds[0] = -1; | |
| close(g_ctx.fds[1]); | |
| g_ctx.fds[1] = -1; | |
| break; | |
| case 0: { /* child */ | |
| int rc = EXIT_SUCCESS; | |
| close(g_ctx.fds[0]); | |
| g_ctx.fds[0] = -1; | |
| if (test->fn_f) | |
| test->fn_f(test_data); | |
| else | |
| test->fn(); | |
| if (test_has_failure(test)) | |
| rc = EXIT_FAILURE; | |
| else if (test_has_skip(test)) | |
| rc = ZUC_EXIT_SKIP; | |
| /* Avoid confusing memory tools like valgrind */ | |
| if (cleanup_fn) | |
| cleanup_fn(cleanup_data); | |
| zuc_cleanup(); | |
| exit(rc); | |
| } | |
| default: { /* parent */ | |
| ssize_t rc = 0; | |
| siginfo_t info = {}; | |
| close(g_ctx.fds[1]); | |
| g_ctx.fds[1] = -1; | |
| do { | |
| rc = zuc_process_message(g_ctx.curr_test, | |
| g_ctx.fds[0]); | |
| } while (rc > 0); | |
| close(g_ctx.fds[0]); | |
| g_ctx.fds[0] = -1; | |
| if (waitid(P_ALL, 0, &info, WEXITED)) { | |
| printf("%s:%d: error: waitid failed. (%d)\n", | |
| __FILE__, __LINE__, errno); | |
| mark_failed(test, ZUC_CHECK_ERROR); | |
| } else { | |
| switch (info.si_code) { | |
| case CLD_EXITED: { | |
| int exit_code = info.si_status; | |
| switch(exit_code) { | |
| case EXIT_SUCCESS: | |
| break; | |
| case ZUC_EXIT_SKIP: | |
| if (!test_has_skip(g_ctx.curr_test) && | |
| !test_has_failure(g_ctx.curr_test)) | |
| ZUC_SKIP("Child exited SKIP"); | |
| break; | |
| default: | |
| /* unexpected failure */ | |
| if (!test_has_failure(g_ctx.curr_test)) | |
| ZUC_ASSERT_EQ(0, exit_code); | |
| } | |
| break; | |
| } | |
| case CLD_KILLED: | |
| case CLD_DUMPED: | |
| printf("%s:%d: error: signaled: %d\n", | |
| __FILE__, __LINE__, info.si_status); | |
| mark_failed(test, ZUC_CHECK_ERROR); | |
| break; | |
| } | |
| } | |
| } | |
| } | |
| } | |
| static void | |
| run_single_test(struct zuc_test *test,const struct zuc_fixture *fxt, | |
| void *case_data, bool spawn) | |
| { | |
| long elapsed = 0; | |
| struct timespec begin; | |
| struct timespec end; | |
| void *test_data = NULL; | |
| void *cleanup_data = NULL; | |
| void (*cleanup_fn)(void *data) = NULL; | |
| memset(&begin, 0, sizeof(begin)); | |
| memset(&end, 0, sizeof(end)); | |
| g_ctx.curr_test = test; | |
| dispatch_test_started(&g_ctx, test); | |
| cleanup_fn = fxt ? fxt->tear_down : NULL; | |
| cleanup_data = NULL; | |
| if (fxt && fxt->set_up) { | |
| test_data = fxt->set_up(case_data); | |
| cleanup_data = test_data; | |
| } else { | |
| test_data = case_data; | |
| } | |
| clock_gettime(TARGET_TIMER, &begin); | |
| /* Need to re-check these, as fixtures might have changed test state. */ | |
| if (!test->fatal && !test->skipped) { | |
| if (spawn) { | |
| spawn_test(test, test_data, | |
| cleanup_fn, cleanup_data); | |
| } else { | |
| if (test->fn_f) | |
| test->fn_f(test_data); | |
| else | |
| test->fn(); | |
| } | |
| } | |
| clock_gettime(TARGET_TIMER, &end); | |
| elapsed = (end.tv_sec - begin.tv_sec) * MS_PER_SEC; | |
| if (end.tv_sec != begin.tv_sec) { | |
| elapsed -= (begin.tv_nsec) / NANO_PER_MS; | |
| elapsed += (end.tv_nsec) / NANO_PER_MS; | |
| } else { | |
| elapsed += (end.tv_nsec - begin.tv_nsec) / NANO_PER_MS; | |
| } | |
| test->elapsed = elapsed; | |
| if (cleanup_fn) | |
| cleanup_fn(cleanup_data); | |
| if (test->deferred) { | |
| if (test_has_failure(test)) | |
| migrate_deferred_events(test, false); | |
| else | |
| free_events(&test->deferred); | |
| } | |
| dispatch_test_ended(&g_ctx, test); | |
| g_ctx.curr_test = NULL; | |
| } | |
| static void | |
| run_single_case(struct zuc_case *test_case) | |
| { | |
| int count_live = test_case->test_count - test_case->disabled; | |
| g_ctx.curr_case = test_case; | |
| if (count_live) { | |
| int i = 0; | |
| const struct zuc_fixture *fxt = test_case->fxt; | |
| void *case_data = fxt ? (void *)fxt->data : NULL; | |
| dispatch_case_started(&g_ctx, test_case, | |
| count_live, test_case->disabled); | |
| if (fxt && fxt->set_up_test_case) | |
| case_data = fxt->set_up_test_case(fxt->data); | |
| for (i = 0; i < test_case->test_count; ++i) { | |
| struct zuc_test *curr = test_case->tests[i]; | |
| if (curr->disabled) { | |
| dispatch_test_disabled(&g_ctx, curr); | |
| } else { | |
| run_single_test(curr, fxt, case_data, | |
| g_ctx.spawn); | |
| if (curr->skipped) | |
| test_case->skipped++; | |
| if (curr->failed) | |
| test_case->failed++; | |
| if (curr->fatal) | |
| test_case->fatal++; | |
| if (!curr->failed && !curr->fatal) | |
| test_case->passed++; | |
| test_case->elapsed += curr->elapsed; | |
| } | |
| } | |
| if (fxt && fxt->tear_down_test_case) | |
| fxt->tear_down_test_case(case_data); | |
| dispatch_case_ended(&g_ctx, test_case); | |
| } | |
| g_ctx.curr_case = NULL; | |
| } | |
| static void | |
| reset_test_values(struct zuc_case **cases, int case_count) | |
| { | |
| int i; | |
| for (i = 0; i < case_count; ++i) { | |
| int j; | |
| cases[i]->disabled = 0; | |
| cases[i]->skipped = 0; | |
| cases[i]->failed = 0; | |
| cases[i]->fatal = 0; | |
| cases[i]->passed = 0; | |
| cases[i]->elapsed = 0; | |
| for (j = 0; j < cases[i]->test_count; ++j) { | |
| struct zuc_test *test = cases[i]->tests[j]; | |
| if (test->disabled) | |
| cases[i]->disabled++; | |
| test->skipped = 0; | |
| test->failed = 0; | |
| test->fatal = 0; | |
| test->elapsed = 0; | |
| free_events(&test->events); | |
| free_events(&test->deferred); | |
| } | |
| } | |
| } | |
| static int | |
| run_single_pass(void) | |
| { | |
| long total_elapsed = 0; | |
| int total_passed = 0; | |
| int total_failed = 0; | |
| int total_skipped = 0; | |
| int live_case_count = 0; | |
| int live_test_count = 0; | |
| int disabled_test_count = 0; | |
| int i; | |
| reset_test_values(g_ctx.cases, g_ctx.case_count); | |
| for (i = 0; i < g_ctx.case_count; ++i) { | |
| int live = g_ctx.cases[i]->test_count | |
| - g_ctx.cases[i]->disabled; | |
| if (live) { | |
| live_test_count += live; | |
| live_case_count++; | |
| } | |
| if (g_ctx.cases[i]->disabled) | |
| disabled_test_count++; | |
| } | |
| dispatch_run_started(&g_ctx, live_case_count, live_test_count, | |
| disabled_test_count); | |
| for (i = 0; i < g_ctx.case_count; ++i) { | |
| run_single_case(g_ctx.cases[i]); | |
| total_failed += g_ctx.cases[i]->test_count | |
| - (g_ctx.cases[i]->passed + g_ctx.cases[i]->disabled); | |
| total_passed += g_ctx.cases[i]->passed; | |
| total_elapsed += g_ctx.cases[i]->elapsed; | |
| total_skipped += g_ctx.cases[i]->skipped; | |
| } | |
| dispatch_run_ended(&g_ctx, live_case_count, live_test_count, | |
| total_passed, total_failed, disabled_test_count, | |
| total_elapsed); | |
| if (total_failed) | |
| return EXIT_FAILURE; | |
| else if (total_skipped) | |
| return ZUC_EXIT_SKIP; | |
| else | |
| return EXIT_SUCCESS; | |
| } | |
| int | |
| zucimpl_run_tests(void) | |
| { | |
| int rc = EXIT_SUCCESS; | |
| int i; | |
| int limit = g_ctx.repeat > 0 ? g_ctx.repeat : 1; | |
| initialize(); | |
| if (g_ctx.fatal) | |
| return EXIT_FAILURE; | |
| if (g_ctx.listeners == NULL) { | |
| zuc_add_event_listener(zuc_collector_create(&(g_ctx.fds[1]))); | |
| zuc_add_event_listener(zuc_base_logger_create()); | |
| if (g_ctx.output_junit) | |
| zuc_add_event_listener(zuc_junit_reporter_create()); | |
| } | |
| if (g_ctx.case_count < 1) { | |
| printf("%s:%d: error: Setup error: test tree is empty\n", | |
| __FILE__, __LINE__); | |
| rc = EXIT_FAILURE; | |
| } | |
| for (i = 0; (i < limit) && (g_ctx.case_count > 0); ++i) { | |
| int pass_code = EXIT_SUCCESS; | |
| dispatch_pre_run(&g_ctx, limit, i + 1, | |
| (g_ctx.random > 0) ? g_ctx.seed : 0, | |
| g_ctx.filter); | |
| order_cases(g_ctx.case_count, g_ctx.cases); | |
| if (g_ctx.random > 0) | |
| shuffle_cases(g_ctx.case_count, g_ctx.cases, | |
| g_ctx.seed); | |
| pass_code = run_single_pass(); | |
| if (pass_code == EXIT_FAILURE) | |
| rc = EXIT_FAILURE; | |
| else if ((pass_code == ZUC_EXIT_SKIP) && (rc == EXIT_SUCCESS)) | |
| rc = ZUC_EXIT_SKIP; | |
| g_ctx.seed++; | |
| } | |
| return rc; | |
| } | |
| int | |
| zucimpl_tracepoint(char const *file, int line, char const *fmt, ...) | |
| { | |
| int rc = -1; | |
| va_list argp; | |
| char *msg = NULL; | |
| va_start(argp, fmt); | |
| rc = vasprintf(&msg, fmt, argp); | |
| if (rc == -1) { | |
| msg = NULL; | |
| } | |
| va_end(argp); | |
| dispatch_collect_event(&g_ctx, | |
| file, line, | |
| msg); | |
| free(msg); | |
| return rc; | |
| } | |
| void | |
| zucimpl_terminate(char const *file, int line, | |
| bool fail, bool fatal, const char *msg) | |
| { | |
| enum zuc_fail_state state = ZUC_CHECK_SKIP; | |
| int level = 2; | |
| if (fail && fatal) { | |
| state = ZUC_CHECK_FATAL; | |
| level = 0; | |
| } else if (fail && !fatal) { | |
| state = ZUC_CHECK_FAIL; | |
| level = 0; | |
| } | |
| mark_failed(g_ctx.curr_test, state); | |
| if ((state != ZUC_CHECK_OK) && g_ctx.curr_test) | |
| migrate_deferred_events(g_ctx.curr_test, false); | |
| dispatch_check_triggered(&g_ctx, | |
| file, line, | |
| state, | |
| ZUC_OP_TERMINATE, ZUC_VAL_INT, | |
| level, 0, | |
| msg, ""); | |
| } | |
| static void | |
| validate_types(enum zuc_check_op op, enum zuc_check_valtype valtype) | |
| { | |
| bool is_valid = true; | |
| switch (op) { | |
| case ZUC_OP_NULL: | |
| case ZUC_OP_NOT_NULL: | |
| is_valid = is_valid && (valtype == ZUC_VAL_PTR); | |
| break; | |
| default: | |
| ; /* all rest OK */ | |
| } | |
| switch (valtype) { | |
| case ZUC_VAL_CSTR: | |
| is_valid = is_valid && ((op == ZUC_OP_EQ) || (op == ZUC_OP_NE)); | |
| break; | |
| default: | |
| ; /* all rest OK */ | |
| } | |
| if (!is_valid) | |
| printf("%s:%d: warning: Unexpected op+type %d/%d.\n", | |
| __FILE__, __LINE__, op, valtype); | |
| } | |
| static int | |
| pred2_unknown(intptr_t lhs, intptr_t rhs) | |
| { | |
| return 0; | |
| } | |
| static int | |
| pred2_true(intptr_t lhs, intptr_t rhs) | |
| { | |
| return lhs; | |
| } | |
| static int | |
| pred2_false(intptr_t lhs, intptr_t rhs) | |
| { | |
| return !lhs; | |
| } | |
| static int | |
| pred2_eq(intptr_t lhs, intptr_t rhs) | |
| { | |
| return lhs == rhs; | |
| } | |
| static int | |
| pred2_streq(intptr_t lhs, intptr_t rhs) | |
| { | |
| int status = 0; | |
| const char *lhptr = (const char *)lhs; | |
| const char *rhptr = (const char *)rhs; | |
| if (!lhptr && !rhptr) | |
| status = 1; | |
| else if (lhptr && rhptr) | |
| status = strcmp(lhptr, rhptr) == 0; | |
| return status; | |
| } | |
| static int | |
| pred2_ne(intptr_t lhs, intptr_t rhs) | |
| { | |
| return lhs != rhs; | |
| } | |
| static int | |
| pred2_strne(intptr_t lhs, intptr_t rhs) | |
| { | |
| int status = 0; | |
| const char *lhptr = (const char *)lhs; | |
| const char *rhptr = (const char *)rhs; | |
| if (lhptr != rhptr) { | |
| if (!lhptr || !rhptr) | |
| status = 1; | |
| else | |
| status = strcmp(lhptr, rhptr) != 0; | |
| } | |
| return status; | |
| } | |
| static int | |
| pred2_ge(intptr_t lhs, intptr_t rhs) | |
| { | |
| return lhs >= rhs; | |
| } | |
| static int | |
| pred2_gt(intptr_t lhs, intptr_t rhs) | |
| { | |
| return lhs > rhs; | |
| } | |
| static int | |
| pred2_le(intptr_t lhs, intptr_t rhs) | |
| { | |
| return lhs <= rhs; | |
| } | |
| static int | |
| pred2_lt(intptr_t lhs, intptr_t rhs) | |
| { | |
| return lhs < rhs; | |
| } | |
| static comp_pred2 | |
| get_pred2(enum zuc_check_op op, enum zuc_check_valtype valtype) | |
| { | |
| switch (op) { | |
| case ZUC_OP_TRUE: | |
| return pred2_true; | |
| case ZUC_OP_FALSE: | |
| return pred2_false; | |
| case ZUC_OP_NULL: | |
| return pred2_false; | |
| case ZUC_OP_NOT_NULL: | |
| return pred2_true; | |
| case ZUC_OP_EQ: | |
| if (valtype == ZUC_VAL_CSTR) | |
| return pred2_streq; | |
| else | |
| return pred2_eq; | |
| case ZUC_OP_NE: | |
| if (valtype == ZUC_VAL_CSTR) | |
| return pred2_strne; | |
| else | |
| return pred2_ne; | |
| case ZUC_OP_GE: | |
| return pred2_ge; | |
| case ZUC_OP_GT: | |
| return pred2_gt; | |
| case ZUC_OP_LE: | |
| return pred2_le; | |
| case ZUC_OP_LT: | |
| return pred2_lt; | |
| default: | |
| return pred2_unknown; | |
| } | |
| } | |
| int | |
| zucimpl_expect_pred2(char const *file, int line, | |
| enum zuc_check_op op, enum zuc_check_valtype valtype, | |
| bool fatal, | |
| intptr_t lhs, intptr_t rhs, | |
| const char *lhs_str, const char* rhs_str) | |
| { | |
| enum zuc_fail_state state = fatal ? ZUC_CHECK_FATAL : ZUC_CHECK_FAIL; | |
| comp_pred2 pred = get_pred2(op, valtype); | |
| int failed = !pred(lhs, rhs); | |
| validate_types(op, valtype); | |
| if (failed) { | |
| mark_failed(g_ctx.curr_test, state); | |
| if (g_ctx.curr_test) | |
| migrate_deferred_events(g_ctx.curr_test, false); | |
| dispatch_check_triggered(&g_ctx, | |
| file, line, | |
| fatal ? ZUC_CHECK_FATAL | |
| : ZUC_CHECK_FAIL, | |
| op, valtype, | |
| lhs, rhs, | |
| lhs_str, rhs_str); | |
| } | |
| return failed; | |
| } |